stdcxx-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From se...@apache.org
Subject svn commit: r381511 - in /incubator/stdcxx/trunk/tests: include/alg_test.h src/alg_test.cpp
Date Tue, 28 Feb 2006 00:48:28 GMT
Author: sebor
Date: Mon Feb 27 16:48:26 2006
New Revision: 381511

URL: http://svn.apache.org/viewcvs?rev=381511&view=rev
Log:
2006-02-27  Martin Sebor  <sebor@roguewave.com>

	* alg_test.h: Added support for arithmetic self-assignment operators
	to allow class X to be used in tests for numeric algorithms.
	* alg_test.cpp: Definitions of the above.
	(_rw_fmtxarrayv): Recognized and handled the '+' flag to force only
	numeric formatting.

Modified:
    incubator/stdcxx/trunk/tests/include/alg_test.h
    incubator/stdcxx/trunk/tests/src/alg_test.cpp

Modified: incubator/stdcxx/trunk/tests/include/alg_test.h
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/include/alg_test.h?rev=381511&r1=381510&r2=381511&view=diff
==============================================================================
--- incubator/stdcxx/trunk/tests/include/alg_test.h (original)
+++ incubator/stdcxx/trunk/tests/include/alg_test.h Mon Feb 27 16:48:26 2006
@@ -47,6 +47,22 @@
     // regardless of whether the operation threw an exception or not
     _RWSTD_SIZE_T n_op_assign_;
 
+    // number of times the object's operator+=() has been invoked,
+    // regardless of whether the operation threw an exception or not
+    _RWSTD_SIZE_T n_op_plus_assign_;
+
+    // number of times the object's operator-=() has been invoked,
+    // regardless of whether the operation threw an exception or not
+    _RWSTD_SIZE_T n_op_minus_assign_;
+
+    // number of times the object's operator*=() has been invoked,
+    // regardless of whether the operation threw an exception or not
+    _RWSTD_SIZE_T n_op_times_assign_;
+
+    // number of times the object's operator/=() has been invoked,
+    // regardless of whether the operation threw an exception or not
+    _RWSTD_SIZE_T n_op_div_assign_;
+
     // number of times the object's operator== was invoked
     // regardless of whether the operation threw an exception
     _RWSTD_SIZE_T n_op_eq_;
@@ -63,6 +79,10 @@
     static _RWSTD_SIZE_T n_total_copy_ctor_;   // ... copy ctors ...
     static _RWSTD_SIZE_T n_total_dtor_;        // ... dtors ...
     static _RWSTD_SIZE_T n_total_op_assign_;   // ... assignment operators ...
+    static _RWSTD_SIZE_T n_total_op_plus_assign_;    // ... operator+=
+    static _RWSTD_SIZE_T n_total_op_minus_assign_;   // ... operator-=
+    static _RWSTD_SIZE_T n_total_op_times_assign_;   // ... operator*=
+    static _RWSTD_SIZE_T n_total_op_div_assign_;     // ... operator/=
     static _RWSTD_SIZE_T n_total_op_eq_;       // ... equality operators ...
     static _RWSTD_SIZE_T n_total_op_lt_;       // ... operators <= ...
 
@@ -72,6 +92,10 @@
     struct CopyCtor: Exception { };
     struct Dtor: Exception { };
     struct OpAssign: Exception { };
+    struct OpPlusAssign: Exception { };
+    struct OpMinusAssign: Exception { };
+    struct OpTimesAssign: Exception { };
+    struct OpDivAssign: Exception { };
     struct OpEq: Exception { };
     struct OpLt: Exception { };
 
@@ -82,6 +106,10 @@
     static _RWSTD_SIZE_T* copy_ctor_throw_ptr_;
     static _RWSTD_SIZE_T* dtor_throw_ptr_;
     static _RWSTD_SIZE_T* op_assign_throw_ptr_;
