URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libstdc++-v3/] [testsuite/] [23_containers/] [vector/] [cons/] [4.cc] - Blame information for rev 424

Details | Compare with Previous | View Log


// 1999-06-29 bkoz
 
// Copyright (C) 1999-2001, 2002, 2003, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
 
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3.  If not see
// <http://www.gnu.org/licenses/>.
 
// 23.2.4.1 vector constructors, copy, and assignment
 
#include <vector>
#include <string>
#include <testsuite_allocator.h>
#include <testsuite_hooks.h>
 
using __gnu_test::copy_tracker;
using __gnu_test::tracker_allocator_counter;
using __gnu_test::tracker_allocator;
using __gnu_test::copy_constructor;
using __gnu_test::assignment_operator;
 
// @fn test_default_ctor_exception_gurantee This test verifies that if
// one of the vector's contained objects throws an exception from its
// constructor while the vector is being constructed and filled with
// default values, all memory is returned to the allocator whence it
// came.
void
test_default_ctor_exception_gurantee()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  copy_tracker::reset();
  copy_constructor::throw_on(3);
  tracker_allocator_counter::reset();
 
  // run test
  try
  {
    X a(7);
    VERIFY(false);
  }
  catch (...)
  {
  }
 
  // assert postconditions
  VERIFY( tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count() );
 
  // teardown
}
 
// @fn test_copy_ctor_exception_gurantee This test verifies that if
// one of the vector's contained objects throws an exception from its
// constructor while the vector is being copy constructed, all memory
// is returned to the allocator whence it came.
void
test_copy_ctor_exception_gurantee()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  tracker_allocator_counter::reset();
  {
    X a(7);
    copy_tracker::reset();
    copy_constructor::throw_on(3);
 
    // run test
    try
    {
      X u(a);
      VERIFY(false);
    }
    catch (...)
    {
    }
  }
 
  // assert postconditions
  VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
// operator=()
//
// case 1: lhs.size() > rhs.size()
// case 2: lhs.size() < rhs.size() < lhs.capacity()
// case 3: lhs.capacity() < rhs.size()
//
void
test_assignment_operator_1()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  X r(9);
  X a(r.size() - 2);
  copy_tracker::reset();
  tracker_allocator_counter::reset();
 
  // preconditions
  VERIFY(r.size() > a.size());
 
  // run test
  r = a;
 
  // assert postconditions
  VERIFY(r == a);
  VERIFY(tracker_allocator_counter::get_allocation_count() == 0);
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_assignment_operator_2()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  X r(1);
  r.reserve(17);
  X a(r.size() + 7);
  copy_tracker::reset();
  tracker_allocator_counter::reset();
 
  // preconditions
  VERIFY(r.size() < a.size());
  VERIFY(a.size() < r.capacity());
 
  // run test
  r = a;
 
  // assert postconditions
  VERIFY(r == a);
  VERIFY(tracker_allocator_counter::get_allocation_count() == 0);
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_assignment_operator_3()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  tracker_allocator_counter::reset();
  {
    X r(1);
    X a(r.capacity() + 7);
    copy_tracker::reset();
 
    // preconditions
    VERIFY(r.capacity() < a.size());
 
    // run test
    r = a;
 
    // assert postconditions
    VERIFY(r == a);
  }
  VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_assignment_operator_3_exception_guarantee()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  tracker_allocator_counter::reset();
  {
    X r(1);
    X a(r.capacity() + 7);
    copy_tracker::reset();
    copy_constructor::throw_on(3);
 
    // preconditions
    VERIFY(r.capacity() < a.size());
 
    // run test
    try
    {
      r = a;
      VERIFY(false);
    }
    catch (...)
    {
    }
  }
 
  // assert postconditions
  VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
