?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge pull request #1844 from jrw972/monterey
[ACE_TAO.git] / TAO / tests / Sequence_Unit_Tests / object_reference_sequence_element_ut.cpp
blobe5467e6a70f593507f122f69ee289c98fdfa93c8
1 /**
2 * @file
3 *
4 * @brief Unit test for object_reference_sequence_element, this is the
5 * type returned by operator[] from a string sequence.
6 *
7 * @author Carlos O'Ryan
8 */
9 #include "testing_object_reference_traits.hpp"
10 #include "mock_reference.hpp"
11
12 #include "tao/Object_Reference_Sequence_Element_T.h"
13 #include "tao/SystemException.h"
14
15 #include "test_macros.h"
16
17 using namespace TAO_VERSIONED_NAMESPACE_NAME::TAO::details;
18
19 typedef object_reference_traits<mock_reference,mock_reference_var,true> tested_element_traits;
20 typedef object_reference_sequence_element<tested_element_traits> tested_element;
21 typedef mock_reference * reference_type;
22 typedef tested_element_traits::object_type_var reference_var;
23
24 int test_assignment_from_var_release_true()
25 {
26 expected_calls d(tested_element_traits::duplicate_calls);
27 expected_calls r(tested_element_traits::release_calls);
28 expected_calls md(mock_reference::duplicate_calls);
29 expected_calls mr(mock_reference::release_calls);
30 {
31 reference_type xe = mock_reference::allocate(1);
32 tested_element x(xe, true);
33 reference_var y(mock_reference::allocate(2));
34
35 FAIL_RETURN_IF_NOT(md.expect(0), md);
36 FAIL_RETURN_IF_NOT(mr.expect(0), mr);
37
38 x = y;
39
40 FAIL_RETURN_IF_NOT(d.expect(0), d);
41 FAIL_RETURN_IF_NOT(r.expect(1), r);
42 FAIL_RETURN_IF_NOT(md.expect(1), md);
43 FAIL_RETURN_IF_NOT(mr.expect(2), mr);
44
45 CHECK_EQUAL(2, x->id());
46
47 tested_element_traits::release(x);
48 FAIL_RETURN_IF_NOT(r.expect(1), r);
49 FAIL_RETURN_IF_NOT(mr.expect(1), mr);
50 }
51
52 FAIL_RETURN_IF_NOT(d.expect(0),d );
53 FAIL_RETURN_IF_NOT(r.expect(0),r );
54 FAIL_RETURN_IF_NOT(md.expect(0), md);
55 FAIL_RETURN_IF_NOT(mr.expect(1), mr);
56
57 return 0;
58 }
59
60 int test_assignment_from_var_release_false()
61 {
62 expected_calls d(tested_element_traits::duplicate_calls);
63 expected_calls r(tested_element_traits::release_calls);
64 expected_calls md(mock_reference::duplicate_calls);
65 expected_calls mr(mock_reference::release_calls);
66 {
67 reference_type xe = mock_reference::allocate(1);
68 reference_type oldxe = xe;
69 tested_element x(xe, false);
70 reference_var y(mock_reference::allocate(2));
71
72 FAIL_RETURN_IF_NOT(md.expect(0), md);
73 FAIL_RETURN_IF_NOT(mr.expect(0), mr);
74
75 x = y;
76
77 FAIL_RETURN_IF_NOT(d.expect(0), d );
78 FAIL_RETURN_IF_NOT(r.expect(0), r);
79 FAIL_RETURN_IF_NOT(md.expect(1), md);
80 FAIL_RETURN_IF_NOT(mr.expect(1), mr);
81
82 CHECK_EQUAL(2, x->id());
83
84 tested_element_traits::release(x);
85 tested_element_traits::release(oldxe);
86 FAIL_RETURN_IF_NOT(r.expect(2), r);
87 FAIL_RETURN_IF_NOT(mr.expect(2), mr);
88 }
89
90 FAIL_RETURN_IF_NOT(d.expect(0),d );
91 FAIL_RETURN_IF_NOT(r.expect(0), r);
92 FAIL_RETURN_IF_NOT(md.expect(0), md);
93 FAIL_RETURN_IF_NOT(mr.expect(1), mr);
94 return 0;
95 }
96
97 int test_assignment_from_var_throw()
98 {
99 expected_calls d(tested_element_traits::duplicate_calls);
100 expected_calls r(tested_element_traits::release_calls);
101 expected_calls md(mock_reference::duplicate_calls);
102 expected_calls mr(mock_reference::release_calls);
103 {
104 reference_type xe = mock_reference::allocate(1);
105 tested_element x(xe, true);
106 reference_var y(mock_reference::allocate(2));
107
108 FAIL_RETURN_IF_NOT(md.expect(0), md);
109 FAIL_RETURN_IF_NOT(mr.expect(0), mr);
110
111 mock_reference::duplicate_calls.failure_countdown(1);
112
113 CHECK_THROW(x = y, testing_exception);
114
115 FAIL_RETURN_IF_NOT(d.expect(0), d);
116 FAIL_RETURN_IF_NOT(r.expect(0), r);
117 FAIL_RETURN_IF_NOT(md.expect(1), md);
118 FAIL_RETURN_IF_NOT(mr.expect(0), mr);
119
120 CHECK_EQUAL(1, x->id());
121 CHECK_EQUAL(2, y->id());
122
123 tested_element_traits::release(x);
124 FAIL_RETURN_IF_NOT(r.expect(1), r);
125 FAIL_RETURN_IF_NOT(mr.expect(1), mr);
126 }
127
128 FAIL_RETURN_IF_NOT(d.expect(0), d);
129 FAIL_RETURN_IF_NOT(r.expect(0), r);
130 FAIL_RETURN_IF_NOT(md.expect(0), md);
131 FAIL_RETURN_IF_NOT(mr.expect(1), mr);
132 return 0;
133 }
134
135 int test_assignment_from_element_release_true()
136 {
137 expected_calls d(tested_element_traits::duplicate_calls);
138 expected_calls r(tested_element_traits::release_calls);
139 expected_calls md(mock_reference::duplicate_calls);
140 expected_calls mr(mock_reference::release_calls);
141 {
142 reference_type xe = mock_reference::allocate(1);
143 tested_element x(xe, true);
144
145 reference_type ye = mock_reference::allocate(2);
146 tested_element y(ye, true);
147
148 FAIL_RETURN_IF_NOT(d.expect(0), d);
149 FAIL_RETURN_IF_NOT(r.expect(0) ,r);
150
151 x = y;
152
153 FAIL_RETURN_IF_NOT(d.expect(1), d);
154 FAIL_RETURN_IF_NOT(r.expect(1), r);
155 FAIL_RETURN_IF_NOT(md.expect(1), md);
156 FAIL_RETURN_IF_NOT(mr.expect(2), mr);
157
158 CHECK_EQUAL(2, x->id());
159
160 tested_element_traits::release(xe);
161 tested_element_traits::release(ye);
162 FAIL_RETURN_IF_NOT(r.expect(2),r );
163 FAIL_RETURN_IF_NOT(mr.expect(2), mr);
164 }
165
166 FAIL_RETURN_IF_NOT(d.expect(0), d);
167 FAIL_RETURN_IF_NOT(r.expect(0), r);
168 FAIL_RETURN_IF_NOT(md.expect(0), md);
169 FAIL_RETURN_IF_NOT(mr.expect(0), mr);
170 return 0;
171 }
172
173 int test_assignment_from_element_release_false()
174 {
175 expected_calls d(tested_element_traits::duplicate_calls);
176 expected_calls r(tested_element_traits::release_calls);
177 expected_calls md(mock_reference::duplicate_calls);
178 expected_calls mr(mock_reference::release_calls);
179 {
180 reference_type xe = mock_reference::allocate(1);
181 reference_type oldxe = xe;
182 tested_element x(xe, false);
183
184 reference_type ye = mock_reference::allocate(2);
185 tested_element y(ye, true);
186
187 FAIL_RETURN_IF_NOT(d.expect(0), d);
188 FAIL_RETURN_IF_NOT(r.expect(0), r);
189
190 x = y;
191
192 FAIL_RETURN_IF_NOT(d.expect(1), d);
193 FAIL_RETURN_IF_NOT(r.expect(0), r);
194 FAIL_RETURN_IF_NOT(md.expect(1), md);
195 FAIL_RETURN_IF_NOT(mr.expect(1), mr);
196
197 CHECK_EQUAL(2, x->id());
198
199 tested_element_traits::release(xe);
200 tested_element_traits::release(oldxe);
201 tested_element_traits::release(ye);
202 FAIL_RETURN_IF_NOT(r.expect(3), r);
203 FAIL_RETURN_IF_NOT(mr.expect(3), mr);
204 }
205
206 FAIL_RETURN_IF_NOT(d.expect(0), d);
207 FAIL_RETURN_IF_NOT(r.expect(0), r);
208 FAIL_RETURN_IF_NOT(md.expect(0), md);
209 FAIL_RETURN_IF_NOT(mr.expect(0), mr);
210 return 0;
211 }
212
213 int test_assignment_from_reference_release_true()
214 {
215 expected_calls d(tested_element_traits::duplicate_calls);
216 expected_calls r(tested_element_traits::release_calls);
217 expected_calls md(mock_reference::duplicate_calls);
218 expected_calls mr(mock_reference::release_calls);
219 {
220 reference_type xe = mock_reference::allocate(1);
221 tested_element x(xe, true);
222
223 reference_type y = mock_reference::allocate(2);
224
225 FAIL_RETURN_IF_NOT(d.expect(0), d);
226 FAIL_RETURN_IF_NOT(r.expect(0), r);
227
228 x = y;
229
230 FAIL_RETURN_IF_NOT(d.expect(0), d);
231 FAIL_RETURN_IF_NOT(r.expect(1), r);
232 FAIL_RETURN_IF_NOT(md.expect(0), md);
233 FAIL_RETURN_IF_NOT(mr.expect(2), mr);
234
235 CHECK_EQUAL(2, x->id());
236
237 tested_element_traits::release(xe);
238 FAIL_RETURN_IF_NOT(r.expect(1), r);
239 FAIL_RETURN_IF_NOT(mr.expect(1), mr);
240 }
241
242 FAIL_RETURN_IF_NOT(d.expect(0), d);
243 FAIL_RETURN_IF_NOT(r.expect(0), r);
244 FAIL_RETURN_IF_NOT(md.expect(0), md);
245 FAIL_RETURN_IF_NOT(mr.expect(0), mr);
246 return 0;
247 }
248
249 int test_assignment_from_reference_release_false()
250 {
251 expected_calls d(tested_element_traits::duplicate_calls);
252 expected_calls r(tested_element_traits::release_calls);
253 expected_calls md(mock_reference::duplicate_calls);
254 expected_calls mr(mock_reference::release_calls);
255 {
256 reference_type xe = mock_reference::allocate(1);
257 reference_type oldxe = xe;
258 tested_element x(xe, false);
259
260 reference_type y = mock_reference::allocate(2);
261
262 FAIL_RETURN_IF_NOT(d.expect(0), d);
263 FAIL_RETURN_IF_NOT(r.expect(0), r);
264
265 x = y;
266
267 FAIL_RETURN_IF_NOT(d.expect(0), d);
268 FAIL_RETURN_IF_NOT(r.expect(0), r);
269 FAIL_RETURN_IF_NOT(md.expect(0), md);
270 FAIL_RETURN_IF_NOT(mr.expect(1), mr);
271
272 CHECK_EQUAL(2, x->id());
273
274 tested_element_traits::release(xe);
275 tested_element_traits::release(oldxe);
276 FAIL_RETURN_IF_NOT(r.expect(2), 2);
277 FAIL_RETURN_IF_NOT(mr.expect(2), mr);
278 }
279
280 FAIL_RETURN_IF_NOT(d.expect(0), d);
281 FAIL_RETURN_IF_NOT(r.expect(0), r);
282 FAIL_RETURN_IF_NOT(md.expect(0), md);
283 FAIL_RETURN_IF_NOT(mr.expect(0), mr);
284 return 0;
285 }
286
287 int ACE_TMAIN(int,ACE_TCHAR*[])
288 {
289 int status = 0;
290 try
291 {
292 status += test_assignment_from_var_release_true ();
293 status += test_assignment_from_var_release_false ();
294 status += test_assignment_from_var_throw ();
295 status += test_assignment_from_element_release_true ();
296 status += test_assignment_from_element_release_false ();
297 status += test_assignment_from_reference_release_true ();
298 status += test_assignment_from_reference_release_false ();
299 }
300 catch (const ::CORBA::Exception &ex)
301 {
302 ex._tao_print_exception("ERROR : unexpected CORBA exception caugth :");
303 ++status;
304 }
305
306 return status;
307 }
308