+    static _RWSTD_SIZE_T* op_plus_assign_throw_ptr_;
+    static _RWSTD_SIZE_T* op_minus_assign_throw_ptr_;
+    static _RWSTD_SIZE_T* op_times_assign_throw_ptr_;
+    static _RWSTD_SIZE_T* op_div_assign_throw_ptr_;
     static _RWSTD_SIZE_T* op_eq_throw_ptr_;
     static _RWSTD_SIZE_T* op_lt_throw_ptr_;
 
@@ -90,6 +118,10 @@
     static _RWSTD_SIZE_T copy_ctor_throw_count_;
     static _RWSTD_SIZE_T dtor_throw_count_;
     static _RWSTD_SIZE_T op_assign_throw_count_;
+    static _RWSTD_SIZE_T op_plus_assign_throw_count_;
+    static _RWSTD_SIZE_T op_minus_assign_throw_count_;
+    static _RWSTD_SIZE_T op_times_assign_throw_count_;
+    static _RWSTD_SIZE_T op_div_assign_throw_count_;
     static _RWSTD_SIZE_T op_eq_throw_count_;
     static _RWSTD_SIZE_T op_lt_throw_count_;
 
@@ -100,6 +132,10 @@
     ~X ();
 
     X& operator= (const X&);
+    X& operator+= (const X&);
+    X& operator-= (const X&);
+    X& operator*= (const X&);
+    X& operator/= (const X&);
 
     bool operator== (const X&) const;
     bool operator< (const X&) const;
@@ -152,6 +188,15 @@
     // returns -1 when less, 0 when same, or +1 when the first
     // array of X objects is greater than the second array
     static int compare (const X*, const X*, _RWSTD_SIZE_T);
+
+private:
+
+    enum assign_op {
+        op_assign, op_plus_assign, op_minus_assign,
+        op_times_assign, op_div_assign
+    };
+
+    void assign (assign_op, const X&);
 };
 
 /**************************************************************************/

Modified: incubator/stdcxx/trunk/tests/src/alg_test.cpp
URL: http://svn.apache.org/viewcvs/incubator/stdcxx/trunk/tests/src/alg_test.cpp?rev=381511&r1=381510&r2=381511&view=diff
==============================================================================
--- incubator/stdcxx/trunk/tests/src/alg_test.cpp (original)
+++ incubator/stdcxx/trunk/tests/src/alg_test.cpp Mon Feb 27 16:48:26 2006
@@ -40,24 +40,46 @@
 /* static */ size_t X::n_total_copy_ctor_;
 /* static */ size_t X::n_total_dtor_;
 /* static */ size_t X::n_total_op_assign_;
+/* static */ size_t X::n_total_op_plus_assign_;
+/* static */ size_t X::n_total_op_minus_assign_;
+/* static */ size_t X::n_total_op_times_assign_;
+/* static */ size_t X::n_total_op_div_assign_;
 /* static */ size_t X::n_total_op_eq_;
 /* static */ size_t X::n_total_op_lt_;
 
 // default values of pointers
-/* static */ size_t* X::def_ctor_throw_ptr_  = &X::def_ctor_throw_count_;
-/* static */ size_t* X::copy_ctor_throw_ptr_ = &X::copy_ctor_throw_count_;
-/* static */ size_t* X::dtor_throw_ptr_      = &X::dtor_throw_count_;
-/* static */ size_t* X::op_assign_throw_ptr_ = &X::op_assign_throw_count_;
-/* static */ size_t* X::op_eq_throw_ptr_     = &X::op_eq_throw_count_;
-/* static */ size_t* X::op_lt_throw_ptr_     = &X::op_lt_throw_count_;
+/* static */ size_t* X::def_ctor_throw_ptr_ =
+    &X::def_ctor_throw_count_;
+/* static */ size_t* X::copy_ctor_throw_ptr_ =
+    &X::copy_ctor_throw_count_;
+/* static */ size_t* X::dtor_throw_ptr_ =
+    &X::dtor_throw_count_;
+/* static */ size_t* X::op_assign_throw_ptr_ =
+    &X::op_assign_throw_count_;
+/* static */ size_t* X::op_plus_assign_throw_ptr_ =
+    &X::op_plus_assign_throw_count_;
+/* static */ size_t* X::op_minus_assign_throw_ptr_ =
+    &X::op_minus_assign_throw_count_;
+/* static */ size_t* X::op_times_assign_throw_ptr_ =
+    &X::op_times_assign_throw_count_;
+/* static */ size_t* X::op_div_assign_throw_ptr_ =
+    &X::op_div_assign_throw_count_;
+/* static */ size_t* X::op_eq_throw_ptr_ =
+    &X::op_eq_throw_count_;
+/* static */ size_t* X::op_lt_throw_ptr_ =
+    &X::op_lt_throw_count_;
 
 // exception throwing initially disabled
