1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
/*******************************************************************************
* Copyright (c) 2013 protos software gmbh (http://www.protos.de).
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* CONTRIBUTORS:
* Juergen Haug (initial contribution)
*
*******************************************************************************/
#include "AddressTest.h"
#include "common/messaging/Address.h"
#include "etUnit/etUnit.h"
using namespace etRuntime;
void AddressTest::testConstructors() {
const char* failMsg = "Address constructor test failed";
// Test Constructor Address(void)
Address addr1;
EXPECT_EQUAL_INT16(m_caseId, failMsg, 0, addr1.m_nodeID);
EXPECT_EQUAL_INT16(m_caseId, failMsg, 0, addr1.m_threadID);
EXPECT_EQUAL_INT16(m_caseId, failMsg, 0, addr1.m_objectID);
// Test Constructor Address(int nodem_caseId, int threadm_caseId, int objectID)
Address addr2(1, 2, 3);
EXPECT_EQUAL_INT16(m_caseId, failMsg, 1, addr2.m_nodeID);
EXPECT_EQUAL_INT16(m_caseId, failMsg, 2, addr2.m_threadID);
EXPECT_EQUAL_INT16(m_caseId, failMsg, 3, addr2.m_objectID);
// Test Constuctor Address(const Address& right)
Address addr3(addr2);
EXPECT_EQUAL_INT16(m_caseId, failMsg, addr2.m_nodeID, addr3.m_nodeID);
EXPECT_EQUAL_INT16(m_caseId, failMsg, addr2.m_threadID, addr3.m_threadID);
EXPECT_EQUAL_INT16(m_caseId, failMsg, addr2.m_objectID, addr3.m_objectID);
}
void AddressTest::testOperators() {
const char* failMsg = "Address operator test failed";
// Test operator==
Address addr1(1, 2, 3);
Address addr2(1, 2, 3);
Address addr3(1, 2, 4);
Address addr4(1, 4, 3);
Address addr5(4, 2, 3);
EXPECT_TRUE(m_caseId, failMsg, addr1 == addr2);
EXPECT_FALSE(m_caseId, failMsg, addr1 == addr3);
EXPECT_FALSE(m_caseId, failMsg, addr1 == addr4);
EXPECT_FALSE(m_caseId, failMsg, addr1 == addr5);
// Test operator!=
EXPECT_FALSE(m_caseId, failMsg, addr1 != addr2);
EXPECT_TRUE(m_caseId, failMsg, addr1 != addr3);
EXPECT_TRUE(m_caseId, failMsg, addr1 != addr4);
EXPECT_TRUE(m_caseId, failMsg, addr1 != addr5);
// Test operator=
Address addr6(1, 2, 3);
Address addr7 = addr6;
EXPECT_TRUE(m_caseId, failMsg, addr6 == addr7);
// Test operator<
Address addr8(1, 2, 3);
Address addr9(1, 2, 4);
Address addr10(1, 3, 3);
Address addr11(2, 2, 3);
EXPECT_TRUE(m_caseId, failMsg, addr8 < addr9);
EXPECT_FALSE(m_caseId, failMsg, addr9 < addr8);
EXPECT_TRUE(m_caseId, failMsg, addr8 < addr10);
EXPECT_FALSE(m_caseId, failMsg, addr10 < addr8);
EXPECT_TRUE(m_caseId, failMsg, addr8 < addr11);
EXPECT_FALSE(m_caseId, failMsg, addr11 < addr8);
}
void AddressTest::testToString() {
}
void AddressTest::testToID() {
// Test toID()
Address addr(1, 2, 3);
EXPECT_TRUE(m_caseId, "Address toID test failed", !addr.toID().compare("1_2_3"));
}
void AddressTest::testCreateInc() {
// Test CreateInc()
Address addr(1, 2, 3);
EXPECT_TRUE(m_caseId, "Address CreateInc test failed",
addr.createInc() == Address(1, 2, 4));
}
void AddressTest::testIsValid() {
const char* failMsg = "Address IsValid test failed";
// Test IsValid()
Address addr1;
Address addr2(1, 2, 3);
EXPECT_FALSE(m_caseId, failMsg, addr1.isValid());
EXPECT_TRUE(m_caseId, failMsg, addr2.isValid());
}
void AddressTest::runAllTestCases() {
ADD_TESTCASE_CPP(testConstructors)
ADD_TESTCASE_CPP(testOperators)
// ADD_TESTCASE(testToString)
ADD_TESTCASE_CPP(testToID)
ADD_TESTCASE_CPP(testCreateInc)
ADD_TESTCASE_CPP(testIsValid)
}
|
