Index: value_sequence_tester.hpp =================================================================== --- value_sequence_tester.hpp (revision 84974) +++ value_sequence_tester.hpp (working copy) @@ -33,10 +33,10 @@ CORBA::ULong(tested_allocation_traits::default_maximum()), x.maximum()); CHECK_EQUAL(CORBA::ULong(0), x.length()); - CHECK_EQUAL(bounded_, x.release()); } FAIL_RETURN_IF_NOT(a.expect(0), a); - FAIL_RETURN_IF_NOT(f.expect(bounded_ ? 1 : 0), f); + // Nothing was allocated then there is nothing to free. + FAIL_RETURN_IF_NOT(f.expect(0), f); return 0; } @@ -52,15 +52,17 @@ CORBA::ULong(tested_allocation_traits::default_maximum()), x.maximum()); CHECK_EQUAL(CORBA::ULong(0), x.length()); - CHECK_EQUAL(bounded_, x.release()); tested_sequence y(x); - FAIL_RETURN_IF_NOT(a.expect(bounded_ ? 1 : 0), a); + // Default constructed sequence doesn't have elements, + // thus there is nothing to allocate/copy in copy constructor. + FAIL_RETURN_IF_NOT(a.expect(0), a); CHECK_EQUAL(x.maximum(), y.maximum()); CHECK_EQUAL(x.length(), y.length()); CHECK_EQUAL(x.release(), y.release()); } - FAIL_RETURN_IF_NOT(f.expect(bounded_ ? 2 : 0), f); + // Nothing was allocated then there is nothing to free. + FAIL_RETURN_IF_NOT(f.expect(0), f); return 0; } @@ -129,19 +131,21 @@ CORBA::ULong(tested_allocation_traits::default_maximum()), x.maximum()); CHECK_EQUAL(CORBA::ULong(0), x.length()); - CHECK_EQUAL(bounded_, x.release()); tested_sequence y; FAIL_RETURN_IF_NOT(a.expect(0), a); y = x; - FAIL_RETURN_IF_NOT(a.expect(bounded_ ? 1 : 0), a); - FAIL_RETURN_IF_NOT(f.expect(bounded_ ? 1 : 0), f); + // Default constructed sequence doesn't have elements, + // thus there is nothing to allocate/copy in operator=. + FAIL_RETURN_IF_NOT(a.expect(0), a); + FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(x.maximum(), y.maximum()); CHECK_EQUAL(x.length(), y.length()); CHECK_EQUAL(x.release(), y.release()); } - FAIL_RETURN_IF_NOT(f.expect(bounded_ ? 2 : 0), f); + // Nothing was allocated then there is nothing to free. + FAIL_RETURN_IF_NOT(f.expect(0), f); return 0; } @@ -220,7 +224,7 @@ int test_all() { int status = 0; - + status +=this->test_default_constructor(); status +=this->test_copy_constructor_from_default(); status +=this->test_index_accessor(); @@ -232,13 +236,8 @@ status +=this->test_exception_in_copy_constructor(); status +=this->test_exception_in_assignment(); status +=this->test_get_buffer_const(); - return status; + return status; } - value_sequence_tester(bool bounded) - : bounded_ (bounded) - {} - - bool bounded_; }; TAO_END_VERSIONED_NAMESPACE_DECL Index: unbounded_sequence_cdr_ut.cpp =================================================================== --- unbounded_sequence_cdr_ut.cpp (revision 84974) +++ unbounded_sequence_cdr_ut.cpp (working copy) @@ -97,6 +97,6 @@ int status = 0; Tester x; status += x.test_stream (); - + return status; } Index: bounded_value_sequence_ut.cpp =================================================================== --- bounded_value_sequence_ut.cpp (revision 84974) +++ bounded_value_sequence_ut.cpp (working copy) @@ -43,7 +43,8 @@ CHECK_EQUAL(CORBA::ULong(8), x.length()); CHECK_EQUAL(true, x.release()); } - FAIL_RETURN_IF_NOT(a.expect(0), a); + // Naturally buffer in x is allocated after length() was called. + FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(1), f); return 0; } @@ -71,26 +72,25 @@ expected_calls a(tested_allocation_traits::allocbuf_calls); expected_calls f(tested_allocation_traits::freebuf_calls); { - tested_sequence a(32, buffer); - CHECK_EQUAL(CORBA::ULong(32), a.maximum()); - CHECK_EQUAL(CORBA::ULong(32), a.length()); - CHECK_EQUAL(buffer, a.get_buffer()); - CHECK_EQUAL(int( 1), a[0]); - CHECK_EQUAL(int( 4), a[1]); - CHECK_EQUAL(int( 9), a[2]); - CHECK_EQUAL(int(16), a[3]); - CHECK_EQUAL(false, a.release()); - a.length (3); - CHECK_EQUAL(CORBA::ULong(32), a.maximum()); - CHECK_EQUAL(CORBA::ULong(3), a.length()); - a.length (4); - CHECK_EQUAL(CORBA::ULong(32), a.maximum()); - CHECK_EQUAL(CORBA::ULong(4), a.length()); - CHECK_EQUAL(int( 0), a[3]); + tested_sequence x(32, buffer, true); + CHECK_EQUAL(CORBA::ULong(32), x.maximum()); + CHECK_EQUAL(CORBA::ULong(32), x.length()); + CHECK_EQUAL(buffer, x.get_buffer()); + CHECK_EQUAL(int( 1), x[0]); + CHECK_EQUAL(int( 4), x[1]); + CHECK_EQUAL(int( 9), x[2]); + CHECK_EQUAL(int(16), x[3]); + CHECK_EQUAL(true, x.release()); + x.length (3); + CHECK_EQUAL(CORBA::ULong(32), x.maximum()); + CHECK_EQUAL(CORBA::ULong(3), x.length()); + x.length (4); + CHECK_EQUAL(CORBA::ULong(32), x.maximum()); + CHECK_EQUAL(CORBA::ULong(4), x.length()); + CHECK_EQUAL(int( 0), x[3]); } FAIL_RETURN_IF_NOT(a.expect(0), a); - FAIL_RETURN_IF_NOT(f.expect(0), f); - tested_sequence::freebuf(buffer); + FAIL_RETURN_IF_NOT(f.expect(1), f); return 0; } @@ -170,7 +170,8 @@ tested_sequence a; a.replace(4, buffer); FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(1), f); + // Default constructed sequence doesn't allocate a buffer. + FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(CORBA::ULong(32), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); @@ -197,7 +198,8 @@ tested_sequence a; a.replace(4, buffer, false); FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(1), f); + // Default constructed sequence doesn't allocate a buffer. + FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(CORBA::ULong(32), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); @@ -224,7 +226,8 @@ tested_sequence a; a.replace(4, buffer, true); FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(1), f); + // Default constructed sequence doesn't allocate a buffer. + FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(CORBA::ULong(32), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); @@ -320,10 +323,9 @@ { typedef value_sequence_tester common; - common tester(true); + common tester; status += tester.test_all (); } return status; } - Index: bounded_object_reference_sequence_ut.cpp =================================================================== --- bounded_object_reference_sequence_ut.cpp (revision 84974) +++ bounded_object_reference_sequence_ut.cpp (working copy) @@ -69,7 +69,9 @@ } FAIL_RETURN_IF_NOT(a.expect(0), a); FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(i.expect(0), i); + // 64 is here because this is a bounded sequence and spec requires + // that maximum() elements are allocated for them by allocbuf. + FAIL_RETURN_IF_NOT(i.expect(64), i); return 0; } @@ -92,7 +94,8 @@ } FAIL_RETURN_IF_NOT(a.expect(0), a); FAIL_RETURN_IF_NOT(f.expect(0), f); - FAIL_RETURN_IF_NOT(i.expect(0), i); + // Same as above. allocbuf default initializes maximum() elements. + FAIL_RETURN_IF_NOT(i.expect(64), i); tested_sequence::freebuf(data); } @@ -123,7 +126,7 @@ expected_calls a(tested_allocation_traits::allocbuf_calls); expected_calls da(tested_allocation_traits::default_buffer_allocation_calls); expected_calls f(tested_allocation_traits::freebuf_calls); - expected_calls i(tested_element_traits::default_initializer_calls); + expected_calls di(tested_element_traits::default_initializer_calls); expected_calls d(mock_reference::duplicate_calls); expected_calls r(mock_reference::release_calls); CORBA::ULong const l = 16; @@ -133,8 +136,10 @@ FAIL_RETURN_IF_NOT(a.expect(0), a); x.length(l); - FAIL_RETURN_IF_NOT(i.expect(l), i); - FAIL_RETURN_IF_NOT(a.expect(0), a); + // length() allocates a buffer of size maximum() and + // default initializes it. + FAIL_RETURN_IF_NOT(di.expect(TMAX), i); + FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(l, x.length()); for(CORBA::ULong i = 0; i != l; ++i) @@ -147,8 +152,9 @@ tested_sequence y(x); FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(0), f); - CHECK_EQUAL(l, x.length()); + CHECK_EQUAL(l, y.length()); FAIL_RETURN_IF_NOT(d.expect(l), d); + FAIL_RETURN_IF_NOT(di.expect(TMAX - l), d); for(CORBA::ULong i = 0; i != l; ++i) { CHECK_EQUAL(int(i), y[i]->id()); @@ -158,7 +164,6 @@ FAIL_RETURN_IF_NOT(r.expect(2*TMAX), r); FAIL_RETURN_IF_NOT(a.expect(0), a); FAIL_RETURN_IF_NOT(f.expect(2), f); - FAIL_RETURN_IF_NOT(i.expect(0), i); return 0; } @@ -177,14 +182,16 @@ FAIL_RETURN_IF_NOT(a.expect(0), a); x.length(l); - FAIL_RETURN_IF_NOT(i.expect(l), i); + // length() allocates a buffer of size maximum() and + // default initializes it. + FAIL_RETURN_IF_NOT(i.expect(TMAX), i); + FAIL_RETURN_IF_NOT(a.expect(1), i); - FAIL_RETURN_IF_NOT(a.expect(0), a); FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(l, x.length()); - for(CORBA::ULong i = 0; i != l; ++i) + for(CORBA::ULong inc = 0; inc != l; ++inc) { - x[i] = mock_reference::allocate(i); + x[inc] = mock_reference::allocate(inc); } d.reset(); r.reset(); @@ -201,7 +208,8 @@ FAIL_RETURN_IF_NOT(r.expect(TMAX), r); FAIL_RETURN_IF_NOT(a.expect(0), a); FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(i.expect(0), i); + // There are TMAX-16 default initializer calls. + FAIL_RETURN_IF_NOT(i.expect(48), i); return 0; } @@ -219,9 +227,11 @@ CHECK_EQUAL(CORBA::ULong(8), x.length()); CHECK_EQUAL(true, x.release()); - FAIL_RETURN_IF_NOT(i.expect(8), i); + // length() allocates a buffer of size maximum() and + // default initializes it. + FAIL_RETURN_IF_NOT(i.expect(TMAX), i); } - FAIL_RETURN_IF_NOT(a.expect(0), a); + FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(da.expect(1), da); FAIL_RETURN_IF_NOT(f.expect(1), f); return 0; @@ -238,10 +248,12 @@ FAIL_RETURN_IF_NOT(da.expect(1), da); FAIL_RETURN_IF_NOT(a.expect(0), a); x.length(16); - FAIL_RETURN_IF_NOT(i.expect(16), i); + // length() allocates a buffer of size maximum() and + // default initializes it. + FAIL_RETURN_IF_NOT(i.expect(TMAX), i); CHECK_THROW(x.length(2 * TMAX), std::runtime_error); - FAIL_RETURN_IF_NOT(a.expect(0), a); + FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(0), f); FAIL_RETURN_IF_NOT(i.expect(0), i); @@ -255,7 +267,7 @@ value_type * alloc_and_init_buffer() { - value_type * buf = tested_sequence::allocbuf(TMAX); + value_type * buf = tested_sequence::allocbuf(); buf[0] = mock_reference::allocate(1); buf[1] = mock_reference::allocate(4); buf[2] = mock_reference::allocate(9); @@ -282,7 +294,7 @@ expected_calls r(tested_element_traits::release_calls); { tested_sequence a; - a.replace(4, buffer, false); + a.replace(4, buffer, true); FAIL_RETURN_IF_NOT(c.expect(0), c); FAIL_RETURN_IF_NOT(f.expect(0), f); FAIL_RETURN_IF_NOT(r.expect(0), r); @@ -290,12 +302,13 @@ CHECK_EQUAL(TMAX, a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); CHECK_EQUAL(buffer, a.get_buffer()); - CHECK_EQUAL(false, a.release()); + CHECK_EQUAL(true, a.release()); check_values(a); } FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(0), f); - tested_sequence::freebuf(buffer); + // Since we've given away the ownership the buffer is deallocated by + // the sequence. + FAIL_RETURN_IF_NOT(f.expect(1), f); FAIL_RETURN_IF_NOT(r.expect(TMAX), r); return 0; } @@ -359,7 +372,7 @@ { int status = 0; Tester mytester; - + status += mytester.test_default_constructor(); status += mytester.test_buffer_constructor_release_true(); status += mytester.test_buffer_constructor_release_false(); Index: unbounded_object_reference_sequence_ut.cpp =================================================================== --- unbounded_object_reference_sequence_ut.cpp (revision 84974) +++ unbounded_object_reference_sequence_ut.cpp (working copy) @@ -63,7 +63,9 @@ } FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(i.expect(0), i); + // ulong constructor calls allocbuf and thus there must be + // maximum() default initilized elements. + FAIL_RETURN_IF_NOT(i.expect(16), i); return 0; } @@ -100,7 +102,8 @@ } FAIL_RETURN_IF_NOT(a.expect(0), a); FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(i.expect(0), i); + // allocbuf default initializes maximum elements. + FAIL_RETURN_IF_NOT(i.expect(32), i); return 0; } @@ -123,7 +126,8 @@ } FAIL_RETURN_IF_NOT(a.expect(0), a); FAIL_RETURN_IF_NOT(f.expect(0), f); - FAIL_RETURN_IF_NOT(i.expect(0), i); + // allocbuf default initializes maximum elements. + FAIL_RETURN_IF_NOT(i.expect(64), i); tested_sequence::freebuf(data); } @@ -242,7 +246,8 @@ CHECK_EQUAL(CORBA::ULong(8), x.length()); CHECK_EQUAL(true, x.release()); - FAIL_RETURN_IF_NOT(i.expect(8), i); + // allocbuf default initializes 16 elements. + FAIL_RETURN_IF_NOT(i.expect(16), i); } FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(1), f); @@ -262,7 +267,10 @@ FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(i.expect(32), i); + // ulong constructor calls allocbuf and thus there must be + // maximum() default initilized elements + length() leads to buffer + // reallocation maximum() gets set to a new value. + FAIL_RETURN_IF_NOT(i.expect(48), i); CHECK_EQUAL(CORBA::ULong(32), x.maximum()); CHECK_EQUAL(CORBA::ULong(32), x.length()); @@ -383,7 +391,7 @@ expected_calls r(tested_element_traits::release_calls); { tested_sequence a; - a.replace(8, 4, buffer, false); + a.replace(8, 4, buffer, true); FAIL_RETURN_IF_NOT(c.expect(0), c); FAIL_RETURN_IF_NOT(f.expect(0), f); FAIL_RETURN_IF_NOT(r.expect(0), r); @@ -391,12 +399,13 @@ CHECK_EQUAL(CORBA::ULong(8), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); CHECK_EQUAL(buffer, a.get_buffer()); - CHECK_EQUAL(false, a.release()); + CHECK_EQUAL(true, a.release()); check_values(a); } FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(0), f); - tested_sequence::freebuf(buffer); + // Since we've given away the ownership the buffer is deallocated by + // the sequence. + FAIL_RETURN_IF_NOT(f.expect(1), f); FAIL_RETURN_IF_NOT(r.expect(8), r); return 0; } @@ -473,7 +482,7 @@ status += this->test_replace_release_true(); status += this->test_replace_release_false(); status += this->test_replace_release_default(); - return status; + return status; } Tester() {} @@ -489,4 +498,3 @@ return status; } - Index: string_sequence_tester.hpp =================================================================== --- string_sequence_tester.hpp (revision 84974) +++ string_sequence_tester.hpp (working copy) @@ -125,10 +125,10 @@ CORBA::ULong(tested_allocation_traits::default_maximum()), x.maximum()); CHECK_EQUAL(CORBA::ULong(0), x.length()); - CHECK_EQUAL(bounded_, x.release()); } FAIL_RETURN_IF_NOT(a.expect(0), a); - FAIL_RETURN_IF_NOT(f.expect(bounded_ ? 1 : 0), f); + // Nothing was allocated then there is nothing to free. + FAIL_RETURN_IF_NOT(f.expect(0), f); return 0; } @@ -144,7 +144,9 @@ a.reset(); f.reset(); i.reset(); d.reset(); tested_sequence y(x); - FAIL_RETURN_IF_NOT(a.expect(bounded_ ? 1 : 0), a); + // Default constructed sequence doesn't have elements, + // thus there is nothing to allocate/copy in copy constructor. + FAIL_RETURN_IF_NOT(a.expect(0), a); FAIL_RETURN_IF_NOT(f.expect(0), f); FAIL_RETURN_IF_NOT(i.expect(0), i); FAIL_RETURN_IF_NOT(d.expect(0), d); @@ -153,7 +155,8 @@ CHECK_EQUAL(x.length(), y.length()); CHECK_EQUAL(x.release(), y.release()); } - FAIL_RETURN_IF_NOT(f.expect(bounded_ ? 2 : 0), f); + // Nothing was allocated then there is nothing to free. + FAIL_RETURN_IF_NOT(f.expect(0), f); return 0; } @@ -238,10 +241,6 @@ int test_freebuf_releases_elements() { value_type * buffer = tested_sequence::allocbuf(32); - for(int i = 0; i != 32; ++i) - { - buffer[i] = helper::allocate_test_string(); - } expected_calls r(tested_element_traits::release_calls); expected_calls f(tested_allocation_traits::freebuf_calls); @@ -265,19 +264,21 @@ CORBA::ULong(tested_allocation_traits::default_maximum()), x.maximum()); CHECK_EQUAL(CORBA::ULong(0), x.length()); - CHECK_EQUAL(bounded_ , x.release()); tested_sequence y; FAIL_RETURN_IF_NOT(a.expect(0), a); y = x; - FAIL_RETURN_IF_NOT(a.expect(bounded_ ? 1 : 0), a); - FAIL_RETURN_IF_NOT(f.expect(bounded_ ? 1 : 0), f); + // Default constructed sequence doesn't have elements, + // thus there is nothing to allocate/copy in operator=. + FAIL_RETURN_IF_NOT(a.expect(0), a); + FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(x.maximum(), y.maximum()); CHECK_EQUAL(x.length(), y.length()); CHECK_EQUAL(x.release(), y.release()); } - FAIL_RETURN_IF_NOT(f.expect(bounded_ ? 2 : 0), f); + // Nothing was allocated then there is nothing to free. + FAIL_RETURN_IF_NOT(f.expect(0), f); return 0; } @@ -403,7 +404,7 @@ { y[i] = helper::allocate_test_string(); } - + a.reset(); d.reset(); r.reset(); @@ -465,12 +466,6 @@ return status; } - string_sequence_tester(bool bounded) - : bounded_(bounded) - {} - -private: - bool bounded_; }; #endif // guard_string_sequence_tester_hpp Index: run_test.pl =================================================================== --- run_test.pl (revision 84974) +++ run_test.pl (working copy) @@ -12,14 +12,13 @@ my $final_result = 0; my @testsToRun = qw(unbounded_value_sequence_ut - unbounded_array_sequence_ut bounded_value_sequence_ut string_sequence_element_ut unbounded_string_sequence_ut bounded_string_sequence_ut testing_allocation_traits_ut unbounded_octet_sequence_ut - unbounded_octet_sequence_no_copy_ut + unbounded_octet_sequence_nocopy_ut object_reference_sequence_element_ut unbounded_object_reference_sequence_ut unbounded_fwd_object_reference_sequence_ut Index: object_reference_sequence_element_ut.cpp =================================================================== --- object_reference_sequence_element_ut.cpp (revision 84974) +++ object_reference_sequence_element_ut.cpp (working copy) @@ -52,7 +52,7 @@ FAIL_RETURN_IF_NOT(r.expect(0),r ); FAIL_RETURN_IF_NOT(md.expect(0), md); FAIL_RETURN_IF_NOT(mr.expect(1), mr); - + return 0; } Index: testing_counters.hpp =================================================================== --- testing_counters.hpp (revision 84974) +++ testing_counters.hpp (working copy) @@ -99,7 +99,6 @@ { return os << "current=" << x.current_count() << ",previous=" << x.previous_count(); - } #endif // guard_testing_counters_hpp Index: bounded_string_sequence_ut.cpp =================================================================== --- bounded_string_sequence_ut.cpp (revision 84974) +++ bounded_string_sequence_ut.cpp (working copy) @@ -49,12 +49,16 @@ tested_sequence x; x.length(8); - FAIL_RETURN_IF_NOT(a.expect(0), a); + // length() after default constructed sequence leads to + // buffer allocation. + FAIL_RETURN_IF_NOT(a.expect(1), a); CHECK_EQUAL(CORBA::ULong(MAXIMUM), x.maximum()); CHECK_EQUAL(CORBA::ULong(8), x.length()); CHECK_EQUAL(true, x.release()); - FAIL_RETURN_IF_NOT(i.expect(8), i); + // 32 is here because allocbuf for bounded sequences + // initializes all elements. + FAIL_RETURN_IF_NOT(i.expect(32), i); } FAIL_RETURN_IF_NOT(f.expect(1), f); return 0; @@ -71,9 +75,13 @@ value_type * alloc_and_init_buffer() { value_type * buf = tested_sequence::allocbuf(); + delete[] buf[0]; buf[0] = helper::to_string(1); + delete[] buf[1]; buf[1] = helper::to_string(4); + delete[] buf[2]; buf[2] = helper::to_string(9); + delete[] buf[3]; buf[3] = helper::to_string(16); return buf; @@ -95,21 +103,22 @@ expected_calls f(tested_allocation_traits::freebuf_calls); expected_calls r(tested_element_traits::release_calls); { - tested_sequence a(4, buffer, false); - CHECK_EQUAL(CORBA::ULong(MAXIMUM), a.maximum()); - CHECK_EQUAL(CORBA::ULong(4), a.length()); - CHECK_EQUAL(buffer, a.get_buffer()); - CHECK_EQUAL(false, a.release()); - a.length (3); - CHECK_EQUAL(CORBA::ULong(3), a.length()); - a.length (4); - CHECK_EQUAL(CORBA::ULong(4), a.length()); - CHECK(helper::compare_empty(a[3])); + tested_sequence x(4, buffer, true); + CHECK_EQUAL(CORBA::ULong(MAXIMUM), x.maximum()); + CHECK_EQUAL(CORBA::ULong(4), x.length()); + CHECK_EQUAL(buffer, x.get_buffer()); + CHECK_EQUAL(true, x.release()); + x.length (3); + CHECK_EQUAL(CORBA::ULong(3), x.length()); + x.length (4); + CHECK_EQUAL(CORBA::ULong(4), x.length()); + CHECK(helper::compare_empty(x[3])); } FAIL_RETURN_IF_NOT(a.expect(0), a); - FAIL_RETURN_IF_NOT(f.expect(0), f); - tested_sequence::freebuf(buffer); - FAIL_RETURN_IF_NOT(r.expect(MAXIMUM), r); + FAIL_RETURN_IF_NOT(f.expect(1), f); + // 1 additional release call happens when we shrink + // the sequence to length 3. + FAIL_RETURN_IF_NOT(r.expect(MAXIMUM + 1), r); return 0; } @@ -186,8 +195,10 @@ tested_sequence a; a.replace(4, buffer); FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(r.expect(MAXIMUM), r); + // Default constructed sequence doesn't allocate a buffer + // thus nothing to release and free. + FAIL_RETURN_IF_NOT(f.expect(0), f); + FAIL_RETURN_IF_NOT(r.expect(0), r); CHECK_EQUAL(CORBA::ULong(MAXIMUM), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); @@ -213,8 +224,9 @@ tested_sequence a; a.replace(4, buffer, false); FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(r.expect(MAXIMUM), r); + // Default constructed sequence doesn't allocate a buffer. + FAIL_RETURN_IF_NOT(f.expect(0), f); + FAIL_RETURN_IF_NOT(r.expect(0), r); CHECK_EQUAL(CORBA::ULong(MAXIMUM), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); @@ -238,20 +250,22 @@ expected_calls r(tested_element_traits::release_calls); { tested_sequence a; - a.replace(4, buffer, false); + a.replace(4, buffer, true); FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(r.expect(MAXIMUM), r); + // Default constructed sequence doesn't allocate a buffer. + FAIL_RETURN_IF_NOT(f.expect(0), f); + FAIL_RETURN_IF_NOT(r.expect(0), r); CHECK_EQUAL(CORBA::ULong(MAXIMUM), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); CHECK_EQUAL(buffer, a.get_buffer()); - CHECK_EQUAL(false, a.release()); + CHECK_EQUAL(true, a.release()); check_values(a); } FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(0), f); - tested_sequence::freebuf(buffer); + // Since we've given away the ownership the buffer is deallocated by + // the sequence. + FAIL_RETURN_IF_NOT(f.expect(1), f); FAIL_RETURN_IF_NOT(r.expect(MAXIMUM), r); return 0; } @@ -297,7 +311,9 @@ CHECK(0 != b.get_buffer()); CHECK_EQUAL(true, b.release()); - FAIL_RETURN_IF_NOT(c.expect(0), c); + // Ownership was taken by get_buffer(true) and later get_buffer call + // allocated a new buffer. + FAIL_RETURN_IF_NOT(c.expect(1), c); CHECK(buffer != b.get_buffer()); } @@ -310,13 +326,13 @@ FAIL_RETURN_IF_NOT(r.expect(MAXIMUM), r); return 0; } - + int test_all () { int status = 0; typedef string_sequence_tester common; - common X (true); + common X; status += X.test_all (); status += this->test_set_length_less_than_maximum(); @@ -332,7 +348,7 @@ status += this->test_get_buffer_false(); status += this->test_get_buffer_true_with_release_false(); status += this->test_get_buffer_true_with_release_true(); - return status; + return status; } }; @@ -343,16 +359,15 @@ typedef TAO::bounded_basic_string_sequence s_sequence; typedef Tester nTester; nTester myntester; - + status += myntester.test_all(); -#if defined(ACE_HAS_WCHAR) +#if defined(ACE_HAS_WCHAR) typedef TAO::bounded_basic_string_sequence w_sequence; typedef Tester wTester; wTester mywtester; status += mywtester.test_all(); -#endif +#endif return status; } - Index: unbounded_octet_sequence_nocopy_ut.cpp =================================================================== --- unbounded_octet_sequence_nocopy_ut.cpp (revision 84974) +++ unbounded_octet_sequence_nocopy_ut.cpp (working copy) @@ -74,7 +74,9 @@ y = x; FAIL_RETURN_IF_NOT(a.expect(1), a); - FAIL_RETURN_IF_NOT(f.expect(1), f); + // Since above no allocation for y was done then + // no deallocation needed during assignment. + FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(CORBA::ULong(16), y.maximum()); CHECK_EQUAL(CORBA::ULong(8), y.length()); CHECK_EQUAL(true, y.release()); @@ -160,7 +162,9 @@ CHECK_THROW(x.length(8), testing_exception); FAIL_RETURN_IF_NOT(a.expect(1), a); } - FAIL_RETURN_IF_NOT(f.expect(1), f); + // length() above tried to allocate a buffer but it didn't reach + // new[] and sequence was not changed, thus no need to deallocate. + FAIL_RETURN_IF_NOT(f.expect(0), f); return 0; } @@ -259,7 +263,8 @@ tested_sequence a; a.replace(8, 4, buffer); FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(1), f); + // Default constructed sequence doesn't allocate a buffer. + FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(CORBA::ULong(8), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); @@ -286,7 +291,8 @@ tested_sequence a; a.replace(8, 4, buffer, false); FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(1), f); + // Default constructed sequence doesn't allocate a buffer. + FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(CORBA::ULong(8), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); @@ -313,7 +319,8 @@ tested_sequence a; a.replace(8, 4, buffer, true); FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(1), f); + // Default constructed sequence doesn't allocate a buffer. + FAIL_RETURN_IF_NOT(f.expect(0), f); CHECK_EQUAL(CORBA::ULong(8), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); @@ -398,6 +405,8 @@ a.replace (n, upper_mb); CHECK_EQUAL(CORBA::Octet( 'T'), a[0]); CHECK_EQUAL(CORBA::Octet( 'S'), a[6]); + delete upper_mb; + delete mb; #endif return 0; } @@ -438,11 +447,9 @@ { typedef value_sequence_tester common; - common tester (false); + common tester; status += tester.test_all (); } return status; } - - Index: bounded_sequence_cdr_ut.cpp =================================================================== --- bounded_sequence_cdr_ut.cpp (revision 84974) +++ bounded_sequence_cdr_ut.cpp (working copy) @@ -53,7 +53,7 @@ value_type * alloc_and_init_buffer() { - value_type * buf = tested_sequence::allocbuf(8); + value_type * buf = tested_sequence::allocbuf(); buf[0] = mock_reference::allocate(1); buf[1] = mock_reference::allocate(4); buf[2] = mock_reference::allocate(9); @@ -99,7 +99,7 @@ { int status = 0; Tester mytester; - + status += mytester.test_stream(); return status; Index: unbounded_string_sequence_ut.cpp =================================================================== --- unbounded_string_sequence_ut.cpp (revision 84974) +++ unbounded_string_sequence_ut.cpp (working copy) @@ -48,7 +48,9 @@ } FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(i.expect(0), i); + // ulong constructor calls allocbuf and thus there must be + // maximum() default initilized elements. + FAIL_RETURN_IF_NOT(i.expect(16), i); return 0; } @@ -57,10 +59,14 @@ expected_calls a(tested_allocation_traits::allocbuf_calls); expected_calls f(tested_allocation_traits::freebuf_calls); expected_calls i(tested_element_traits::default_initializer_calls); + expected_calls r(tested_element_traits::release_calls); expected_calls d(tested_element_traits::duplicate_calls); { tested_sequence x(16); FAIL_RETURN_IF_NOT(a.expect(1), a); + // ulong constructor calls allocbuf and thus there must be + // maximum() default initilized elements. + FAIL_RETURN_IF_NOT(i.expect(16), i); x.length(8); @@ -68,7 +74,9 @@ CHECK_EQUAL(CORBA::ULong(8), x.length()); CHECK_EQUAL(true, x.release()); - FAIL_RETURN_IF_NOT(i.expect(8), i); + // length() doesn't default initialize anything since initialization + // was done in ulong constructor. + FAIL_RETURN_IF_NOT(i.expect(0), i); tested_sequence y(x); FAIL_RETURN_IF_NOT(a.expect(1), a); @@ -77,9 +85,13 @@ CHECK_EQUAL(true, y.release()); FAIL_RETURN_IF_NOT(d.expect(8), d); + // Copy constructor must duplicate length() elements and default + // initilize rest maximum()-length(). + FAIL_RETURN_IF_NOT(i.expect(8), d); } FAIL_RETURN_IF_NOT(f.expect(2), f); - FAIL_RETURN_IF_NOT(i.expect(0), i); + // There must be 32 elements released since maximum() is 16. + FAIL_RETURN_IF_NOT(r.expect(32), i); return 0; } @@ -96,7 +108,9 @@ CHECK_EQUAL(CORBA::ULong(8), x.length()); CHECK_EQUAL(true, x.release()); - FAIL_RETURN_IF_NOT(i.expect(8), i); + // ulong constructor calls allocbuf and thus there must be + // maximum() default initilized elements. + FAIL_RETURN_IF_NOT(i.expect(16), i); } FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(1), f); @@ -116,7 +130,10 @@ FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(1), f); - FAIL_RETURN_IF_NOT(i.expect(32), i); + // ulong constructor calls allocbuf and thus there must be + // maximum() default initilized elements + length() leads to buffer + // reallocation maximum() gets set to a new value. + FAIL_RETURN_IF_NOT(i.expect(48), i); CHECK_EQUAL(CORBA::ULong(32), x.maximum()); CHECK_EQUAL(CORBA::ULong(32), x.length()); @@ -176,11 +193,11 @@ return 0; } - int test_duplicate_exception_in_length() + int test_default_initializer_exception_in_length() { expected_calls f(tested_allocation_traits::freebuf_calls); expected_calls a(tested_allocation_traits::allocbuf_calls); - expected_calls d(tested_element_traits::duplicate_calls); + expected_calls d(tested_element_traits::default_initializer_calls); expected_calls r(tested_element_traits::release_calls); { tested_sequence y; y.length(4); @@ -193,7 +210,7 @@ d.reset(); r.reset(); f.reset(); - tested_element_traits::duplicate_calls.failure_countdown(3); + tested_element_traits::default_initializer_calls.failure_countdown(3); CHECK_THROW(y.length(8), testing_exception); FAIL_RETURN_IF_NOT(a.expect(1), a); FAIL_RETURN_IF_NOT(f.expect(1), f); @@ -216,9 +233,13 @@ value_type * alloc_and_init_buffer() { value_type * buf = tested_sequence::allocbuf(8); + delete[] buf[0]; buf[0] = helper::to_string(1); + delete[] buf[1]; buf[1] = helper::to_string(4); + delete[] buf[2]; buf[2] = helper::to_string(9); + delete[] buf[3]; buf[3] = helper::to_string(16); return buf; @@ -358,7 +379,7 @@ expected_calls r(tested_element_traits::release_calls); { tested_sequence a; - a.replace(8, 4, buffer, false); + a.replace(8, 4, buffer, true); FAIL_RETURN_IF_NOT(c.expect(0), c); FAIL_RETURN_IF_NOT(f.expect(0), f); FAIL_RETURN_IF_NOT(r.expect(0), r); @@ -366,12 +387,13 @@ CHECK_EQUAL(CORBA::ULong(8), a.maximum()); CHECK_EQUAL(CORBA::ULong(4), a.length()); CHECK_EQUAL(buffer, a.get_buffer()); - CHECK_EQUAL(false, a.release()); + CHECK_EQUAL(true, a.release()); check_values(a); } FAIL_RETURN_IF_NOT(c.expect(0), c); - FAIL_RETURN_IF_NOT(f.expect(0), f); - tested_sequence::freebuf(buffer); + // Since we've given away the ownership the buffer is deallocated by + // the sequence. + FAIL_RETURN_IF_NOT(f.expect(1), f); FAIL_RETURN_IF_NOT(r.expect(8), r); return 0; } @@ -435,22 +457,23 @@ expected_calls f(tested_allocation_traits::freebuf_calls); expected_calls r(tested_element_traits::release_calls); { - tested_sequence a(8, 4, buffer, false); - CHECK_EQUAL(CORBA::ULong(8), a.maximum()); - CHECK_EQUAL(CORBA::ULong(4), a.length()); - CHECK_EQUAL(buffer, a.get_buffer()); - CHECK_EQUAL(false, a.release()); - check_values(a); - a.length (3); - CHECK_EQUAL(CORBA::ULong(3), a.length()); - a.length (4); - CHECK_EQUAL(CORBA::ULong(4), a.length()); - CHECK(helper::compare_empty(a[3])); + tested_sequence x(8, 4, buffer, true); + CHECK_EQUAL(CORBA::ULong(8), x.maximum()); + CHECK_EQUAL(CORBA::ULong(4), x.length()); + CHECK_EQUAL(buffer, x.get_buffer()); + CHECK_EQUAL(true, x.release()); + check_values(x); + x.length (3); + CHECK_EQUAL(CORBA::ULong(3), x.length()); + x.length (4); + CHECK_EQUAL(CORBA::ULong(4), x.length()); + CHECK(helper::compare_empty(x[3])); } FAIL_RETURN_IF_NOT(a.expect(0), a); - FAIL_RETURN_IF_NOT(f.expect(0), f); - tested_sequence::freebuf(buffer); - FAIL_RETURN_IF_NOT(r.expect(8), r); + FAIL_RETURN_IF_NOT(f.expect(1), f); + // 1 additional release call happens when we shrink + // the sequence to length 3. + FAIL_RETURN_IF_NOT(r.expect(9), r); return 0; } @@ -459,7 +482,7 @@ { int status = 0; typedef string_sequence_tester common; - common tester (false); + common tester; status += tester.test_all (); status += this->test_ulong_constructor(); @@ -468,7 +491,7 @@ status += this->test_set_length_more_than_maximum(); status += this->test_exception_in_ulong_constructor(); status += this->test_exception_in_length(); - status += this->test_duplicate_exception_in_length(); + status += this->test_default_initializer_exception_in_length(); status += this->test_buffer_constructor_default(); status += this->test_buffer_constructor_false(); status += this->test_buffer_constructor_true(); @@ -480,7 +503,7 @@ status += this->test_get_buffer_true_with_release_false(); status += this->test_get_buffer_true_with_release_true(); status += this->test_regression_2201(); - return status; + return status; } Tester() {} }; @@ -494,7 +517,7 @@ status += ntester.test_all (); } -#if defined(ACE_HAS_WCHAR) +#if defined(ACE_HAS_WCHAR) { typedef Tester > wTester; wTester wtester; @@ -504,4 +527,3 @@ return status; } - Index: testing_allocation_traits.hpp =================================================================== --- testing_allocation_traits.hpp (revision 84974) +++ testing_allocation_traits.hpp (working copy) @@ -37,6 +37,13 @@ return base::allocbuf(maximum); } + // allocbuf_calls must be updated when allocbuf_noinit is called as well. + inline static value_type * allocbuf_noinit(CORBA::ULong maximum) + { + allocbuf_calls(); + return base::allocbuf_noinit(maximum); + } + static call_counter freebuf_calls; inline static void freebuf(value_type * buffer) { Index: string_sequence_element_ut.cpp =================================================================== --- string_sequence_element_ut.cpp (revision 84974) +++ string_sequence_element_ut.cpp (working copy) @@ -61,7 +61,7 @@ } }; -#if defined(ACE_HAS_WCHAR) +#if defined(ACE_HAS_WCHAR) template<> struct helper { Index: unbounded_value_sequence_ut.cpp =================================================================== --- unbounded_value_sequence_ut.cpp (revision 84974) +++ unbounded_value_sequence_ut.cpp (working copy) @@ -174,24 +174,23 @@ expected_calls a(tested_allocation_traits::allocbuf_calls); expected_calls f(tested_allocation_traits::freebuf_calls); { - tested_sequence a(8, 4, buffer); - CHECK_EQUAL(CORBA::ULong(8), a.maximum()); - CHECK_EQUAL(CORBA::ULong(4), a.length()); - CHECK_EQUAL(buffer, a.get_buffer()); - CHECK_EQUAL(int( 1), a[0]); - CHECK_EQUAL(int( 4), a[1]); - CHECK_EQUAL(int( 9), a[2]); - CHECK_EQUAL(int(16), a[3]); - CHECK_EQUAL(false, a.release()); - a.length (3); - CHECK_EQUAL(CORBA::ULong(3), a.length()); - a.length (4); - CHECK_EQUAL(CORBA::ULong(4), a.length()); - CHECK_EQUAL(int(0), a[3]); + tested_sequence x(8, 4, buffer, true); + CHECK_EQUAL(CORBA::ULong(8), x.maximum()); + CHECK_EQUAL(CORBA::ULong(4), x.length()); + CHECK_EQUAL(buffer, x.get_buffer()); + CHECK_EQUAL(int( 1), x[0]); + CHECK_EQUAL(int( 4), x[1]); + CHECK_EQUAL(int( 9), x[2]); + CHECK_EQUAL(int(16), x[3]); + CHECK_EQUAL(true, x.release()); + x.length (3); + CHECK_EQUAL(CORBA::ULong(3), x.length()); + x.length (4); + CHECK_EQUAL(CORBA::ULong(4), x.length()); + CHECK_EQUAL(int(0), x[3]); } FAIL_RETURN_IF_NOT(a.expect(0), a); - FAIL_RETURN_IF_NOT(f.expect(0), f); - tested_sequence::freebuf(buffer); + FAIL_RETURN_IF_NOT(f.expect(1), f); return 0; } @@ -423,9 +422,8 @@ status += tester.test_all (); typedef value_sequence_tester common; - common tester2 (false); + common tester2; status += tester2.test_all (); return status; } - Index: testing_allocation_traits_ut.cpp =================================================================== --- testing_allocation_traits_ut.cpp (revision 84974) +++ testing_allocation_traits_ut.cpp (working copy) @@ -75,7 +75,9 @@ s = bounded::default_buffer_allocation(); FAIL_RETURN_IF_NOT(u.expect(0), u); FAIL_RETURN_IF_NOT(b.expect(1), b); - CHECK(static_cast(0) != s); + // default_buffer_allocation doesn't allocate a buffer for + // bounded sequences (see bug 3042). + CHECK_EQUAL(static_cast(0), s); bounded::freebuf(s); return 0; } @@ -140,7 +142,7 @@ status += this->test_allocbuf_bounded(); status += this->test_freebuf_unbounded(); status += this->test_freebuf_bounded(); - return status; + return status; } Tester() {} }; @@ -167,4 +169,3 @@ return status; } - Index: unbounded_octet_sequence_ut.cpp =================================================================== --- unbounded_octet_sequence_ut.cpp (revision 84974) +++ unbounded_octet_sequence_ut.cpp (working copy) @@ -312,6 +312,8 @@ CHECK_EQUAL(true, a.release()); } FAIL_RETURN_IF_NOT(c.expect(0), c); + // Since we've given away the ownership the buffer is deallocated by + // the sequence. FAIL_RETURN_IF_NOT(f.expect(1), f); return 0; } @@ -369,7 +371,7 @@ int test_all() { int status = 0; - + status += this->test_ulong_constructor(); status += this->test_copy_constructor_from_ulong(); status += this->test_assignment_from_ulong(); @@ -402,7 +404,7 @@ { typedef value_sequence_tester common; - common tester (false); + common tester; status += tester.test_all (); } Index: Sequence_Unit_Tests.mpc =================================================================== --- Sequence_Unit_Tests.mpc (revision 84974) +++ Sequence_Unit_Tests.mpc (working copy) @@ -90,7 +90,7 @@ } project(*UB_Oct_Seq_No_Cpy): taoexe { - exename = unbounded_octet_sequence_no_copy_ut + exename = unbounded_octet_sequence_nocopy_ut Source_Files { mock_reference.cpp unbounded_octet_sequence_nocopy_ut.cpp Index: unbounded_fwd_object_reference_sequence_ut.cpp =================================================================== --- unbounded_fwd_object_reference_sequence_ut.cpp (revision 84974) +++ unbounded_fwd_object_reference_sequence_ut.cpp (working copy) @@ -55,6 +55,6 @@ int status = 0; Tester x; status += x.test_default_constructor (); - + return status; } Index: Makefile.am =================================================================== --- Makefile.am (revision 84974) +++ Makefile.am (working copy) @@ -411,9 +411,9 @@ if BUILD_BOOST if BUILD_EXCEPTIONS -noinst_PROGRAMS += unbounded_octet_sequence_no_copy_ut +noinst_PROGRAMS += unbounded_octet_sequence_nocopy_ut -unbounded_octet_sequence_no_copy_ut_CPPFLAGS = \ +unbounded_octet_sequence_nocopy_ut_CPPFLAGS = \ -I$(ACE_ROOT) \ -I$(ACE_BUILDDIR) \ -I$(TAO_ROOT) \ @@ -421,15 +421,15 @@ -I$(BOOST_ROOT)/include/$(BOOST_VERSION) \ -I$(BOOST_ROOT)/. -unbounded_octet_sequence_no_copy_ut_SOURCES = \ +unbounded_octet_sequence_nocopy_ut_SOURCES = \ mock_reference.cpp \ unbounded_octet_sequence_nocopy_ut.cpp \ mock_reference.hpp -unbounded_octet_sequence_no_copy_ut_LDFLAGS = \ +unbounded_octet_sequence_nocopy_ut_LDFLAGS = \ -L$(BOOST_ROOT)/lib -unbounded_octet_sequence_no_copy_ut_LDADD = \ +unbounded_octet_sequence_nocopy_ut_LDADD = \ $(TAO_BUILDDIR)/tao/libTAO.la \ $(ACE_BUILDDIR)/ace/libACE.la \ -l$(BOOST_STATIC_LIB_PREFIX)boost_unit_test_framework$(BOOST_CFG)