[PATCH 1/2] UNITTEST: Fix expected/actual assertions and accidental tautologies.


Lee Skillen <lskillen@...>
 

- Reversed all EXPECT_*, ASSERT_* where the actual and expected where
in the format of EXPECT_*(actual, expected) instead of the suggested
format of EXPECT_*(expected, actual). Doesn't impact functionality
but does impact meaningfulness of output when a test fails. I used
regex to achieve this but manually stepped through each to avoid a
reversal of ones already in the correct format.

Before:

[snip]/fieldcompositetests.cpp:300: Failure
Value of: MAMA_STATUS_OK
Actual: 0
Expected: ret
Which is: 19

After:

[snip]/fieldcompositetests.cpp:300: Failure
Value of: ret
Actual: 19
Expected: MAMA_STATUS_OK
Which is: 0

- Also fixed tautologies in PayloadAtomicTestsC, such as:

EXPECT_EQ(returnedValue, returnedValue);

Changed to:

EXPECT_EQ (initialValue, returnedValue);

Signed-off-by: Lee Skillen <lskillen@...>
---
.../src/gunittest/c/payload/fieldatomictests.cpp | 506 ++---
.../gunittest/c/payload/fieldcompositetests.cpp | 198 +-
.../src/gunittest/c/payload/fieldvectortests.cpp | 176 +-
.../src/gunittest/c/payload/payloadatomictests.cpp | 352 ++--
.../gunittest/c/payload/payloadcompositetests.cpp | 128 +-
.../gunittest/c/payload/payloadgeneraltests.cpp | 422 ++---
.../src/gunittest/c/payload/payloadvectortests.cpp | 1928 ++++++++++----------
7 files changed, 1855 insertions(+), 1855 deletions(-)