// fill assign()
//
// case 1: [23.2.4.1 (3)] n <= size()
// case 2: [23.2.4.1 (3)] size() < n <= capacity()
// case 3: [23.2.4.1 (3)] n > capacity()
// case 4: [23.2.4.1 (3)] n > capacity(), exception guarantees
// case 5: [23.1.1 (9)] fill assign disguised as a range assign
//
void
test_fill_assign_1()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  X a(7);
  X::size_type old_size = a.size();
  X::size_type new_size = old_size - 2;
  const T t;
 
  copy_tracker::reset();
  tracker_allocator_counter::reset();
 
  // run test
  a.assign(new_size, t);
 
  // assert postconditions
  VERIFY(a.size() == new_size);
  VERIFY(tracker_allocator_counter::get_allocation_count() == 0);
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_fill_assign_2()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  X a(7);
  a.reserve(11);
  X::size_type old_size     = a.size();
  X::size_type old_capacity = a.capacity();
  X::size_type new_size     = old_size + 2;
  const T t;
 
  copy_tracker::reset();
  tracker_allocator_counter::reset();
 
  // assert preconditions
  VERIFY(old_size < new_size);
  VERIFY(new_size <= old_capacity);
 
  // run test
  a.assign(new_size, t);
 
  // assert postconditions
  VERIFY(a.size() == new_size);
  VERIFY(tracker_allocator_counter::get_allocation_count() == 0);
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_fill_assign_3()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  tracker_allocator_counter::reset();
  {
    X a(7);
    X::size_type old_capacity = a.capacity();
    X::size_type new_size     = old_capacity + 4;
    const T t;
 
    copy_tracker::reset();
 
    // assert preconditions
    VERIFY(new_size > old_capacity);
 
    // run test
    a.assign(new_size, t);
 
    // assert postconditions
    VERIFY(a.size() == new_size);
  }
 
  VERIFY(tracker_allocator_counter::get_allocation_count() > 0);
  VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_fill_assign_3_exception_guarantee()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  tracker_allocator_counter::reset();
  {
    X a(7);
    X::size_type old_size     = a.size();
    X::size_type old_capacity = a.capacity();
    X::size_type new_size     = old_capacity + 4;
    const T t;
 
    copy_tracker::reset();
    copy_constructor::throw_on(3);
 
    // assert preconditions
    VERIFY(new_size > old_capacity);
 
    // run test
    try
    {
      a.assign(new_size, t);
      VERIFY(false);
    }
    catch (...)
    {
    }
 
    // assert postconditions
    VERIFY(a.size() == old_size);
    VERIFY(a.capacity() == old_capacity);
  }
 
  VERIFY(tracker_allocator_counter::get_allocation_count() > 0);
  VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_fill_assign_4()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  X a(7);
  X::size_type old_size  = a.size();
  X::size_type new_size  = old_size - 2;
  X::size_type new_value = 117;
 
  copy_tracker::reset();
  tracker_allocator_counter::reset();
 
  // run test
  a.assign(new_size, new_value);
 
  // assert postconditions
  VERIFY(a.size() == new_size);
  VERIFY(tracker_allocator_counter::get_allocation_count() == 0);
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
// range assign()
//
// case 1: [23.2.4.1 (2)] input iterator
// case 2: [23.2.4.1 (2)] forward iterator, distance(first, last) <= size()
// case 3: [23.2.4.1 (2)] 
//         forward iterator, size() < distance(first, last) <= capacity()
// case 4: [23.2.4.1 (2)] forward iterator, distance(first, last) > capacity()
// case 5: [23.2.4.1 (2)] 
//         forward iterator, distance(first, last) > capacity(), 
//         exception guarantees
void
test_range_assign_1()
{
  // @TODO
}
 
void
test_range_assign_2()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  X a(7);
  X b(3);
 
  copy_tracker::reset();
  tracker_allocator_counter::reset();
 
  // assert preconditions
  VERIFY(b.size() < a.capacity());
 
  // run test
  a.assign(b.begin(), b.end());
 
  // assert postconditions
  VERIFY(a.size() == b.size());
  VERIFY(a == b);
  VERIFY(tracker_allocator_counter::get_allocation_count() == 0);
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_range_assign_3()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  X a(7);
  a.reserve(a.size() + 7);
  X b(a.size() + 3);
 
  copy_tracker::reset();
  tracker_allocator_counter::reset();
 
  // assert preconditions
  VERIFY(a.size() < b.size());
  VERIFY(b.size() < a.capacity());
 
  // run test
  a.assign(b.begin(), b.end());
 
  // assert postconditions
  VERIFY(a.size() == b.size());
  VERIFY(a == b);
  VERIFY(tracker_allocator_counter::get_allocation_count() == 0);
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_range_assign_4()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  tracker_allocator_counter::reset();
  {
    X a(7);
    X b(a.capacity() + 7);
 
    copy_tracker::reset();
 
    // assert preconditions
    VERIFY(b.size() > a.capacity());
 
    // run test
    a.assign(b.begin(), b.end());
 
    // assert postconditions
    VERIFY(a.size() == b.size());
    VERIFY(a == b);
  }
  VERIFY(tracker_allocator_counter::get_allocation_count() > 0);
  VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