-/* static */ size_t X::def_ctor_throw_count_  = size_t (-1);
-/* static */ size_t X::copy_ctor_throw_count_ = size_t (-1);
-/* static */ size_t X::dtor_throw_count_      = size_t (-1);
-/* static */ size_t X::op_assign_throw_count_ = size_t (-1);
-/* static */ size_t X::op_eq_throw_count_     = size_t (-1);
-/* static */ size_t X::op_lt_throw_count_     = size_t (-1);
+/* static */ size_t X::def_ctor_throw_count_        = size_t (-1);
+/* static */ size_t X::copy_ctor_throw_count_       = size_t (-1);
+/* static */ size_t X::dtor_throw_count_            = size_t (-1);
+/* static */ size_t X::op_assign_throw_count_       = size_t (-1);
+/* static */ size_t X::op_plus_assign_throw_count_  = size_t (-1);
+/* static */ size_t X::op_minus_assign_throw_count_ = size_t (-1);
+/* static */ size_t X::op_times_assign_throw_count_ = size_t (-1);
+/* static */ size_t X::op_div_assign_throw_count_   = size_t (-1);
+/* static */ size_t X::op_eq_throw_count_           = size_t (-1);
+/* static */ size_t X::op_lt_throw_count_           = size_t (-1);
 
 
 static int
@@ -159,31 +181,87 @@
 }
 
 
