diff options
author | Boris Kolpackov <boris@codesynthesis.com> | 2009-09-06 12:52:53 +0200 |
---|---|---|
committer | Boris Kolpackov <boris@codesynthesis.com> | 2009-09-06 12:52:53 +0200 |
commit | cb9ea47e7825b5073d4d645afb94f6326cb7cf4d (patch) | |
tree | 201c215b08df918924153a60520046c294438a6b /tests/shared-ptr/driver.cxx |
Start the libcutl repository
Diffstat (limited to 'tests/shared-ptr/driver.cxx')
-rw-r--r-- | tests/shared-ptr/driver.cxx | 186 |
1 files changed, 186 insertions, 0 deletions
diff --git a/tests/shared-ptr/driver.cxx b/tests/shared-ptr/driver.cxx new file mode 100644 index 0000000..c32192e --- /dev/null +++ b/tests/shared-ptr/driver.cxx @@ -0,0 +1,186 @@ +// file : tests/shared-ptr/driver.cxx +// author : Boris Kolpackov <boris@codesynthesis.com> +// copyright : Copyright (c) 2009 Code Synthesis Tools CC +// license : MIT; see accompanying LICENSE file + +#include <string> +#include <cassert> + +#include <cutl/shared-ptr.hxx> + +using namespace cutl; + +struct type +{ + type (int x, char const* y) : x_ (x), y_ (y) {} + + int x_; + std::string y_; +}; + +struct base1 +{ + virtual + ~base1 () {} + base1 (int x) : x_ (x) {} + + int x_; +}; + +struct base2 +{ + virtual + ~base2 () {} + base2 (char const* y) : y_ (y) {} + + std::string y_; +}; + +struct derived: base1, base2 +{ + derived (int x, char const* y) : base1 (x), base2 (y) {} +}; + +struct shared_type: shared_base +{ + shared_type (int x, char const* y) + : x_ (x), y_ (y) + { + assert (ref_count (this) == 1); + } + + int x_; + std::string y_; +}; + +int +main () +{ + // + // inc_ref, dec_ref, ref_count + // + + // Non-polymorphic type. + // + { + type* x (new (shared) type (5, "foo")); + assert (ref_count (x) == 1); + inc_ref (x); + assert (ref_count (x) == 2); + dec_ref (x); + assert (ref_count (x) == 1); + dec_ref (x); + } + + // Polymorphic type. + // + { + base2* x (new (shared) derived (5, "foo")); + assert (ref_count (x) == 1); + inc_ref (x); + assert (ref_count (x) == 2); + dec_ref (x); + assert (ref_count (x) == 1); + dec_ref (x); + } + + // Shared type. + // + { + shared_type* x (new (shared) shared_type (5, "foo")); + assert (ref_count (x) == 1); + inc_ref (x); + assert (ref_count (x) == 2); + dec_ref (x); + assert (ref_count (x) == 1); + dec_ref (x); + } + + // Error handling (this theoretically can segfault). + // + { + type* x (new type (5, "foo")); + + try + { + inc_ref (x); + assert (false); + } + catch (not_shared const&) + { + } + + delete x; + } + + // + // shared_ptr + // + + // Non-polymorphic type. + // + { + shared_ptr<type> x (new (shared) type (5, "foo")); + assert (x.count () == 1); + assert (x); + assert (x->x_ == 5); + assert ((*x).y_ == "foo"); + { + shared_ptr<type> y (x); + assert (y.count () == 2); + } + { + shared_ptr<type> y; + y = x; + assert (y.count () == 2); + } + assert (x.count () == 1); + shared_ptr<type> y (x.release ()); + assert (y.count () == 1); + } + + // Polymorphic type. + // + { + shared_ptr<derived> x (new (shared) derived (5, "foo")); + assert (x.count () == 1); + { + shared_ptr<base2> y (x); + assert (y.count () == 2); + assert (y->y_ == "foo"); + } + { + shared_ptr<base2> y; + y = x; + assert (y.count () == 2); + } + assert (x.count () == 1); + } + + // Non-polymorphic type. + // + { + shared_ptr<shared_type> x (new (shared) shared_type (5, "foo")); + assert (x.count () == 1); + assert (x); + assert (x->x_ == 5); + assert ((*x).y_ == "foo"); + assert (x->_ref_count () == 1); + x->_inc_ref (); + assert (x.count () == 2); + x->_dec_ref (); + assert (x.count () == 1); + { + shared_ptr<shared_type> y (x); + assert (y.count () == 2); + } + { + shared_ptr<shared_type> y; + y = x; + assert (y.count () == 2); + } + assert (x.count () == 1); + shared_ptr<shared_type> y (x.release ()); + assert (y.count () == 1); + } +} |