void
test_range_assign_4_exception_guarantee()
{
  // setup
  bool test __attribute__((unused)) = true;
  typedef copy_tracker T;
  typedef std::vector<T, tracker_allocator<T> > X;
 
  tracker_allocator_counter::reset();
  {
    X a(7);
    X b(a.capacity() + 7);
 
    copy_tracker::reset();
    copy_constructor::throw_on(3);
 
    // assert preconditions
    VERIFY(b.size() > a.capacity());
 
    // run test
    try
    {
      a.assign(b.begin(), b.end());
      VERIFY(false);
    }
    catch (...)
    {
    }
  }
 
  // assert postconditions
  VERIFY(tracker_allocator_counter::get_allocation_count() > 0);
  VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());
 
  // teardown
  copy_tracker::reset();
  tracker_allocator_counter::reset();
}
 
 
int main()
{
  test_default_ctor_exception_gurantee();
  test_copy_ctor_exception_gurantee();
  test_assignment_operator_1();
  test_assignment_operator_2();
  test_assignment_operator_3();
  test_assignment_operator_3_exception_guarantee();
  test_fill_assign_1();
  test_fill_assign_2();
  test_fill_assign_3();
  test_fill_assign_3_exception_guarantee();
  test_fill_assign_4();
  test_range_assign_1();
  test_range_assign_2();
  test_range_assign_3();
  test_range_assign_4();
  test_range_assign_4_exception_guarantee();
 
  return 0;
}

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [libstdc++-v3/] [testsuite/] [23_containers/] [vector/] [cons/] [4.cc] - Blame information for rev 424