-X&
-X::operator= (const X &rhs)
+void X::
+assign (assign_op which, const X &rhs)
 {
-    // verify id validity and uniqueness
+    // verify id validity and uniqueness:
+    // a valid id is non-zero (dtor resets)
     RW_ASSERT (id_ && id_ <= id_gen_);
     RW_ASSERT (rhs.id_ && rhs.id_ <= id_gen_);
+
+    // no two id's have the same value
     RW_ASSERT (this == &rhs || id_ != rhs.id_);
 
-    // increment the total number of invocations of the operator
-    // (do so even if the function throws an exception below)
-    ++n_total_op_assign_;
+    size_t *p_total_op = 0;
+    size_t *p_op       = 0;
+    size_t *p_throw    = 0;
+
+    Exception *pex = 0; 
+
+    OpAssign      ex_assign;
+    OpPlusAssign  ex_plus_assign;
+    OpMinusAssign ex_minus_assign;
+    OpTimesAssign ex_times_assign;
+    OpDivAssign   ex_div_assign;
+
+    int new_val;
+
+    switch (which) {
+    case op_assign:
+        p_total_op = &n_total_op_assign_;
+        p_op       = &n_op_assign_;
+        p_throw    = op_assign_throw_ptr_;
+        pex        = &ex_assign;
+        new_val    = rhs.val_;
+        break;
+
+    case op_plus_assign:
+        p_total_op = &n_total_op_plus_assign_;
+        p_op       = &n_op_plus_assign_;
+        p_throw    = op_plus_assign_throw_ptr_;
+        pex        = &ex_plus_assign;
+        new_val    = val_ + rhs.val_;
+        break;
+
+    case op_minus_assign:
+        p_total_op = &n_total_op_minus_assign_;
+        p_op       = &n_op_minus_assign_;
+        p_throw    = op_minus_assign_throw_ptr_;
+        pex        = &ex_minus_assign;
+        new_val    = val_ - rhs.val_;
+        break;
+
+    case op_times_assign:
+        p_total_op = &n_total_op_times_assign_;
+        p_op       = &n_op_times_assign_;
+        p_throw    = op_times_assign_throw_ptr_;
+        pex        = &ex_times_assign;
+        new_val    = val_ * rhs.val_;
+        break;
+
+    case op_div_assign:
+        p_total_op = &n_total_op_div_assign_;
+        p_op       = &n_op_div_assign_;
+        p_throw    = op_div_assign_throw_ptr_;
+        pex        = &ex_div_assign;
+        new_val    = val_ / rhs.val_;
+        break;
+    }
 
-    // increment the number of times the object has been assigned to
+    // increment the number of invocations of the operator
     // (do so even if the function throws an exception below)
-    ++n_op_assign_;
+
+    ++*p_total_op;
+    ++*p_op;
 
 #ifndef _RWSTD_NO_EXCEPTIONS
 
     // throw an exception if the number of calls to
     // the assignment operator reaches the given value
 
-    if (op_assign_throw_ptr_ && n_total_op_assign_ == *op_assign_throw_ptr_) {
-        OpAssign ex;
-        ex.id_ = id_;
-        throw ex;
+    if (p_throw && *p_throw == *p_total_op) {
+        pex->id_ = id_;
+        throw *pex;
     }
 
 #endif   // _RWSTD_NO_EXCEPTIONS
@@ -193,7 +271,50 @@
 
     origin_ = rhs.origin_;
     src_id_ = rhs.id_;
-    val_    = rhs.val_;
+    val_    = new_val;
+}
+
+
+X& X::
+operator= (const X &rhs)
+{
+    assign (op_assign, rhs);
+
+    return *this;
+}
+
+
+X& X::
+operator+= (const X &rhs)
+{
+    assign (op_plus_assign, rhs);
+
+    return *this;
+}
+
+
+X& X::
+operator-= (const X &rhs)
+{
+    assign (op_minus_assign, rhs);
+
+    return *this;
+}
+
+
+X& X::
+operator*= (const X &rhs)
+{
+    assign (op_times_assign, rhs);
+
+    return *this;
+}
+
+
+X& X::
+operator/= (const X &rhs)
+{
+    assign (op_div_assign, rhs);
 
     return *this;
 }
@@ -605,13 +726,14 @@
     RW_ASSERT (0 != fmt);
 
     va_list* pva      =  0;
+    bool     fl_plus  =  false;
     bool     fl_pound =  false;
     int      nelems   = -1;
     int      paramno  = -1;
     int      cursor   = -1;
 
     // directive syntax:
-    // "X=" [ '#' ] [ '*' | <n> ] [ '.' [ '*' | <n> ] ]
+    // "X=" [ '#' ] [ '+' ] [ '*' | <n> ] [ '.' [ '*' | <n> ] ]
 
 
     if ('X' != fmt [0] || '=' != fmt [1])
@@ -619,7 +741,14 @@
 
     fmt += 2;
 
+    if ('+' == *fmt) {
+        // use numerical formatting for X::val_
+        fl_plus = true;
+        ++fmt;
+    }
+
     if ('#' == *fmt) {
+        // include X::id_ in output
         fl_pound = true;
         ++fmt;
     }
@@ -703,11 +832,16 @@
     for (const X *px = xbeg; px != xbeg + nelems; ++px) {
         const int n =
             rw_asnprintf (pbuf, pbufsize,
-                          "%{+}%{?}>%{;}%{?}%d:%{;}%{lc}%{?}<%{;}",
-                          px - xbeg == cursor,     // '>'
-                          fl_pound, px->id_,       // "<id>:"
-                          px->val_,                // <val>
-                          px - xbeg == cursor);    // '<'
+                          "%{+}%{?}>%{;}"
+                          "%{?}%d:%{;}"
+                          "%{?}%d%{?},%{;}%{:}%{lc}%{;}"
+                          "%{?}<%{;}",
+                          px - xbeg == cursor,            // '>'
+                          fl_pound, px->id_,              // "<id>:"
+                          fl_plus, px->val_,              // <val>
+                          px + 1 < xbeg + nelems,         // ','
+                          px->val_,                       // <val>
+                          px - xbeg == cursor);           // '<'
         if (n < 0)
             return n;
 



Mime
View raw message