diff --git a/mama/c_cpp/src/gunittest/c/payload/fieldatomictests.cpp b/mama/c_cpp/src/gunittest/c/payload/fieldatomictests.cpp
index 2e60999..933524a 100644
--- a/mama/c_cpp/src/gunittest/c/payload/fieldatomictests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/fieldatomictests.cpp
@@ -82,14 +82,14 @@ TEST_F(FieldBoolTests, UpdateBoolValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateBool(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldBoolTests, UpdateBoolInvalidType)
@@ -99,14 +99,14 @@ TEST_F(FieldBoolTests, UpdateBoolInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, 'A');
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateBool(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldBoolTests, UpdateBoolInValid)
@@ -116,18 +116,18 @@ TEST_F(FieldBoolTests, UpdateBoolInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateBool(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateBool(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

ret = aBridge->msgPayloadDestroy(field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldBoolTests, GetBoolValid)
@@ -137,14 +137,14 @@ TEST_F(FieldBoolTests, GetBoolValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetBool(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldBoolTests, GetBoolInvalidType)
@@ -154,11 +154,11 @@ TEST_F(FieldBoolTests, GetBoolInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetBool(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -170,15 +170,15 @@ TEST_F(FieldBoolTests, GetBoolInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetBool(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetBool(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -207,14 +207,14 @@ TEST_F(FieldCharTests, UpdateCharValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateChar(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldCharTests, UpdateCharInvalidType)
@@ -224,14 +224,14 @@ TEST_F(FieldCharTests, UpdateCharInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateChar(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldCharTests, UpdateCharInValid)
@@ -241,15 +241,15 @@ TEST_F(FieldCharTests, UpdateCharInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateChar(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateChar(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldCharTests, GetCharValid)
@@ -259,14 +259,14 @@ TEST_F(FieldCharTests, GetCharValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetChar(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldCharTests, GetCharInvalidType)
@@ -276,11 +276,11 @@ TEST_F(FieldCharTests, GetCharInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetChar(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -292,15 +292,15 @@ TEST_F(FieldCharTests, GetCharInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetChar(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetChar(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -329,14 +329,14 @@ TEST_F(FieldI8Tests, UpdateI8Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI8(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI8(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI8Tests, UpdateI8InvalidType)
@@ -346,14 +346,14 @@ TEST_F(FieldI8Tests, UpdateI8InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI8(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldI8Tests, UpdateI8InValid)
@@ -363,15 +363,15 @@ TEST_F(FieldI8Tests, UpdateI8InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateI8(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateI8(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldI8Tests, GetI8Valid)
@@ -381,14 +381,14 @@ TEST_F(FieldI8Tests, GetI8Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI8(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI8(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI8Tests, GetI8InvalidType)
@@ -398,11 +398,11 @@ TEST_F(FieldI8Tests, GetI8InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI8(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -414,15 +414,15 @@ TEST_F(FieldI8Tests, GetI8InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetI8(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetI8(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -451,14 +451,14 @@ TEST_F(FieldU8Tests, UpdateU8Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU8(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU8(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU8Tests, UpdateU8InvalidType)
@@ -468,14 +468,14 @@ TEST_F(FieldU8Tests, UpdateU8InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU8(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldU8Tests, UpdateU8InValid)
@@ -485,15 +485,15 @@ TEST_F(FieldU8Tests, UpdateU8InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateU8(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateU8(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldU8Tests, GetU8Valid)
@@ -503,14 +503,14 @@ TEST_F(FieldU8Tests, GetU8Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU8(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU8(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU8Tests, GetU8InvalidType)
@@ -520,11 +520,11 @@ TEST_F(FieldU8Tests, GetU8InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU8(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -536,15 +536,15 @@ TEST_F(FieldU8Tests, GetU8InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetU8(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetU8(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -573,14 +573,14 @@ TEST_F(FieldI16Tests, UpdateI16Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI16(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI16(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI16Tests, UpdateI16InvalidType)
@@ -590,14 +590,14 @@ TEST_F(FieldI16Tests, UpdateI16InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI16(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldI16Tests, UpdateI16InValid)
@@ -607,15 +607,15 @@ TEST_F(FieldI16Tests, UpdateI16InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateI16(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateI16(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldI16Tests, GetI16Valid)
@@ -625,14 +625,14 @@ TEST_F(FieldI16Tests, GetI16Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI16(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI16(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI16Tests, GetI16InvalidType)
@@ -642,11 +642,11 @@ TEST_F(FieldI16Tests, GetI16InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI16(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -658,15 +658,15 @@ TEST_F(FieldI16Tests, GetI16InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetI16(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetI16(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -695,14 +695,14 @@ TEST_F(FieldU16Tests, UpdateU16Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU16(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU16(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU16Tests, UpdateU16InvalidType)
@@ -712,14 +712,14 @@ TEST_F(FieldU16Tests, UpdateU16InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU16(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldU16Tests, UpdateU16InValid)
@@ -729,15 +729,15 @@ TEST_F(FieldU16Tests, UpdateU16InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateU16(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateU16(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldU16Tests, GetU16Valid)
@@ -747,14 +747,14 @@ TEST_F(FieldU16Tests, GetU16Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU16(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU16(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU16Tests, GetU16InvalidType)
@@ -764,11 +764,11 @@ TEST_F(FieldU16Tests, GetU16InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU16(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -780,15 +780,15 @@ TEST_F(FieldU16Tests, GetU16InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetU16(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetU16(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -817,14 +817,14 @@ TEST_F(FieldI32Tests, UpdateI32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI32(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI32Tests, UpdateI32InvalidType)
@@ -834,14 +834,14 @@ TEST_F(FieldI32Tests, UpdateI32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldI32Tests, UpdateI32InValid)
@@ -851,15 +851,15 @@ TEST_F(FieldI32Tests, UpdateI32InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateI32(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateI32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldI32Tests, GetI32Valid)
@@ -869,14 +869,14 @@ TEST_F(FieldI32Tests, GetI32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI32(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI32Tests, GetI32InvalidType)
@@ -886,11 +886,11 @@ TEST_F(FieldI32Tests, GetI32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI32(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -902,15 +902,15 @@ TEST_F(FieldI32Tests, GetI32InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetI32(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetI32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -939,14 +939,14 @@ TEST_F(FieldU32Tests, UpdateU32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU32(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU32Tests, UpdateU32InvalidType)
@@ -956,14 +956,14 @@ TEST_F(FieldU32Tests, UpdateU32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldU32Tests, UpdateU32InValid)
@@ -973,15 +973,15 @@ TEST_F(FieldU32Tests, UpdateU32InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateU32(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateU32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldU32Tests, GetU32Valid)
@@ -991,14 +991,14 @@ TEST_F(FieldU32Tests, GetU32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU32(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU32Tests, GetU32InvalidType)
@@ -1008,11 +1008,11 @@ TEST_F(FieldU32Tests, GetU32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU32(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1024,15 +1024,15 @@ TEST_F(FieldU32Tests, GetU32InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetU32(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetU32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -1061,14 +1061,14 @@ TEST_F(FieldI64Tests, UpdateI64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI64Tests, UpdateI64InvalidType)
@@ -1078,14 +1078,14 @@ TEST_F(FieldI64Tests, UpdateI64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldI64Tests, UpdateI64InValid)
@@ -1095,15 +1095,15 @@ TEST_F(FieldI64Tests, UpdateI64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateI64(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateI64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldI64Tests, GetI64Valid)
@@ -1113,14 +1113,14 @@ TEST_F(FieldI64Tests, GetI64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI64Tests, GetI64InvalidType)
@@ -1130,11 +1130,11 @@ TEST_F(FieldI64Tests, GetI64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI64(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1146,15 +1146,15 @@ TEST_F(FieldI64Tests, GetI64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetI64(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetI64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -1183,14 +1183,14 @@ TEST_F(FieldU64Tests, UpdateU64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU64Tests, UpdateU64InvalidType)
@@ -1200,14 +1200,14 @@ TEST_F(FieldU64Tests, UpdateU64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldU64Tests, UpdateU64InValid)
@@ -1217,15 +1217,15 @@ TEST_F(FieldU64Tests, UpdateU64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateU64(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateU64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldU64Tests, GetU64Valid)
@@ -1235,14 +1235,14 @@ TEST_F(FieldU64Tests, GetU64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU64Tests, GetU64InvalidType)
@@ -1252,11 +1252,11 @@ TEST_F(FieldU64Tests, GetU64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU64(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1268,15 +1268,15 @@ TEST_F(FieldU64Tests, GetU64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetU64(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetU64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}
/**********************************************************************
* F32 Tests
@@ -1304,14 +1304,14 @@ TEST_F(FieldF32Tests, UpdateF32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddF32(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateF32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldF32Tests, UpdateF32InvalidType)
@@ -1321,14 +1321,14 @@ TEST_F(FieldF32Tests, UpdateF32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateF32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldF32Tests, UpdateF32InValid)
@@ -1338,15 +1338,15 @@ TEST_F(FieldF32Tests, UpdateF32InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateF32(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateF32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldF32Tests, GetF32Valid)
@@ -1356,14 +1356,14 @@ TEST_F(FieldF32Tests, GetF32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddF32(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetF32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldF32Tests, GetF32InvalidType)
@@ -1373,11 +1373,11 @@ TEST_F(FieldF32Tests, GetF32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetF32(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1389,15 +1389,15 @@ TEST_F(FieldF32Tests, GetF32InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetF32(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetF32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -1426,14 +1426,14 @@ TEST_F(FieldF64Tests, UpdateF64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddF64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateF64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldF64Tests, UpdateF64InvalidType)
@@ -1443,14 +1443,14 @@ TEST_F(FieldF64Tests, UpdateF64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateF64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldF64Tests, UpdateF64InValid)
@@ -1460,15 +1460,15 @@ TEST_F(FieldF64Tests, UpdateF64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateF64(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateF64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldF64Tests, GetF64Valid)
@@ -1478,14 +1478,14 @@ TEST_F(FieldF64Tests, GetF64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddF64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetF64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldF64Tests, GetF64InvalidType)
@@ -1495,11 +1495,11 @@ TEST_F(FieldF64Tests, GetF64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetF64(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1511,13 +1511,13 @@ TEST_F(FieldF64Tests, GetF64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetF64(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetF64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}
diff --git a/mama/c_cpp/src/gunittest/c/payload/fieldcompositetests.cpp b/mama/c_cpp/src/gunittest/c/payload/fieldcompositetests.cpp
index 55d72cf..f7875f6 100644
--- a/mama/c_cpp/src/gunittest/c/payload/fieldcompositetests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/fieldcompositetests.cpp
@@ -92,14 +92,14 @@ TEST_F(FieldStringTests, UpdateStringValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateString(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldStringTests, UpdateStringInvalidType)
@@ -109,14 +109,14 @@ TEST_F(FieldStringTests, UpdateStringInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, 'A');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateString(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldStringTests, UpdateStringInValid)
@@ -126,15 +126,15 @@ TEST_F(FieldStringTests, UpdateStringInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateString(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateString(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldStringTests, GetStringValid)
@@ -144,14 +144,14 @@ TEST_F(FieldStringTests, GetStringValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetString(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldStringTests, GetStringInvalidType)
@@ -161,14 +161,14 @@ TEST_F(FieldStringTests, GetStringInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetString(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldStringTests, GetStringInValid)
@@ -177,15 +177,15 @@ TEST_F(FieldStringTests, GetStringInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetString(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetString(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -231,14 +231,14 @@ TEST_F(FieldDateTimeTests, UpdateDateTimeValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddDateTime(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateDateTime(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldDateTimeTests, UpdateDateTimeInvalidType)
@@ -248,14 +248,14 @@ TEST_F(FieldDateTimeTests, UpdateDateTimeInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, 'A');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateDateTime(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldDateTimeTests, UpdateDateTimeInValid)
@@ -265,15 +265,15 @@ TEST_F(FieldDateTimeTests, UpdateDateTimeInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateDateTime(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateDateTime(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldDateTimeTests, GetDateTimeValid)
@@ -283,42 +283,42 @@ TEST_F(FieldDateTimeTests, GetDateTimeValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
//DateTime
ret = aBridge->msgPayloadAddDateTime(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//String
ret = aBridge->msgPayloadAddString(msg, NULL, 2, m_str);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 2, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//F64
ret = aBridge->msgPayloadAddF64(msg, NULL, 3, 123456.009);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 3, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//I64
ret = aBridge->msgPayloadAddI64(msg, NULL, 4, 1234556);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 4, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//U64
ret = aBridge->msgPayloadAddU64(msg, NULL, 5, 1234556);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 5, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);



@@ -333,14 +333,14 @@ TEST_F(FieldDateTimeTests, GetDateTimeInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldDateTimeTests, GetDateTimeInValid)
@@ -349,7 +349,7 @@ TEST_F(FieldDateTimeTests, GetDateTimeInValid)

/*Null Field*/
ret = aBridge->msgFieldPayloadGetDateTime(NULL, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

/**********************************************************************
@@ -387,14 +387,14 @@ TEST_F(FieldOpaqueTests, GetOpaqueValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddOpaque(msg, NULL, 1, m_in, in_size);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetOpaque(field, &m_out, &out_size);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldOpaqueTests, GetOpaqueInvalidType)
@@ -404,14 +404,14 @@ TEST_F(FieldOpaqueTests, GetOpaqueInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetOpaque(field, &m_out, &out_size);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldOpaqueTests, GetOpaqueInValid)
@@ -420,15 +420,15 @@ TEST_F(FieldOpaqueTests, GetOpaqueInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetOpaque(NULL, &m_out, &out_size);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetOpaque(field, &m_out, &out_size);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -468,14 +468,14 @@ TEST_F(FieldPriceTests, UpdatePriceValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddPrice(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdatePrice(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldPriceTests, UpdatePriceInvalidType)
@@ -485,14 +485,14 @@ TEST_F(FieldPriceTests, UpdatePriceInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, 'A');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdatePrice(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldPriceTests, UpdatePriceInValid)
@@ -502,15 +502,15 @@ TEST_F(FieldPriceTests, UpdatePriceInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdatePrice(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdatePrice(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldPriceTests, GetPriceValid)
@@ -520,21 +520,21 @@ TEST_F(FieldPriceTests, GetPriceValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
//Price
ret = aBridge->msgPayloadAddPrice(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetPrice(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//F64
ret = aBridge->msgPayloadAddF64(msg, NULL, 3, 123456.009);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 3, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetPrice(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldPriceTests, GetPriceInvalidType)
@@ -544,14 +544,14 @@ TEST_F(FieldPriceTests, GetPriceInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetPrice(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldPriceTests, GetPriceInValid)
@@ -560,7 +560,7 @@ TEST_F(FieldPriceTests, GetPriceInValid)

/*Null Field*/
ret = aBridge->msgFieldPayloadGetPrice(NULL, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

/**********************************************************************
@@ -595,14 +595,14 @@ TEST_F(FieldMsgTests, GetMsgValid)

aBridge->msgPayloadCreate(&m_in);
ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddMsg(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetMsg(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

aBridge->msgPayloadDestroy(m_in);
}
@@ -615,14 +615,14 @@ TEST_F(FieldMsgTests, GetMsgInvalidType)

aBridge->msgPayloadCreate(&m_in);
ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetMsg(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);

aBridge->msgPayloadDestroy(m_in);
}
@@ -635,15 +635,15 @@ TEST_F(FieldMsgTests, GetMsgInValid)
aBridge->msgPayloadCreate(&m_in);

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetMsg(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetMsg(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);

aBridge->msgPayloadDestroy(m_in);
}
diff --git a/mama/c_cpp/src/gunittest/c/payload/fieldvectortests.cpp b/mama/c_cpp/src/gunittest/c/payload/fieldvectortests.cpp
index a857504..9c701c8 100644
--- a/mama/c_cpp/src/gunittest/c/payload/fieldvectortests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/fieldvectortests.cpp
@@ -64,14 +64,14 @@ protected:
mama_loadPayloadBridge(&m_payloadBridge, m_payload.c_str());

m_status = m_payloadBridge->msgPayloadCreate(&m_msg);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
}

// Common TearDown
virtual void TearDown()
{
m_status = m_payloadBridge->msgPayloadDestroy(m_msg);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
}
};

@@ -118,19 +118,19 @@ TEST_F(FieldVectorBoolTests, GetVectorBool)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorBool(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorBoolTests, GetVectorBoolNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorBool(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorBoolTests, GetVectorBoolNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorBool(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

/**
@@ -177,22 +177,22 @@ TEST_F(FieldVectorCharTests, GetVectorChar)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorChar(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 'X');
- ASSERT_EQ(m_out[1], 'Y');
- ASSERT_EQ(m_size, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ ('X', m_out[0]);
+ ASSERT_EQ ('Y', m_out[1]);
+ ASSERT_EQ ((mama_size_t)VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorCharTests, GetVectorCharNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorChar(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorCharTests, GetVectorCharNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorChar(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -239,22 +239,22 @@ TEST_F(FieldVectorI8Tests, GetVectorI8)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorI8(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 1);
- ASSERT_EQ(m_out[1], 2);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE * sizeof(mama_i8_t));
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (1, m_out[0]);
+ ASSERT_EQ (2, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE * sizeof(mama_i8_t), m_size);
}

TEST_F(FieldVectorI8Tests, GetVectorI8NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI8(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorI8Tests, GetVectorI8NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI8(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -303,22 +303,22 @@ TEST_F(FieldVectorU8Tests, GetVectorU8)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorU8(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 128);
- ASSERT_EQ(m_out[1], 255);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (128, m_out[0]);
+ ASSERT_EQ (255, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorU8Tests, GetVectorU8NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU8(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorU8Tests, GetVectorU8NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU8(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -369,22 +369,22 @@ TEST_F(FieldVectorI16Tests, GetVectorI16)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorI16(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], -32768);
- ASSERT_EQ(m_out[1], 32767);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (-32768, m_out[0]);
+ ASSERT_EQ (32767, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorI16Tests, GetVectorI16NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI16(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorI16Tests, GetVectorI16NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI16(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -432,22 +432,22 @@ TEST_F(FieldVectorU16Tests, GetVectorU16)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorU16(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 32768);
- ASSERT_EQ(m_out[1], 65535);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (32768, m_out[0]);
+ ASSERT_EQ (65535, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorU16Tests, GetVectorU16NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU16(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorU16Tests, GetVectorU16NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU16(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -494,22 +494,22 @@ TEST_F(FieldVectorI32Tests, GetVectorI32)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorI32(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], -214783648);
- ASSERT_EQ(m_out[1], 214783647);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (-214783648, m_out[0]);
+ ASSERT_EQ (214783647, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorI32Tests, GetVectorI32NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI32(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorI32Tests, GetVectorI32NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI32(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -556,22 +556,22 @@ TEST_F(FieldVectorU32Tests, GetVectorU32)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorU32(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 2147483648);
- ASSERT_EQ(m_out[1], 4294967295);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (2147483648, m_out[0]);
+ ASSERT_EQ (4294967295, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorU32Tests, GetVectorU32NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU32(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorU32Tests, GetVectorU32NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU32(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -622,22 +622,22 @@ TEST_F(FieldVectorI64Tests, GetVectorI64)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorI64(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], -9223372036854775807);
- ASSERT_EQ(m_out[1], 9223372036854775807);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (-9223372036854775807, m_out[0]);
+ ASSERT_EQ (9223372036854775807, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorI64Tests, GetVectorI64NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI64(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorI64Tests, GetVectorI64NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI64(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -693,22 +693,22 @@ TEST_F(FieldVectorU64Tests, GetVectorU64)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorU64(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], FieldVectorU64Tests::LARGE_NUM_1);
- ASSERT_EQ(m_out[1], FieldVectorU64Tests::LARGE_NUM_2);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (FieldVectorU64Tests::LARGE_NUM_1, m_out[0]);
+ ASSERT_EQ (FieldVectorU64Tests::LARGE_NUM_2, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorU64Tests, GetVectorU64NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU64(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorU64Tests, GetVectorU64NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU64(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -755,22 +755,22 @@ TEST_F(FieldVectorF32Tests, GetVectorF32)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorF32(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 1.0f);
- ASSERT_EQ(m_out[1], 2.0f);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (1.0f, m_out[0]);
+ ASSERT_EQ (2.0f, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorF32Tests, GetVectorF32NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorF32(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorF32Tests, GetVectorF32NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorF32(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -817,22 +817,22 @@ TEST_F(FieldVectorF64Tests, GetVectorF64)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorF64(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 1.0f);
- ASSERT_EQ(m_out[1], 2.0f);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (1.0f, m_out[0]);
+ ASSERT_EQ (2.0f, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorF64Tests, GetVectorF64NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorF64(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorF64Tests, GetVectorF64NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorF64(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -879,22 +879,22 @@ TEST_F(FieldVectorStringTests, GetVectorString)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorString(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_STREQ(m_out[0], "ABC");
- EXPECT_STREQ(m_out[1], "XYZ");
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_STREQ ("ABC", m_out[0]);
+ EXPECT_STREQ ("XYZ", m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorStringTests, GetVectorStringNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorString(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorStringTests, GetVectorStringNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorString(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -958,19 +958,19 @@ protected:
TEST_F(FieldVectorDateTimeTests, GetVectorDateTime)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorDateTime(m_field, m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorDateTimeTests, GetVectorDateTimeNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorDateTime(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorDateTimeTests, GetVectorDateTimeNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorDateTime(m_field, m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

/**
@@ -1036,19 +1036,19 @@ protected:
TEST_F(FieldVectorPriceTests, GetVectorPrice)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorPrice(m_field, m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorPriceTests, GetVectorPriceNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorPrice(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorPriceTests, GetVectorPriceNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorPrice(m_field, m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

/**
@@ -1114,24 +1114,24 @@ TEST_F(FieldVectorSubMsgTests, GetVectorSubMsg)
char testName;

m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

// The following is to populate impl->mWombatField
m_status = m_payloadBridge->msgPayloadGetField(m_msg, &testName, 1, &m_field);

m_status = m_payloadBridge->msgFieldPayloadGetVectorMsg(m_field, &m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorSubMsgTests, GetVectorSubMsgNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorMsg(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorSubMsgTests, GetVectorSubMsgNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorMsg(m_field, &m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}
diff --git a/mama/c_cpp/src/gunittest/c/payload/payloadatomictests.cpp b/mama/c_cpp/src/gunittest/c/payload/payloadatomictests.cpp
index 8925a94..6e16fbb 100644
--- a/mama/c_cpp/src/gunittest/c/payload/payloadatomictests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/payloadatomictests.cpp
@@ -68,15 +68,15 @@ TEST_F(PayloadAtomicTestsC, addBoolValid)

/* Adding the boolean to payload. */
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the boolean from the payload. */
res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addBoolInvalidFID)
@@ -86,9 +86,9 @@ TEST_F(PayloadAtomicTestsC, addBoolInvalidFID)

/* Adding the boolean to the payload */
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F (PayloadAtomicTestsC, addBoolInValidName)
@@ -98,9 +98,9 @@ TEST_F (PayloadAtomicTestsC, addBoolInValidName)

/* Adding the boolean to payload */
res = m_payloadBridge->msgPayloadAddBool(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addBoolNullPayload)
@@ -110,7 +110,7 @@ TEST_F(PayloadAtomicTestsC, addBoolNullPayload)

/* Adding the boolean to payload. */
res = m_payloadBridge->msgPayloadAddBool(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addCharValid)
@@ -121,15 +121,15 @@ TEST_F(PayloadAtomicTestsC, addCharValid)

/* Adding the char to payload. */
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);

/* Recover the char from the payload. */
res = m_payloadBridge->msgPayloadGetChar(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Test initial and returned values match. */
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addCharInValidFID)
@@ -138,9 +138,9 @@ TEST_F(PayloadAtomicTestsC, addCharInValidFID)
mama_status res;
/* Adding the char to payload. */
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addCharInValidName)
@@ -150,9 +150,9 @@ TEST_F(PayloadAtomicTestsC, addCharInValidName)

/* Adding the char to the payload */
res = m_payloadBridge->msgPayloadAddChar(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addCharNullPayload)
@@ -162,7 +162,7 @@ TEST_F(PayloadAtomicTestsC, addCharNullPayload)

/* Adding the char to payload. */
res = m_payloadBridge->msgPayloadAddChar(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI8Valid)
@@ -173,14 +173,14 @@ TEST_F(PayloadAtomicTestsC, addI8Valid)

/* Adding the i8 to the payload */
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 2, initialValue);
/* Recover the i8 from the payload */
res = m_payloadBridge->msgPayloadGetI8(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addI8InValidFID)
@@ -190,9 +190,9 @@ TEST_F(PayloadAtomicTestsC, addI8InValidFID)

/* Adding the I8 to payload. */
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI8InValidName)
@@ -202,9 +202,9 @@ TEST_F(PayloadAtomicTestsC, addI8InValidName)

/* Adding the I8 to the payload */
res = m_payloadBridge->msgPayloadAddI8(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI8NullPayload)
@@ -214,7 +214,7 @@ TEST_F(PayloadAtomicTestsC, addI8NullPayload)

/* Adding the I8 to payload. */
res = m_payloadBridge->msgPayloadAddI8(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU8Valid)
@@ -225,15 +225,15 @@ TEST_F(PayloadAtomicTestsC, addU8Valid)

/* Adding the u8 to the payload */
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the u8 from the payload */
res = m_payloadBridge->msgPayloadGetU8(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addU8InValidFID)
@@ -244,9 +244,9 @@ TEST_F(PayloadAtomicTestsC, addU8InValidFID)

/* Adding the U8 to payload. */
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU8InValidName)
@@ -257,9 +257,9 @@ TEST_F(PayloadAtomicTestsC, addU8InValidName)

/* Adding the U8 to the payload */
res = m_payloadBridge->msgPayloadAddU8(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU8NullPayload)
@@ -269,7 +269,7 @@ TEST_F(PayloadAtomicTestsC, addU8NullPayload)

/* Adding the U8 to payload. */
res = m_payloadBridge->msgPayloadAddU8(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI16Valid)
@@ -280,14 +280,14 @@ TEST_F(PayloadAtomicTestsC, addI16Valid)

/* Adding the i16 to the payload */
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 2, initialValue);
/* Recover the i16 from the payload */
res = m_payloadBridge->msgPayloadGetI16(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addI16InValidFID)
@@ -297,9 +297,9 @@ TEST_F(PayloadAtomicTestsC, addI16InValidFID)

/* Adding the I16 to payload. */
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI16InValidName)
@@ -309,9 +309,9 @@ TEST_F(PayloadAtomicTestsC, addI16InValidName)

/* Adding the I16 to the payload */
res = m_payloadBridge->msgPayloadAddI16(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI16NullPayload)
@@ -321,7 +321,7 @@ TEST_F(PayloadAtomicTestsC, addI16NullPayload)

/* Adding the I16 to payload. */
res = m_payloadBridge->msgPayloadAddI16(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU16Valid)
@@ -332,15 +332,15 @@ TEST_F(PayloadAtomicTestsC, addU16Valid)

/* Adding the u16 to the payload */
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the u16 from the payload */
res = m_payloadBridge->msgPayloadGetU16(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addU16InValidFID)
@@ -350,9 +350,9 @@ TEST_F(PayloadAtomicTestsC, addU16InValidFID)

/* Adding the U16 to payload. */
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU16InValidName)
@@ -362,9 +362,9 @@ TEST_F(PayloadAtomicTestsC, addU16InValidName)

/* Adding the U16 to the payload */
res = m_payloadBridge->msgPayloadAddU16(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU16NullPayload)
@@ -374,7 +374,7 @@ TEST_F(PayloadAtomicTestsC, addU16NullPayload)

/* Adding the U16 to payload. */
res = m_payloadBridge->msgPayloadAddU16(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI32Valid)
@@ -385,15 +385,15 @@ TEST_F(PayloadAtomicTestsC, addI32Valid)

/* Adding the i32 to the payload */
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the i32 from the payload */
res = m_payloadBridge->msgPayloadGetI32(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addI32InValidFID)
@@ -403,9 +403,9 @@ TEST_F(PayloadAtomicTestsC, addI32InValidFID)

/* Adding the I32 to payload. */
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI32InValidName)
@@ -415,9 +415,9 @@ TEST_F(PayloadAtomicTestsC, addI32InValidName)

/* Adding the I32 to the payload */
res = m_payloadBridge->msgPayloadAddI32(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI32NullPayload)
@@ -427,7 +427,7 @@ TEST_F(PayloadAtomicTestsC, addI32NullPayload)

/* Adding the I32 to payload. */
res = m_payloadBridge->msgPayloadAddI32(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU32Valid)
@@ -438,16 +438,16 @@ TEST_F(PayloadAtomicTestsC, addU32Valid)

/* Adding the u32 to the payload */
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);

/* Recover the u32 from the payload */
res = m_payloadBridge->msgPayloadGetU32(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addU32InValidFID)
@@ -457,9 +457,9 @@ TEST_F(PayloadAtomicTestsC, addU32InValidFID)

/* Adding the U32 to payload. */
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU32InValidName)
@@ -469,9 +469,9 @@ TEST_F(PayloadAtomicTestsC, addU32InValidName)

/* Adding the U32 to the payload */
res = m_payloadBridge->msgPayloadAddU32(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU32NullPayload)
@@ -481,7 +481,7 @@ TEST_F(PayloadAtomicTestsC, addU32NullPayload)

/* Adding the U32 to payload. */
res = m_payloadBridge->msgPayloadAddU32(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI64Valid)
@@ -492,16 +492,16 @@ TEST_F(PayloadAtomicTestsC, addI64Valid)

/* Adding the i64 to the payload */
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);

/* Recover the i64 from the payload */
res = m_payloadBridge->msgPayloadGetI64(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addI64InValidFID)
@@ -511,9 +511,9 @@ TEST_F(PayloadAtomicTestsC, addI64InValidFID)

/* Adding the I64 to payload. */
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI64InValidName)
@@ -523,9 +523,9 @@ TEST_F(PayloadAtomicTestsC, addI64InValidName)

/* Adding the I64 to the payload */
res = m_payloadBridge->msgPayloadAddI64(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI64NullPayload)
@@ -535,7 +535,7 @@ TEST_F(PayloadAtomicTestsC, addI64NullPayload)

/* Adding the I64 to payload. */
res = m_payloadBridge->msgPayloadAddI64(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU64Valid)
@@ -546,15 +546,15 @@ TEST_F(PayloadAtomicTestsC, addU64Valid)

/* Adding the u64 to the payload */
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the u64 from the payload */
res = m_payloadBridge->msgPayloadGetU64(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addU64InValidFID)
@@ -564,9 +564,9 @@ TEST_F(PayloadAtomicTestsC, addU64InValidFID)

/* Adding the U64 to payload. */
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU64InValidName)
@@ -576,9 +576,9 @@ TEST_F(PayloadAtomicTestsC, addU64InValidName)

/* Adding the U64 to the payload */
res = m_payloadBridge->msgPayloadAddU64(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU64NullPayload)
@@ -588,7 +588,7 @@ TEST_F(PayloadAtomicTestsC, addU64NullPayload)

/* Adding the U64 to payload. */
res = m_payloadBridge->msgPayloadAddU64(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF32Valid)
@@ -599,16 +599,16 @@ TEST_F(PayloadAtomicTestsC, addF32Valid)

/* Adding the f32 to the payload */
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);

/* Recover the f32 from the payload */
res = m_payloadBridge->msgPayloadGetF32(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addF32InValidFID)
@@ -618,9 +618,9 @@ TEST_F(PayloadAtomicTestsC, addF32InValidFID)

/* Adding the F32 to payload. */
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF32InValidName)
@@ -630,9 +630,9 @@ TEST_F(PayloadAtomicTestsC, addF32InValidName)

/* Adding the F32 to the payload */
res = m_payloadBridge->msgPayloadAddF32(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF32NullPayload)
@@ -642,7 +642,7 @@ TEST_F(PayloadAtomicTestsC, addF32NullPayload)

/* Adding the F32 to payload. */
res = m_payloadBridge->msgPayloadAddF32(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF64Valid)
@@ -653,15 +653,15 @@ TEST_F(PayloadAtomicTestsC, addF64Valid)

/* Adding the f64 to the payload */
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 2, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the f64 from the payload */
res = m_payloadBridge->msgPayloadGetF64(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addF64InValidFID)
@@ -671,9 +671,9 @@ TEST_F(PayloadAtomicTestsC, addF64InValidFID)

/* Adding the F64 to payload. */
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF64InValidName)
@@ -683,9 +683,9 @@ TEST_F(PayloadAtomicTestsC, addF64InValidName)

/* Adding the F64 to the payload */
res = m_payloadBridge->msgPayloadAddF64(m_payload, "testValue", 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 0, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF64NullPayload)
@@ -695,7 +695,7 @@ TEST_F(PayloadAtomicTestsC, addF64NullPayload)

/* Adding the F64 to payload. */
res = m_payloadBridge->msgPayloadAddF64(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

/************************************************
@@ -711,21 +711,21 @@ TEST_F(PayloadAtomicTestsC, updateBoolValid)

/* Adding the boolean to payload. */
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 1, initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Check the stored value. */
res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(initialValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);

/* Update the payload with the value from another bool.*/
res = m_payloadBridge->msgPayloadUpdateBool(m_payload, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the boolean from the payload. */
res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateBoolNullPayload)
@@ -734,7 +734,7 @@ TEST_F(PayloadAtomicTestsC, updateBoolNullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateBool(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateCharValid)
@@ -754,8 +754,8 @@ TEST_F(PayloadAtomicTestsC, updateCharValid)
res = m_payloadBridge->msgPayloadGetChar(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateCharNullPayload)
@@ -764,7 +764,7 @@ TEST_F(PayloadAtomicTestsC, updateCharNullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateChar(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateU8Valid)
@@ -784,8 +784,8 @@ TEST_F(PayloadAtomicTestsC, updateU8Valid)
res = m_payloadBridge->msgPayloadGetU8(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateU8NullPayload)
@@ -794,7 +794,7 @@ TEST_F(PayloadAtomicTestsC, updateU8NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateU8(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateI8Valid)
@@ -814,8 +814,8 @@ TEST_F(PayloadAtomicTestsC, updateI8Valid)
res = m_payloadBridge->msgPayloadGetI8(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateI8NullPayload)
@@ -824,7 +824,7 @@ TEST_F(PayloadAtomicTestsC, updateI8NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateI8(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateI16Valid)
@@ -844,8 +844,8 @@ TEST_F(PayloadAtomicTestsC, updateI16Valid)
res = m_payloadBridge->msgPayloadGetI16(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateI16NullPayload)
@@ -854,7 +854,7 @@ TEST_F(PayloadAtomicTestsC, updateI16NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateI16(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateU16Valid)
@@ -874,8 +874,8 @@ TEST_F(PayloadAtomicTestsC, updateU16Valid)
res = m_payloadBridge->msgPayloadGetU16(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateU16NullPayload)
@@ -884,7 +884,7 @@ TEST_F(PayloadAtomicTestsC, updateU16NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateU16(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}


@@ -905,8 +905,8 @@ TEST_F(PayloadAtomicTestsC, updateI32Valid)
res = m_payloadBridge->msgPayloadGetI32(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateI32NullPayload)
@@ -915,7 +915,7 @@ TEST_F(PayloadAtomicTestsC, updateI32NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateI32(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateU32Valid)
@@ -935,8 +935,8 @@ TEST_F(PayloadAtomicTestsC, updateU32Valid)
res = m_payloadBridge->msgPayloadGetU32(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateU32NullPayload)
@@ -945,7 +945,7 @@ TEST_F(PayloadAtomicTestsC, updateU32NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateU32(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateF32Valid)
@@ -965,8 +965,8 @@ TEST_F(PayloadAtomicTestsC, updateF32Valid)
res = m_payloadBridge->msgPayloadGetF32(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateF32NullPayload)
@@ -975,7 +975,7 @@ TEST_F(PayloadAtomicTestsC, updateF32NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateF32(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateF64Valid)
@@ -995,8 +995,8 @@ TEST_F(PayloadAtomicTestsC, updateF64Valid)
res = m_payloadBridge->msgPayloadGetF64(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateF64NullPayload)
@@ -1005,7 +1005,7 @@ TEST_F(PayloadAtomicTestsC, updateF64NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateF64(NULL, NULL, 1, updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}
/************************************************
* Tests which get the payload *
@@ -1024,8 +1024,8 @@ TEST_F(PayloadAtomicTestsC, getBoolValid)
res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getBoolInValid)
@@ -1034,7 +1034,7 @@ TEST_F(PayloadAtomicTestsC, getBoolInValid)
mama_bool_t returnedValue = (mama_bool_t)0;

res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getCharValid)
@@ -1050,8 +1050,8 @@ TEST_F(PayloadAtomicTestsC, getCharValid)
res = m_payloadBridge->msgPayloadGetChar(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getCharInValid)
@@ -1060,7 +1060,7 @@ TEST_F(PayloadAtomicTestsC, getCharInValid)
char returnedValue = 'A';

res = m_payloadBridge->msgPayloadGetChar(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getI8Valid)
@@ -1076,8 +1076,8 @@ TEST_F(PayloadAtomicTestsC, getI8Valid)
res = m_payloadBridge->msgPayloadGetI8(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getI8InValid)
@@ -1086,7 +1086,7 @@ TEST_F(PayloadAtomicTestsC, getI8InValid)
mama_i8_t returnedValue = (mama_i8_t)0;

res = m_payloadBridge->msgPayloadGetI8(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getU8Valid)
@@ -1102,8 +1102,8 @@ TEST_F(PayloadAtomicTestsC, getU8Valid)
res = m_payloadBridge->msgPayloadGetU8(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getU8InValid)
@@ -1112,7 +1112,7 @@ TEST_F(PayloadAtomicTestsC, getU8InValid)
mama_u8_t returnedValue = (mama_u8_t)0;

res = m_payloadBridge->msgPayloadGetU8(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getI16Valid)
@@ -1128,8 +1128,8 @@ TEST_F(PayloadAtomicTestsC, getI16Valid)
res = m_payloadBridge->msgPayloadGetI16(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getI16InValid)
@@ -1138,7 +1138,7 @@ TEST_F(PayloadAtomicTestsC, getI16InValid)
mama_i16_t returnedValue = (mama_i16_t)0;

res = m_payloadBridge->msgPayloadGetI16(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getU16Valid)
@@ -1154,8 +1154,8 @@ TEST_F(PayloadAtomicTestsC, getU16Valid)
res = m_payloadBridge->msgPayloadGetU16(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getU16InValid)
@@ -1164,7 +1164,7 @@ TEST_F(PayloadAtomicTestsC, getU16InValid)
mama_u16_t returnedValue = (mama_u16_t)0;

res = m_payloadBridge->msgPayloadGetU16(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getI32Valid)
@@ -1180,8 +1180,8 @@ TEST_F(PayloadAtomicTestsC, getI32Valid)
res = m_payloadBridge->msgPayloadGetI32(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getI32InValid)
@@ -1190,7 +1190,7 @@ TEST_F(PayloadAtomicTestsC, getI32InValid)
mama_i32_t returnedValue = (mama_i32_t)0;

res = m_payloadBridge->msgPayloadGetI32(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getU32Valid)
@@ -1206,8 +1206,8 @@ TEST_F(PayloadAtomicTestsC, getU32Valid)
res = m_payloadBridge->msgPayloadGetU32(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getU32InValid)
@@ -1216,7 +1216,7 @@ TEST_F(PayloadAtomicTestsC, getU32InValid)
mama_u32_t returnedValue = (mama_u32_t)0;

res = m_payloadBridge->msgPayloadGetU32(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getI64Valid)
@@ -1232,8 +1232,8 @@ TEST_F(PayloadAtomicTestsC, getI64Valid)
res = m_payloadBridge->msgPayloadGetI64(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getI64InValid)
@@ -1242,7 +1242,7 @@ TEST_F(PayloadAtomicTestsC, getI64InValid)
mama_i64_t returnedValue = (mama_i64_t)0;

res = m_payloadBridge->msgPayloadGetI64(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getU64Valid)
@@ -1258,8 +1258,8 @@ TEST_F(PayloadAtomicTestsC, getU64Valid)
res = m_payloadBridge->msgPayloadGetU64(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getU64InValid)
@@ -1268,7 +1268,7 @@ TEST_F(PayloadAtomicTestsC, getU64InValid)
mama_u64_t returnedValue = (mama_u64_t)0;

res = m_payloadBridge->msgPayloadGetU64(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getF32Valid)
@@ -1284,8 +1284,8 @@ TEST_F(PayloadAtomicTestsC, getF32Valid)
res = m_payloadBridge->msgPayloadGetF32(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getF32InValid)
@@ -1294,7 +1294,7 @@ TEST_F(PayloadAtomicTestsC, getF32InValid)
mama_f32_t returnedValue = (mama_f32_t)0;

res = m_payloadBridge->msgPayloadGetF32(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getF64Valid)
@@ -1310,8 +1310,8 @@ TEST_F(PayloadAtomicTestsC, getF64Valid)
res = m_payloadBridge->msgPayloadGetF64(m_payload, NULL, 1, &returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getF64InValid)
@@ -1320,6 +1320,6 @@ TEST_F(PayloadAtomicTestsC, getF64InValid)
mama_f64_t returnedValue = (mama_f64_t)0;

res = m_payloadBridge->msgPayloadGetF64(m_payload, NULL, 1, &returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

diff --git a/mama/c_cpp/src/gunittest/c/payload/payloadcompositetests.cpp b/mama/c_cpp/src/gunittest/c/payload/payloadcompositetests.cpp
index 3a6af02..48cc6b0 100644
--- a/mama/c_cpp/src/gunittest/c/payload/payloadcompositetests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/payloadcompositetests.cpp
@@ -59,14 +59,14 @@ protected:

mama_loadPayloadBridge(&m_payloadBridge, m_payload.c_str());
m_status = m_payloadBridge->msgPayloadCreate(&m_msg);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
}

// Common TearDown
virtual void TearDown()
{
m_status = m_payloadBridge->msgPayloadDestroy(m_msg);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//ForkedTest::TearDown();
}
@@ -112,20 +112,20 @@ protected:
TEST_F(PayloadStringTests, AddString)
{
m_status = m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadStringTests, AddStringNullAdd)
{
ASSERT_NO_FATAL_FAILURE(m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, NULL));
m_status = m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadStringTests, AddStringNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddString(NULL, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -138,7 +138,7 @@ TEST_F(PayloadStringTests, UpdateString)
m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdateString(m_msg, NULL, 1, m_update);
m_payloadBridge->msgPayloadGetString(m_msg, NULL, 1, &m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
EXPECT_STREQ(m_out, m_update);
}

@@ -146,20 +146,20 @@ TEST_F(PayloadStringTests, UpdateStringNoAdd)
{
m_status = m_payloadBridge->msgPayloadUpdateString(m_msg, NULL, 1, m_update);
m_payloadBridge->msgPayloadGetString(m_msg, NULL, 1, &m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
EXPECT_STREQ(m_out, m_update);
}

TEST_F(PayloadStringTests, UpdateStringNullUpdate)
{
m_status = m_payloadBridge->msgPayloadUpdateString(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadStringTests, UpdateStringNullMessage)
{
m_status = m_payloadBridge->msgPayloadUpdateString(NULL, NULL, 1, m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -171,7 +171,7 @@ TEST_F(PayloadStringTests, GetString)
{
m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetString(m_msg, NULL, 1, &m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
EXPECT_STREQ(m_out, m_in);
}

@@ -179,14 +179,14 @@ TEST_F(PayloadStringTests, GetStringNullOutput)
{
m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetString(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadStringTests, GetStringNullMessage)
{
m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetString(NULL, NULL, 1, &m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -232,19 +232,19 @@ protected:
TEST_F(PayloadOpaqueTests, AddOpaque)
{
m_status = m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadOpaqueTests, AddOpaqueNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, NULL, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadOpaqueTests, AddOpaqueNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddOpaque(NULL, NULL, 1, (void*)&m_in, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -258,9 +258,9 @@ TEST_F(PayloadOpaqueTests, UpdateOpaque)
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in, sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadUpdateOpaque(m_msg, NULL, 1, (void*)&m_update, sizeof(uint32_t));
m_payloadBridge->msgPayloadGetOpaque(m_msg, NULL, 1, (const void**)&m_out, &size);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(std::memcmp((void*)&m_update, (void*)m_out, sizeof(uint32_t)), 0);
- EXPECT_EQ(size, sizeof(uint32_t));
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, std::memcmp((void*)&m_update, (void*)m_out, sizeof(uint32_t)));
+ EXPECT_EQ (sizeof(uint32_t), size);
}

TEST_F(PayloadOpaqueTests, UpdateOpaqueNoAdd)
@@ -268,23 +268,23 @@ TEST_F(PayloadOpaqueTests, UpdateOpaqueNoAdd)
mama_size_t size;
m_status = m_payloadBridge->msgPayloadUpdateOpaque(m_msg, NULL, 1, (void*)&m_update, sizeof(uint32_t));
m_payloadBridge->msgPayloadGetOpaque(m_msg, NULL, 1, (const void**)&m_out, &size);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(std::memcmp((void*)&m_update, (void*)m_out, sizeof(uint32_t)), 0);
- EXPECT_EQ(size, sizeof(uint32_t));
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, std::memcmp((void*)&m_update, (void*)m_out, sizeof(uint32_t)));
+ EXPECT_EQ (sizeof(uint32_t), size);
}

TEST_F(PayloadOpaqueTests, UpdateOpaqueNullUpdate)
{
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in, sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadUpdateOpaque(m_msg, NULL, 1, NULL, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadOpaqueTests, UpdateOpaqueNullMessage)
{
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in, sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadUpdateOpaque(NULL, NULL, 1, (void*)&m_update, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -297,9 +297,9 @@ TEST_F(PayloadOpaqueTests, GetOpaque)
mama_size_t size (0);
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in, sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadGetOpaque(m_msg, NULL, 1, (const void**)&m_out, &size);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(std::memcmp((void*)&m_in, (void*)m_out, sizeof(uint32_t)), 0);
- EXPECT_EQ(size, sizeof(uint32_t));
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, std::memcmp((void*)&m_in, (void*)m_out, sizeof(uint32_t)));
+ EXPECT_EQ (sizeof(uint32_t), size);
}

TEST_F(PayloadOpaqueTests, GetOpaqueNullOutput)
@@ -307,7 +307,7 @@ TEST_F(PayloadOpaqueTests, GetOpaqueNullOutput)
mama_size_t size (0);
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in, sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadGetOpaque(m_msg, NULL, 1, NULL, &size);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadOpaqueTests, GetOpaqueNullMessage)
@@ -315,7 +315,7 @@ TEST_F(PayloadOpaqueTests, GetOpaqueNullMessage)
mama_size_t size (0);
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in, sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadAddOpaque(NULL, NULL, 1, (void*)&m_in, size);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -367,19 +367,19 @@ protected:
TEST_F(PayloadDateTimeTests, AddDateTime)
{
m_status = m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadDateTimeTests, AddDateTimeNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadDateTimeTests, AddDateTimeNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddDateTime(NULL, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}


@@ -393,30 +393,30 @@ TEST_F(PayloadDateTimeTests, UpdateDateTime)
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdateDateTime(m_msg, NULL, 1, m_update);
m_payloadBridge->msgPayloadGetDateTime(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaDateTime_equal(m_out, m_update), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaDateTime_equal(m_out, m_update));
}

TEST_F(PayloadDateTimeTests, UpdateDateTimeNoAdd)
{
m_status = m_payloadBridge->msgPayloadUpdateDateTime(m_msg, NULL, 1, m_update);
m_payloadBridge->msgPayloadGetDateTime(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaDateTime_equal(m_out, m_update), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaDateTime_equal(m_out, m_update));
}

TEST_F(PayloadDateTimeTests, UpdateDateTimeNullUpdate)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdateDateTime(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadDateTimeTests, UpdateDateTimeNullMessage)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdateDateTime(NULL, NULL, 1, m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -428,22 +428,22 @@ TEST_F(PayloadDateTimeTests, GetDateTime)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetDateTime(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaDateTime_equal(m_in, m_out), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaDateTime_equal(m_in, m_out));
}

TEST_F(PayloadDateTimeTests, GetDateTimeNullOutput)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetDateTime(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadDateTimeTests, GetDateTimeNullMessage)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetDateTime(NULL, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -496,20 +496,20 @@ TEST_F(PayloadPriceTests, AddPrice)
{
m_status = m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaPrice_equal(m_out, m_in), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaPrice_equal(m_out, m_in));
}

TEST_F(PayloadPriceTests, AddPriceNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadPriceTests, AddPriceNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddPrice(NULL, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -522,30 +522,30 @@ TEST_F(PayloadPriceTests, UpdatePrice)
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdatePrice(m_msg, NULL, 1, m_update);
m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaPrice_equal(m_out, m_update), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaPrice_equal(m_out, m_update));
}

TEST_F(PayloadPriceTests, UpdatePriceNoAdd)
{
m_status = m_payloadBridge->msgPayloadUpdatePrice(m_msg, NULL, 1, m_update);
m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaPrice_equal(m_out, m_update), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaPrice_equal(m_out, m_update));
}

TEST_F(PayloadPriceTests, UpdatePriceNullUpdate)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdatePrice(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadPriceTests, UpdatePriceNullMessage)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdatePrice(NULL, NULL, 1, m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -557,22 +557,22 @@ TEST_F(PayloadPriceTests, GetPrice)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaPrice_equal(m_in, m_out), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaPrice_equal(m_in, m_out));
}

TEST_F(PayloadPriceTests, GetPriceNullOutput)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadPriceTests, GetPriceNullMessage)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetPrice(NULL, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -616,19 +616,19 @@ protected:
TEST_F(PayloadSubMsgTests, AddSubMsg)
{
m_status = m_payloadBridge->msgPayloadAddMsg(m_msg, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadSubMsgTests, AddSubMsgNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddMsg(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadSubMsgTests, AddSubMsgNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddMsg(NULL, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -640,19 +640,19 @@ TEST_F(PayloadSubMsgTests, UpdateSubMsg)
{
/* TODO revist this */
m_status = m_payloadBridge->msgPayloadUpdateSubMsg(m_msg, NULL, 1, m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadSubMsgTests, UpdateSubMsgNullUpdate)
{
m_status = m_payloadBridge->msgPayloadUpdateSubMsg(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadSubMsgTests, UpdateSubMsgNullMessage)
{
m_status = m_payloadBridge->msgPayloadUpdateSubMsg(NULL, NULL, 1, m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -666,7 +666,7 @@ TEST_F(PayloadSubMsgTests, GetSubMsg)
m_payloadBridge->msgPayloadGetMsg(m_msg, NULL, 1, &m_out);
// m_payloadBridge->msgPayloadGetBool(m_in, NULL, 2, &a);
// m_payloadBridge->msgPayloadGetBool(m_in, NULL, 2, &b);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
// EXPECT_EQ(a|b, 0xFF);
// TODO: Fix
}
@@ -674,11 +674,11 @@ TEST_F(PayloadSubMsgTests, GetSubMsg)
TEST_F(PayloadSubMsgTests, GetSubMsgNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddMsg(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadSubMsgTests, GetSubMsgNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddMsg(NULL, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}
diff --git a/mama/c_cpp/src/gunittest/c/payload/payloadgeneraltests.cpp b/mama/c_cpp/src/gunittest/c/payload/payloadgeneraltests.cpp
index 32dd7cc..ccaa470 100644
--- a/mama/c_cpp/src/gunittest/c/payload/payloadgeneraltests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/payloadgeneraltests.cpp
@@ -78,14 +78,14 @@ TEST_F(PayloadGeneralTests, CreateValid)

result = aBridge->msgPayloadCreate(&testPayload);

- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, CreateInValid)
{
result = aBridge->msgPayloadCreate(NULL);

- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* OPTIONAL TEST:
@@ -102,7 +102,7 @@ TEST_F(PayloadGeneralTests, CreateForTemplateValid)

CHECK_NON_IMPLEMENTED_OPTIONAL(result);

- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetTypeValid)
@@ -119,10 +119,10 @@ TEST_F(PayloadGeneralTests, CopyValid)
msgPayload copyPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreate(&copyPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -130,7 +130,7 @@ TEST_F(PayloadGeneralTests, CopyValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadCopy(testPayload, &copyPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, CopyInValidPayload)
@@ -138,7 +138,7 @@ TEST_F(PayloadGeneralTests, CopyInValidPayload)
msgPayload copyPayload = NULL;

result = aBridge->msgPayloadCopy(NULL, &copyPayload);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* Requires discussion regarding what this test is actually expecting to check.
@@ -150,7 +150,7 @@ TEST_F(PayloadGeneralTests, CopyInValidCopy)
msgPayload copyPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -158,7 +158,7 @@ TEST_F(PayloadGeneralTests, CopyInValidCopy)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadCopy(testPayload, &copyPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, ClearValid)
@@ -166,16 +166,16 @@ TEST_F(PayloadGeneralTests, ClearValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadClear(testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, ClearInValid)
{
result = aBridge->msgPayloadClear(NULL);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, DestroyValid)
@@ -183,10 +183,10 @@ TEST_F(PayloadGeneralTests, DestroyValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadDestroy(testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, DestroyInValid)
@@ -194,10 +194,10 @@ TEST_F(PayloadGeneralTests, DestroyInValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadDestroy(NULL);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetParentValid)
@@ -206,10 +206,10 @@ TEST_F(PayloadGeneralTests, SetParentValid)
mamaMsg testParent = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetParent(testPayload, testParent);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, SetParentInValidPayload)
@@ -217,7 +217,7 @@ TEST_F(PayloadGeneralTests, SetParentInValidPayload)
mamaMsg testParent = NULL;

result = aBridge->msgPayloadSetParent(NULL, testParent);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetParentInValidParent)
@@ -225,7 +225,7 @@ TEST_F(PayloadGeneralTests, SetParentInValidParent)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadSetParent(testPayload, NULL);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteSizeValid)
@@ -234,7 +234,7 @@ TEST_F(PayloadGeneralTests, GetByteSizeValid)
mama_size_t testSize = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -245,7 +245,7 @@ TEST_F(PayloadGeneralTests, GetByteSizeValid)

CHECK_NON_IMPLEMENTED_OPTIONAL(result);

- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetByteSizeInValidPayload)
@@ -253,7 +253,7 @@ TEST_F(PayloadGeneralTests, GetByteSizeInValidPayload)
mama_size_t testSize = 0;

result = aBridge->msgPayloadGetByteSize(NULL, &testSize);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteSizeInValidSize)
@@ -261,7 +261,7 @@ TEST_F(PayloadGeneralTests, GetByteSizeInValidSize)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadGetByteSize(testPayload, NULL);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}


@@ -271,7 +271,7 @@ TEST_F(PayloadGeneralTests, GetNumberFieldsValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadAddChar(testPayload, NULL, 1, 'a');
result = aBridge->msgPayloadAddChar(testPayload, NULL, 2, 'b');
@@ -282,11 +282,11 @@ TEST_F(PayloadGeneralTests, GetNumberFieldsValid)
result = aBridge->msgPayloadAddChar(testPayload, NULL, 7, 'g');
result = aBridge->msgPayloadAddChar(testPayload, NULL, 8, 'h');
result = aBridge->msgPayloadAddChar(testPayload, NULL, 9, 'i');
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNumFields(testPayload, &numFields);
- EXPECT_EQ (result, MAMA_STATUS_OK);
- EXPECT_EQ (numFields, (mama_size_t)9);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
+ EXPECT_EQ ((mama_size_t)9, numFields);
}

TEST_F(PayloadGeneralTests, GetNumberFieldsInValidPayload)
@@ -294,7 +294,7 @@ TEST_F(PayloadGeneralTests, GetNumberFieldsInValidPayload)
mama_size_t numFields = 0;

result = aBridge->msgPayloadGetNumFields(NULL, &numFields);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetNumberFieldsInValidNumFields)
@@ -305,7 +305,7 @@ TEST_F(PayloadGeneralTests, GetNumberFieldsInValidNumFields)
aBridge->msgPayloadAddChar(testPayload, NULL, 1, 'a');

result = aBridge->msgPayloadGetNumFields(testPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetSendSubjectValid)
@@ -313,10 +313,10 @@ TEST_F(PayloadGeneralTests, GetSendSubjectValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetSendSubject(testPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NOT_IMPLEMENTED);
+ EXPECT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, result);
}


@@ -328,7 +328,7 @@ TEST_F(PayloadGeneralTests, GetSendSubjectInValidMsg)

CHECK_NON_IMPLEMENTED_OPTIONAL(result);

- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetSendSubjectInValidSubject)
@@ -336,10 +336,10 @@ TEST_F(PayloadGeneralTests, GetSendSubjectInValidSubject)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetSendSubject(testPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NOT_IMPLEMENTED);
+ EXPECT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, result);
}

TEST_F(PayloadGeneralTests, ToStringValid)
@@ -348,7 +348,7 @@ TEST_F(PayloadGeneralTests, ToStringValid)
const char* char_result;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

char_result = aBridge->msgPayloadToString(testPayload);
EXPECT_STREQ (char_result, "{}");
@@ -362,7 +362,7 @@ TEST_F(PayloadGeneralTests, ToStringValidConsistent)
const char* char_result2;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadAddChar(testPayload, NULL, 1, 'a');
result = aBridge->msgPayloadAddChar(testPayload, NULL, 2, 'b');
@@ -386,7 +386,7 @@ TEST_F(PayloadGeneralTests, ToStringInValid)
const char* char_result;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

char_result = aBridge->msgPayloadToString(NULL);
EXPECT_STREQ (char_result, NULL);
@@ -403,10 +403,10 @@ TEST_F(PayloadGeneralTests, IterateFieldsValid)
msgFieldPayload testMamaField = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);

aBridge->msgFieldPayloadCreate(&testMamaField);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterateFields(
testPayload,
@@ -415,7 +415,7 @@ TEST_F(PayloadGeneralTests, IterateFieldsValid)
dummyIteratorCallback,
NULL);

- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

/* TODO: This test should return NULL, but needs to have the parent msg,
@@ -429,7 +429,7 @@ TEST_F(PayloadGeneralTests, IterateFieldsInValidPayload)
void* testClosure;

result = aBridge->msgPayloadIterateFields(NULL, testMamaMsg, testMamaField, testMamaMsgIteratorCb, &testClosure);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* TODO: This test should return NULL, but needs to have the callback and
@@ -443,10 +443,10 @@ TEST_F(PayloadGeneralTests, IterateFieldsInValidParent)
void* testClosure;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterateFields(testPayload, NULL, testMamaField, testMamaMsgIteratorCb, &testClosure);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* TODO: This test should return NULL, but needs to have the parent msg and
@@ -460,10 +460,10 @@ TEST_F(PayloadGeneralTests, IterateFieldsInValidMamaField)
void* testClosure;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterateFields(testPayload, testMamaMsg, NULL, testMamaMsgIteratorCb, &testClosure);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* TODO: This test should return NULL, but needs to have the parent msg and
@@ -477,10 +477,10 @@ TEST_F(PayloadGeneralTests, IterateFieldsInValidCallBack)
void* testClosure;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterateFields(testPayload, testMamaMsg, testMamaField, NULL, &testClosure);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SerializeValid)
@@ -490,7 +490,7 @@ TEST_F(PayloadGeneralTests, SerializeValid)
mama_size_t testBufferLength = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -498,7 +498,7 @@ TEST_F(PayloadGeneralTests, SerializeValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadSerialize(testPayload, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, SerializeInValidPayLoad)
@@ -508,10 +508,10 @@ TEST_F(PayloadGeneralTests, SerializeInValidPayLoad)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSerialize(NULL, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SerializeInValidBuffer)
@@ -520,7 +520,7 @@ TEST_F(PayloadGeneralTests, SerializeInValidBuffer)
mama_size_t testBufferLength = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -528,7 +528,7 @@ TEST_F(PayloadGeneralTests, SerializeInValidBuffer)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadSerialize(testPayload, NULL, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SerializeInValidBufferLength)
@@ -537,7 +537,7 @@ TEST_F(PayloadGeneralTests, SerializeInValidBufferLength)
char* testBuffer;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -545,7 +545,7 @@ TEST_F(PayloadGeneralTests, SerializeInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadSerialize(testPayload, (const void**)&testBuffer, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, UnSerializeValid)
@@ -555,14 +555,14 @@ TEST_F(PayloadGeneralTests, UnSerializeValid)
mama_size_t testBufferLength = 50;

result = aBridge->msgPayloadCreate(&testPayload);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
result = aBridge->msgPayloadSerialize(testPayload, (const void**)&testBuffer, &testBufferLength);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadUnSerialize(testPayload, (const void**)testBuffer, testBufferLength);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, UnSerializeInValidPayload)
@@ -572,10 +572,10 @@ TEST_F(PayloadGeneralTests, UnSerializeInValidPayload)
mama_size_t testBufferLength = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadUnSerialize(NULL, &testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, UnSerializeInValidBuffer)
@@ -584,10 +584,10 @@ TEST_F(PayloadGeneralTests, UnSerializeInValidBuffer)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadUnSerialize(testPayload, NULL, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, UnSerializeInValidBufferLength)
@@ -596,10 +596,10 @@ TEST_F(PayloadGeneralTests, UnSerializeInValidBufferLength)
const void* testBuffer;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadUnSerialize(testPayload, &testBuffer, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteBufferValid)
@@ -610,10 +610,10 @@ TEST_F(PayloadGeneralTests, GetByteBufferValid)
mamaMsg testMamaMsg = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetParent(testPayload, testMamaMsg);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -621,7 +621,7 @@ TEST_F(PayloadGeneralTests, GetByteBufferValid)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetByteBufferInValidPayload)
@@ -631,7 +631,7 @@ TEST_F(PayloadGeneralTests, GetByteBufferInValidPayload)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -639,7 +639,7 @@ TEST_F(PayloadGeneralTests, GetByteBufferInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(NULL, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteBufferInValidBuffer)
@@ -648,7 +648,7 @@ TEST_F(PayloadGeneralTests, GetByteBufferInValidBuffer)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -656,7 +656,7 @@ TEST_F(PayloadGeneralTests, GetByteBufferInValidBuffer)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, NULL, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteBufferInValidBufferLength)
@@ -665,7 +665,7 @@ TEST_F(PayloadGeneralTests, GetByteBufferInValidBufferLength)
char* testBuffer;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -673,7 +673,7 @@ TEST_F(PayloadGeneralTests, GetByteBufferInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const void**)&testBuffer, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferValid)
@@ -683,7 +683,7 @@ TEST_F(PayloadGeneralTests, SetByteBufferValid)
mama_size_t testBufferLength = 100;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -691,13 +691,13 @@ TEST_F(PayloadGeneralTests, SetByteBufferValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayload, aBridge, (const void*)testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetByteBuffer(&testPayload, aBridge, &testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferInValidPayload)
@@ -707,10 +707,10 @@ TEST_F(PayloadGeneralTests, SetByteBufferInValidPayload)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetByteBuffer(NULL, aBridge, &testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferInValidBridge)
@@ -720,7 +720,7 @@ TEST_F(PayloadGeneralTests, SetByteBufferInValidBridge)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -728,7 +728,7 @@ TEST_F(PayloadGeneralTests, SetByteBufferInValidBridge)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadSetByteBuffer(&testPayload, NULL, &testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferInValidBuffer)
@@ -737,10 +737,10 @@ TEST_F(PayloadGeneralTests, SetByteBufferInValidBuffer)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetByteBuffer(&testPayload, aBridge, NULL, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferInValidBufferLength)
@@ -749,7 +749,7 @@ TEST_F(PayloadGeneralTests, SetByteBufferInValidBufferLength)
const char* testBuffer;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -757,7 +757,7 @@ TEST_F(PayloadGeneralTests, SetByteBufferInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadSetByteBuffer(&testPayload, aBridge, &testBuffer, 0);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* TODO: Check the values in the created payload.
@@ -771,7 +771,7 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferValid)

result = aBridge->msgPayloadCreate(&testPayload);
result = aBridge->msgPayloadCreate(&testPayloadNew);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -779,10 +779,10 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferValid)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayloadNew, aBridge, (const void*)testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidPayLoad)
@@ -792,13 +792,13 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidPayLoad)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(NULL, aBridge, (const void*)testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBridge)
@@ -810,7 +810,7 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBridge)

result = aBridge->msgPayloadCreate(&testPayload);
result = aBridge->msgPayloadCreate(&testPayloadNew);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -818,10 +818,10 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBridge)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayloadNew, NULL, (const void*)testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBuffer)
@@ -833,7 +833,7 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBuffer)

result = aBridge->msgPayloadCreate(&testPayload);
result = aBridge->msgPayloadCreate(&testPayloadNew);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -841,10 +841,10 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBuffer)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayloadNew, aBridge, NULL, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBufferLength)
@@ -856,7 +856,7 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBufferLength)

result = aBridge->msgPayloadCreate(&testPayload);
result = aBridge->msgPayloadCreate(&testPayloadNew);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -864,10 +864,10 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayloadNew, aBridge, (const void*)testBuffer, 0);
- EXPECT_EQ (result, MAMA_STATUS_INVALID_ARG);
+ EXPECT_EQ (MAMA_STATUS_INVALID_ARG, result);
}

TEST_F(PayloadGeneralTests, ApplyValid)
@@ -876,23 +876,23 @@ TEST_F(PayloadGeneralTests, ApplyValid)
msgPayload testSrcPayload = NULL;

result = aBridge->msgPayloadCreate(&testDestPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreate(&testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadApply(testDestPayload, testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testSrcPayload, "name", NULL, "Unit");

result = aBridge->msgPayloadApply(testDestPayload, testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testSrcPayload, NULL, 101, "Testing");

result = aBridge->msgPayloadApply(testDestPayload, testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, ApplyInValidDestPayload)
@@ -901,17 +901,17 @@ TEST_F(PayloadGeneralTests, ApplyInValidDestPayload)
mama_size_t numFields = 0;

result = aBridge->msgPayloadCreate(&testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadAddChar(testSrcPayload, NULL, 9, 'i');
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNumFields(testSrcPayload, &numFields);
- EXPECT_EQ (result, MAMA_STATUS_OK);
- EXPECT_EQ (numFields, (mama_size_t) 1);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
+ EXPECT_EQ ((mama_size_t) 1, numFields);

result = aBridge->msgPayloadApply(NULL, testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, ApplyInValidSrcPayload)
@@ -920,17 +920,17 @@ TEST_F(PayloadGeneralTests, ApplyInValidSrcPayload)
mama_size_t numFields = 0;

result = aBridge->msgPayloadCreate(&testDestPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadAddChar(testDestPayload, NULL, 9, 'i');
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNumFields(testDestPayload, &numFields);
- EXPECT_EQ (result, MAMA_STATUS_OK);
- EXPECT_EQ (numFields, (mama_size_t) 1);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
+ EXPECT_EQ ((mama_size_t) 1, numFields);

result = aBridge->msgPayloadApply(testDestPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetNativeMsgValid)
@@ -939,10 +939,10 @@ TEST_F(PayloadGeneralTests, GetNativeMsgValid)
char* testNativeMsg;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNativeMsg(testPayload, (void**)&testNativeMsg);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetNativeMsgInValidMsg)
@@ -951,10 +951,10 @@ TEST_F(PayloadGeneralTests, GetNativeMsgInValidMsg)
char* testNativeMsg;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNativeMsg(NULL, (void**)&testNativeMsg);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetNativeMsgInValidNativeMsg)
@@ -962,10 +962,10 @@ TEST_F(PayloadGeneralTests, GetNativeMsgInValidNativeMsg)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNativeMsg(testPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringValid)
@@ -977,7 +977,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringValid)
mama_size_t testLen = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -985,7 +985,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, &testName, testFid, testBuf, testLen);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringInValidPayload)
@@ -997,10 +997,10 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringInValidPayload)
mama_size_t testLen = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetFieldAsString(NULL, &testName, testFid, &testBuf, testLen);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringInValidName)
@@ -1011,7 +1011,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringInValidName)
mama_size_t testLen = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1019,7 +1019,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringInValidName)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, NULL, testFid, testBuf, testLen);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringInValidFid)
@@ -1033,7 +1033,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringInValidFid)
mama_size_t testLen = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1041,7 +1041,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringInValidFid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, &testName, 0, &testBuf, testLen);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
*/
}

@@ -1053,7 +1053,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringInValidBuffer)
mama_size_t testLen = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1061,7 +1061,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringInValidBuffer)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, &testName, testFid, NULL, testLen);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringInValidBufferLength)
@@ -1072,7 +1072,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringInValidBufferLength)
char testBuf[256];

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1080,7 +1080,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, &testName, testFid, testBuf, 0);
- EXPECT_EQ (result, MAMA_STATUS_INVALID_ARG);
+ EXPECT_EQ (MAMA_STATUS_INVALID_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldValid)
@@ -1091,7 +1091,7 @@ TEST_F(PayloadGeneralTests, GetFieldValid)
msgFieldPayload testResult = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1099,10 +1099,10 @@ TEST_F(PayloadGeneralTests, GetFieldValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testResult);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetField(testPayload, &testName, testFid, &testResult);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetFieldInValidPayload)
@@ -1113,13 +1113,13 @@ TEST_F(PayloadGeneralTests, GetFieldInValidPayload)
msgFieldPayload testResult = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgFieldPayloadCreate(&testResult);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetField(NULL, &testName, testFid, &testResult);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldInValidName)
@@ -1129,7 +1129,7 @@ TEST_F(PayloadGeneralTests, GetFieldInValidName)
msgFieldPayload testResult = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1137,10 +1137,10 @@ TEST_F(PayloadGeneralTests, GetFieldInValidName)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testResult);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetField(testPayload, NULL, testFid, &testResult);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetFieldInValidFid)
@@ -1152,7 +1152,7 @@ TEST_F(PayloadGeneralTests, GetFieldInValidFid)
msgFieldPayload testResult = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1160,10 +1160,10 @@ TEST_F(PayloadGeneralTests, GetFieldInValidFid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testResult);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetField(testPayload, &testName, 0, &testResult);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
*/
}

@@ -1176,7 +1176,7 @@ TEST_F(PayloadGeneralTests, GetFieldInValidResult)
//mama_bool_t value = 1;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1184,13 +1184,13 @@ TEST_F(PayloadGeneralTests, GetFieldInValidResult)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

//result = aBridge->msgFieldPayloadUpdateBool(testField, testPayload, value);
- //EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ //EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);

result = aBridge->msgPayloadGetField(testPayload, &testName, testFid, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* ************************************************************************* */
@@ -1203,7 +1203,7 @@ TEST_F(PayloadGeneralTests, IterCreateValid)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1211,7 +1211,7 @@ TEST_F(PayloadGeneralTests, IterCreateValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, IterCreateInValidtestIter)
@@ -1219,7 +1219,7 @@ TEST_F(PayloadGeneralTests, IterCreateInValidtestIter)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1227,7 +1227,7 @@ TEST_F(PayloadGeneralTests, IterCreateInValidtestIter)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(NULL, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, IterCreateInValidPayload)
@@ -1235,7 +1235,7 @@ TEST_F(PayloadGeneralTests, IterCreateInValidPayload)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadIterCreate(&testIter, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, IterDestroyValid)
@@ -1244,18 +1244,18 @@ TEST_F(PayloadGeneralTests, IterDestroyValid)
msgFieldPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);

result = aBridge->msgPayloadIterDestroy(testIter);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, IterDestroyInValidIter)
{
result = aBridge->msgPayloadIterDestroy(NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, IterEndValid)
@@ -1299,7 +1299,7 @@ TEST_F(PayloadGeneralTests, IterNextValid)
msgFieldPayload testField = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1307,7 +1307,7 @@ TEST_F(PayloadGeneralTests, IterNextValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

if (NULL == aBridge->msgPayloadIterNext(testIter, testField, testPayload))
FAIL();
@@ -1329,7 +1329,7 @@ TEST_F(PayloadGeneralTests, IterNextValidConsistent)
msgFieldPayload testField = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

/* A reference group of fids. The same fids as in the payload testPayload.
* See later on.
@@ -1346,7 +1346,7 @@ TEST_F(PayloadGeneralTests, IterNextValidConsistent)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

mama_fid_t test_fid;
std::set<mama_fid_t> returned_fids_set;
@@ -1404,10 +1404,10 @@ TEST_F(PayloadGeneralTests, IterNextInValidIter)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterNext(NULL, testField, testPayload);
if (output != NULL)
@@ -1421,7 +1421,7 @@ TEST_F(PayloadGeneralTests, IterNextInValidField)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1429,7 +1429,7 @@ TEST_F(PayloadGeneralTests, IterNextInValidField)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterNext(testIter, NULL, testPayload);
if (output == NULL)
@@ -1444,7 +1444,7 @@ TEST_F(PayloadGeneralTests, IterNextInValidPayload)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1452,10 +1452,10 @@ TEST_F(PayloadGeneralTests, IterNextInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterNext(testIter, testField, NULL);
if (output != NULL)
@@ -1469,7 +1469,7 @@ TEST_F(PayloadGeneralTests, IterBeginValid)
msgFieldPayload testField = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

//Call on empty msg first
aBridge->msgPayloadIterBegin(testIter, testField, testPayload);
@@ -1480,10 +1480,10 @@ TEST_F(PayloadGeneralTests, IterBeginValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

if (NULL == aBridge->msgPayloadIterBegin(testIter, testField, testPayload))
FAIL();
@@ -1497,7 +1497,7 @@ TEST_F(PayloadGeneralTests, IterBeginInValidIter)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1505,10 +1505,10 @@ TEST_F(PayloadGeneralTests, IterBeginInValidIter)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterBegin(NULL, testField, testPayload);
if (output != NULL)
@@ -1523,7 +1523,7 @@ TEST_F(PayloadGeneralTests, IterBeginInValidField)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1531,10 +1531,10 @@ TEST_F(PayloadGeneralTests, IterBeginInValidField)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterBegin(testIter, NULL, testPayload);
if (output == NULL)
@@ -1549,7 +1549,7 @@ TEST_F(PayloadGeneralTests, IterBeginInValidPayload)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1557,10 +1557,10 @@ TEST_F(PayloadGeneralTests, IterBeginInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterBegin(testIter, testField, NULL);
if (output != NULL)
@@ -1574,7 +1574,7 @@ TEST_F(PayloadGeneralTests, IterHasNextValid)
mama_bool_t output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1582,10 +1582,10 @@ TEST_F(PayloadGeneralTests, IterHasNextValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterHasNext(testIter, testPayload);
- EXPECT_EQ (output, true);
+ EXPECT_EQ (true, output);
}

TEST_F(PayloadGeneralTests, IterHasNextInValidIter)
@@ -1594,7 +1594,7 @@ TEST_F(PayloadGeneralTests, IterHasNextInValidIter)
mama_bool_t output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1602,7 +1602,7 @@ TEST_F(PayloadGeneralTests, IterHasNextInValidIter)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

output = aBridge->msgPayloadIterHasNext(NULL, testPayload);
- EXPECT_EQ (output, false);
+ EXPECT_EQ (false, output);
}

TEST_F(PayloadGeneralTests, IterHasNextInValidPayload)
@@ -1612,7 +1612,7 @@ TEST_F(PayloadGeneralTests, IterHasNextInValidPayload)
mama_bool_t output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1620,10 +1620,10 @@ TEST_F(PayloadGeneralTests, IterHasNextInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterHasNext(testIter, NULL);
- EXPECT_EQ (output, 0);
+ EXPECT_EQ (0, output);
}

TEST_F(PayloadGeneralTests, IterAssociateValid)
@@ -1632,7 +1632,7 @@ TEST_F(PayloadGeneralTests, IterAssociateValid)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1640,13 +1640,13 @@ TEST_F(PayloadGeneralTests, IterAssociateValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterAssociate(testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterAssociate(testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, IterAssociateTwiceValid)
@@ -1658,7 +1658,7 @@ TEST_F(PayloadGeneralTests, IterAssociateTwiceValid)
mama_fid_t test_fid = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

// Create 2 payloads
aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
@@ -1667,7 +1667,7 @@ TEST_F(PayloadGeneralTests, IterAssociateTwiceValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadCreate(&testPayload2);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload2, "name2", 202, "Repeating");
aBridge->msgPayloadAddString (testPayload2, "name3", 203, "Things");
@@ -1676,46 +1676,46 @@ TEST_F(PayloadGeneralTests, IterAssociateTwiceValid)

// Create iterator
result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

// associate iterator with a payload
result = aBridge->msgPayloadIterAssociate(testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

// Test current payload exist and iterated correctly
result = aBridge->msgPayloadGetField(testPayload,NULL,102,&testField);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

testField = aBridge->msgPayloadIterNext(testIter,testField,testPayload);
// Make sure we're traversing on a payload
testField = aBridge->msgPayloadIterNext(testIter,testField,testPayload);

result = aBridge->msgFieldPayloadGetFid(testField,NULL,NULL, &test_fid);
- EXPECT_EQ (test_fid, 103);
+ EXPECT_EQ (103, test_fid);

// reuse iterator with new payload
result = aBridge->msgPayloadIterAssociate(testIter, testPayload2);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

// Test current payload exists and iterated correctly
result = aBridge->msgPayloadGetField(testPayload2,NULL,202,&testField);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

testField = aBridge->msgPayloadIterNext(testIter,testField,testPayload2);
// Make sure we're traversing on the 2nd payload
testField = aBridge->msgPayloadIterNext(testIter,testField,testPayload2);

result = aBridge->msgFieldPayloadGetFid(testField,NULL,NULL, &test_fid);
- EXPECT_EQ (test_fid, 203);
+ EXPECT_EQ (203, test_fid);

result = aBridge->msgPayloadIterDestroy(testIter);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadDestroy(testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadDestroy(testPayload2);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, IterAssociateInValidIter)
@@ -1724,7 +1724,7 @@ TEST_F(PayloadGeneralTests, IterAssociateInValidIter)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1732,10 +1732,10 @@ TEST_F(PayloadGeneralTests, IterAssociateInValidIter)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterAssociate(NULL, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, IterAssociateInValidPayload)
@@ -1744,7 +1744,7 @@ TEST_F(PayloadGeneralTests, IterAssociateInValidPayload)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1752,9 +1752,9 @@ TEST_F(PayloadGeneralTests, IterAssociateInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterAssociate(&testIter, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

diff --git a/mama/c_cpp/src/gunittest/c/payload/payloadvectortests.cpp b/mama/c_cpp/src/gunittest/c/payload/payloadvectortests.cpp
index 9fded70..ab5483b 100644
--- a/mama/c_cpp/src/gunittest/c/payload/payloadvectortests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/payloadvectortests.cpp
@@ -140,12 +140,12 @@ protected:
TEST_F(PayloadVectorBoolTests, AddVectorBool)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -153,15 +153,15 @@ TEST_F(PayloadVectorBoolTests, AddVectorBool)
TEST_F(PayloadVectorBoolTests, AddVectorBoolAfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -169,31 +169,31 @@ TEST_F(PayloadVectorBoolTests, AddVectorBoolAfterInit)
TEST_F(PayloadVectorBoolTests, AddVectorBoolNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorBoolTests, AddVectorBoolNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, AddVectorBoolInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, AddVectorBoolInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorBool test fixtures
@@ -202,107 +202,107 @@ TEST_F(PayloadVectorBoolTests, AddVectorBoolInvalidFid)
TEST_F(PayloadVectorBoolTests, UpdateVectorBool)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInitByFid)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, "Rhubarb", 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, "Rhubarb", 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorBool test fixtures
@@ -311,50 +311,50 @@ TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInvalidFidNo)
TEST_F(PayloadVectorBoolTests, GetVectorBool)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorBoolTests, GetVectorBoolNullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, GetVectorBoolNullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, GetVectorBoolNotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -406,38 +406,38 @@ protected:
TEST_F(PayloadVectorCharTests, AddVectorChar)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorCharTests, AddVectorCharNullChar)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorCharTests, AddVectorCharNullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, AddVectorCharAfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -445,19 +445,19 @@ TEST_F(PayloadVectorCharTests, AddVectorCharAfterInit)
TEST_F(PayloadVectorCharTests, AddVectorCharInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, AddVectorCharInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorChar test fixtures
@@ -466,96 +466,96 @@ TEST_F(PayloadVectorCharTests, AddVectorCharInvalidFid)
TEST_F(PayloadVectorCharTests, UpdateVectorChar)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(char) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(char) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharInitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharInvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorChar test fixtures
@@ -564,50 +564,50 @@ TEST_F(PayloadVectorCharTests, UpdateVectorCharInvalidFidNo)
TEST_F(PayloadVectorCharTests, GetVectorChar)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(char) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(char) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorCharTests, GetVectorCharNullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, GetVectorCharNullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, GetVectorCharNotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -660,38 +660,38 @@ protected:
TEST_F(PayloadVectorI8Tests, AddVectorI8)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorI8Tests, AddVectorI8NullI8)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorI8Tests, AddVectorI8NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, AddVectorI8AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -699,19 +699,19 @@ TEST_F(PayloadVectorI8Tests, AddVectorI8AfterInit)
TEST_F(PayloadVectorI8Tests, AddVectorI8InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, AddVectorI8InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorI8 test fixtures
@@ -720,96 +720,96 @@ TEST_F(PayloadVectorI8Tests, AddVectorI8InvalidFid)
TEST_F(PayloadVectorI8Tests, UpdateVectorI8)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_i8_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_i8_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorI8 test fixtures
@@ -818,50 +818,50 @@ TEST_F(PayloadVectorI8Tests, UpdateVectorI8InvalidFidNo)
TEST_F(PayloadVectorI8Tests, GetVectorI8)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_i8_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_i8_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorI8Tests, GetVectorI8NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, GetVectorI8NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, GetVectorI8NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -914,38 +914,38 @@ protected:
TEST_F(PayloadVectorU8Tests, AddVectorU8)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorU8Tests, AddVectorU8NullU8)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorU8Tests, AddVectorU8NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, AddVectorU8AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -953,19 +953,19 @@ TEST_F(PayloadVectorU8Tests, AddVectorU8AfterInit)
TEST_F(PayloadVectorU8Tests, AddVectorU8InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, AddVectorU8InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorU8 test fixtures
@@ -974,96 +974,96 @@ TEST_F(PayloadVectorU8Tests, AddVectorU8InvalidFid)
TEST_F(PayloadVectorU8Tests, UpdateVectorU8)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_u8_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_u8_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorU8 test fixtures
@@ -1072,50 +1072,50 @@ TEST_F(PayloadVectorU8Tests, UpdateVectorU8InvalidFidNo)
TEST_F(PayloadVectorU8Tests, GetVectorU8)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_u8_t) * VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_u8_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorU8Tests, GetVectorU8NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, GetVectorU8NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, GetVectorU8NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -1168,38 +1168,38 @@ protected:
TEST_F(PayloadVectorI16Tests, AddVectorI16)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorI16Tests, AddVectorI16NullI16)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorI16Tests, AddVectorI16NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, AddVectorI16AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -1207,19 +1207,19 @@ TEST_F(PayloadVectorI16Tests, AddVectorI16AfterInit)
TEST_F(PayloadVectorI16Tests, AddVectorI16InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, AddVectorI16InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorI16 test fixtures
@@ -1228,96 +1228,96 @@ TEST_F(PayloadVectorI16Tests, AddVectorI16InvalidFid)
TEST_F(PayloadVectorI16Tests, UpdateVectorI16)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorI16 test fixtures
@@ -1326,50 +1326,50 @@ TEST_F(PayloadVectorI16Tests, UpdateVectorI16InvalidFidNo)
TEST_F(PayloadVectorI16Tests, GetVectorI16)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_i16_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_i16_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorI16Tests, GetVectorI16NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, GetVectorI16NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, GetVectorI16NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -1422,38 +1422,38 @@ protected:
TEST_F(PayloadVectorU16Tests, AddVectorU16)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorU16Tests, AddVectorU16NullU16)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorU16Tests, AddVectorU16NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, AddVectorU16AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -1461,19 +1461,19 @@ TEST_F(PayloadVectorU16Tests, AddVectorU16AfterInit)
TEST_F(PayloadVectorU16Tests, AddVectorU16InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, AddVectorU16InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorU16 test fixtures
@@ -1482,96 +1482,96 @@ TEST_F(PayloadVectorU16Tests, AddVectorU16InvalidFid)
TEST_F(PayloadVectorU16Tests, UpdateVectorU16)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_u16_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_u16_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorU16 test fixtures
@@ -1580,50 +1580,50 @@ TEST_F(PayloadVectorU16Tests, UpdateVectorU16InvalidFidNo)
TEST_F(PayloadVectorU16Tests, GetVectorU16)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_u16_t) * VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_u16_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorU16Tests, GetVectorU16NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, GetVectorU16NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, GetVectorU16NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -1676,38 +1676,38 @@ protected:
TEST_F(PayloadVectorI32Tests, AddVectorI32)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorI32Tests, AddVectorI32NullI32)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorI32Tests, AddVectorI32NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, AddVectorI32AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -1715,19 +1715,19 @@ TEST_F(PayloadVectorI32Tests, AddVectorI32AfterInit)
TEST_F(PayloadVectorI32Tests, AddVectorI32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, AddVectorI32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorI32 test fixtures
@@ -1736,96 +1736,96 @@ TEST_F(PayloadVectorI32Tests, AddVectorI32InvalidFid)
TEST_F(PayloadVectorI32Tests, UpdateVectorI32)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_i32_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_i32_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorI32 test fixtures
@@ -1834,50 +1834,50 @@ TEST_F(PayloadVectorI32Tests, UpdateVectorI32InvalidFidNo)
TEST_F(PayloadVectorI32Tests, GetVectorI32)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_i32_t) * VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_i32_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorI32Tests, GetVectorI32NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, GetVectorI32NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, GetVectorI32NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -1930,38 +1930,38 @@ protected:
TEST_F(PayloadVectorU32Tests, AddVectorU32)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorU32Tests, AddVectorU32NullU32)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorU32Tests, AddVectorU32NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, AddVectorU32AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -1969,19 +1969,19 @@ TEST_F(PayloadVectorU32Tests, AddVectorU32AfterInit)
TEST_F(PayloadVectorU32Tests, AddVectorU32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, AddVectorU32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorU32 test fixtures
@@ -1990,96 +1990,96 @@ TEST_F(PayloadVectorU32Tests, AddVectorU32InvalidFid)
TEST_F(PayloadVectorU32Tests, UpdateVectorU32)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_u32_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_u32_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorU32 test fixtures
@@ -2088,50 +2088,50 @@ TEST_F(PayloadVectorU32Tests, UpdateVectorU32InvalidFidNo)
TEST_F(PayloadVectorU32Tests, GetVectorU32)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_u32_t) * VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_u32_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorU32Tests, GetVectorU32NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, GetVectorU32NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, GetVectorU32NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -2184,38 +2184,38 @@ protected:
TEST_F(PayloadVectorI64Tests, AddVectorI64)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorI64Tests, AddVectorI64NullI64)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorI64Tests, AddVectorI64NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, AddVectorI64AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -2223,19 +2223,19 @@ TEST_F(PayloadVectorI64Tests, AddVectorI64AfterInit)
TEST_F(PayloadVectorI64Tests, AddVectorI64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, AddVectorI64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorI64 test fixtures
@@ -2244,96 +2244,96 @@ TEST_F(PayloadVectorI64Tests, AddVectorI64InvalidFid)
TEST_F(PayloadVectorI64Tests, UpdateVectorI64)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_i64_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_i64_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorI64 test fixtures
@@ -2342,49 +2342,49 @@ TEST_F(PayloadVectorI64Tests, UpdateVectorI64InvalidFidNo)
TEST_F(PayloadVectorI64Tests, GetVectorI64)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_i64_t) * VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_i64_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI64Tests, GetVectorI64NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, GetVectorI64NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, GetVectorI64NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -2437,38 +2437,38 @@ protected:
TEST_F(PayloadVectorU64Tests, AddVectorU64)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorU64Tests, AddVectorU64NullU64)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorU64Tests, AddVectorU64NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, AddVectorU64AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -2476,19 +2476,19 @@ TEST_F(PayloadVectorU64Tests, AddVectorU64AfterInit)
TEST_F(PayloadVectorU64Tests, AddVectorU64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, AddVectorU64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorU64 test fixtures
@@ -2497,96 +2497,96 @@ TEST_F(PayloadVectorU64Tests, AddVectorU64InvalidFid)
TEST_F(PayloadVectorU64Tests, UpdateVectorU64)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_u64_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_u64_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorU64 test fixtures
@@ -2595,50 +2595,50 @@ TEST_F(PayloadVectorU64Tests, UpdateVectorU64InvalidFidNo)
TEST_F(PayloadVectorU64Tests, GetVectorU64)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_u64_t) * VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_u64_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorU64Tests, GetVectorU64NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, GetVectorU64NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, GetVectorU64NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -2695,38 +2695,38 @@ protected:
TEST_F(PayloadVectorF32Tests, AddVectorF32)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorF32Tests, AddVectorF32NullF32)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorF32Tests, AddVectorF32NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, AddVectorF32AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -2734,19 +2734,19 @@ TEST_F(PayloadVectorF32Tests, AddVectorF32AfterInit)
TEST_F(PayloadVectorF32Tests, AddVectorF32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, AddVectorF32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorF32 test fixtures
@@ -2755,96 +2755,96 @@ TEST_F(PayloadVectorF32Tests, AddVectorF32InvalidFid)
TEST_F(PayloadVectorF32Tests, UpdateVectorF32)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_f32_t) * VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_f32_t) * VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorF32 test fixtures
@@ -2853,50 +2853,50 @@ TEST_F(PayloadVectorF32Tests, UpdateVectorF32InvalidFidNo)
TEST_F(PayloadVectorF32Tests, GetVectorF32)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_f32_t) * VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_f32_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorF32Tests, GetVectorF32NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, GetVectorF32NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, GetVectorF32NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -2953,38 +2953,38 @@ protected:
TEST_F(PayloadVectorF64Tests, AddVectorF64)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorF64Tests, AddVectorF64NullF64)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorF64Tests, AddVectorF64NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, AddVectorF64AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 2, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -2992,19 +2992,19 @@ TEST_F(PayloadVectorF64Tests, AddVectorF64AfterInit)
TEST_F(PayloadVectorF64Tests, AddVectorF64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, AddVectorF64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorF64 test fixtures
@@ -3013,96 +3013,96 @@ TEST_F(PayloadVectorF64Tests, AddVectorF64InvalidFid)
TEST_F(PayloadVectorF64Tests, UpdateVectorF64)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(NULL, NULL, 1, m_update, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, "Bob", 0, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) * VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorF64 test fixtures
@@ -3111,50 +3111,50 @@ TEST_F(PayloadVectorF64Tests, UpdateVectorF64InvalidFidNo)
TEST_F(PayloadVectorF64Tests, GetVectorF64)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_f64_t) * VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_f64_t) * VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorF64Tests, GetVectorF64NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, GetVectorF64NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, GetVectorF64NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -3225,10 +3225,10 @@ protected:
TEST_F(PayloadVectorStringTests, AddVectorString)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);

int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult)) ; ++ii )
@@ -3236,29 +3236,29 @@ TEST_F(PayloadVectorStringTests, AddVectorString)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorStringTests, AddVectorStringNullString)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorStringTests, AddVectorStringNullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, AddVectorStringAfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 2, &m_out, &m_outSize);

@@ -3268,26 +3268,26 @@ TEST_F(PayloadVectorStringTests, AddVectorStringAfterInit)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorStringTests, AddVectorStringInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, AddVectorStringInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorString test fixtures
@@ -3296,10 +3296,10 @@ TEST_F(PayloadVectorStringTests, AddVectorStringInvalidFid)
TEST_F(PayloadVectorStringTests, UpdateVectorString)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult)) ; ++ii )
@@ -3307,14 +3307,14 @@ TEST_F(PayloadVectorStringTests, UpdateVectorString)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
ASSERT_EQ(MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

getResult = 0;
for( unsigned int ii( 0 ) ; ((ii < VECTOR_UPDATE_SIZE) && (0 == getResult)) ; ++ii )
@@ -3322,54 +3322,54 @@ TEST_F(PayloadVectorStringTests, UpdateVectorString)
getResult = ::strncmp( m_update[ii], m_out[ii], 20 );
}

- EXPECT_EQ(0, getResult);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (0, getResult);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult)) ; ++ii )
{
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult)) ; ++ii )
{
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(NULL, NULL, 1, m_update, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringInitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, "Bob", 0, &m_out, &m_outSize);

@@ -3379,14 +3379,14 @@ TEST_F(PayloadVectorStringTests, UpdateVectorStringInitByName)
getResult = ::strncmp( m_update[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, "Bob", 0, &m_out, &m_outSize);
int getResult(0);
@@ -3395,41 +3395,41 @@ TEST_F(PayloadVectorStringTests, UpdateVectorStringInvalidName)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult)) ; ++ii )
{
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringInvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorString test fixtures
@@ -3438,10 +3438,10 @@ TEST_F(PayloadVectorStringTests, UpdateVectorStringInvalidFidNo)
TEST_F(PayloadVectorStringTests, GetVectorString)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult)) ; ++ii )
@@ -3449,14 +3449,14 @@ TEST_F(PayloadVectorStringTests, GetVectorString)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

getResult = 0;
for( unsigned int ii( 0 ) ; ((ii < VECTOR_UPDATE_SIZE) && (0 == getResult)) ; ++ii )
@@ -3464,36 +3464,36 @@ TEST_F(PayloadVectorStringTests, GetVectorString)
getResult = ::strncmp( m_update[ii], m_out[ii], 20 );
}

- EXPECT_EQ(0, getResult);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (0, getResult);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorStringTests, GetVectorStringNullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, GetVectorStringNullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, GetVectorStringNotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL, 2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -3579,62 +3579,62 @@ protected:
TEST_F(PayloadVectorMsgTests, AddVectorMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg,
NULL,
1,
(void* const**) &m_out,
&m_outSize);
- EXPECT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgNullMsgDst)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgNullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgAfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg,
NULL,
1,
(void* const**) &m_out,
&m_outSize);
- EXPECT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorMsg test fixtures
@@ -3643,77 +3643,77 @@ TEST_F(PayloadVectorMsgTests, AddVectorMsgInvalidFid)
TEST_F(PayloadVectorMsgTests, UpdateVectorMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1, (void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgInitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, "Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, "Bob", 0, (void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, "Bob", 0, (void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1, (void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgInvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, "Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorMsg test fixtures
@@ -3722,45 +3722,45 @@ TEST_F(PayloadVectorMsgTests, UpdateVectorMsgInvalidFidNo)
TEST_F(PayloadVectorMsgTests, GetVectorMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1, (void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1, (void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorMsgTests, GetVectorMsgNullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1, (void* const**) NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, GetVectorMsgNullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1, (void* const**) &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, GetVectorMsgNotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 2, (void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

// ****************************************************************************
@@ -3835,11 +3835,11 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTime)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( m_outSize, VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ (VECTOR_SIZE , m_outSize);

for( unsigned int ii(0) ; ii < VECTOR_SIZE ; ++ii )
{
@@ -3848,7 +3848,7 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTime)
m_out[ii] );
mamaDateTime_getAsString(m_in[ii], buf, 56);
mamaDateTime_getAsString(m_out[ii], buf, 56);
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}

@@ -3856,44 +3856,44 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeNullDateTime)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeNullMsg)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeAfterInit)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeInvalidName)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeInvalidFid)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorDateTime test fixtures
@@ -3902,11 +3902,11 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeInvalidFid)
TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTime)
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- //EXPECT_EQ(m_status, MAMA_STATUS_OK);
- //EXPECT_EQ(m_outSize, VECTOR_SIZE);
+ //EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ //EXPECT_EQ (VECTOR_SIZE, m_outSize);

/*
if( MAMA_STATUS_OK == m_status )
@@ -3915,7 +3915,7 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTime)
{
int eq = mamaDateTime_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(0, eq);
+ EXPECT_EQ (0, eq);
}
}
else
@@ -3925,11 +3925,11 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTime)
*/

m_status = m_payloadBridge->msgPayloadUpdateVectorTime(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- //EXPECT_EQ(m_status, MAMA_STATUS_OK);
- //EXPECT_EQ(m_outSize, VECTOR_UPDATE_SIZE);
+ //EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ //EXPECT_EQ (VECTOR_UPDATE_SIZE, m_outSize);

/*
if( MAMA_STATUS_OK == m_status )
@@ -3938,7 +3938,7 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTime)
{
int eq = mamaDateTime_equal( m_update[ii],
m_out[ii] );
- EXPECT_EQ(0, eq);
+ EXPECT_EQ (0, eq);
}
}
else
@@ -3952,11 +3952,11 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTimeNullUpdate)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- //EXPECT_EQ(m_status, MAMA_STATUS_OK);
- //EXPECT_EQ(m_outSize, VECTOR_SIZE);
+ //EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ //EXPECT_EQ (VECTOR_SIZE, m_outSize);

/*
if( MAMA_STATUS_OK == m_status )
@@ -3965,7 +3965,7 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTimeNullUpdate)
{
int eq = mamaDateTime_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(0, eq);
+ EXPECT_EQ (0, eq);
}
}
else
@@ -3975,18 +3975,18 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTimeNullUpdate)
*/

m_status = m_payloadBridge->msgPayloadUpdateVectorTime(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTimeNullMessage)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- //EXPECT_EQ(m_status, MAMA_STATUS_OK);
- //EXPECT_EQ(m_outSize, VECTOR_SIZE);
+ //EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ //EXPECT_EQ (VECTOR_SIZE, m_outSize);

/*
if( MAMA_STATUS_OK == m_status )
@@ -3996,7 +3996,7 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTimeNullMessage)
int eq = mamaDateTime_equal( m_in[ii],
m_out[ii] );

- EXPECT_EQ(0, eq);
+ EXPECT_EQ (0, eq);
}
}
else
@@ -4006,7 +4006,7 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTimeNullMessage)
*/

m_status = m_payloadBridge->msgPayloadUpdateVectorTime(NULL, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// GetVectorDateTime test fixtures
@@ -4015,12 +4015,12 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_GetVectorDateTime)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorDateTime
m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4029,7 +4029,7 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_GetVectorDateTime)
int eq = mamaDateTime_equal( m_in[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4038,12 +4038,12 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_GetVectorDateTime)
}

m_status = m_payloadBridge->msgPayloadUpdateVectorTime(m_msg, NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorDateTime
m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4052,7 +4052,7 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_GetVectorDateTime)
int eq = mamaDateTime_equal( m_update[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4065,22 +4065,22 @@ TEST_F(PayloadVectorDateTimeTests, DISABLED_GetVectorDateTimeNullResult)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorDateTime
m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_GetVectorDateTimeNullSize)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorDateTime
m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL, 1, m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// ****************************************************************************
@@ -4149,13 +4149,13 @@ TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPrice)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorPrice
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1, (void* const*) &m_out, &m_outSize);
- EXPECT_EQ( m_status, MAMA_STATUS_OK );
+ EXPECT_EQ (MAMA_STATUS_OK , m_status);

- EXPECT_EQ( m_outSize, VECTOR_SIZE );
+ EXPECT_EQ (VECTOR_SIZE , m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4163,7 +4163,7 @@ TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPrice)
{
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4176,44 +4176,44 @@ TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPriceNullPrice)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPriceNullMsg)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(NULL, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPriceAfterInit)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 2, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPriceInvalidName)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, "Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPriceInvalidFid)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorPrice test fixtures
@@ -4223,11 +4223,11 @@ TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPrice)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1, (void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4235,7 +4235,7 @@ TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPrice)
{
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4245,12 +4245,12 @@ TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPrice)

// TODO Interface inconsistent
m_status = m_payloadBridge->msgPayloadUpdateVectorPrice(m_msg, NULL, 1, (void* const**) m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

/*
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1, (void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (VECTOR_UPDATE_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4258,7 +4258,7 @@ TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPrice)
{
int eq = mamaPrice_equal( m_update[ii],
m_out[ii] );
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4272,12 +4272,12 @@ TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPriceNullUpdate)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorPrice
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1, (void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4285,7 +4285,7 @@ TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPriceNullUpdate)
{
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4294,19 +4294,19 @@ TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPriceNullUpdate)
}

m_status = m_payloadBridge->msgPayloadUpdateVectorPrice(m_msg, NULL, 1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPriceNullMessage)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorPrice
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1, (void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4315,7 +4315,7 @@ TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPriceNullMessage)
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4324,7 +4324,7 @@ TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPriceNullMessage)
}

m_status = m_payloadBridge->msgPayloadUpdateVectorPrice(NULL, NULL, 1, (void* const**) m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// GetVectorPrice test fixtures
@@ -4333,12 +4333,12 @@ TEST_F(PayloadVectorPriceTests, DISABLED_GetVectorPrice)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorPrice
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1, (void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4347,7 +4347,7 @@ TEST_F(PayloadVectorPriceTests, DISABLED_GetVectorPrice)
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4357,11 +4357,11 @@ TEST_F(PayloadVectorPriceTests, DISABLED_GetVectorPrice)

// TODO Interface Inconsistent
m_status = m_payloadBridge->msgPayloadUpdateVectorPrice(m_msg, NULL, 1, (void* const**) m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1, (void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4370,7 +4370,7 @@ TEST_F(PayloadVectorPriceTests, DISABLED_GetVectorPrice)
int eq = mamaPrice_equal( m_update[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4383,29 +4383,29 @@ TEST_F(PayloadVectorPriceTests, DISABLED_GetVectorPriceNullResult)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_GetVectorPriceNullSize)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1, (void* const*) &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_GetVectorPriceNotFound)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 2, (void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

--
1.9.0


Damian Maguire <DMaguire@...>
 

Hey Lee,

Raised this to Bugzilla for tracking. Ticket Number:
http://bugs.oenmama.org/show_bug.cgi?id=73

Cheers,

D




On 3/5/14 4:5 PM, "Lee Skillen"<lskillen@... wrote:

- eversed all EXPECT_*, ASSERT_* where the actual and expected where
in the format of EXPECT_*(actual, expected) instead of the suggested
format of EXPECT_(expected, actual). Doesn't impact functionality
but does impact meaningfulness of output whena test fails. I used
regex to achieve this butmanualy stepped through each to avoid a
reversal of ones already in the correct format.

Before:

[snip]/fieldcompositetsts.cpp:300: Failure
Value of: MAM_STATUS_O
Actua: 0
Expected: ret
Which is: 19

After:

[snip]/fieldcompositetests.cpp:300: Failure
Value of: ret
Actual: 19
Expected: MAMA_STATUS_OK
Which is: 0

- Als fixed tautologies in PayloadAtomicTestsC, such as:
EXPECT_EQreturnedValue, returnedValue);

Changed to:

EXPCT_EQ (iniialValue, returnedValue);

Signed-off-by: Lee killen <lskillen@...>
---
.../src/gunittest/c/payload/fieldatomictests.cpp | 506 ++---
.../gunittest/c/payload/fieldcompositetest.cp | 198 +-
.../src/gunittest/c/payload/fieldvectortests.cpp | 176 +-
.../src/gunittest//paylod/payloadatomictests.cpp | 352 ++--
.../gunittest/c/payload/payloadcompositetests.cp | 128 +-
.../gunttest/c/payload/payloadgeneraltests.cpp | 422 ++---
.../src/gunittest//payload/payloadvectortests.cpp| 1928
++++++++++----------> 7 files changed, 1855 insertions(+), 1855 deletions-)

diff --git a/mama/c_cpp/src/gunittest/c/payload/ieldaomictests.cpp
b/mama/c_cpp/src/gunittest/c/payload/fieldatomictests.cpp
indx 2e60999..933524 100644
--- a/mama/c_cpp/src/gunittest/c/payload/fieldatomictests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payoad/fieldatomictests.cpp
@@ -82,14 +82,14 @@ TEST_F(FieldBoolTests, UpdateBoolValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
rt = aBridge->msgPayloadAddBol(msg, NULL, 1, m_in);>- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1,&field);
- ASSERT_EQ(ret, MMA_STATUS_OK);
+ ASERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateBool(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(ieldBoolTests,UpdateBoolInvalidType)
@@ -99,14 +99,14 @@ TEST_F(FieldBoolTests, UpdateBoolInvalidType)
mama_staus ret = MAMA_STATUS_OK;

ret = aBridge->msPayladCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_K, ret);> ret = aBridge->msgPayloadAddChar(msg, NULL, 1, 'A');
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridg->sgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_TATUS_OK, ret);>
ret = aBridge->msgFieldPayloadUpdateBool(field, msg, m_udate);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_YPE, ret);
}

TEST_F(FeldBoolTests, UpdateBoolInValid)
@@ -116,18 +116,18 @@ TEST_F(FieldBoolTsts, UpdateBoolInValid)
mama_status ret = MAMA_STATUS_OK;

rt = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Nul Field*/
ret = aBridge->msgFieldPayloadUpdateBool(NULL, ms, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSET_Q (MAMA_STATUS_NULL_ARG, ret);

/*Null Unerlying field*/
ret = aBridge->msgFeldPayloadUpdateBool(field, msg, m_updae);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_AG, ret);

ret = aBidge->msgPayloadDestroy(field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STAUS_OK, ret);
}

TEST_F(FieldBoolests, GetBoolValid)
@@ -137,14 +137,14 @@ TEST_FFieldBoolTests, GetBoolValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge-msgPayloadCreate(&msg);
- ASSRT_EQ(ret, MAMA_STAUS_OK);
+ ASSERT_EQ (MAMA_STTUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->sgPayloadGetField(msg, NULL, 1, &fild);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret)

ret = aBridge->msgFieldPayloadGetBool(fied, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);>+ ASSERT_EQ (MAMA_STATUS_OK, ret);> }

TEST_F(FieldBoolTests, GetBoolInvalidType)
@@ -154,11 +154,11 @@ TEST_F(FieldBoolTests, GetBoolInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret aBrdge->msgPayloadCreae(&msg);
- ASSERT_EQ(re, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(mg, NULL, 1, "FRED");
- ASERT_EQret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSRT_Q(ret, MAMA_TATUS_OK);
+ ASERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetBool(field, &m_out);
ASSERT_EQ MAMA_STATUS_RONG_FIELD_TYPE, ret);
@@ -10,15 +170,15 @@ TEST_F(FieldBoolTess, GetBoolInValid)
mama_status ret MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadreate(&field);
- ASSRT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUSOK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloaGetBool(NULL, &m_out);
- ASSRT_EQ(rt, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetBool(field,&m_out);
- ASERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_E (MAMA_STATUS_INVALID_RG, ret);
}

/*********************************************************************
@@ -207,14 +207,14 @@ TEST_F(FieldCharTests, UpdateCharValid)
mama_status re = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreae(&msg);
- ASSERT_EQ(ret, MAMA_STATU_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg NULL,1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK)
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret =aBrige->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_SATUS_OK ret);

ret = aBridge->msgFieldPayloadUpdateChar(field, msg mupdate);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STTUS_OK, ret);
}

TEST_F(FieldCharTsts, UpdateCarInvalidType)
@@ -224,14 +224,14 @@ TEST_F(ieldCharTests, UpdateharInvalidType)
mama_status ret = MAMA_STATUS_OK;
ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBrdge->msgPayloadAddBol(msg, NULL, 1, (mama_bool_t)1);
- ASSET_EQ(ret, MAMA_STATUS_OK);
+ ASSERTEQ (MAMA_STATUS_OK, ret);
ret = aBridg->msgPayloadGetField(msg NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateChar(field msg, m_update);>- ASSERT_EQ(ret, MAMA_STAUS_WRONG_FIELD_TYPE);
+ ASERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldCharTests, UpdateCharInValid)
@@ -241,15 +241,15 @@ TST_(FieldCharTests, UpdateCharInValid)
mama_status ret = MAMA_STTUS_OK;

et = aBridge->msgFieldPayloadCreate(&eld);
- ASSER_EQ(ret, MAMA_STATU_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFildPayloadUpdateChar(NULL, msg, m_update);
- ASERT_EQ(rt, MAMA_STATUS_NUL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/> ret = aBridge->msgFieldPayloadpdateChar(field, msg, m_update);
- ASSERT_EQ(re, MAMA_STATUS_NULL_ARG);
ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldCharTests, GetCharValid)
@@ -259,14 +259,14 @@ TEST_F(FieldCharests, GetCharValid)
mama_status ret = MAMASTATUS_OK;
ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, et);
ret = aBridge>msgPayloadAddChar(msg, NULL, 1, min);
- ASSERT_EQ(re, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(sg, NULL, 1, &field);
- ASSERT_E(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldayloadGetChar(fild,&m_out);
- ASSERT_EQret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK ret);
}

TEST_F(FieldCharTests, GetCharInvalidType)
@@ -276,11 +276,11 @@ TEST_F(FieldCharests, GetCharInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridg->msgPayloadCreate(&msg);
- ASERT_Q(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayoadAddString(msg, NLL, 1, "FRED");
- ASSERT_EQ(ret MAMA_STATUS_OK);
+ ASSERT_EQ (AMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(sg, NULL, 1, &field);
- ASSRT_EQ(ret, MAMA_STATUS_OK);
+ ASSRT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetChar(field, &m_out);
ASSERT_EQ (MAMA_STATU_WRONG_FIELD_TYPE, ret);
@ -292,15 +292,15 @@ TEST_F(FieldCharTsts, GetCharInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBrige->msgFieldPayloadCreate&field);
- ASSERT_EQ(ret, MAMA_STAUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Nul Field*/
ret = aBridge->msgFieldPayloadGetChar(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_TATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null nderlying field*/
ret = aBridge->msFieldPayloadGetChar(field, &_out);
- ASSRT_EQ(ret, MAMA_STATU_INVALID_ARG);
+ ASSERT_EQ (MAMA_SATUS_INVALID_ARG, ret);
}

/********************************************************************
@@ -329,14 +329,14 @@ TEST_F(FieldI8Tests, UpdateI8Valid)
mama_status ret = MAMA_STATUS_OK

ret = aBridge->msgPaylodCreate(&msg;
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
re = aBridge->msgPayloadAddI8(msg, NUL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERTEQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret;

ret = aBridge->msgFieldPayloadUpdateI8(field, msg,m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (AMA_STATUS_OK, ret);
}

TEST_F(FieldI8Tests, UpdteI8InvalidType)
@@ -346,14 +346,1 @@ TEST_F(FieldI8Tests, UpdateI8InvalidType)
mama_status ret = MAMA_STATUS_OK;
ret = aBridge->msgPayloadCreate(&mg);
- ASSERT_EQ(rt, MMA_STATUS_OK);
+ ASERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bol_t)1);
- ASSERT_EQ(ret, MAMA_SATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetFieldmsg, NULL, 1, &field);
ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_O, ret);

ret = aBridge->msgFieldPayloadUpdateI8(field, sg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_TATU_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldI8Tets, UpdateI8InValid)
@@ -363,15 +36315 @@ TEST_F(FieldI8Tests, UpdateI8InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&feld);>- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/> ret= aBridge->msgFieldPaloadUpdateI8(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_TATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying fied*/
ret = aBridge->sgFieldPayloadUpdaeI8(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_RG);
+ ASERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_FFieldI8Tests, GetI8Valid)
@@ -381,14 +381,14 @@ TEST_F(FieldI8Tests, GetI8Valid)
mama_status ret = MAMA_STATUS_OK

ret = aBride->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMASTATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBrdge->msgPayladAddI8(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATU_OK);
+ SSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge>msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(et, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMASTATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI8(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret)
}

TES_(FeldI8Tests, GeI8InvalidType)
@@ -398,11 +398,11 @@ TEST_F(FieldI8Tests, GetI8InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret =aBridge->msgPayloadCreate(&msg)
- ASSERT_EQ(ret MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSER_EQ(ret, MAMA_STATUS_OK);>+ ASSERT_EQ (MAMA_STATUSOK, ret);
et = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERTEQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayladGetI8(fiel, &m_ou);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, rt);
@@ -414,15 +414,15 @@TEST_F(FieldI8Tests, GetI8InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->sgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, AMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_K, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetI8(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null ndrlyingfeld*/
ret = aBridge->msgFieldPayloadGetI8(field, &m_out);
- ASSER_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSRT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/*********************************************************************
@@ -451,14 +41,14@@ TEST_F(FieldU8Tests, UpdateU8Valid
mama_status ret = MAMA_STATUS_OK;

ret =aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSET_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU8(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK;
+ ASSERT_EQ (MAMA_STAUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
ASSERT_EQ(ret, AMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, rt);

ret = aBridge->msgFieldPayloadUpdateU8(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATS_OK, ret);
}

TEST_F(FieldU8Tests,UpdateU8InvalidType)
@ -468,14 +468,14 @@ TEST_F(FieldU8Tests, UpdateU8InvlidType)
mama_status ret = MAMA_STATUS_OK;

ret= aBridge->msgPayloadCreate(&msg;
- ASSERT_EQ(ret, MAA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_O);
+ ASSERT_EQ (MAM_STATUS_OK, ret);
ret = aBridge->msgPayloadGetFieldmsg, NULL 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridg->msgFieldPayloadUpdateU8(field, msg, m_update);
- ASERT_EQ(ret, MAMA_STATUS_RONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_RONG_FIED_TYPE, ret);
}

TEST_F(FieldU8Tests, UpdateU8InValid)
@@ -485,15 +485,15 @@TEST_F(FieldUTests, UpdateU8InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUdateU8(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldaylodUpdateU8(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, et);
}

TEST_F(FieldU8Tests, GetU8Valid)
@@ -503,14 +503,1 @@ TEST_F(FeldU8Tests, GetU8Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);> ASERT_EQ(ret, MAMA_STATUS_O);
+ ASSERT_Q (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU8(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK;
+ ASSERT_EQ(MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (AMA_STATUS_OK, ret);

et = aBridge->msgFieldPaylodGetU8(fiel, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU8Tets, GetU8InvalidType)
@@ -520,11 +520,11 @@ TEST_F(FieldU8Tests, GetU8InvalidType
mama_status ret = MAMA_STATUS_OK;

ret= aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
ASSERT_EQ (MAMA_STATUS_OK ret);
rt = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STTUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
re aBridge->msgPayloaGetField(msg, NULL, 1,&field);
- ASSERT_EQ(ret, MAMASTATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU8(field, &m_ut);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -536,15 +536,15 @ TEST_F(FieldU8Tests, GetU8InValid)
mama_statu ret = MAMA_STATUS_OK;

ret = aBridge-msgFieldPayloadCreate(&field);
- ASSERT_E(ret, MAMA_STATUS_OK);
+ ASSET_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/> ret = aBridge->msgieldPayloadGetU8(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG;
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
re = aBridg->msgFieldPayloadGetU8(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUSINVALID_ARG, ret);
}

/*******************************************************************
@@ -573,14 +573,14 @@ TEST_F(FieldI16Tests, UpdateI16Valid)
mama_status rt = MAMA_STAUS_OK;

ret = aBridge->msgPayloadCreate(&sg);
- ASSERT_EQ(ret, MAMA_STATUS_O);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge-msgPayloadAddI16(msg, NULL, 1, min);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_TATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ MAMA_STATUS_OK, ret);
ret = aBridge->msFieldPayloadUdateI16(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FilI16Tests,UpdateI16InvalidType)
@@ -590,14 +590,14 @@TEST_F(FieldI16Tests, UpdateI16InvalidType)
mama_status ret = MAMA_STATUS_OK;
ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSRT_EQ (MAMA_STATUS_OK,ret);
ret = aBridge-msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret aBridge->msgPayloadetField(msg, NULL, 1, &field);
- ASSERT_EQ(re, MAMA_STATS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadUpdateI16(fied, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_RONG_FIELD_TYPE, ret);
}>
TEST_F(Field16Tests, UpdateI16InValid)
@@ -607,15 +607,15 @@ TEST_F(FieldI16Tests, UpdateI16InValid)
mama_status ret = MAMA_STATUS_OK;
ret = aBridge->msgFeldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret =aBridge->msgieldPayloadUpdateI16(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSRT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldyloadUpdateI16(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_SATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}>
TEST_F(FieldI16Tests, GetI16Valid)
@@ -625,1 +625,14 @@ TEST_F(FieldI16Tests GetI16Valid)
mama_status rt = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCeate(&msg);
- ASERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret;
ret = aBridge->msgPayloadAddI16(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK;
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBidge->msgPayoadGetField(msg, NULL, 1, &feld);
- ASSERT_EQ(ret, MAMA_STATUS_OK)
+ ASSRT_EQ (MAMA_STATUS_OK, ret);

ret aBridge->msgFieldPayloadGetI16(field, &m_out);
- ASSERT_Q(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TESTF(FieldI16Tests GetI16InvalidType)
@@ -642,11 +62,11 @@ TEST_F(FieldI16ests, GetI16InvalidType)
mama_status ret = MAMA_STATUS_OK;
ret = aBridge->msgPayloadCreate(&msg);
- ASERT_EQ(ret, MAMA_STATUS_OK);
ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPaylodAddString(msg, NULL, 1, "FRED");
- ASERT_EQ(rt, MAMA_STATUS_OK);
+ ASSERT_Q (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMASTATUS_OK, ret);

ret = aBridge->msgFieldPayoadGetI16(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, et);>@@ -658,15 +658,15 @@ TEST_F(FieldI16Tests, GetI16InValid)
mama_status ret = MAMA_TATUS_OK;

ret =aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(re, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
/*Null Fild*/
ret = aBridge->msFieldPayloadGetI16(NULL, m_out);
- ASERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = Bridge->msgFieldPayloadGetI16(field,&m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/********************************************************************
@@-695,14 +695,14 @@ TEST_F(FieldU16Tests, UpdateU16Valid)
mama_satus ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSET_EQ (MAMA_STATUS_OK, ret);
ret= aBrige->msgPayloadAddU16(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASERTEQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFielPayloadUpdateU1(field, msg, m_update);>- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TES_F(FieldU16Tests, UpdateU16InvalidType)
@@ -712,14 +712,14 @@ TEST_F(FieldU16Tests, UpdateU16Invalidype)
mamastatus ret = MAMA_STATUS_OK;

rt = aBridge->msgPayladCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgayloadAddBool(msg, NUL, 1,(mama_bol_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
re = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STTUS_OK);
+ ASERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU16(fiel, mg, m_update);
- ASSERTEQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldU16Tsts, UpdateU16InValid)
@@ -729,15 +72915 @@ TEST_F(FieldU16Tets, UpdateU16InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMASTATUS_OK);
+ ASSERT_EQ (MMA_STATUS_OK,ret);

/*Nll Field*/
ret = aBridge->msgFieldPayloadUpdateU16(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
ASSET_EQ (MAMA_STATUS_NULL_ARG, ret);

/*NullUnderlying field*/
ret =aBridge->msgFieldPayloadUpdateU16(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_AG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldU16Tests, GetU1Valid)
@@ -747,14 +747,14 @@ TEST_F(FieldU16Tests, GetU16Vali)
mam_status ret = MMA_STATUS_OK;

ret = aBrige->msgPayloadCreate(&msg);
- ASSERT_EQ(re, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret;
ret = Bridge->msgPaylodAddU16(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, AMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATU_OK)
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBrdge->msgFieldPayloadGetU16(field, &m_out)
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FildU16Tests, GetU16InvalidType)
@@ -764,11 +74,11 @@ TEST_F(FieldU16Tests, GtU16InvalidType)
mama_status ret = MAMA_SATUS_OK;

ret = aBridge->msgPayloaCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ SSERT_EQ (MAMA_STATUS_OK, ret;
et = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STAUS_OK);
+ ASERT_EQ (MAMA_STATS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSER_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU16(field, &m_out);> ASSERT_EQ (MAMA_STATUSWRONG_FIELD_TYPE, ret);
@@ -780,15 +780,15 @@ TEST_F(FieldU16Tests, GetU16InValid)
mama_status ret = MAMASTATUS_OK;

ret = aBridge-msgFieldPayloadCreate(&field)
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge>msgFieldPayloadGeU16(NULL, &m_ot);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
/*Null Underlying ield*/
ret = aBridge->msgFieldPayloadGetU16(field, &m_out;
- ASSERT_EQ(ret, MAMA_STATUS_INVLID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, re);
}

/*********************************************************************
@@ -817,14 +817,14 @@ TET_F(FieldI32Tests, UpdteI32Valid)
mama_status ret = MAMA_SATUS_OK;

ret = aBridge->msgPayloadCeate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK ret);
ret = aBridge->msgPayloadAdI32(msg, NULL, 1, m_in);
- ASSERT_Q(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUSOK, ret);
ret = aBidge->msgPayloadGetField(msg, NULL, 1, &fild);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMASATUSOK, ret);

ret = aBridge->msgFieldPayloadUpdateI32(field, msg, m_pdate);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI32Tests, UpdateI32InvalidType)
@@ -834,14 +834,14 @@ TEST_F(FieldI32Tests, UpdaeI32InvalidType)
mam_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg;
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, et);
ret = aBridge->msgPaylodAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);>+ ASSERT_EQ (MAMA_STATUSOK, ret);
ret = aBridge->msgPayloadGeField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUSOK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge-msgFieldPayloadUpdateI32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ SSERT_EQ (MMA_STAUS_WRONG_FIELD_TYPE, ret);
}

TST_F(FieldI32Tests, UpdateI32InValid)
@@ -851,1 +851,15 @@ TEST_F(FieldI32Tests, UpdateI32InValid)
mama_status ret = MAMA_STATUS_OK;
ret = aBridge>msgFieldPaylodCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_Q (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateI32(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG)
+ ASSERT_E (MAMA_TATUS_NULL_AR, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateI32(field, msg, m_update);
- ASERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_E (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldI32Tests, GetI32Vlid)
@@ -869,14 +869,14 @@ TST_F(FieldI32Tests, GetI32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_SATUS_OK);
+ ASSERT_EQ (MAMA_STTUS_OK, ret);
ret = aBridge->msgPayloadAddI32(msg, NULL, 1, m_in);
- ASSERT_E(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
rt = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMASTATUS_OK, re);
ret = aBridge->msgFieldPayloadGetI32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_Q (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI32Tests, GetI32Invalidyp)
@@ -886,11 +886,11 @@ TEST_F(FieldI32Tests, GetI32InvalidType)
mama_status ret = MAMA_STATUS_OK;
ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->sgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAASTATUSOK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERTEQ (MAMA_STATUS_OK, et);

ret = aBridge->msgFieldPayloadGetI32(field, &m_out);
ASERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -902,15 +902,15 @@ TEST_F(FieldI32Tests, GetI32InValid)
mamastatus ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayoadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ MAMA_STATUS_OK, ret);

/*Null ield*/
ret = aBridge->msgFieldPayloadGetI32(NULL, &m_out);
- ASERT_EQ(et, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATS_NULL_AR, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetI32(field, &m_out);
- ASSERT_EQ(ret, AM_STATUS_INVALID_AG);
+ ASSERT_EQ (MAMA_STATUS_INVALD_ARG, ret);
}

/*********************************************************************
@@ -93,14 +939,14 @ TEST_F(FieldU32Tess, UpdateU32Valid)
mama_tatus ret = MAMA_STATUS_OK;

ret = aBride->msgPayoadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ(MAMA_STATUS_OK, ret)
ret = aBridge->msgPayloadAddU32(msg, NULL 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSER_EQ (MAM_STATUS_OK, ret);
ret = aBridge->msgPayloaGtField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);>
ret = aBrige->msgFieldPayloadUpdateU32(fiel, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(Field32Tets, UpdateU32InvalidType)
@@ -956,14 +956,14 @@ TEST_F(FieldU2Tests, UpdateU32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- SSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ(MAMA_STATUS_OK, ret);
ret = aBrige->msgPayloadAddBool(msg, NULL, 1, (mama_ool_t));
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAM_STATU_OK)
+ ASSERT_EQ(MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU32(field, msg, m_update);
- ASSERT_EQ(et, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ(MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldU32Tsts, Update32InValid)
@@ -973,15 +973,15 @@ TEST_F(FieldU32Tests, UpdateU32InVali)
mama_status ret = MAMA_SATUSOK;

ret = aBridge->msgFieldPayloadCreate(&field);>- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK ret);

/*Null Field*/
ret = aBridge->msgFeldPyloadUpdateU32(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, rt);

/*Null Underlying field*/
ret = aBridge>msgFieldPayloadUpdateU32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

EST_F(FieldU32Tests, GetU32Valid)
@@ -991,14 +991,14 @@ TEST_F(FieldU32Tests, GetU32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU32(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU32Tests, GetU32InvalidType)
@@ -1008,11 +1008,11 @@ TEST_F(FieldU32Tests, GetU32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU32(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1024,15 +1024,15 @@ TEST_F(FieldU32Tests, GetU32InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetU32(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetU32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -1061,14 +1061,14 @@ TEST_F(FieldI64Tests, UpdateI64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI64Tests, UpdateI64InvalidType)
@@ -1078,14 +1078,14 @@ TEST_F(FieldI64Tests, UpdateI64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateI64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldI64Tests, UpdateI64InValid)
@@ -1095,15 +1095,15 @@ TEST_F(FieldI64Tests, UpdateI64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateI64(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateI64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldI64Tests, GetI64Valid)
@@ -1113,14 +1113,14 @@ TEST_F(FieldI64Tests, GetI64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddI64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldI64Tests, GetI64InvalidType)
@@ -1130,11 +1130,11 @@ TEST_F(FieldI64Tests, GetI64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetI64(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1146,15 +1146,15 @@ TEST_F(FieldI64Tests, GetI64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetI64(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetI64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -1183,14 +1183,14 @@ TEST_F(FieldU64Tests, UpdateU64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU64Tests, UpdateU64InvalidType)
@@ -1200,14 +1200,14 @@ TEST_F(FieldU64Tests, UpdateU64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateU64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldU64Tests, UpdateU64InValid)
@@ -1217,15 +1217,15 @@ TEST_F(FieldU64Tests, UpdateU64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateU64(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateU64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldU64Tests, GetU64Valid)
@@ -1235,14 +1235,14 @@ TEST_F(FieldU64Tests, GetU64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddU64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldU64Tests, GetU64InvalidType)
@@ -1252,11 +1252,11 @@ TEST_F(FieldU64Tests, GetU64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetU64(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1268,15 +1268,15 @@ TEST_F(FieldU64Tests, GetU64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetU64(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetU64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}
/**********************************************************************
* F32 Tests
@@ -1304,14 +1304,14 @@ TEST_F(FieldF32Tests, UpdateF32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddF32(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateF32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldF32Tests, UpdateF32InvalidType)
@@ -1321,14 +1321,14 @@ TEST_F(FieldF32Tests, UpdateF32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateF32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldF32Tests, UpdateF32InValid)
@@ -1338,15 +1338,15 @@ TEST_F(FieldF32Tests, UpdateF32InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateF32(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateF32(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldF32Tests, GetF32Valid)
@@ -1356,14 +1356,14 @@ TEST_F(FieldF32Tests, GetF32Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddF32(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetF32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldF32Tests, GetF32InvalidType)
@@ -1373,11 +1373,11 @@ TEST_F(FieldF32Tests, GetF32InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetF32(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1389,15 +1389,15 @@ TEST_F(FieldF32Tests, GetF32InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetF32(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetF32(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -1426,14 +1426,14 @@ TEST_F(FieldF64Tests, UpdateF64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddF64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateF64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldF64Tests, UpdateF64InvalidType)
@@ -1443,14 +1443,14 @@ TEST_F(FieldF64Tests, UpdateF64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddBool(msg, NULL, 1, (mama_bool_t)1);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateF64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldF64Tests, UpdateF64InValid)
@@ -1460,15 +1460,15 @@ TEST_F(FieldF64Tests, UpdateF64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateF64(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateF64(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldF64Tests, GetF64Valid)
@@ -1478,14 +1478,14 @@ TEST_F(FieldF64Tests, GetF64Valid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddF64(msg, NULL, 1, m_in);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetF64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldF64Tests, GetF64InvalidType)
@@ -1495,11 +1495,11 @@ TEST_F(FieldF64Tests, GetF64InvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, "FRED");
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetF64(field, &m_out);
ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
@@ -1511,13 +1511,13 @@ TEST_F(FieldF64Tests, GetF64InValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetF64(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetF64(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}
diff --git a/mama/c_cpp/src/gunittest/c/payload/fieldcompositetests.cpp
b/mama/c_cpp/src/gunittest/c/payload/fieldcompositetests.cpp
index 55d72cf..f7875f6 100644
--- a/mama/c_cpp/src/gunittest/c/payload/fieldcompositetests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/fieldcompositetests.cpp
@@ -92,14 +92,14 @@ TEST_F(FieldStringTests, UpdateStringValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateString(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldStringTests, UpdateStringInvalidType)
@@ -109,14 +109,14 @@ TEST_F(FieldStringTests, UpdateStringInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, 'A');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateString(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldStringTests, UpdateStringInValid)
@@ -126,15 +126,15 @@ TEST_F(FieldStringTests, UpdateStringInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateString(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateString(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldStringTests, GetStringValid)
@@ -144,14 +144,14 @@ TEST_F(FieldStringTests, GetStringValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddString(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetString(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldStringTests, GetStringInvalidType)
@@ -161,14 +161,14 @@ TEST_F(FieldStringTests, GetStringInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetString(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldStringTests, GetStringInValid)
@@ -177,15 +177,15 @@ TEST_F(FieldStringTests, GetStringInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetString(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetString(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -231,14 +231,14 @@ TEST_F(FieldDateTimeTests, UpdateDateTimeValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddDateTime(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateDateTime(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldDateTimeTests, UpdateDateTimeInvalidType)
@@ -248,14 +248,14 @@ TEST_F(FieldDateTimeTests,
UpdateDateTimeInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, 'A');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdateDateTime(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldDateTimeTests, UpdateDateTimeInValid)
@@ -265,15 +265,15 @@ TEST_F(FieldDateTimeTests, UpdateDateTimeInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdateDateTime(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdateDateTime(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldDateTimeTests, GetDateTimeValid)
@@ -283,42 +283,42 @@ TEST_F(FieldDateTimeTests, GetDateTimeValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
//DateTime
ret = aBridge->msgPayloadAddDateTime(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//String
ret = aBridge->msgPayloadAddString(msg, NULL, 2, m_str);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 2, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//F64
ret = aBridge->msgPayloadAddF64(msg, NULL, 3, 123456.009);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 3, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//I64
ret = aBridge->msgPayloadAddI64(msg, NULL, 4, 1234556);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 4, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//U64
ret = aBridge->msgPayloadAddU64(msg, NULL, 5, 1234556);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 5, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);



@@ -333,14 +333,14 @@ TEST_F(FieldDateTimeTests, GetDateTimeInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetDateTime(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldDateTimeTests, GetDateTimeInValid)
@@ -349,7 +349,7 @@ TEST_F(FieldDateTimeTests, GetDateTimeInValid)

/*Null Field*/
ret = aBridge->msgFieldPayloadGetDateTime(NULL, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

/**********************************************************************
@@ -387,14 +387,14 @@ TEST_F(FieldOpaqueTests, GetOpaqueValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddOpaque(msg, NULL, 1, m_in, in_size);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetOpaque(field, &m_out, &out_size);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldOpaqueTests, GetOpaqueInvalidType)
@@ -404,14 +404,14 @@ TEST_F(FieldOpaqueTests, GetOpaqueInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetOpaque(field, &m_out, &out_size);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldOpaqueTests, GetOpaqueInValid)
@@ -420,15 +420,15 @@ TEST_F(FieldOpaqueTests, GetOpaqueInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetOpaque(NULL, &m_out, &out_size);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetOpaque(field, &m_out, &out_size);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);
}

/**********************************************************************
@@ -468,14 +468,14 @@ TEST_F(FieldPriceTests, UpdatePriceValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddPrice(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdatePrice(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldPriceTests, UpdatePriceInvalidType)
@@ -485,14 +485,14 @@ TEST_F(FieldPriceTests, UpdatePriceInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, 'A');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadUpdatePrice(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldPriceTests, UpdatePriceInValid)
@@ -502,15 +502,15 @@ TEST_F(FieldPriceTests, UpdatePriceInValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadUpdatePrice(NULL, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadUpdatePrice(field, msg, m_update);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

TEST_F(FieldPriceTests, GetPriceValid)
@@ -520,21 +520,21 @@ TEST_F(FieldPriceTests, GetPriceValid)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
//Price
ret = aBridge->msgPayloadAddPrice(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetPrice(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
//F64
ret = aBridge->msgPayloadAddF64(msg, NULL, 3, 123456.009);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 3, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgFieldPayloadGetPrice(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);
}

TEST_F(FieldPriceTests, GetPriceInvalidType)
@@ -544,14 +544,14 @@ TEST_F(FieldPriceTests, GetPriceInvalidType)
mama_status ret = MAMA_STATUS_OK;

ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetPrice(field, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);
}

TEST_F(FieldPriceTests, GetPriceInValid)
@@ -560,7 +560,7 @@ TEST_F(FieldPriceTests, GetPriceInValid)

/*Null Field*/
ret = aBridge->msgFieldPayloadGetPrice(NULL, m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);
}

/**********************************************************************
@@ -595,14 +595,14 @@ TEST_F(FieldMsgTests, GetMsgValid)

aBridge->msgPayloadCreate(&m_in);
ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddMsg(msg, NULL, 1, m_in);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetMsg(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, ret);

aBridge->msgPayloadDestroy(m_in);
}
@@ -615,14 +615,14 @@ TEST_F(FieldMsgTests, GetMsgInvalidType)

aBridge->msgPayloadCreate(&m_in);
ret = aBridge->msgPayloadCreate(&msg);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadAddChar(msg, NULL, 1, '0');
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);
ret = aBridge->msgPayloadGetField(msg, NULL, 1, &field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

ret = aBridge->msgFieldPayloadGetMsg(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_WRONG_FIELD_TYPE);
+ ASSERT_EQ (MAMA_STATUS_WRONG_FIELD_TYPE, ret);

aBridge->msgPayloadDestroy(m_in);
}
@@ -635,15 +635,15 @@ TEST_F(FieldMsgTests, GetMsgInValid)
aBridge->msgPayloadCreate(&m_in);

ret = aBridge->msgFieldPayloadCreate(&field);
- EXPECT_EQ(ret, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, ret);

/*Null Field*/
ret = aBridge->msgFieldPayloadGetMsg(NULL, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, ret);

/*Null Underlying field*/
ret = aBridge->msgFieldPayloadGetMsg(field, &m_out);
- ASSERT_EQ(ret, MAMA_STATUS_INVALID_ARG);
+ ASSERT_EQ (MAMA_STATUS_INVALID_ARG, ret);

aBridge->msgPayloadDestroy(m_in);
}
diff --git a/mama/c_cpp/src/gunittest/c/payload/fieldvectortests.cpp
b/mama/c_cpp/src/gunittest/c/payload/fieldvectortests.cpp
index a857504..9c701c8 100644
--- a/mama/c_cpp/src/gunittest/c/payload/fieldvectortests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/fieldvectortests.cpp
@@ -64,14 +64,14 @@ protected:
mama_loadPayloadBridge(&m_payloadBridge, m_payload.c_str());

m_status = m_payloadBridge->msgPayloadCreate(&m_msg);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
}

// Common TearDown
virtual void TearDown()
{
m_status = m_payloadBridge->msgPayloadDestroy(m_msg);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
}
};

@@ -118,19 +118,19 @@ TEST_F(FieldVectorBoolTests, GetVectorBool)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorBool(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorBoolTests, GetVectorBoolNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorBool(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorBoolTests, GetVectorBoolNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorBool(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

/**
@@ -177,22 +177,22 @@ TEST_F(FieldVectorCharTests, GetVectorChar)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorChar(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 'X');
- ASSERT_EQ(m_out[1], 'Y');
- ASSERT_EQ(m_size, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ ('X', m_out[0]);
+ ASSERT_EQ ('Y', m_out[1]);
+ ASSERT_EQ ((mama_size_t)VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorCharTests, GetVectorCharNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorChar(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorCharTests, GetVectorCharNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorChar(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -239,22 +239,22 @@ TEST_F(FieldVectorI8Tests, GetVectorI8)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorI8(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 1);
- ASSERT_EQ(m_out[1], 2);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE * sizeof(mama_i8_t));
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (1, m_out[0]);
+ ASSERT_EQ (2, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE * sizeof(mama_i8_t), m_size);
}

TEST_F(FieldVectorI8Tests, GetVectorI8NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI8(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorI8Tests, GetVectorI8NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI8(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -303,22 +303,22 @@ TEST_F(FieldVectorU8Tests, GetVectorU8)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorU8(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 128);
- ASSERT_EQ(m_out[1], 255);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (128, m_out[0]);
+ ASSERT_EQ (255, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorU8Tests, GetVectorU8NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU8(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorU8Tests, GetVectorU8NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU8(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -369,22 +369,22 @@ TEST_F(FieldVectorI16Tests, GetVectorI16)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorI16(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], -32768);
- ASSERT_EQ(m_out[1], 32767);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (-32768, m_out[0]);
+ ASSERT_EQ (32767, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorI16Tests, GetVectorI16NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI16(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorI16Tests, GetVectorI16NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI16(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -432,22 +432,22 @@ TEST_F(FieldVectorU16Tests, GetVectorU16)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorU16(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 32768);
- ASSERT_EQ(m_out[1], 65535);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (32768, m_out[0]);
+ ASSERT_EQ (65535, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorU16Tests, GetVectorU16NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU16(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorU16Tests, GetVectorU16NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU16(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -494,22 +494,22 @@ TEST_F(FieldVectorI32Tests, GetVectorI32)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorI32(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], -214783648);
- ASSERT_EQ(m_out[1], 214783647);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (-214783648, m_out[0]);
+ ASSERT_EQ (214783647, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorI32Tests, GetVectorI32NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI32(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorI32Tests, GetVectorI32NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI32(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -556,22 +556,22 @@ TEST_F(FieldVectorU32Tests, GetVectorU32)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorU32(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 2147483648);
- ASSERT_EQ(m_out[1], 4294967295);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (2147483648, m_out[0]);
+ ASSERT_EQ (4294967295, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorU32Tests, GetVectorU32NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU32(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorU32Tests, GetVectorU32NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU32(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -622,22 +622,22 @@ TEST_F(FieldVectorI64Tests, GetVectorI64)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorI64(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], -9223372036854775807);
- ASSERT_EQ(m_out[1], 9223372036854775807);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (-9223372036854775807, m_out[0]);
+ ASSERT_EQ (9223372036854775807, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorI64Tests, GetVectorI64NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI64(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorI64Tests, GetVectorI64NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorI64(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -693,22 +693,22 @@ TEST_F(FieldVectorU64Tests, GetVectorU64)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorU64(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], FieldVectorU64Tests::LARGE_NUM_1);
- ASSERT_EQ(m_out[1], FieldVectorU64Tests::LARGE_NUM_2);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (FieldVectorU64Tests::LARGE_NUM_1, m_out[0]);
+ ASSERT_EQ (FieldVectorU64Tests::LARGE_NUM_2, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorU64Tests, GetVectorU64NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU64(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorU64Tests, GetVectorU64NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorU64(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -755,22 +755,22 @@ TEST_F(FieldVectorF32Tests, GetVectorF32)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorF32(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 1.0f);
- ASSERT_EQ(m_out[1], 2.0f);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (1.0f, m_out[0]);
+ ASSERT_EQ (2.0f, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorF32Tests, GetVectorF32NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorF32(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorF32Tests, GetVectorF32NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorF32(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -817,22 +817,22 @@ TEST_F(FieldVectorF64Tests, GetVectorF64)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorF64(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_out[0], 1.0f);
- ASSERT_EQ(m_out[1], 2.0f);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ (1.0f, m_out[0]);
+ ASSERT_EQ (2.0f, m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorF64Tests, GetVectorF64NullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorF64(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorF64Tests, GetVectorF64NullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorF64(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -879,22 +879,22 @@ TEST_F(FieldVectorStringTests, GetVectorString)
{
m_payloadBridge->msgPayloadGetField (m_msg, NULL, 1, &m_field);
m_status = m_payloadBridge->msgFieldPayloadGetVectorString(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_STREQ(m_out[0], "ABC");
- EXPECT_STREQ(m_out[1], "XYZ");
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_STREQ ("ABC", m_out[0]);
+ EXPECT_STREQ ("XYZ", m_out[1]);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorStringTests, GetVectorStringNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorString(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorStringTests, GetVectorStringNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorString(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -958,19 +958,19 @@ protected:
TEST_F(FieldVectorDateTimeTests, GetVectorDateTime)
{
m_status =
m_payloadBridge->msgFieldPayloadGetVectorDateTime(m_field, m_out,
&m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorDateTimeTests, GetVectorDateTimeNullOut)
{
m_status =
m_payloadBridge->msgFieldPayloadGetVectorDateTime(m_field, NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorDateTimeTests, GetVectorDateTimeNullSize)
{
m_status =
m_payloadBridge->msgFieldPayloadGetVectorDateTime(m_field, m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

/**
@@ -1036,19 +1036,19 @@ protected:
TEST_F(FieldVectorPriceTests, GetVectorPrice)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorPrice(m_field,
m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorPriceTests, GetVectorPriceNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorPrice(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

TEST_F(FieldVectorPriceTests, GetVectorPriceNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorPrice(m_field,
m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NOT_IMPLEMENTED);
+ ASSERT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, m_status);
}

/**
@@ -1114,24 +1114,24 @@ TEST_F(FieldVectorSubMsgTests, GetVectorSubMsg)
char testName;

m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

// The following is to populate impl->mWombatField
m_status = m_payloadBridge->msgPayloadGetField(m_msg, &testName, 1,
&m_field);

m_status = m_payloadBridge->msgFieldPayloadGetVectorMsg(m_field,
&m_out, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- ASSERT_EQ(m_size, (mama_size_t) VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ ASSERT_EQ ((mama_size_t) VECTOR_SIZE, m_size);
}

TEST_F(FieldVectorSubMsgTests, GetVectorSubMsgNullOut)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorMsg(m_field,
NULL, &m_size);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(FieldVectorSubMsgTests, GetVectorSubMsgNullSize)
{
m_status = m_payloadBridge->msgFieldPayloadGetVectorMsg(m_field,
&m_out, NULL);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}
diff --git a/mama/c_cpp/src/gunittest/c/payload/payloadatomictests.cpp
b/mama/c_cpp/src/gunittest/c/payload/payloadatomictests.cpp
index 8925a94..6e16fbb 100644
--- a/mama/c_cpp/src/gunittest/c/payload/payloadatomictests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/payloadatomictests.cpp
@@ -68,15 +68,15 @@ TEST_F(PayloadAtomicTestsC, addBoolValid)

/* Adding the boolean to payload. */
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the boolean from the payload. */
res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addBoolInvalidFID)
@@ -86,9 +86,9 @@ TEST_F(PayloadAtomicTestsC, addBoolInvalidFID)

/* Adding the boolean to the payload */
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F (PayloadAtomicTestsC, addBoolInValidName)
@@ -98,9 +98,9 @@ TEST_F (PayloadAtomicTestsC, addBoolInValidName)

/* Adding the boolean to payload */
res = m_payloadBridge->msgPayloadAddBool(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addBoolNullPayload)
@@ -110,7 +110,7 @@ TEST_F(PayloadAtomicTestsC, addBoolNullPayload)

/* Adding the boolean to payload. */
res = m_payloadBridge->msgPayloadAddBool(NULL, NULL, 1,
initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addCharValid)
@@ -121,15 +121,15 @@ TEST_F(PayloadAtomicTestsC, addCharValid)

/* Adding the char to payload. */
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);

/* Recover the char from the payload. */
res = m_payloadBridge->msgPayloadGetChar(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Test initial and returned values match. */
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addCharInValidFID)
@@ -138,9 +138,9 @@ TEST_F(PayloadAtomicTestsC, addCharInValidFID)
mama_status res;
/* Adding the char to payload. */
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addCharInValidName)
@@ -150,9 +150,9 @@ TEST_F(PayloadAtomicTestsC, addCharInValidName)

/* Adding the char to the payload */
res = m_payloadBridge->msgPayloadAddChar(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddChar(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addCharNullPayload)
@@ -162,7 +162,7 @@ TEST_F(PayloadAtomicTestsC, addCharNullPayload)

/* Adding the char to payload. */
res = m_payloadBridge->msgPayloadAddChar(NULL, NULL, 1,
initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI8Valid)
@@ -173,14 +173,14 @@ TEST_F(PayloadAtomicTestsC, addI8Valid)

/* Adding the i8 to the payload */
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 2,
initialValue);
/* Recover the i8 from the payload */
res = m_payloadBridge->msgPayloadGetI8(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addI8InValidFID)
@@ -190,9 +190,9 @@ TEST_F(PayloadAtomicTestsC, addI8InValidFID)

/* Adding the I8 to payload. */
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI8InValidName)
@@ -202,9 +202,9 @@ TEST_F(PayloadAtomicTestsC, addI8InValidName)

/* Adding the I8 to the payload */
res = m_payloadBridge->msgPayloadAddI8(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI8(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI8NullPayload)
@@ -214,7 +214,7 @@ TEST_F(PayloadAtomicTestsC, addI8NullPayload)

/* Adding the I8 to payload. */
res = m_payloadBridge->msgPayloadAddI8(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU8Valid)
@@ -225,15 +225,15 @@ TEST_F(PayloadAtomicTestsC, addU8Valid)

/* Adding the u8 to the payload */
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the u8 from the payload */
res = m_payloadBridge->msgPayloadGetU8(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addU8InValidFID)
@@ -244,9 +244,9 @@ TEST_F(PayloadAtomicTestsC, addU8InValidFID)

/* Adding the U8 to payload. */
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU8InValidName)
@@ -257,9 +257,9 @@ TEST_F(PayloadAtomicTestsC, addU8InValidName)

/* Adding the U8 to the payload */
res = m_payloadBridge->msgPayloadAddU8(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU8(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU8NullPayload)
@@ -269,7 +269,7 @@ TEST_F(PayloadAtomicTestsC, addU8NullPayload)

/* Adding the U8 to payload. */
res = m_payloadBridge->msgPayloadAddU8(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI16Valid)
@@ -280,14 +280,14 @@ TEST_F(PayloadAtomicTestsC, addI16Valid)

/* Adding the i16 to the payload */
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 2,
initialValue);
/* Recover the i16 from the payload */
res = m_payloadBridge->msgPayloadGetI16(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addI16InValidFID)
@@ -297,9 +297,9 @@ TEST_F(PayloadAtomicTestsC, addI16InValidFID)

/* Adding the I16 to payload. */
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI16InValidName)
@@ -309,9 +309,9 @@ TEST_F(PayloadAtomicTestsC, addI16InValidName)

/* Adding the I16 to the payload */
res = m_payloadBridge->msgPayloadAddI16(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI16(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI16NullPayload)
@@ -321,7 +321,7 @@ TEST_F(PayloadAtomicTestsC, addI16NullPayload)

/* Adding the I16 to payload. */
res = m_payloadBridge->msgPayloadAddI16(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU16Valid)
@@ -332,15 +332,15 @@ TEST_F(PayloadAtomicTestsC, addU16Valid)

/* Adding the u16 to the payload */
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the u16 from the payload */
res = m_payloadBridge->msgPayloadGetU16(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addU16InValidFID)
@@ -350,9 +350,9 @@ TEST_F(PayloadAtomicTestsC, addU16InValidFID)

/* Adding the U16 to payload. */
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU16InValidName)
@@ -362,9 +362,9 @@ TEST_F(PayloadAtomicTestsC, addU16InValidName)

/* Adding the U16 to the payload */
res = m_payloadBridge->msgPayloadAddU16(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU16(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU16NullPayload)
@@ -374,7 +374,7 @@ TEST_F(PayloadAtomicTestsC, addU16NullPayload)

/* Adding the U16 to payload. */
res = m_payloadBridge->msgPayloadAddU16(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI32Valid)
@@ -385,15 +385,15 @@ TEST_F(PayloadAtomicTestsC, addI32Valid)

/* Adding the i32 to the payload */
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the i32 from the payload */
res = m_payloadBridge->msgPayloadGetI32(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addI32InValidFID)
@@ -403,9 +403,9 @@ TEST_F(PayloadAtomicTestsC, addI32InValidFID)

/* Adding the I32 to payload. */
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI32InValidName)
@@ -415,9 +415,9 @@ TEST_F(PayloadAtomicTestsC, addI32InValidName)

/* Adding the I32 to the payload */
res = m_payloadBridge->msgPayloadAddI32(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI32(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI32NullPayload)
@@ -427,7 +427,7 @@ TEST_F(PayloadAtomicTestsC, addI32NullPayload)

/* Adding the I32 to payload. */
res = m_payloadBridge->msgPayloadAddI32(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU32Valid)
@@ -438,16 +438,16 @@ TEST_F(PayloadAtomicTestsC, addU32Valid)

/* Adding the u32 to the payload */
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);

/* Recover the u32 from the payload */
res = m_payloadBridge->msgPayloadGetU32(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addU32InValidFID)
@@ -457,9 +457,9 @@ TEST_F(PayloadAtomicTestsC, addU32InValidFID)

/* Adding the U32 to payload. */
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU32InValidName)
@@ -469,9 +469,9 @@ TEST_F(PayloadAtomicTestsC, addU32InValidName)

/* Adding the U32 to the payload */
res = m_payloadBridge->msgPayloadAddU32(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU32(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU32NullPayload)
@@ -481,7 +481,7 @@ TEST_F(PayloadAtomicTestsC, addU32NullPayload)

/* Adding the U32 to payload. */
res = m_payloadBridge->msgPayloadAddU32(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI64Valid)
@@ -492,16 +492,16 @@ TEST_F(PayloadAtomicTestsC, addI64Valid)

/* Adding the i64 to the payload */
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);

/* Recover the i64 from the payload */
res = m_payloadBridge->msgPayloadGetI64(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addI64InValidFID)
@@ -511,9 +511,9 @@ TEST_F(PayloadAtomicTestsC, addI64InValidFID)

/* Adding the I64 to payload. */
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI64InValidName)
@@ -523,9 +523,9 @@ TEST_F(PayloadAtomicTestsC, addI64InValidName)

/* Adding the I64 to the payload */
res = m_payloadBridge->msgPayloadAddI64(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddI64(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addI64NullPayload)
@@ -535,7 +535,7 @@ TEST_F(PayloadAtomicTestsC, addI64NullPayload)

/* Adding the I64 to payload. */
res = m_payloadBridge->msgPayloadAddI64(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU64Valid)
@@ -546,15 +546,15 @@ TEST_F(PayloadAtomicTestsC, addU64Valid)

/* Adding the u64 to the payload */
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the u64 from the payload */
res = m_payloadBridge->msgPayloadGetU64(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addU64InValidFID)
@@ -564,9 +564,9 @@ TEST_F(PayloadAtomicTestsC, addU64InValidFID)

/* Adding the U64 to payload. */
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU64InValidName)
@@ -576,9 +576,9 @@ TEST_F(PayloadAtomicTestsC, addU64InValidName)

/* Adding the U64 to the payload */
res = m_payloadBridge->msgPayloadAddU64(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddU64(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addU64NullPayload)
@@ -588,7 +588,7 @@ TEST_F(PayloadAtomicTestsC, addU64NullPayload)

/* Adding the U64 to payload. */
res = m_payloadBridge->msgPayloadAddU64(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF32Valid)
@@ -599,16 +599,16 @@ TEST_F(PayloadAtomicTestsC, addF32Valid)

/* Adding the f32 to the payload */
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);

/* Recover the f32 from the payload */
res = m_payloadBridge->msgPayloadGetF32(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addF32InValidFID)
@@ -618,9 +618,9 @@ TEST_F(PayloadAtomicTestsC, addF32InValidFID)

/* Adding the F32 to payload. */
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF32InValidName)
@@ -630,9 +630,9 @@ TEST_F(PayloadAtomicTestsC, addF32InValidName)

/* Adding the F32 to the payload */
res = m_payloadBridge->msgPayloadAddF32(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF32(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF32NullPayload)
@@ -642,7 +642,7 @@ TEST_F(PayloadAtomicTestsC, addF32NullPayload)

/* Adding the F32 to payload. */
res = m_payloadBridge->msgPayloadAddF32(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF64Valid)
@@ -653,15 +653,15 @@ TEST_F(PayloadAtomicTestsC, addF64Valid)

/* Adding the f64 to the payload */
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 2,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the f64 from the payload */
res = m_payloadBridge->msgPayloadGetF64(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, addF64InValidFID)
@@ -671,9 +671,9 @@ TEST_F(PayloadAtomicTestsC, addF64InValidFID)

/* Adding the F64 to payload. */
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF64InValidName)
@@ -683,9 +683,9 @@ TEST_F(PayloadAtomicTestsC, addF64InValidName)

/* Adding the F64 to the payload */
res = m_payloadBridge->msgPayloadAddF64(m_payload, "testValue", 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
res = m_payloadBridge->msgPayloadAddF64(m_payload, NULL, 0,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, addF64NullPayload)
@@ -695,7 +695,7 @@ TEST_F(PayloadAtomicTestsC, addF64NullPayload)

/* Adding the F64 to payload. */
res = m_payloadBridge->msgPayloadAddF64(NULL, NULL, 1, initialValue);
- EXPECT_EQ(MAMA_STATUS_NULL_ARG, res);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

/************************************************
@@ -711,21 +711,21 @@ TEST_F(PayloadAtomicTestsC, updateBoolValid)

/* Adding the boolean to payload. */
res = m_payloadBridge->msgPayloadAddBool(m_payload, NULL, 1,
initialValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Check the stored value. */
res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(initialValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);

/* Update the payload with the value from another bool.*/
res = m_payloadBridge->msgPayloadUpdateBool(m_payload, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
/* Recover the boolean from the payload. */
res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateBoolNullPayload)
@@ -734,7 +734,7 @@ TEST_F(PayloadAtomicTestsC, updateBoolNullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateBool(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateCharValid)
@@ -754,8 +754,8 @@ TEST_F(PayloadAtomicTestsC, updateCharValid)
res = m_payloadBridge->msgPayloadGetChar(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateCharNullPayload)
@@ -764,7 +764,7 @@ TEST_F(PayloadAtomicTestsC, updateCharNullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateChar(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateU8Valid)
@@ -784,8 +784,8 @@ TEST_F(PayloadAtomicTestsC, updateU8Valid)
res = m_payloadBridge->msgPayloadGetU8(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateU8NullPayload)
@@ -794,7 +794,7 @@ TEST_F(PayloadAtomicTestsC, updateU8NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateU8(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateI8Valid)
@@ -814,8 +814,8 @@ TEST_F(PayloadAtomicTestsC, updateI8Valid)
res = m_payloadBridge->msgPayloadGetI8(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateI8NullPayload)
@@ -824,7 +824,7 @@ TEST_F(PayloadAtomicTestsC, updateI8NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateI8(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateI16Valid)
@@ -844,8 +844,8 @@ TEST_F(PayloadAtomicTestsC, updateI16Valid)
res = m_payloadBridge->msgPayloadGetI16(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateI16NullPayload)
@@ -854,7 +854,7 @@ TEST_F(PayloadAtomicTestsC, updateI16NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateI16(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateU16Valid)
@@ -874,8 +874,8 @@ TEST_F(PayloadAtomicTestsC, updateU16Valid)
res = m_payloadBridge->msgPayloadGetU16(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateU16NullPayload)
@@ -884,7 +884,7 @@ TEST_F(PayloadAtomicTestsC, updateU16NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateU16(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}


@@ -905,8 +905,8 @@ TEST_F(PayloadAtomicTestsC, updateI32Valid)
res = m_payloadBridge->msgPayloadGetI32(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateI32NullPayload)
@@ -915,7 +915,7 @@ TEST_F(PayloadAtomicTestsC, updateI32NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateI32(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateU32Valid)
@@ -935,8 +935,8 @@ TEST_F(PayloadAtomicTestsC, updateU32Valid)
res = m_payloadBridge->msgPayloadGetU32(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateU32NullPayload)
@@ -945,7 +945,7 @@ TEST_F(PayloadAtomicTestsC, updateU32NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateU32(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateF32Valid)
@@ -965,8 +965,8 @@ TEST_F(PayloadAtomicTestsC, updateF32Valid)
res = m_payloadBridge->msgPayloadGetF32(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateF32NullPayload)
@@ -975,7 +975,7 @@ TEST_F(PayloadAtomicTestsC, updateF32NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateF32(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}

TEST_F(PayloadAtomicTestsC, updateF64Valid)
@@ -995,8 +995,8 @@ TEST_F(PayloadAtomicTestsC, updateF64Valid)
res = m_payloadBridge->msgPayloadGetF64(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(updatedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (updatedValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, updateF64NullPayload)
@@ -1005,7 +1005,7 @@ TEST_F(PayloadAtomicTestsC, updateF64NullPayload)
mama_status res;

res = m_payloadBridge->msgPayloadUpdateF64(NULL, NULL, 1,
updatedValue);
- EXPECT_EQ(res, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, res);
}
/************************************************
* Tests which get the payload *
@@ -1024,8 +1024,8 @@ TEST_F(PayloadAtomicTestsC, getBoolValid)
res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getBoolInValid)
@@ -1034,7 +1034,7 @@ TEST_F(PayloadAtomicTestsC, getBoolInValid)
mama_bool_t returnedValue = (mama_bool_t)0;

res = m_payloadBridge->msgPayloadGetBool(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getCharValid)
@@ -1050,8 +1050,8 @@ TEST_F(PayloadAtomicTestsC, getCharValid)
res = m_payloadBridge->msgPayloadGetChar(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, initialValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getCharInValid)
@@ -1060,7 +1060,7 @@ TEST_F(PayloadAtomicTestsC, getCharInValid)
char returnedValue = 'A';

res = m_payloadBridge->msgPayloadGetChar(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getI8Valid)
@@ -1076,8 +1076,8 @@ TEST_F(PayloadAtomicTestsC, getI8Valid)
res = m_payloadBridge->msgPayloadGetI8(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getI8InValid)
@@ -1086,7 +1086,7 @@ TEST_F(PayloadAtomicTestsC, getI8InValid)
mama_i8_t returnedValue = (mama_i8_t)0;

res = m_payloadBridge->msgPayloadGetI8(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getU8Valid)
@@ -1102,8 +1102,8 @@ TEST_F(PayloadAtomicTestsC, getU8Valid)
res = m_payloadBridge->msgPayloadGetU8(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getU8InValid)
@@ -1112,7 +1112,7 @@ TEST_F(PayloadAtomicTestsC, getU8InValid)
mama_u8_t returnedValue = (mama_u8_t)0;

res = m_payloadBridge->msgPayloadGetU8(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getI16Valid)
@@ -1128,8 +1128,8 @@ TEST_F(PayloadAtomicTestsC, getI16Valid)
res = m_payloadBridge->msgPayloadGetI16(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getI16InValid)
@@ -1138,7 +1138,7 @@ TEST_F(PayloadAtomicTestsC, getI16InValid)
mama_i16_t returnedValue = (mama_i16_t)0;

res = m_payloadBridge->msgPayloadGetI16(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getU16Valid)
@@ -1154,8 +1154,8 @@ TEST_F(PayloadAtomicTestsC, getU16Valid)
res = m_payloadBridge->msgPayloadGetU16(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getU16InValid)
@@ -1164,7 +1164,7 @@ TEST_F(PayloadAtomicTestsC, getU16InValid)
mama_u16_t returnedValue = (mama_u16_t)0;

res = m_payloadBridge->msgPayloadGetU16(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getI32Valid)
@@ -1180,8 +1180,8 @@ TEST_F(PayloadAtomicTestsC, getI32Valid)
res = m_payloadBridge->msgPayloadGetI32(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getI32InValid)
@@ -1190,7 +1190,7 @@ TEST_F(PayloadAtomicTestsC, getI32InValid)
mama_i32_t returnedValue = (mama_i32_t)0;

res = m_payloadBridge->msgPayloadGetI32(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getU32Valid)
@@ -1206,8 +1206,8 @@ TEST_F(PayloadAtomicTestsC, getU32Valid)
res = m_payloadBridge->msgPayloadGetU32(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getU32InValid)
@@ -1216,7 +1216,7 @@ TEST_F(PayloadAtomicTestsC, getU32InValid)
mama_u32_t returnedValue = (mama_u32_t)0;

res = m_payloadBridge->msgPayloadGetU32(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getI64Valid)
@@ -1232,8 +1232,8 @@ TEST_F(PayloadAtomicTestsC, getI64Valid)
res = m_payloadBridge->msgPayloadGetI64(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getI64InValid)
@@ -1242,7 +1242,7 @@ TEST_F(PayloadAtomicTestsC, getI64InValid)
mama_i64_t returnedValue = (mama_i64_t)0;

res = m_payloadBridge->msgPayloadGetI64(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getU64Valid)
@@ -1258,8 +1258,8 @@ TEST_F(PayloadAtomicTestsC, getU64Valid)
res = m_payloadBridge->msgPayloadGetU64(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getU64InValid)
@@ -1268,7 +1268,7 @@ TEST_F(PayloadAtomicTestsC, getU64InValid)
mama_u64_t returnedValue = (mama_u64_t)0;

res = m_payloadBridge->msgPayloadGetU64(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getF32Valid)
@@ -1284,8 +1284,8 @@ TEST_F(PayloadAtomicTestsC, getF32Valid)
res = m_payloadBridge->msgPayloadGetF32(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getF32InValid)
@@ -1294,7 +1294,7 @@ TEST_F(PayloadAtomicTestsC, getF32InValid)
mama_f32_t returnedValue = (mama_f32_t)0;

res = m_payloadBridge->msgPayloadGetF32(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

TEST_F(PayloadAtomicTestsC, getF64Valid)
@@ -1310,8 +1310,8 @@ TEST_F(PayloadAtomicTestsC, getF64Valid)
res = m_payloadBridge->msgPayloadGetF64(m_payload, NULL, 1,
&returnedValue);

/* Test initial and returned values match. */
- EXPECT_EQ(res, MAMA_STATUS_OK);
- EXPECT_EQ(returnedValue, returnedValue);
+ EXPECT_EQ (MAMA_STATUS_OK, res);
+ EXPECT_EQ (initialValue, returnedValue);
}

TEST_F(PayloadAtomicTestsC, getF64InValid)
@@ -1320,6 +1320,6 @@ TEST_F(PayloadAtomicTestsC, getF64InValid)
mama_f64_t returnedValue = (mama_f64_t)0;

res = m_payloadBridge->msgPayloadGetF64(m_payload, NULL, 1,
&returnedValue);
- EXPECT_EQ(res, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, res);
}

diff --git a/mama/c_cpp/src/gunittest/c/payload/payloadcompositetests.cpp
b/mama/c_cpp/src/gunittest/c/payload/payloadcompositetests.cpp
index 3a6af02..48cc6b0 100644
--- a/mama/c_cpp/src/gunittest/c/payload/payloadcompositetests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/payloadcompositetests.cpp
@@ -59,14 +59,14 @@ protected:

mama_loadPayloadBridge(&m_payloadBridge, m_payload.c_str());
m_status = m_payloadBridge->msgPayloadCreate(&m_msg);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
}

// Common TearDown
virtual void TearDown()
{
m_status = m_payloadBridge->msgPayloadDestroy(m_msg);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//ForkedTest::TearDown();
}
@@ -112,20 +112,20 @@ protected:
TEST_F(PayloadStringTests, AddString)
{
m_status = m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1,
m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadStringTests, AddStringNullAdd)
{
ASSERT_NO_FATAL_FAILURE(m_payloadBridge->msgPayloadAddString(m_msg,
NULL, 1, NULL));
m_status = m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1,
NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadStringTests, AddStringNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddString(NULL, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -138,7 +138,7 @@ TEST_F(PayloadStringTests, UpdateString)
m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdateString(m_msg, NULL, 1,
m_update);
m_payloadBridge->msgPayloadGetString(m_msg, NULL, 1, &m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
EXPECT_STREQ(m_out, m_update);
}

@@ -146,20 +146,20 @@ TEST_F(PayloadStringTests, UpdateStringNoAdd)
{
m_status = m_payloadBridge->msgPayloadUpdateString(m_msg, NULL, 1,
m_update);
m_payloadBridge->msgPayloadGetString(m_msg, NULL, 1, &m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
EXPECT_STREQ(m_out, m_update);
}

TEST_F(PayloadStringTests, UpdateStringNullUpdate)
{
m_status = m_payloadBridge->msgPayloadUpdateString(m_msg, NULL, 1,
NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadStringTests, UpdateStringNullMessage)
{
m_status = m_payloadBridge->msgPayloadUpdateString(NULL, NULL, 1,
m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -171,7 +171,7 @@ TEST_F(PayloadStringTests, GetString)
{
m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetString(m_msg, NULL, 1,
&m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
EXPECT_STREQ(m_out, m_in);
}

@@ -179,14 +179,14 @@ TEST_F(PayloadStringTests, GetStringNullOutput)
{
m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetString(m_msg, NULL, 1,
NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadStringTests, GetStringNullMessage)
{
m_payloadBridge->msgPayloadAddString(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetString(NULL, NULL, 1,
&m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -232,19 +232,19 @@ protected:
TEST_F(PayloadOpaqueTests, AddOpaque)
{
m_status = m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1,
(void*)&m_in, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadOpaqueTests, AddOpaqueNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1,
NULL, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadOpaqueTests, AddOpaqueNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddOpaque(NULL, NULL, 1,
(void*)&m_in, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -258,9 +258,9 @@ TEST_F(PayloadOpaqueTests, UpdateOpaque)
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in,
sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadUpdateOpaque(m_msg, NULL, 1,
(void*)&m_update, sizeof(uint32_t));
m_payloadBridge->msgPayloadGetOpaque(m_msg, NULL, 1, (const
void**)&m_out, &size);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(std::memcmp((void*)&m_update, (void*)m_out,
sizeof(uint32_t)), 0);
- EXPECT_EQ(size, sizeof(uint32_t));
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, std::memcmp((void*)&m_update, (void*)m_out,
sizeof(uint32_t)));
+ EXPECT_EQ (sizeof(uint32_t), size);
}

TEST_F(PayloadOpaqueTests, UpdateOpaqueNoAdd)
@@ -268,23 +268,23 @@ TEST_F(PayloadOpaqueTests, UpdateOpaqueNoAdd)
mama_size_t size;
m_status = m_payloadBridge->msgPayloadUpdateOpaque(m_msg, NULL, 1,
(void*)&m_update, sizeof(uint32_t));
m_payloadBridge->msgPayloadGetOpaque(m_msg, NULL, 1, (const
void**)&m_out, &size);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(std::memcmp((void*)&m_update, (void*)m_out,
sizeof(uint32_t)), 0);
- EXPECT_EQ(size, sizeof(uint32_t));
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, std::memcmp((void*)&m_update, (void*)m_out,
sizeof(uint32_t)));
+ EXPECT_EQ (sizeof(uint32_t), size);
}

TEST_F(PayloadOpaqueTests, UpdateOpaqueNullUpdate)
{
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in,
sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadUpdateOpaque(m_msg, NULL, 1,
NULL, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadOpaqueTests, UpdateOpaqueNullMessage)
{
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in,
sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadUpdateOpaque(NULL, NULL, 1,
(void*)&m_update, sizeof(uint32_t));
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -297,9 +297,9 @@ TEST_F(PayloadOpaqueTests, GetOpaque)
mama_size_t size (0);
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in,
sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadGetOpaque(m_msg, NULL, 1,
(const void**)&m_out, &size);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(std::memcmp((void*)&m_in, (void*)m_out, sizeof(uint32_t)),
0);
- EXPECT_EQ(size, sizeof(uint32_t));
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, std::memcmp((void*)&m_in, (void*)m_out,
sizeof(uint32_t)));
+ EXPECT_EQ (sizeof(uint32_t), size);
}

TEST_F(PayloadOpaqueTests, GetOpaqueNullOutput)
@@ -307,7 +307,7 @@ TEST_F(PayloadOpaqueTests, GetOpaqueNullOutput)
mama_size_t size (0);
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in,
sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadGetOpaque(m_msg, NULL, 1,
NULL, &size);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadOpaqueTests, GetOpaqueNullMessage)
@@ -315,7 +315,7 @@ TEST_F(PayloadOpaqueTests, GetOpaqueNullMessage)
mama_size_t size (0);
m_payloadBridge->msgPayloadAddOpaque(m_msg, NULL, 1, (void*)&m_in,
sizeof(uint32_t));
m_status = m_payloadBridge->msgPayloadAddOpaque(NULL, NULL, 1,
(void*)&m_in, size);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -367,19 +367,19 @@ protected:
TEST_F(PayloadDateTimeTests, AddDateTime)
{
m_status = m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1,
m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadDateTimeTests, AddDateTimeNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1,
NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadDateTimeTests, AddDateTimeNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddDateTime(NULL, NULL, 1,
m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}


@@ -393,30 +393,30 @@ TEST_F(PayloadDateTimeTests, UpdateDateTime)
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdateDateTime(m_msg, NULL, 1,
m_update);
m_payloadBridge->msgPayloadGetDateTime(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaDateTime_equal(m_out, m_update), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaDateTime_equal(m_out, m_update));
}

TEST_F(PayloadDateTimeTests, UpdateDateTimeNoAdd)
{
m_status = m_payloadBridge->msgPayloadUpdateDateTime(m_msg, NULL, 1,
m_update);
m_payloadBridge->msgPayloadGetDateTime(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaDateTime_equal(m_out, m_update), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaDateTime_equal(m_out, m_update));
}

TEST_F(PayloadDateTimeTests, UpdateDateTimeNullUpdate)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdateDateTime(m_msg, NULL, 1,
NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadDateTimeTests, UpdateDateTimeNullMessage)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdateDateTime(NULL, NULL, 1,
m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -428,22 +428,22 @@ TEST_F(PayloadDateTimeTests, GetDateTime)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetDateTime(m_msg, NULL, 1,
m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaDateTime_equal(m_in, m_out), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaDateTime_equal(m_in, m_out));
}

TEST_F(PayloadDateTimeTests, GetDateTimeNullOutput)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetDateTime(m_msg, NULL, 1,
NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadDateTimeTests, GetDateTimeNullMessage)
{
m_payloadBridge->msgPayloadAddDateTime(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetDateTime(NULL, NULL, 1,
m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -496,20 +496,20 @@ TEST_F(PayloadPriceTests, AddPrice)
{
m_status = m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaPrice_equal(m_out, m_in), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaPrice_equal(m_out, m_in));
}

TEST_F(PayloadPriceTests, AddPriceNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadPriceTests, AddPriceNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddPrice(NULL, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -522,30 +522,30 @@ TEST_F(PayloadPriceTests, UpdatePrice)
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdatePrice(m_msg, NULL, 1,
m_update);
m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaPrice_equal(m_out, m_update), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaPrice_equal(m_out, m_update));
}

TEST_F(PayloadPriceTests, UpdatePriceNoAdd)
{
m_status = m_payloadBridge->msgPayloadUpdatePrice(m_msg, NULL, 1,
m_update);
m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaPrice_equal(m_out, m_update), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaPrice_equal(m_out, m_update));
}

TEST_F(PayloadPriceTests, UpdatePriceNullUpdate)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdatePrice(m_msg, NULL, 1,
NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadPriceTests, UpdatePriceNullMessage)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadUpdatePrice(NULL, NULL, 1,
m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -557,22 +557,22 @@ TEST_F(PayloadPriceTests, GetPrice)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1,
m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(mamaPrice_equal(m_in, m_out), 1);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (1, mamaPrice_equal(m_in, m_out));
}

TEST_F(PayloadPriceTests, GetPriceNullOutput)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetPrice(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadPriceTests, GetPriceNullMessage)
{
m_payloadBridge->msgPayloadAddPrice(m_msg, NULL, 1, m_in);
m_status = m_payloadBridge->msgPayloadGetPrice(NULL, NULL, 1, m_out);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -616,19 +616,19 @@ protected:
TEST_F(PayloadSubMsgTests, AddSubMsg)
{
m_status = m_payloadBridge->msgPayloadAddMsg(m_msg, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadSubMsgTests, AddSubMsgNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddMsg(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadSubMsgTests, AddSubMsgNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddMsg(NULL, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -640,19 +640,19 @@ TEST_F(PayloadSubMsgTests, UpdateSubMsg)
{
/* TODO revist this */
m_status = m_payloadBridge->msgPayloadUpdateSubMsg(m_msg, NULL, 1,
m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadSubMsgTests, UpdateSubMsgNullUpdate)
{
m_status = m_payloadBridge->msgPayloadUpdateSubMsg(m_msg, NULL, 1,
NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadSubMsgTests, UpdateSubMsgNullMessage)
{
m_status = m_payloadBridge->msgPayloadUpdateSubMsg(NULL, NULL, 1,
m_update);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

/**
@@ -666,7 +666,7 @@ TEST_F(PayloadSubMsgTests, GetSubMsg)
m_payloadBridge->msgPayloadGetMsg(m_msg, NULL, 1, &m_out);
// m_payloadBridge->msgPayloadGetBool(m_in, NULL, 2, &a);
// m_payloadBridge->msgPayloadGetBool(m_in, NULL, 2, &b);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
// EXPECT_EQ(a|b, 0xFF);
// TODO: Fix
}
@@ -674,11 +674,11 @@ TEST_F(PayloadSubMsgTests, GetSubMsg)
TEST_F(PayloadSubMsgTests, GetSubMsgNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddMsg(m_msg, NULL, 1, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadSubMsgTests, GetSubMsgNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddMsg(NULL, NULL, 1, m_in);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}
diff --git a/mama/c_cpp/src/gunittest/c/payload/payloadgeneraltests.cpp
b/mama/c_cpp/src/gunittest/c/payload/payloadgeneraltests.cpp
index 32dd7cc..ccaa470 100644
--- a/mama/c_cpp/src/gunittest/c/payload/payloadgeneraltests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/payloadgeneraltests.cpp
@@ -78,14 +78,14 @@ TEST_F(PayloadGeneralTests, CreateValid)

result = aBridge->msgPayloadCreate(&testPayload);

- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, CreateInValid)
{
result = aBridge->msgPayloadCreate(NULL);

- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* OPTIONAL TEST:
@@ -102,7 +102,7 @@ TEST_F(PayloadGeneralTests, CreateForTemplateValid)

CHECK_NON_IMPLEMENTED_OPTIONAL(result);

- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetTypeValid)
@@ -119,10 +119,10 @@ TEST_F(PayloadGeneralTests, CopyValid)
msgPayload copyPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreate(&copyPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -130,7 +130,7 @@ TEST_F(PayloadGeneralTests, CopyValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadCopy(testPayload, &copyPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, CopyInValidPayload)
@@ -138,7 +138,7 @@ TEST_F(PayloadGeneralTests, CopyInValidPayload)
msgPayload copyPayload = NULL;

result = aBridge->msgPayloadCopy(NULL, &copyPayload);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* Requires discussion regarding what this test is actually expecting to
check.
@@ -150,7 +150,7 @@ TEST_F(PayloadGeneralTests, CopyInValidCopy)
msgPayload copyPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -158,7 +158,7 @@ TEST_F(PayloadGeneralTests, CopyInValidCopy)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadCopy(testPayload, &copyPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, ClearValid)
@@ -166,16 +166,16 @@ TEST_F(PayloadGeneralTests, ClearValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadClear(testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, ClearInValid)
{
result = aBridge->msgPayloadClear(NULL);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, DestroyValid)
@@ -183,10 +183,10 @@ TEST_F(PayloadGeneralTests, DestroyValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadDestroy(testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, DestroyInValid)
@@ -194,10 +194,10 @@ TEST_F(PayloadGeneralTests, DestroyInValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadDestroy(NULL);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetParentValid)
@@ -206,10 +206,10 @@ TEST_F(PayloadGeneralTests, SetParentValid)
mamaMsg testParent = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetParent(testPayload, testParent);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, SetParentInValidPayload)
@@ -217,7 +217,7 @@ TEST_F(PayloadGeneralTests, SetParentInValidPayload)
mamaMsg testParent = NULL;

result = aBridge->msgPayloadSetParent(NULL, testParent);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetParentInValidParent)
@@ -225,7 +225,7 @@ TEST_F(PayloadGeneralTests, SetParentInValidParent)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadSetParent(testPayload, NULL);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteSizeValid)
@@ -234,7 +234,7 @@ TEST_F(PayloadGeneralTests, GetByteSizeValid)
mama_size_t testSize = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -245,7 +245,7 @@ TEST_F(PayloadGeneralTests, GetByteSizeValid)

CHECK_NON_IMPLEMENTED_OPTIONAL(result);

- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetByteSizeInValidPayload)
@@ -253,7 +253,7 @@ TEST_F(PayloadGeneralTests, GetByteSizeInValidPayload)
mama_size_t testSize = 0;

result = aBridge->msgPayloadGetByteSize(NULL, &testSize);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteSizeInValidSize)
@@ -261,7 +261,7 @@ TEST_F(PayloadGeneralTests, GetByteSizeInValidSize)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadGetByteSize(testPayload, NULL);
- EXPECT_EQ(result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}


@@ -271,7 +271,7 @@ TEST_F(PayloadGeneralTests, GetNumberFieldsValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadAddChar(testPayload, NULL, 1, 'a');
result = aBridge->msgPayloadAddChar(testPayload, NULL, 2, 'b');
@@ -282,11 +282,11 @@ TEST_F(PayloadGeneralTests, GetNumberFieldsValid)
result = aBridge->msgPayloadAddChar(testPayload, NULL, 7, 'g');
result = aBridge->msgPayloadAddChar(testPayload, NULL, 8, 'h');
result = aBridge->msgPayloadAddChar(testPayload, NULL, 9, 'i');
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNumFields(testPayload, &numFields);
- EXPECT_EQ (result, MAMA_STATUS_OK);
- EXPECT_EQ (numFields, (mama_size_t)9);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
+ EXPECT_EQ ((mama_size_t)9, numFields);
}

TEST_F(PayloadGeneralTests, GetNumberFieldsInValidPayload)
@@ -294,7 +294,7 @@ TEST_F(PayloadGeneralTests,
GetNumberFieldsInValidPayload)
mama_size_t numFields = 0;

result = aBridge->msgPayloadGetNumFields(NULL, &numFields);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetNumberFieldsInValidNumFields)
@@ -305,7 +305,7 @@ TEST_F(PayloadGeneralTests,
GetNumberFieldsInValidNumFields)
aBridge->msgPayloadAddChar(testPayload, NULL, 1, 'a');

result = aBridge->msgPayloadGetNumFields(testPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetSendSubjectValid)
@@ -313,10 +313,10 @@ TEST_F(PayloadGeneralTests, GetSendSubjectValid)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetSendSubject(testPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NOT_IMPLEMENTED);
+ EXPECT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, result);
}


@@ -328,7 +328,7 @@ TEST_F(PayloadGeneralTests, GetSendSubjectInValidMsg)

CHECK_NON_IMPLEMENTED_OPTIONAL(result);

- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetSendSubjectInValidSubject)
@@ -336,10 +336,10 @@ TEST_F(PayloadGeneralTests,
GetSendSubjectInValidSubject)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetSendSubject(testPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NOT_IMPLEMENTED);
+ EXPECT_EQ (MAMA_STATUS_NOT_IMPLEMENTED, result);
}

TEST_F(PayloadGeneralTests, ToStringValid)
@@ -348,7 +348,7 @@ TEST_F(PayloadGeneralTests, ToStringValid)
const char* char_result;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

char_result = aBridge->msgPayloadToString(testPayload);
EXPECT_STREQ (char_result, "{}");
@@ -362,7 +362,7 @@ TEST_F(PayloadGeneralTests, ToStringValidConsistent)
const char* char_result2;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadAddChar(testPayload, NULL, 1, 'a');
result = aBridge->msgPayloadAddChar(testPayload, NULL, 2, 'b');
@@ -386,7 +386,7 @@ TEST_F(PayloadGeneralTests, ToStringInValid)
const char* char_result;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

char_result = aBridge->msgPayloadToString(NULL);
EXPECT_STREQ (char_result, NULL);
@@ -403,10 +403,10 @@ TEST_F(PayloadGeneralTests, IterateFieldsValid)
msgFieldPayload testMamaField = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);

aBridge->msgFieldPayloadCreate(&testMamaField);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterateFields(
testPayload,
@@ -415,7 +415,7 @@ TEST_F(PayloadGeneralTests, IterateFieldsValid)
dummyIteratorCallback,
NULL);

- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

/* TODO: This test should return NULL, but needs to have the parent
msg,
@@ -429,7 +429,7 @@ TEST_F(PayloadGeneralTests,
IterateFieldsInValidPayload)
void* testClosure;

result = aBridge->msgPayloadIterateFields(NULL, testMamaMsg,
testMamaField, testMamaMsgIteratorCb, &testClosure);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* TODO: This test should return NULL, but needs to have the callback
and
@@ -443,10 +443,10 @@ TEST_F(PayloadGeneralTests,
IterateFieldsInValidParent)
void* testClosure;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterateFields(testPayload, NULL,
testMamaField, testMamaMsgIteratorCb, &testClosure);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* TODO: This test should return NULL, but needs to have the parent msg
and
@@ -460,10 +460,10 @@ TEST_F(PayloadGeneralTests,
IterateFieldsInValidMamaField)
void* testClosure;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterateFields(testPayload, testMamaMsg,
NULL, testMamaMsgIteratorCb, &testClosure);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* TODO: This test should return NULL, but needs to have the parent msg
and
@@ -477,10 +477,10 @@ TEST_F(PayloadGeneralTests,
IterateFieldsInValidCallBack)
void* testClosure;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterateFields(testPayload, testMamaMsg,
testMamaField, NULL, &testClosure);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SerializeValid)
@@ -490,7 +490,7 @@ TEST_F(PayloadGeneralTests, SerializeValid)
mama_size_t testBufferLength = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -498,7 +498,7 @@ TEST_F(PayloadGeneralTests, SerializeValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadSerialize(testPayload, (const
void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, SerializeInValidPayLoad)
@@ -508,10 +508,10 @@ TEST_F(PayloadGeneralTests, SerializeInValidPayLoad)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSerialize(NULL, (const void**)&testBuffer,
&testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SerializeInValidBuffer)
@@ -520,7 +520,7 @@ TEST_F(PayloadGeneralTests, SerializeInValidBuffer)
mama_size_t testBufferLength = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -528,7 +528,7 @@ TEST_F(PayloadGeneralTests, SerializeInValidBuffer)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadSerialize(testPayload, NULL,
&testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SerializeInValidBufferLength)
@@ -537,7 +537,7 @@ TEST_F(PayloadGeneralTests,
SerializeInValidBufferLength)
char* testBuffer;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -545,7 +545,7 @@ TEST_F(PayloadGeneralTests,
SerializeInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadSerialize(testPayload, (const
void**)&testBuffer, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, UnSerializeValid)
@@ -555,14 +555,14 @@ TEST_F(PayloadGeneralTests, UnSerializeValid)
mama_size_t testBufferLength = 50;

result = aBridge->msgPayloadCreate(&testPayload);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
result = aBridge->msgPayloadSerialize(testPayload, (const
void**)&testBuffer, &testBufferLength);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadUnSerialize(testPayload, (const
void**)testBuffer, testBufferLength);
- ASSERT_EQ (result, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, UnSerializeInValidPayload)
@@ -572,10 +572,10 @@ TEST_F(PayloadGeneralTests,
UnSerializeInValidPayload)
mama_size_t testBufferLength = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadUnSerialize(NULL, &testBuffer,
testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, UnSerializeInValidBuffer)
@@ -584,10 +584,10 @@ TEST_F(PayloadGeneralTests,
UnSerializeInValidBuffer)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadUnSerialize(testPayload, NULL,
testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, UnSerializeInValidBufferLength)
@@ -596,10 +596,10 @@ TEST_F(PayloadGeneralTests,
UnSerializeInValidBufferLength)
const void* testBuffer;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadUnSerialize(testPayload, &testBuffer,
NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteBufferValid)
@@ -610,10 +610,10 @@ TEST_F(PayloadGeneralTests, GetByteBufferValid)
mamaMsg testMamaMsg = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetParent(testPayload, testMamaMsg);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -621,7 +621,7 @@ TEST_F(PayloadGeneralTests, GetByteBufferValid)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const
void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetByteBufferInValidPayload)
@@ -631,7 +631,7 @@ TEST_F(PayloadGeneralTests,
GetByteBufferInValidPayload)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -639,7 +639,7 @@ TEST_F(PayloadGeneralTests,
GetByteBufferInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(NULL, (const
void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteBufferInValidBuffer)
@@ -648,7 +648,7 @@ TEST_F(PayloadGeneralTests,
GetByteBufferInValidBuffer)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -656,7 +656,7 @@ TEST_F(PayloadGeneralTests,
GetByteBufferInValidBuffer)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, NULL,
&testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetByteBufferInValidBufferLength)
@@ -665,7 +665,7 @@ TEST_F(PayloadGeneralTests,
GetByteBufferInValidBufferLength)
char* testBuffer;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -673,7 +673,7 @@ TEST_F(PayloadGeneralTests,
GetByteBufferInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const
void**)&testBuffer, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferValid)
@@ -683,7 +683,7 @@ TEST_F(PayloadGeneralTests, SetByteBufferValid)
mama_size_t testBufferLength = 100;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -691,13 +691,13 @@ TEST_F(PayloadGeneralTests, SetByteBufferValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const
void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayload, aBridge,
(const void*)testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetByteBuffer(&testPayload, aBridge,
&testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferInValidPayload)
@@ -707,10 +707,10 @@ TEST_F(PayloadGeneralTests,
SetByteBufferInValidPayload)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetByteBuffer(NULL, aBridge,
&testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferInValidBridge)
@@ -720,7 +720,7 @@ TEST_F(PayloadGeneralTests,
SetByteBufferInValidBridge)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -728,7 +728,7 @@ TEST_F(PayloadGeneralTests,
SetByteBufferInValidBridge)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadSetByteBuffer(&testPayload, NULL,
&testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferInValidBuffer)
@@ -737,10 +737,10 @@ TEST_F(PayloadGeneralTests,
SetByteBufferInValidBuffer)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadSetByteBuffer(&testPayload, aBridge,
NULL, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, SetByteBufferInValidBufferLength)
@@ -749,7 +749,7 @@ TEST_F(PayloadGeneralTests,
SetByteBufferInValidBufferLength)
const char* testBuffer;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -757,7 +757,7 @@ TEST_F(PayloadGeneralTests,
SetByteBufferInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadSetByteBuffer(&testPayload, aBridge,
&testBuffer, 0);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/* TODO: Check the values in the created payload.
@@ -771,7 +771,7 @@ TEST_F(PayloadGeneralTests, CreateFromByteBufferValid)

result = aBridge->msgPayloadCreate(&testPayload);
result = aBridge->msgPayloadCreate(&testPayloadNew);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -779,10 +779,10 @@ TEST_F(PayloadGeneralTests,
CreateFromByteBufferValid)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const
void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayloadNew,
aBridge, (const void*)testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidPayLoad)
@@ -792,13 +792,13 @@ TEST_F(PayloadGeneralTests,
CreateFromByteBufferInValidPayLoad)
mama_size_t testBufferLength = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const
void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(NULL, aBridge, (const
void*)testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBridge)
@@ -810,7 +810,7 @@ TEST_F(PayloadGeneralTests,
CreateFromByteBufferInValidBridge)

result = aBridge->msgPayloadCreate(&testPayload);
result = aBridge->msgPayloadCreate(&testPayloadNew);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -818,10 +818,10 @@ TEST_F(PayloadGeneralTests,
CreateFromByteBufferInValidBridge)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const
void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayloadNew, NULL,
(const void*)testBuffer, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBuffer)
@@ -833,7 +833,7 @@ TEST_F(PayloadGeneralTests,
CreateFromByteBufferInValidBuffer)

result = aBridge->msgPayloadCreate(&testPayload);
result = aBridge->msgPayloadCreate(&testPayloadNew);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -841,10 +841,10 @@ TEST_F(PayloadGeneralTests,
CreateFromByteBufferInValidBuffer)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const
void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayloadNew,
aBridge, NULL, testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, CreateFromByteBufferInValidBufferLength)
@@ -856,7 +856,7 @@ TEST_F(PayloadGeneralTests,
CreateFromByteBufferInValidBufferLength)

result = aBridge->msgPayloadCreate(&testPayload);
result = aBridge->msgPayloadCreate(&testPayloadNew);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 101, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 101, "Testing");
@@ -864,10 +864,10 @@ TEST_F(PayloadGeneralTests,
CreateFromByteBufferInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 101, "Fun");

result = aBridge->msgPayloadGetByteBuffer(testPayload, (const
void**)&testBuffer, &testBufferLength);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreateFromByteBuffer(&testPayloadNew,
aBridge, (const void*)testBuffer, 0);
- EXPECT_EQ (result, MAMA_STATUS_INVALID_ARG);
+ EXPECT_EQ (MAMA_STATUS_INVALID_ARG, result);
}

TEST_F(PayloadGeneralTests, ApplyValid)
@@ -876,23 +876,23 @@ TEST_F(PayloadGeneralTests, ApplyValid)
msgPayload testSrcPayload = NULL;

result = aBridge->msgPayloadCreate(&testDestPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadCreate(&testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadApply(testDestPayload, testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testSrcPayload, "name", NULL, "Unit");

result = aBridge->msgPayloadApply(testDestPayload, testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testSrcPayload, NULL, 101, "Testing");

result = aBridge->msgPayloadApply(testDestPayload, testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, ApplyInValidDestPayload)
@@ -901,17 +901,17 @@ TEST_F(PayloadGeneralTests, ApplyInValidDestPayload)
mama_size_t numFields = 0;

result = aBridge->msgPayloadCreate(&testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadAddChar(testSrcPayload, NULL, 9, 'i');
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNumFields(testSrcPayload, &numFields);
- EXPECT_EQ (result, MAMA_STATUS_OK);
- EXPECT_EQ (numFields, (mama_size_t) 1);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
+ EXPECT_EQ ((mama_size_t) 1, numFields);

result = aBridge->msgPayloadApply(NULL, testSrcPayload);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, ApplyInValidSrcPayload)
@@ -920,17 +920,17 @@ TEST_F(PayloadGeneralTests, ApplyInValidSrcPayload)
mama_size_t numFields = 0;

result = aBridge->msgPayloadCreate(&testDestPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadAddChar(testDestPayload, NULL, 9, 'i');
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNumFields(testDestPayload, &numFields);
- EXPECT_EQ (result, MAMA_STATUS_OK);
- EXPECT_EQ (numFields, (mama_size_t) 1);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
+ EXPECT_EQ ((mama_size_t) 1, numFields);

result = aBridge->msgPayloadApply(testDestPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetNativeMsgValid)
@@ -939,10 +939,10 @@ TEST_F(PayloadGeneralTests, GetNativeMsgValid)
char* testNativeMsg;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNativeMsg(testPayload,
(void**)&testNativeMsg);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetNativeMsgInValidMsg)
@@ -951,10 +951,10 @@ TEST_F(PayloadGeneralTests, GetNativeMsgInValidMsg)
char* testNativeMsg;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNativeMsg(NULL,
(void**)&testNativeMsg);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetNativeMsgInValidNativeMsg)
@@ -962,10 +962,10 @@ TEST_F(PayloadGeneralTests,
GetNativeMsgInValidNativeMsg)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetNativeMsg(testPayload, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringValid)
@@ -977,7 +977,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringValid)
mama_size_t testLen = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -985,7 +985,7 @@ TEST_F(PayloadGeneralTests, GetFieldAsStringValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, &testName,
testFid, testBuf, testLen);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringInValidPayload)
@@ -997,10 +997,10 @@ TEST_F(PayloadGeneralTests,
GetFieldAsStringInValidPayload)
mama_size_t testLen = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetFieldAsString(NULL, &testName,
testFid, &testBuf, testLen);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringInValidName)
@@ -1011,7 +1011,7 @@ TEST_F(PayloadGeneralTests,
GetFieldAsStringInValidName)
mama_size_t testLen = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1019,7 +1019,7 @@ TEST_F(PayloadGeneralTests,
GetFieldAsStringInValidName)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, NULL,
testFid, testBuf, testLen);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringInValidFid)
@@ -1033,7 +1033,7 @@ TEST_F(PayloadGeneralTests,
GetFieldAsStringInValidFid)
mama_size_t testLen = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1041,7 +1041,7 @@ TEST_F(PayloadGeneralTests,
GetFieldAsStringInValidFid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, &testName,
0, &testBuf, testLen);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
*/
}

@@ -1053,7 +1053,7 @@ TEST_F(PayloadGeneralTests,
GetFieldAsStringInValidBuffer)
mama_size_t testLen = 10;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1061,7 +1061,7 @@ TEST_F(PayloadGeneralTests,
GetFieldAsStringInValidBuffer)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, &testName,
testFid, NULL, testLen);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldAsStringInValidBufferLength)
@@ -1072,7 +1072,7 @@ TEST_F(PayloadGeneralTests,
GetFieldAsStringInValidBufferLength)
char testBuf[256];

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1080,7 +1080,7 @@ TEST_F(PayloadGeneralTests,
GetFieldAsStringInValidBufferLength)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadGetFieldAsString(testPayload, &testName,
testFid, testBuf, 0);
- EXPECT_EQ (result, MAMA_STATUS_INVALID_ARG);
+ EXPECT_EQ (MAMA_STATUS_INVALID_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldValid)
@@ -1091,7 +1091,7 @@ TEST_F(PayloadGeneralTests, GetFieldValid)
msgFieldPayload testResult = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1099,10 +1099,10 @@ TEST_F(PayloadGeneralTests, GetFieldValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testResult);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetField(testPayload, &testName,
testFid, &testResult);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetFieldInValidPayload)
@@ -1113,13 +1113,13 @@ TEST_F(PayloadGeneralTests,
GetFieldInValidPayload)
msgFieldPayload testResult = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgFieldPayloadCreate(&testResult);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetField(NULL, &testName, testFid,
&testResult);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, GetFieldInValidName)
@@ -1129,7 +1129,7 @@ TEST_F(PayloadGeneralTests, GetFieldInValidName)
msgFieldPayload testResult = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1137,10 +1137,10 @@ TEST_F(PayloadGeneralTests, GetFieldInValidName)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testResult);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetField(testPayload, NULL, testFid,
&testResult);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, GetFieldInValidFid)
@@ -1152,7 +1152,7 @@ TEST_F(PayloadGeneralTests, GetFieldInValidFid)
msgFieldPayload testResult = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1160,10 +1160,10 @@ TEST_F(PayloadGeneralTests, GetFieldInValidFid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testResult);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadGetField(testPayload, &testName, 0,
&testResult);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
*/
}

@@ -1176,7 +1176,7 @@ TEST_F(PayloadGeneralTests, GetFieldInValidResult)
//mama_bool_t value = 1;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1184,13 +1184,13 @@ TEST_F(PayloadGeneralTests, GetFieldInValidResult)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

//result = aBridge->msgFieldPayloadUpdateBool(testField,
testPayload, value);
- //EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ //EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);

result = aBridge->msgPayloadGetField(testPayload, &testName,
testFid, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

/*
*************************************************************************
*/
@@ -1203,7 +1203,7 @@ TEST_F(PayloadGeneralTests, IterCreateValid)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1211,7 +1211,7 @@ TEST_F(PayloadGeneralTests, IterCreateValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, IterCreateInValidtestIter)
@@ -1219,7 +1219,7 @@ TEST_F(PayloadGeneralTests,
IterCreateInValidtestIter)
msgPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1227,7 +1227,7 @@ TEST_F(PayloadGeneralTests,
IterCreateInValidtestIter)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(NULL, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, IterCreateInValidPayload)
@@ -1235,7 +1235,7 @@ TEST_F(PayloadGeneralTests,
IterCreateInValidPayload)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadIterCreate(&testIter, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, IterDestroyValid)
@@ -1244,18 +1244,18 @@ TEST_F(PayloadGeneralTests, IterDestroyValid)
msgFieldPayload testPayload = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);

result = aBridge->msgPayloadIterDestroy(testIter);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, IterDestroyInValidIter)
{
result = aBridge->msgPayloadIterDestroy(NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, IterEndValid)
@@ -1299,7 +1299,7 @@ TEST_F(PayloadGeneralTests, IterNextValid)
msgFieldPayload testField = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1307,7 +1307,7 @@ TEST_F(PayloadGeneralTests, IterNextValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

if (NULL == aBridge->msgPayloadIterNext(testIter, testField,
testPayload))
FAIL();
@@ -1329,7 +1329,7 @@ TEST_F(PayloadGeneralTests, IterNextValidConsistent)
msgFieldPayload testField = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

/* A reference group of fids. The same fids as in the payload
testPayload.
* See later on.
@@ -1346,7 +1346,7 @@ TEST_F(PayloadGeneralTests, IterNextValidConsistent)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

mama_fid_t test_fid;
std::set<mama_fid_t> returned_fids_set;
@@ -1404,10 +1404,10 @@ TEST_F(PayloadGeneralTests, IterNextInValidIter)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterNext(NULL, testField, testPayload);
if (output != NULL)
@@ -1421,7 +1421,7 @@ TEST_F(PayloadGeneralTests, IterNextInValidField)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1429,7 +1429,7 @@ TEST_F(PayloadGeneralTests, IterNextInValidField)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterNext(testIter, NULL, testPayload);
if (output == NULL)
@@ -1444,7 +1444,7 @@ TEST_F(PayloadGeneralTests, IterNextInValidPayload)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1452,10 +1452,10 @@ TEST_F(PayloadGeneralTests,
IterNextInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterNext(testIter, testField, NULL);
if (output != NULL)
@@ -1469,7 +1469,7 @@ TEST_F(PayloadGeneralTests, IterBeginValid)
msgFieldPayload testField = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

//Call on empty msg first
aBridge->msgPayloadIterBegin(testIter, testField, testPayload);
@@ -1480,10 +1480,10 @@ TEST_F(PayloadGeneralTests, IterBeginValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

if (NULL == aBridge->msgPayloadIterBegin(testIter, testField,
testPayload))
FAIL();
@@ -1497,7 +1497,7 @@ TEST_F(PayloadGeneralTests, IterBeginInValidIter)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1505,10 +1505,10 @@ TEST_F(PayloadGeneralTests, IterBeginInValidIter)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterBegin(NULL, testField, testPayload);
if (output != NULL)
@@ -1523,7 +1523,7 @@ TEST_F(PayloadGeneralTests, IterBeginInValidField)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1531,10 +1531,10 @@ TEST_F(PayloadGeneralTests, IterBeginInValidField)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterBegin(testIter, NULL, testPayload);
if (output == NULL)
@@ -1549,7 +1549,7 @@ TEST_F(PayloadGeneralTests, IterBeginInValidPayload)
msgFieldPayload output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1557,10 +1557,10 @@ TEST_F(PayloadGeneralTests,
IterBeginInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgFieldPayloadCreate(&testField);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterBegin(testIter, testField, NULL);
if (output != NULL)
@@ -1574,7 +1574,7 @@ TEST_F(PayloadGeneralTests, IterHasNextValid)
mama_bool_t output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1582,10 +1582,10 @@ TEST_F(PayloadGeneralTests, IterHasNextValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterHasNext(testIter, testPayload);
- EXPECT_EQ (output, true);
+ EXPECT_EQ (true, output);
}

TEST_F(PayloadGeneralTests, IterHasNextInValidIter)
@@ -1594,7 +1594,7 @@ TEST_F(PayloadGeneralTests, IterHasNextInValidIter)
mama_bool_t output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1602,7 +1602,7 @@ TEST_F(PayloadGeneralTests, IterHasNextInValidIter)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

output = aBridge->msgPayloadIterHasNext(NULL, testPayload);
- EXPECT_EQ (output, false);
+ EXPECT_EQ (false, output);
}

TEST_F(PayloadGeneralTests, IterHasNextInValidPayload)
@@ -1612,7 +1612,7 @@ TEST_F(PayloadGeneralTests,
IterHasNextInValidPayload)
mama_bool_t output = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1620,10 +1620,10 @@ TEST_F(PayloadGeneralTests,
IterHasNextInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

output = aBridge->msgPayloadIterHasNext(testIter, NULL);
- EXPECT_EQ (output, 0);
+ EXPECT_EQ (0, output);
}

TEST_F(PayloadGeneralTests, IterAssociateValid)
@@ -1632,7 +1632,7 @@ TEST_F(PayloadGeneralTests, IterAssociateValid)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1640,13 +1640,13 @@ TEST_F(PayloadGeneralTests, IterAssociateValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterAssociate(testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterAssociate(testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, IterAssociateTwiceValid)
@@ -1658,7 +1658,7 @@ TEST_F(PayloadGeneralTests, IterAssociateTwiceValid)
mama_fid_t test_fid = 0;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

// Create 2 payloads
aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
@@ -1667,7 +1667,7 @@ TEST_F(PayloadGeneralTests, IterAssociateTwiceValid)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadCreate(&testPayload2);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload2, "name2", 202,
"Repeating");
aBridge->msgPayloadAddString (testPayload2, "name3", 203, "Things");
@@ -1676,46 +1676,46 @@ TEST_F(PayloadGeneralTests,
IterAssociateTwiceValid)

// Create iterator
result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

// associate iterator with a payload
result = aBridge->msgPayloadIterAssociate(testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

// Test current payload exist and iterated correctly
result =
aBridge->msgPayloadGetField(testPayload,NULL,102,&testField);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

testField =
aBridge->msgPayloadIterNext(testIter,testField,testPayload);
// Make sure we're traversing on a payload
testField =
aBridge->msgPayloadIterNext(testIter,testField,testPayload);

result = aBridge->msgFieldPayloadGetFid(testField,NULL,NULL,
&test_fid);
- EXPECT_EQ (test_fid, 103);
+ EXPECT_EQ (103, test_fid);

// reuse iterator with new payload
result = aBridge->msgPayloadIterAssociate(testIter, testPayload2);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

// Test current payload exists and iterated correctly
result =
aBridge->msgPayloadGetField(testPayload2,NULL,202,&testField);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

testField =
aBridge->msgPayloadIterNext(testIter,testField,testPayload2);
// Make sure we're traversing on the 2nd payload
testField =
aBridge->msgPayloadIterNext(testIter,testField,testPayload2);

result = aBridge->msgFieldPayloadGetFid(testField,NULL,NULL,
&test_fid);
- EXPECT_EQ (test_fid, 203);
+ EXPECT_EQ (203, test_fid);

result = aBridge->msgPayloadIterDestroy(testIter);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadDestroy(testPayload);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadDestroy(testPayload2);
- EXPECT_EQ(result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);
}

TEST_F(PayloadGeneralTests, IterAssociateInValidIter)
@@ -1724,7 +1724,7 @@ TEST_F(PayloadGeneralTests,
IterAssociateInValidIter)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1732,10 +1732,10 @@ TEST_F(PayloadGeneralTests,
IterAssociateInValidIter)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterAssociate(NULL, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

TEST_F(PayloadGeneralTests, IterAssociateInValidPayload)
@@ -1744,7 +1744,7 @@ TEST_F(PayloadGeneralTests,
IterAssociateInValidPayload)
msgPayloadIter testIter = NULL;

result = aBridge->msgPayloadCreate(&testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

aBridge->msgPayloadAddString (testPayload, "name2", 102, "Unit");
aBridge->msgPayloadAddString (testPayload, "name3", 103, "Testing");
@@ -1752,9 +1752,9 @@ TEST_F(PayloadGeneralTests,
IterAssociateInValidPayload)
aBridge->msgPayloadAddString (testPayload, "name5", 105, "Fun");

result = aBridge->msgPayloadIterCreate(&testIter, testPayload);
- EXPECT_EQ (result, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, result);

result = aBridge->msgPayloadIterAssociate(&testIter, NULL);
- EXPECT_EQ (result, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, result);
}

diff --git a/mama/c_cpp/src/gunittest/c/payload/payloadvectortests.cpp
b/mama/c_cpp/src/gunittest/c/payload/payloadvectortests.cpp
index 9fded70..ab5483b 100644
--- a/mama/c_cpp/src/gunittest/c/payload/payloadvectortests.cpp
+++ b/mama/c_cpp/src/gunittest/c/payload/payloadvectortests.cpp
@@ -140,12 +140,12 @@ protected:
TEST_F(PayloadVectorBoolTests, AddVectorBool)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -153,15 +153,15 @@ TEST_F(PayloadVectorBoolTests, AddVectorBool)
TEST_F(PayloadVectorBoolTests, AddVectorBoolAfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -169,31 +169,31 @@ TEST_F(PayloadVectorBoolTests,
AddVectorBoolAfterInit)
TEST_F(PayloadVectorBoolTests, AddVectorBoolNullAdd)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorBoolTests, AddVectorBoolNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, AddVectorBoolInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, AddVectorBoolInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorBool test fixtures
@@ -202,107 +202,107 @@ TEST_F(PayloadVectorBoolTests,
AddVectorBoolInvalidFid)
TEST_F(PayloadVectorBoolTests, UpdateVectorBool)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInitByFid)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg,
"Rhubarb", 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg,
"Rhubarb", 1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(NULL, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, UpdateVectorBoolInvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorBool test fixtures
@@ -311,50 +311,50 @@ TEST_F(PayloadVectorBoolTests,
UpdateVectorBoolInvalidFidNo)
TEST_F(PayloadVectorBoolTests, GetVectorBool)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorBool(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorBoolTests, GetVectorBoolNullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, GetVectorBoolNullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorBoolTests, GetVectorBoolNotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorBool(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorBool(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -406,38 +406,38 @@ protected:
TEST_F(PayloadVectorCharTests, AddVectorChar)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) )
);
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) )
);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorCharTests, AddVectorCharNullChar)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorCharTests, AddVectorCharNullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, AddVectorCharAfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -445,19 +445,19 @@ TEST_F(PayloadVectorCharTests,
AddVectorCharAfterInit)
TEST_F(PayloadVectorCharTests, AddVectorCharInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, AddVectorCharInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ ASSERT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorChar test fixtures
@@ -466,96 +466,96 @@ TEST_F(PayloadVectorCharTests,
AddVectorCharInvalidFid)
TEST_F(PayloadVectorCharTests, UpdateVectorChar)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) )
);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(char) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(char) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharInitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) )
);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) )
);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(NULL, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, UpdateVectorCharInvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorChar test fixtures
@@ -564,50 +564,50 @@ TEST_F(PayloadVectorCharTests,
UpdateVectorCharInvalidFidNo)
TEST_F(PayloadVectorCharTests, GetVectorChar)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(char) * VECTOR_SIZE) )
);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorChar(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(char) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(char) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(char) * VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorCharTests, GetVectorCharNullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, GetVectorCharNullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorCharTests, GetVectorCharNotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorChar(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorChar(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -660,38 +660,38 @@ protected:
TEST_F(PayloadVectorI8Tests, AddVectorI8)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorI8Tests, AddVectorI8NullI8)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorI8Tests, AddVectorI8NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, AddVectorI8AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -699,19 +699,19 @@ TEST_F(PayloadVectorI8Tests, AddVectorI8AfterInit)
TEST_F(PayloadVectorI8Tests, AddVectorI8InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, AddVectorI8InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorI8 test fixtures
@@ -720,96 +720,96 @@ TEST_F(PayloadVectorI8Tests, AddVectorI8InvalidFid)
TEST_F(PayloadVectorI8Tests, UpdateVectorI8)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_i8_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_i8_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 1,
NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i8_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 0,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 0,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, UpdateVectorI8InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorI8 test fixtures
@@ -818,50 +818,50 @@ TEST_F(PayloadVectorI8Tests,
UpdateVectorI8InvalidFidNo)
TEST_F(PayloadVectorI8Tests, GetVectorI8)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE)
) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_i8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI8(m_msg, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_i8_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_i8_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_i8_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorI8Tests, GetVectorI8NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, GetVectorI8NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI8Tests, GetVectorI8NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorI8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI8(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -914,38 +914,38 @@ protected:
TEST_F(PayloadVectorU8Tests, AddVectorU8)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorU8Tests, AddVectorU8NullU8)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorU8Tests, AddVectorU8NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, AddVectorU8AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -953,19 +953,19 @@ TEST_F(PayloadVectorU8Tests, AddVectorU8AfterInit)
TEST_F(PayloadVectorU8Tests, AddVectorU8InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, AddVectorU8InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorU8 test fixtures
@@ -974,96 +974,96 @@ TEST_F(PayloadVectorU8Tests, AddVectorU8InvalidFid)
TEST_F(PayloadVectorU8Tests, UpdateVectorU8)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_u8_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_u8_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 1,
NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u8_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 0,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 0,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, UpdateVectorU8InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorU8 test fixtures
@@ -1072,50 +1072,50 @@ TEST_F(PayloadVectorU8Tests,
UpdateVectorU8InvalidFidNo)
TEST_F(PayloadVectorU8Tests, GetVectorU8)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE)
) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_u8_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU8(m_msg, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_u8_t) *
VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_u8_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_u8_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorU8Tests, GetVectorU8NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, GetVectorU8NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU8Tests, GetVectorU8NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorU8(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU8(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -1168,38 +1168,38 @@ protected:
TEST_F(PayloadVectorI16Tests, AddVectorI16)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorI16Tests, AddVectorI16NullI16)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorI16Tests, AddVectorI16NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, AddVectorI16AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -1207,19 +1207,19 @@ TEST_F(PayloadVectorI16Tests,
AddVectorI16AfterInit)
TEST_F(PayloadVectorI16Tests, AddVectorI16InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, AddVectorI16InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorI16 test fixtures
@@ -1228,96 +1228,96 @@ TEST_F(PayloadVectorI16Tests,
AddVectorI16InvalidFid)
TEST_F(PayloadVectorI16Tests, UpdateVectorI16)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, UpdateVectorI16InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorI16 test fixtures
@@ -1326,50 +1326,50 @@ TEST_F(PayloadVectorI16Tests,
UpdateVectorI16InvalidFidNo)
TEST_F(PayloadVectorI16Tests, GetVectorI16)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_i16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI16(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_i16_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_i16_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_i16_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorI16Tests, GetVectorI16NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, GetVectorI16NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI16Tests, GetVectorI16NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorI16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI16(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -1422,38 +1422,38 @@ protected:
TEST_F(PayloadVectorU16Tests, AddVectorU16)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorU16Tests, AddVectorU16NullU16)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorU16Tests, AddVectorU16NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, AddVectorU16AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -1461,19 +1461,19 @@ TEST_F(PayloadVectorU16Tests,
AddVectorU16AfterInit)
TEST_F(PayloadVectorU16Tests, AddVectorU16InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, AddVectorU16InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorU16 test fixtures
@@ -1482,96 +1482,96 @@ TEST_F(PayloadVectorU16Tests,
AddVectorU16InvalidFid)
TEST_F(PayloadVectorU16Tests, UpdateVectorU16)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_u16_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_u16_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, UpdateVectorU16InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorU16 test fixtures
@@ -1580,50 +1580,50 @@ TEST_F(PayloadVectorU16Tests,
UpdateVectorU16InvalidFidNo)
TEST_F(PayloadVectorU16Tests, GetVectorU16)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_u16_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU16(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_u16_t) *
VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_u16_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_u16_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorU16Tests, GetVectorU16NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, GetVectorU16NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU16Tests, GetVectorU16NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorU16(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU16(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -1676,38 +1676,38 @@ protected:
TEST_F(PayloadVectorI32Tests, AddVectorI32)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorI32Tests, AddVectorI32NullI32)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorI32Tests, AddVectorI32NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, AddVectorI32AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -1715,19 +1715,19 @@ TEST_F(PayloadVectorI32Tests,
AddVectorI32AfterInit)
TEST_F(PayloadVectorI32Tests, AddVectorI32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, AddVectorI32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorI32 test fixtures
@@ -1736,96 +1736,96 @@ TEST_F(PayloadVectorI32Tests,
AddVectorI32InvalidFid)
TEST_F(PayloadVectorI32Tests, UpdateVectorI32)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_i32_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_i32_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, UpdateVectorI32InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorI32 test fixtures
@@ -1834,50 +1834,50 @@ TEST_F(PayloadVectorI32Tests,
UpdateVectorI32InvalidFidNo)
TEST_F(PayloadVectorI32Tests, GetVectorI32)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_i32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI32(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_i32_t) *
VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_i32_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_i32_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorI32Tests, GetVectorI32NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, GetVectorI32NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI32Tests, GetVectorI32NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorI32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI32(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -1930,38 +1930,38 @@ protected:
TEST_F(PayloadVectorU32Tests, AddVectorU32)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorU32Tests, AddVectorU32NullU32)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorU32Tests, AddVectorU32NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, AddVectorU32AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -1969,19 +1969,19 @@ TEST_F(PayloadVectorU32Tests,
AddVectorU32AfterInit)
TEST_F(PayloadVectorU32Tests, AddVectorU32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, AddVectorU32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorU32 test fixtures
@@ -1990,96 +1990,96 @@ TEST_F(PayloadVectorU32Tests,
AddVectorU32InvalidFid)
TEST_F(PayloadVectorU32Tests, UpdateVectorU32)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_u32_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_u32_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, UpdateVectorU32InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorU32 test fixtures
@@ -2088,50 +2088,50 @@ TEST_F(PayloadVectorU32Tests,
UpdateVectorU32InvalidFidNo)
TEST_F(PayloadVectorU32Tests, GetVectorU32)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_u32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU32(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_u32_t) *
VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_u32_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_u32_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorU32Tests, GetVectorU32NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, GetVectorU32NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU32Tests, GetVectorU32NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorU32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU32(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -2184,38 +2184,38 @@ protected:
TEST_F(PayloadVectorI64Tests, AddVectorI64)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorI64Tests, AddVectorI64NullI64)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorI64Tests, AddVectorI64NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, AddVectorI64AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -2223,19 +2223,19 @@ TEST_F(PayloadVectorI64Tests,
AddVectorI64AfterInit)
TEST_F(PayloadVectorI64Tests, AddVectorI64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, AddVectorI64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorI64 test fixtures
@@ -2244,96 +2244,96 @@ TEST_F(PayloadVectorI64Tests,
AddVectorI64InvalidFid)
TEST_F(PayloadVectorI64Tests, UpdateVectorI64)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_i64_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_i64_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, UpdateVectorI64InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorI64 test fixtures
@@ -2342,49 +2342,49 @@ TEST_F(PayloadVectorI64Tests,
UpdateVectorI64InvalidFidNo)
TEST_F(PayloadVectorI64Tests, GetVectorI64)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_i64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorI64(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_i64_t) *
VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_i64_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_i64_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorI64Tests, GetVectorI64NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, GetVectorI64NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorI64Tests, GetVectorI64NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorI64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorI64(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -2437,38 +2437,38 @@ protected:
TEST_F(PayloadVectorU64Tests, AddVectorU64)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorU64Tests, AddVectorU64NullU64)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorU64Tests, AddVectorU64NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, AddVectorU64AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -2476,19 +2476,19 @@ TEST_F(PayloadVectorU64Tests,
AddVectorU64AfterInit)
TEST_F(PayloadVectorU64Tests, AddVectorU64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, AddVectorU64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorU64 test fixtures
@@ -2497,96 +2497,96 @@ TEST_F(PayloadVectorU64Tests,
AddVectorU64InvalidFid)
TEST_F(PayloadVectorU64Tests, UpdateVectorU64)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_u64_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_u64_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, UpdateVectorU64InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorU64 test fixtures
@@ -2595,50 +2595,50 @@ TEST_F(PayloadVectorU64Tests,
UpdateVectorU64InvalidFidNo)
TEST_F(PayloadVectorU64Tests, GetVectorU64)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_u64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorU64(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_u64_t) *
VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_u64_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_u64_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorU64Tests, GetVectorU64NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, GetVectorU64NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorU64Tests, GetVectorU64NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorU64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorU64(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -2695,38 +2695,38 @@ protected:
TEST_F(PayloadVectorF32Tests, AddVectorF32)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorF32Tests, AddVectorF32NullF32)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorF32Tests, AddVectorF32NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, AddVectorF32AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -2734,19 +2734,19 @@ TEST_F(PayloadVectorF32Tests,
AddVectorF32AfterInit)
TEST_F(PayloadVectorF32Tests, AddVectorF32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, AddVectorF32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorF32 test fixtures
@@ -2755,96 +2755,96 @@ TEST_F(PayloadVectorF32Tests,
AddVectorF32InvalidFid)
TEST_F(PayloadVectorF32Tests, UpdateVectorF32)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_f32_t) *
VECTOR_UPDATE_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_f32_t) *
VECTOR_UPDATE_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, UpdateVectorF32InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorF32 test fixtures
@@ -2853,50 +2853,50 @@ TEST_F(PayloadVectorF32Tests,
UpdateVectorF32InvalidFidNo)
TEST_F(PayloadVectorF32Tests, GetVectorF32)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_f32_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF32(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_f32_t) *
VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_f32_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_f32_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorF32Tests, GetVectorF32NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, GetVectorF32NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF32Tests, GetVectorF32NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorF32(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF32(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -2953,38 +2953,38 @@ protected:
TEST_F(PayloadVectorF64Tests, AddVectorF64)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorF64Tests, AddVectorF64NullF64)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorF64Tests, AddVectorF64NullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, AddVectorF64AfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 2,
&m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ( 0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

//freeVector( m_out );
}
@@ -2992,19 +2992,19 @@ TEST_F(PayloadVectorF64Tests,
AddVectorF64AfterInit)
TEST_F(PayloadVectorF64Tests, AddVectorF64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, AddVectorF64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorF64 test fixtures
@@ -3013,96 +3013,96 @@ TEST_F(PayloadVectorF64Tests,
AddVectorF64InvalidFid)
TEST_F(PayloadVectorF64Tests, UpdateVectorF64)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64NullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64NullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(NULL, NULL, 1,
m_update, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64InitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_update, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64InvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, "Bob", 0,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64InvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, ::memcmp( m_in, m_out, (sizeof(mama_bool_t) *
VECTOR_SIZE) ) );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, UpdateVectorF64InvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorF64 test fixtures
@@ -3111,50 +3111,50 @@ TEST_F(PayloadVectorF64Tests,
UpdateVectorF64InvalidFidNo)
TEST_F(PayloadVectorF64Tests, GetVectorF64)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE)
) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_in, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
EXPECT_NE(0, memcmp( m_update, m_out, (sizeof(mama_f64_t) *
VECTOR_SIZE) ) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorF64(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
&m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(0, memcmp( m_update, m_out, (sizeof(mama_f64_t) *
VECTOR_UPDATE_SIZE) ) );
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (0, memcmp( m_update, m_out, (sizeof(mama_f64_t) *
VECTOR_UPDATE_SIZE) ) );
EXPECT_NE(0, memcmp( m_in, m_out, (sizeof(mama_f64_t) * VECTOR_SIZE)
) );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorF64Tests, GetVectorF64NullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, GetVectorF64NullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 1,
&m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorF64Tests, GetVectorF64NotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorF64(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorF64(m_msg, NULL, 2,
&m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -3225,10 +3225,10 @@ protected:
TEST_F(PayloadVectorStringTests, AddVectorString)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);

int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult))
; ++ii )
@@ -3236,29 +3236,29 @@ TEST_F(PayloadVectorStringTests, AddVectorString)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorStringTests, AddVectorStringNullString)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorStringTests, AddVectorStringNullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, AddVectorStringAfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
2, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
2, &m_out, &m_outSize);

@@ -3268,26 +3268,26 @@ TEST_F(PayloadVectorStringTests,
AddVectorStringAfterInit)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorStringTests, AddVectorStringInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, "Bob",
0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, AddVectorStringInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorString test fixtures
@@ -3296,10 +3296,10 @@ TEST_F(PayloadVectorStringTests,
AddVectorStringInvalidFid)
TEST_F(PayloadVectorStringTests, UpdateVectorString)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult))
; ++ii )
@@ -3307,14 +3307,14 @@ TEST_F(PayloadVectorStringTests,
UpdateVectorString)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg,
NULL, 1, m_update, VECTOR_UPDATE_SIZE);
ASSERT_EQ(MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

getResult = 0;
for( unsigned int ii( 0 ) ; ((ii < VECTOR_UPDATE_SIZE) && (0 ==
getResult)) ; ++ii )
@@ -3322,54 +3322,54 @@ TEST_F(PayloadVectorStringTests,
UpdateVectorString)
getResult = ::strncmp( m_update[ii], m_out[ii], 20 );
}

- EXPECT_EQ(0, getResult);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (0, getResult);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult))
; ++ii )
{
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg,
NULL, 1, NULL, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult))
; ++ii )
{
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(NULL, NULL,
1, m_update, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringInitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg,
"Bob", 0, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, "Bob",
0, &m_out, &m_outSize);

@@ -3379,14 +3379,14 @@ TEST_F(PayloadVectorStringTests,
UpdateVectorStringInitByName)
getResult = ::strncmp( m_update[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, "Bob",
0, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, "Bob",
0, &m_out, &m_outSize);
int getResult(0);
@@ -3395,41 +3395,41 @@ TEST_F(PayloadVectorStringTests,
UpdateVectorStringInvalidName)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg,
NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);
int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult))
; ++ii )
{
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg,
NULL, 0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, UpdateVectorStringInvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, "Bob",
0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg,
"Bob", 1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorString test fixtures
@@ -3438,10 +3438,10 @@ TEST_F(PayloadVectorStringTests,
UpdateVectorStringInvalidFidNo)
TEST_F(PayloadVectorStringTests, GetVectorString)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

int getResult(0);
for( unsigned int ii( 0 ) ; ((ii < VECTOR_SIZE) && (0 == getResult))
; ++ii )
@@ -3449,14 +3449,14 @@ TEST_F(PayloadVectorStringTests, GetVectorString)
getResult = ::strncmp( m_in[ii], m_out[ii], 20 );
}

- EXPECT_EQ( 0, getResult );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ ( 0, getResult );
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorString(m_msg,
NULL, 1, m_update, VECTOR_UPDATE_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, &m_out, &m_outSize);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

getResult = 0;
for( unsigned int ii( 0 ) ; ((ii < VECTOR_UPDATE_SIZE) && (0 ==
getResult)) ; ++ii )
@@ -3464,36 +3464,36 @@ TEST_F(PayloadVectorStringTests, GetVectorString)
getResult = ::strncmp( m_update[ii], m_out[ii], 20 );
}

- EXPECT_EQ(0, getResult);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
- EXPECT_NE(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (0, getResult);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
+ EXPECT_NE ((mama_size_t)VECTOR_SIZE, m_outSize);
}

TEST_F(PayloadVectorStringTests, GetVectorStringNullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, GetVectorStringNullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
1, &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorStringTests, GetVectorStringNotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorString(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorString(m_msg, NULL,
2, &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -3579,62 +3579,62 @@ protected:
TEST_F(PayloadVectorMsgTests, AddVectorMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg,
NULL,
1,
(void* const**)
&m_out,
&m_outSize);
- EXPECT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgNullMsgDst)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgNullMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgAfterInit)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- ASSERT_EQ(m_status, MAMA_STATUS_OK);
+ ASSERT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg,
NULL,
1,
(void* const**)
&m_out,
&m_outSize);
- EXPECT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, AddVectorMsgInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorMsg test fixtures
@@ -3643,77 +3643,77 @@ TEST_F(PayloadVectorMsgTests,
AddVectorMsgInvalidFid)
TEST_F(PayloadVectorMsgTests, UpdateVectorMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1,
(void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgNullUpdate)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgNullMessage)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(NULL, NULL, 1,
m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgInitByName)
{
m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, "Bob",
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, "Bob", 0,
(void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgInvalidName)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, "Bob", 0,
(void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgInvalidFid)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1,
(void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL,
0, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, UpdateVectorMsgInvalidFidNo)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, "Bob", 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, "Bob",
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

// GetVectorMsg test fixtures
@@ -3722,45 +3722,45 @@ TEST_F(PayloadVectorMsgTests,
UpdateVectorMsgInvalidFidNo)
TEST_F(PayloadVectorMsgTests, GetVectorMsg)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1,
(void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ( m_outSize, (mama_size_t)VECTOR_SIZE );
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE , m_outSize);

m_status = m_payloadBridge->msgPayloadUpdateVectorMsg(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1,
(void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);
}

TEST_F(PayloadVectorMsgTests, GetVectorMsgNullResult)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1,
(void* const**) NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, GetVectorMsgNullSize)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 1,
(void* const**) &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorMsgTests, GetVectorMsgNotFound)
{
m_status = m_payloadBridge->msgPayloadAddVectorMsg(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorMsg(m_msg, NULL, 2,
(void* const**) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

//
**************************************************************************
**
@@ -3835,11 +3835,11 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_AddVectorDateTime)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL,
1, (mama_u64_t* const*) &m_out, &m_outSize);
- ASSERT_EQ( m_status, MAMA_STATUS_OK );
- EXPECT_EQ( m_outSize, VECTOR_SIZE );
+ ASSERT_EQ (MAMA_STATUS_OK , m_status);
+ EXPECT_EQ (VECTOR_SIZE , m_outSize);

for( unsigned int ii(0) ; ii < VECTOR_SIZE ; ++ii )
{
@@ -3848,7 +3848,7 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_AddVectorDateTime)
m_out[ii] );
mamaDateTime_getAsString(m_in[ii], buf, 56);
mamaDateTime_getAsString(m_out[ii], buf, 56);
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}

@@ -3856,44 +3856,44 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_AddVectorDateTimeNullDateTime)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeNullMsg)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(NULL, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeAfterInit)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
2, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeInvalidName)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg,
"Bob", 0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_AddVectorDateTimeInvalidFid)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorDateTime test fixtures
@@ -3902,11 +3902,11 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_AddVectorDateTimeInvalidFid)
TEST_F(PayloadVectorDateTimeTests, DISABLED_UpdateVectorDateTime)
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg,
NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- //EXPECT_EQ(m_status, MAMA_STATUS_OK);
- //EXPECT_EQ(m_outSize, VECTOR_SIZE);
+ //EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ //EXPECT_EQ (VECTOR_SIZE, m_outSize);

/*
if( MAMA_STATUS_OK == m_status )
@@ -3915,7 +3915,7 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_UpdateVectorDateTime)
{
int eq = mamaDateTime_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(0, eq);
+ EXPECT_EQ (0, eq);
}
}
else
@@ -3925,11 +3925,11 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_UpdateVectorDateTime)
*/

m_status = m_payloadBridge->msgPayloadUpdateVectorTime(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg,
NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- //EXPECT_EQ(m_status, MAMA_STATUS_OK);
- //EXPECT_EQ(m_outSize, VECTOR_UPDATE_SIZE);
+ //EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ //EXPECT_EQ (VECTOR_UPDATE_SIZE, m_outSize);

/*
if( MAMA_STATUS_OK == m_status )
@@ -3938,7 +3938,7 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_UpdateVectorDateTime)
{
int eq = mamaDateTime_equal( m_update[ii],
m_out[ii] );
- EXPECT_EQ(0, eq);
+ EXPECT_EQ (0, eq);
}
}
else
@@ -3952,11 +3952,11 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_UpdateVectorDateTimeNullUpdate)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg,
NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- //EXPECT_EQ(m_status, MAMA_STATUS_OK);
- //EXPECT_EQ(m_outSize, VECTOR_SIZE);
+ //EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ //EXPECT_EQ (VECTOR_SIZE, m_outSize);

/*
if( MAMA_STATUS_OK == m_status )
@@ -3965,7 +3965,7 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_UpdateVectorDateTimeNullUpdate)
{
int eq = mamaDateTime_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(0, eq);
+ EXPECT_EQ (0, eq);
}
}
else
@@ -3975,18 +3975,18 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_UpdateVectorDateTimeNullUpdate)
*/

m_status = m_payloadBridge->msgPayloadUpdateVectorTime(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorDateTimeTests,
DISABLED_UpdateVectorDateTimeNullMessage)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

//m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg,
NULL, 1, (mama_u64_t* const*) &m_out, &m_outSize);
- //EXPECT_EQ(m_status, MAMA_STATUS_OK);
- //EXPECT_EQ(m_outSize, VECTOR_SIZE);
+ //EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ //EXPECT_EQ (VECTOR_SIZE, m_outSize);

/*
if( MAMA_STATUS_OK == m_status )
@@ -3996,7 +3996,7 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_UpdateVectorDateTimeNullMessage)
int eq = mamaDateTime_equal( m_in[ii],
m_out[ii] );

- EXPECT_EQ(0, eq);
+ EXPECT_EQ (0, eq);
}
}
else
@@ -4006,7 +4006,7 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_UpdateVectorDateTimeNullMessage)
*/

m_status = m_payloadBridge->msgPayloadUpdateVectorTime(NULL, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// GetVectorDateTime test fixtures
@@ -4015,12 +4015,12 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_GetVectorDateTime)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorDateTime
m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL,
1, (mama_u64_t* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4029,7 +4029,7 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_GetVectorDateTime)
int eq = mamaDateTime_equal( m_in[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4038,12 +4038,12 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_GetVectorDateTime)
}

m_status = m_payloadBridge->msgPayloadUpdateVectorTime(m_msg, NULL,
1, m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorDateTime
m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL,
1, (mama_u64_t* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4052,7 +4052,7 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_GetVectorDateTime)
int eq = mamaDateTime_equal( m_update[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4065,22 +4065,22 @@ TEST_F(PayloadVectorDateTimeTests,
DISABLED_GetVectorDateTimeNullResult)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorDateTime
m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL,
1, NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorDateTimeTests, DISABLED_GetVectorDateTimeNullSize)
// Disabled as mamaMsg_addVectorDateTime is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorDateTime(m_msg, NULL,
1, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorDateTime
m_status = m_payloadBridge->msgPayloadGetVectorDateTime(m_msg, NULL,
1, m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

//
**************************************************************************
**
@@ -4149,13 +4149,13 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_AddVectorPrice)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorPrice
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1,
(void* const*) &m_out, &m_outSize);
- EXPECT_EQ( m_status, MAMA_STATUS_OK );
+ EXPECT_EQ (MAMA_STATUS_OK , m_status);

- EXPECT_EQ( m_outSize, VECTOR_SIZE );
+ EXPECT_EQ (VECTOR_SIZE , m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4163,7 +4163,7 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_AddVectorPrice)
{
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4176,44 +4176,44 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_AddVectorPriceNullPrice)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
NULL, VECTOR_SIZE);
- EXPECT_EQ( m_status, MAMA_STATUS_NULL_ARG );
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG , m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPriceNullMsg)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(NULL, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPriceAfterInit)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 2,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPriceInvalidName)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, "Bob",
0, m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_AddVectorPriceInvalidFid)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 0,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// UpdateVectorPrice test fixtures
@@ -4223,11 +4223,11 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_UpdateVectorPrice)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1,
(void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4235,7 +4235,7 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_UpdateVectorPrice)
{
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4245,12 +4245,12 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_UpdateVectorPrice)

// TODO Interface inconsistent
m_status = m_payloadBridge->msgPayloadUpdateVectorPrice(m_msg, NULL,
1, (void* const**) m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

/*
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1,
(void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ (VECTOR_UPDATE_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4258,7 +4258,7 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_UpdateVectorPrice)
{
int eq = mamaPrice_equal( m_update[ii],
m_out[ii] );
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4272,12 +4272,12 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_UpdateVectorPriceNullUpdate)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorPrice
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1,
(void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4285,7 +4285,7 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_UpdateVectorPriceNullUpdate)
{
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );
- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4294,19 +4294,19 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_UpdateVectorPriceNullUpdate)
}

m_status = m_payloadBridge->msgPayloadUpdateVectorPrice(m_msg, NULL,
1, NULL, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_UpdateVectorPriceNullMessage)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorPrice
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1,
(void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4315,7 +4315,7 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_UpdateVectorPriceNullMessage)
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4324,7 +4324,7 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_UpdateVectorPriceNullMessage)
}

m_status = m_payloadBridge->msgPayloadUpdateVectorPrice(NULL, NULL,
1, (void* const**) m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

// GetVectorPrice test fixtures
@@ -4333,12 +4333,12 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_GetVectorPrice)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

// TODO Check prototype for GetVectorPrice
m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1,
(void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4347,7 +4347,7 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_GetVectorPrice)
int eq = mamaPrice_equal( m_in[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4357,11 +4357,11 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_GetVectorPrice)

// TODO Interface Inconsistent
m_status = m_payloadBridge->msgPayloadUpdateVectorPrice(m_msg, NULL,
1, (void* const**) m_update, VECTOR_UPDATE_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1,
(void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
- EXPECT_EQ(m_outSize, (mama_size_t)VECTOR_UPDATE_SIZE);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);
+ EXPECT_EQ ((mama_size_t)VECTOR_UPDATE_SIZE, m_outSize);

if( MAMA_STATUS_OK == m_status )
{
@@ -4370,7 +4370,7 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_GetVectorPrice)
int eq = mamaPrice_equal( m_update[ii],
m_out[ii] );

- EXPECT_EQ(1, eq);
+ EXPECT_EQ (1, eq);
}
}
else
@@ -4383,29 +4383,29 @@ TEST_F(PayloadVectorPriceTests,
DISABLED_GetVectorPriceNullResult)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1,
NULL, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_GetVectorPriceNullSize)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 1,
(void* const*) &m_out, NULL);
- EXPECT_EQ(m_status, MAMA_STATUS_NULL_ARG);
+ EXPECT_EQ (MAMA_STATUS_NULL_ARG, m_status);
}

TEST_F(PayloadVectorPriceTests, DISABLED_GetVectorPriceNotFound)
// Disabled as mamaMsg_addVectorPrice is not implemented.
{
m_status = m_payloadBridge->msgPayloadAddVectorPrice(m_msg, NULL, 1,
m_in, VECTOR_SIZE);
- EXPECT_EQ(m_status, MAMA_STATUS_OK);
+ EXPECT_EQ (MAMA_STATUS_OK, m_status);

m_status = m_payloadBridge->msgPayloadGetVectorPrice(m_msg, NULL, 2,
(void* const*) &m_out, &m_outSize);
- EXPECT_EQ(m_status, MAMA_STATUS_NOT_FOUND);
+ EXPECT_EQ (MAMA_STATUS_NOT_FOUND, m_status);
}

--
1.9.0
________________________________________________________

This message may contain confidential information and is intended for specific recipients unless explicitly noted otherwise. If you have reason to believe you are not an intended recipient of this message, please delete it and notify the sender. This message may not represent the opinion of IntercontinentalExchange Group, Inc. (ICE), NYSE Euronext or any of their subsidiaries or affiliates, and does not constitute a contract or guarantee. Unencrypted electronic mail is not secure and the recipient of this message is expected to provide safeguards from viruses and pursue alternate means of communication where privacy or a binding message is desired.
________________________________________________________