Line No.	Rev	Author	Line
1	424	jeremybenn	`// 1999-06-29 bkoz`
2
3			`// Copyright (C) 1999-2001, 2002, 2003, 2009 Free Software Foundation, Inc.`
4			`//`
5			`// This file is part of the GNU ISO C++ Library. This library is free`
6			`// software; you can redistribute it and/or modify it under the`
7			`// terms of the GNU General Public License as published by the`
8			`// Free Software Foundation; either version 3, or (at your option)`
9			`// any later version.`
10
11			`// This library is distributed in the hope that it will be useful,`
12			`// but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`// GNU General Public License for more details.`
15
16			`// You should have received a copy of the GNU General Public License along`
17			`// with this library; see the file COPYING3. If not see`
18			`// <http://www.gnu.org/licenses/>.`
19
20			`// 23.2.4.1 vector constructors, copy, and assignment`
21
22			`#include <vector>`
23			`#include <string>`
24			`#include <testsuite_allocator.h>`
25			`#include <testsuite_hooks.h>`
26
27			`using __gnu_test::copy_tracker;`
28			`using __gnu_test::tracker_allocator_counter;`
29			`using __gnu_test::tracker_allocator;`
30			`using __gnu_test::copy_constructor;`
31			`using __gnu_test::assignment_operator;`
32
33			`// @fn test_default_ctor_exception_gurantee This test verifies that if`
34			`// one of the vector's contained objects throws an exception from its`
35			`// constructor while the vector is being constructed and filled with`
36			`// default values, all memory is returned to the allocator whence it`
37			`// came.`
38			`void`
39			`test_default_ctor_exception_gurantee()`
40			`{`
41			`// setup`
42			`bool test __attribute__((unused)) = true;`
43			`typedef copy_tracker T;`
44			`typedef std::vector<T, tracker_allocator<T> > X;`
45
46			`copy_tracker::reset();`
47			`copy_constructor::throw_on(3);`
48			`tracker_allocator_counter::reset();`
49
50			`// run test`
51			`try`
52			`{`
53			`X a(7);`
54			`VERIFY(false);`
55			`}`
56			`catch (...)`
57			`{`
58			`}`
59
60			`// assert postconditions`
61			`VERIFY( tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count() );`
62
63			`// teardown`
64			`}`
65
66			`// @fn test_copy_ctor_exception_gurantee This test verifies that if`
67			`// one of the vector's contained objects throws an exception from its`
68			`// constructor while the vector is being copy constructed, all memory`
69			`// is returned to the allocator whence it came.`
70			`void`
71			`test_copy_ctor_exception_gurantee()`
72			`{`
73			`// setup`
74			`bool test __attribute__((unused)) = true;`
75			`typedef copy_tracker T;`
76			`typedef std::vector<T, tracker_allocator<T> > X;`
77
78			`tracker_allocator_counter::reset();`
79			`{`
80			`X a(7);`
81			`copy_tracker::reset();`
82			`copy_constructor::throw_on(3);`
83
84			`// run test`
85			`try`
86			`{`
87			`X u(a);`
88			`VERIFY(false);`
89			`}`
90			`catch (...)`
91			`{`
92			`}`
93			`}`
94
95			`// assert postconditions`
96			`VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());`
97
98			`// teardown`
99			`copy_tracker::reset();`
100			`tracker_allocator_counter::reset();`
101			`}`
102
103			`// operator=()`
104			`//`
105			`// case 1: lhs.size() > rhs.size()`
106			`// case 2: lhs.size() < rhs.size() < lhs.capacity()`
107			`// case 3: lhs.capacity() < rhs.size()`
108			`//`
109			`void`
110			`test_assignment_operator_1()`
111			`{`
112			`// setup`
113			`bool test __attribute__((unused)) = true;`
114			`typedef copy_tracker T;`
115			`typedef std::vector<T, tracker_allocator<T> > X;`
116
117			`X r(9);`
118			`X a(r.size() - 2);`
119			`copy_tracker::reset();`
120			`tracker_allocator_counter::reset();`
121
122			`// preconditions`
123			`VERIFY(r.size() > a.size());`
124
125			`// run test`
126			`r = a;`
127
128			`// assert postconditions`
129			`VERIFY(r == a);`
130			`VERIFY(tracker_allocator_counter::get_allocation_count() == 0);`
131
132			`// teardown`
133			`copy_tracker::reset();`
134			`tracker_allocator_counter::reset();`
135			`}`
136
137			`void`
138			`test_assignment_operator_2()`
139			`{`
140			`// setup`
141			`bool test __attribute__((unused)) = true;`
142			`typedef copy_tracker T;`
143			`typedef std::vector<T, tracker_allocator<T> > X;`
144
145			`X r(1);`
146			`r.reserve(17);`
147			`X a(r.size() + 7);`
148			`copy_tracker::reset();`
149			`tracker_allocator_counter::reset();`
150
151			`// preconditions`
152			`VERIFY(r.size() < a.size());`
153			`VERIFY(a.size() < r.capacity());`
154
155			`// run test`
156			`r = a;`
157
158			`// assert postconditions`
159			`VERIFY(r == a);`
160			`VERIFY(tracker_allocator_counter::get_allocation_count() == 0);`
161
162			`// teardown`
163			`copy_tracker::reset();`
164			`tracker_allocator_counter::reset();`
165			`}`
166
167			`void`
168			`test_assignment_operator_3()`
169			`{`
170			`// setup`
171			`bool test __attribute__((unused)) = true;`
172			`typedef copy_tracker T;`
173			`typedef std::vector<T, tracker_allocator<T> > X;`
174
175			`tracker_allocator_counter::reset();`
176			`{`
177			`X r(1);`
178			`X a(r.capacity() + 7);`
179			`copy_tracker::reset();`
180
181			`// preconditions`
182			`VERIFY(r.capacity() < a.size());`
183
184			`// run test`
185			`r = a;`
186
187			`// assert postconditions`
188			`VERIFY(r == a);`
189			`}`
190			`VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());`
191
192			`// teardown`
193			`copy_tracker::reset();`
194			`tracker_allocator_counter::reset();`
195			`}`
196
197			`void`
198			`test_assignment_operator_3_exception_guarantee()`
199			`{`
200			`// setup`
201			`bool test __attribute__((unused)) = true;`
202			`typedef copy_tracker T;`
203			`typedef std::vector<T, tracker_allocator<T> > X;`
204
205			`tracker_allocator_counter::reset();`
206			`{`
207			`X r(1);`
208			`X a(r.capacity() + 7);`
209			`copy_tracker::reset();`
210			`copy_constructor::throw_on(3);`
211
212			`// preconditions`
213			`VERIFY(r.capacity() < a.size());`
214
215			`// run test`
216			`try`
217			`{`
218			`r = a;`
219			`VERIFY(false);`
220			`}`
221			`catch (...)`
222			`{`
223			`}`
224			`}`
225
226			`// assert postconditions`
227			`VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());`
228
229			`// teardown`
230			`copy_tracker::reset();`
231			`tracker_allocator_counter::reset();`
232			`}`
233
234			`// fill assign()`
235			`//`
236			`// case 1: [23.2.4.1 (3)] n <= size()`
237			`// case 2: [23.2.4.1 (3)] size() < n <= capacity()`
238			`// case 3: [23.2.4.1 (3)] n > capacity()`
239			`// case 4: [23.2.4.1 (3)] n > capacity(), exception guarantees`
240			`// case 5: [23.1.1 (9)] fill assign disguised as a range assign`
241			`//`
242			`void`
243			`test_fill_assign_1()`
244			`{`
245			`// setup`
246			`bool test __attribute__((unused)) = true;`
247			`typedef copy_tracker T;`
248			`typedef std::vector<T, tracker_allocator<T> > X;`
249
250			`X a(7);`
251			`X::size_type old_size = a.size();`
252			`X::size_type new_size = old_size - 2;`
253			`const T t;`
254
255			`copy_tracker::reset();`
256			`tracker_allocator_counter::reset();`
257
258			`// run test`
259			`a.assign(new_size, t);`
260
261			`// assert postconditions`
262			`VERIFY(a.size() == new_size);`
263			`VERIFY(tracker_allocator_counter::get_allocation_count() == 0);`
264
265			`// teardown`
266			`copy_tracker::reset();`
267			`tracker_allocator_counter::reset();`
268			`}`
269
270			`void`
271			`test_fill_assign_2()`
272			`{`
273			`// setup`
274			`bool test __attribute__((unused)) = true;`
275			`typedef copy_tracker T;`
276			`typedef std::vector<T, tracker_allocator<T> > X;`
277
278			`X a(7);`
279			`a.reserve(11);`
280			`X::size_type old_size = a.size();`
281			`X::size_type old_capacity = a.capacity();`
282			`X::size_type new_size = old_size + 2;`
283			`const T t;`
284
285			`copy_tracker::reset();`
286			`tracker_allocator_counter::reset();`
287
288			`// assert preconditions`
289			`VERIFY(old_size < new_size);`
290			`VERIFY(new_size <= old_capacity);`
291
292			`// run test`
293			`a.assign(new_size, t);`
294
295			`// assert postconditions`
296			`VERIFY(a.size() == new_size);`
297			`VERIFY(tracker_allocator_counter::get_allocation_count() == 0);`
298
299			`// teardown`
300			`copy_tracker::reset();`
301			`tracker_allocator_counter::reset();`
302			`}`
303
304			`void`
305			`test_fill_assign_3()`
306			`{`
307			`// setup`
308			`bool test __attribute__((unused)) = true;`
309			`typedef copy_tracker T;`
310			`typedef std::vector<T, tracker_allocator<T> > X;`
311
312			`tracker_allocator_counter::reset();`
313			`{`
314			`X a(7);`
315			`X::size_type old_capacity = a.capacity();`
316			`X::size_type new_size = old_capacity + 4;`
317			`const T t;`
318
319			`copy_tracker::reset();`
320
321			`// assert preconditions`
322			`VERIFY(new_size > old_capacity);`
323
324			`// run test`
325			`a.assign(new_size, t);`
326
327			`// assert postconditions`
328			`VERIFY(a.size() == new_size);`
329			`}`
330
331			`VERIFY(tracker_allocator_counter::get_allocation_count() > 0);`
332			`VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());`
333
334			`// teardown`
335			`copy_tracker::reset();`
336			`tracker_allocator_counter::reset();`
337			`}`
338
339			`void`
340			`test_fill_assign_3_exception_guarantee()`
341			`{`
342			`// setup`
343			`bool test __attribute__((unused)) = true;`
344			`typedef copy_tracker T;`
345			`typedef std::vector<T, tracker_allocator<T> > X;`
346
347			`tracker_allocator_counter::reset();`
348			`{`
349			`X a(7);`
350			`X::size_type old_size = a.size();`
351			`X::size_type old_capacity = a.capacity();`
352			`X::size_type new_size = old_capacity + 4;`
353			`const T t;`
354
355			`copy_tracker::reset();`
356			`copy_constructor::throw_on(3);`
357
358			`// assert preconditions`
359			`VERIFY(new_size > old_capacity);`
360
361			`// run test`
362			`try`
363			`{`
364			`a.assign(new_size, t);`
365			`VERIFY(false);`
366			`}`
367			`catch (...)`
368			`{`
369			`}`
370
371			`// assert postconditions`
372			`VERIFY(a.size() == old_size);`
373			`VERIFY(a.capacity() == old_capacity);`
374			`}`
375
376			`VERIFY(tracker_allocator_counter::get_allocation_count() > 0);`
377			`VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());`
378
379			`// teardown`
380			`copy_tracker::reset();`
381			`tracker_allocator_counter::reset();`
382			`}`
383
384			`void`
385			`test_fill_assign_4()`
386			`{`
387			`// setup`
388			`bool test __attribute__((unused)) = true;`
389			`typedef copy_tracker T;`
390			`typedef std::vector<T, tracker_allocator<T> > X;`
391
392			`X a(7);`
393			`X::size_type old_size = a.size();`
394			`X::size_type new_size = old_size - 2;`
395			`X::size_type new_value = 117;`
396
397			`copy_tracker::reset();`
398			`tracker_allocator_counter::reset();`
399
400			`// run test`
401			`a.assign(new_size, new_value);`
402
403			`// assert postconditions`
404			`VERIFY(a.size() == new_size);`
405			`VERIFY(tracker_allocator_counter::get_allocation_count() == 0);`
406
407			`// teardown`
408			`copy_tracker::reset();`
409			`tracker_allocator_counter::reset();`
410			`}`
411
412			`// range assign()`
413			`//`
414			`// case 1: [23.2.4.1 (2)] input iterator`
415			`// case 2: [23.2.4.1 (2)] forward iterator, distance(first, last) <= size()`
416			`// case 3: [23.2.4.1 (2)]`
417			`// forward iterator, size() < distance(first, last) <= capacity()`
418			`// case 4: [23.2.4.1 (2)] forward iterator, distance(first, last) > capacity()`
419			`// case 5: [23.2.4.1 (2)]`
420			`// forward iterator, distance(first, last) > capacity(),`
421			`// exception guarantees`
422			`void`
423			`test_range_assign_1()`
424			`{`
425			`// @TODO`
426			`}`
427
428			`void`
429			`test_range_assign_2()`
430			`{`
431			`// setup`
432			`bool test __attribute__((unused)) = true;`
433			`typedef copy_tracker T;`
434			`typedef std::vector<T, tracker_allocator<T> > X;`
435
436			`X a(7);`
437			`X b(3);`
438
439			`copy_tracker::reset();`
440			`tracker_allocator_counter::reset();`
441
442			`// assert preconditions`
443			`VERIFY(b.size() < a.capacity());`
444
445			`// run test`
446			`a.assign(b.begin(), b.end());`
447
448			`// assert postconditions`
449			`VERIFY(a.size() == b.size());`
450			`VERIFY(a == b);`
451			`VERIFY(tracker_allocator_counter::get_allocation_count() == 0);`
452
453			`// teardown`
454			`copy_tracker::reset();`
455			`tracker_allocator_counter::reset();`
456			`}`
457
458			`void`
459			`test_range_assign_3()`
460			`{`
461			`// setup`
462			`bool test __attribute__((unused)) = true;`
463			`typedef copy_tracker T;`
464			`typedef std::vector<T, tracker_allocator<T> > X;`
465
466			`X a(7);`
467			`a.reserve(a.size() + 7);`
468			`X b(a.size() + 3);`
469
470			`copy_tracker::reset();`
471			`tracker_allocator_counter::reset();`
472
473			`// assert preconditions`
474			`VERIFY(a.size() < b.size());`
475			`VERIFY(b.size() < a.capacity());`
476
477			`// run test`
478			`a.assign(b.begin(), b.end());`
479
480			`// assert postconditions`
481			`VERIFY(a.size() == b.size());`
482			`VERIFY(a == b);`
483			`VERIFY(tracker_allocator_counter::get_allocation_count() == 0);`
484
485			`// teardown`
486			`copy_tracker::reset();`
487			`tracker_allocator_counter::reset();`
488			`}`
489
490			`void`
491			`test_range_assign_4()`
492			`{`
493			`// setup`
494			`bool test __attribute__((unused)) = true;`
495			`typedef copy_tracker T;`
496			`typedef std::vector<T, tracker_allocator<T> > X;`
497
498			`tracker_allocator_counter::reset();`
499			`{`
500			`X a(7);`
501			`X b(a.capacity() + 7);`
502
503			`copy_tracker::reset();`
504
505			`// assert preconditions`
506			`VERIFY(b.size() > a.capacity());`
507
508			`// run test`
509			`a.assign(b.begin(), b.end());`
510
511			`// assert postconditions`
512			`VERIFY(a.size() == b.size());`
513			`VERIFY(a == b);`
514			`}`
515			`VERIFY(tracker_allocator_counter::get_allocation_count() > 0);`
516			`VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());`
517
518			`// teardown`
519			`copy_tracker::reset();`
520			`tracker_allocator_counter::reset();`
521			`}`
522
523			`void`
524			`test_range_assign_4_exception_guarantee()`
525			`{`
526			`// setup`
527			`bool test __attribute__((unused)) = true;`
528			`typedef copy_tracker T;`
529			`typedef std::vector<T, tracker_allocator<T> > X;`
530
531			`tracker_allocator_counter::reset();`
532			`{`
533			`X a(7);`
534			`X b(a.capacity() + 7);`
535
536			`copy_tracker::reset();`
537			`copy_constructor::throw_on(3);`
538
539			`// assert preconditions`
540			`VERIFY(b.size() > a.capacity());`
541
542			`// run test`
543			`try`
544			`{`
545			`a.assign(b.begin(), b.end());`
546			`VERIFY(false);`
547			`}`
548			`catch (...)`
549			`{`
550			`}`
551			`}`
552
553			`// assert postconditions`
554			`VERIFY(tracker_allocator_counter::get_allocation_count() > 0);`
555			`VERIFY(tracker_allocator_counter::get_allocation_count() == tracker_allocator_counter::get_deallocation_count());`
556
557			`// teardown`
558			`copy_tracker::reset();`
559			`tracker_allocator_counter::reset();`
560			`}`
561
562
563			`int main()`
564			`{`
565			`test_default_ctor_exception_gurantee();`
566			`test_copy_ctor_exception_gurantee();`
567			`test_assignment_operator_1();`
568			`test_assignment_operator_2();`
569			`test_assignment_operator_3();`
570			`test_assignment_operator_3_exception_guarantee();`
571			`test_fill_assign_1();`
572			`test_fill_assign_2();`
573			`test_fill_assign_3();`
574			`test_fill_assign_3_exception_guarantee();`
575			`test_fill_assign_4();`
576			`test_range_assign_1();`
577			`test_range_assign_2();`
578			`test_range_assign_3();`
579			`test_range_assign_4();`
580			`test_range_assign_4_exception_guarantee();`
581
582			`return 0;`
583			`}`