Author: sebor
Date: Wed Jul 25 16:54:16 2007
New Revision: 559650
URL: http://svn.apache.org/viewvc?view=rev&rev=559650
Log:
2007-07-25 Martin Sebor <[EMAIL PROTECTED]>
* 26.valarray.cassign.cpp: New test exercising [lib.valarray.cassign],
valarray computed assignment operators.
Added:
incubator/stdcxx/trunk/tests/numerics/26.valarray.cassign.cpp (with props)
Added: incubator/stdcxx/trunk/tests/numerics/26.valarray.cassign.cpp
URL:
http://svn.apache.org/viewvc/incubator/stdcxx/trunk/tests/numerics/26.valarray.cassign.cpp?view=auto&rev=559650
==============================================================================
--- incubator/stdcxx/trunk/tests/numerics/26.valarray.cassign.cpp (added)
+++ incubator/stdcxx/trunk/tests/numerics/26.valarray.cassign.cpp Wed Jul 25
16:54:16 2007
@@ -0,0 +1,842 @@
+/***************************************************************************
+ *
+ * 26.valarray.cassign.cpp - tests exercising valarray computed assignment
+ *
+ * $Id$
+ *
+ ***************************************************************************
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ *
+ * Copyright (C) 2007 Rogue Wave Software, Inc.
+ *
+ **************************************************************************/
+
+#include <cstdlib> // for free(), strtod(), size_t
+#include <valarray> // for indirect_array, valarray
+
+#include <rw_value.h> // for UserClass
+#include <driver.h> // for rw_test()
+#include <rw_printf.h> // for rw_asnprintf()
+
+/**************************************************************************/
+
+// returns an array of size elements of type T constructed from a string
+// of comma-separated values
+template <class T>
+T*
+make_array (const T*, const char *s, std::size_t *psize)
+{
+ std::size_t bufsize = 0; // capacity of buffer
+ std::size_t nelems = 0; // number of elements in buffer
+
+ if (psize)
+ *psize = 0;
+
+ if (0 == s)
+ s = "";
+
+ T* buf = 0;
+
+ while (*s) {
+
+ // get the next value from the string
+ char *end = 0;
+ const double val = std::strtod (s, &end);
+
+ unsigned long repeat = 1;
+
+ if ('@' == *end) {
+ // process repeat directive (e.g., "[EMAIL PROTECTED]" expands into
+ // 5 copies of the number 123)
+ char *e = 0;
+ repeat = std::strtoul (++end, &e, 10);
+
+ // skip trailing whitespace
+ for (; ' ' == *end; ++end);
+
+ // the next character must be either a NUL or comma
+ RW_ASSERT ('\0' == *e || ',' == *e);
+
+ if (',' == *e)
+ ++e;
+
+ s = e;
+ }
+ else {
+ // skip trailing whitespace
+ for (; ' ' == *end; ++end);
+
+ // the next character must be NUL or a comma
+ RW_ASSERT ('\0' == *end || ',' == *end);
+ s = end;
+
+ if (*s)
+ ++s;
+ }
+
+ while (repeat--) {
+
+ if (nelems == bufsize) {
+ // reallocate buffer
+
+ const std::size_t newsize = (bufsize + 1) * 2;
+ T* const tmp = new T [newsize];
+
+ // copy data to the newly allocated buffer
+ for (std::size_t i = 0; i != nelems; ++i)
+ tmp [i] = buf [i];
+
+ // increase the capacity
+ bufsize = newsize;
+
+ // deallocate old buffer
+ delete[] buf;
+ buf = tmp;
+ }
+
+ // append value to the end of the buffer
+ buf [nelems++] = T (val);
+ }
+ }
+
+ if (psize)
+ *psize = nelems;
+
+ return buf;
+}
+
+
+// deletes an array of elements of type T returned from make_array
+template <class T>
+void
+delete_array (const T *array, std::size_t)
+{
+ T* const a = _RWSTD_CONST_CAST (T*, array);
+ delete[] a;
+}
+
+
+template <class T>
+const std::size_t* count (const T*) { return 0; }
+
+
+template <class T>
+T value (const T &val) { return val; }
+
+/**************************************************************************/
+
+// deletes an array of elements of type T returned from make_array
+void
+delete_array (const UserClass *array, std::size_t nelems)
+{
+ UserClass* const a = _RWSTD_CONST_CAST (UserClass*, array);
+
+ for (std::size_t i = 0; i != nelems; ++i)
+ (a + i)->~UserClass ();
+
+ operator delete (a);
+}
+
+
+// returns an array of size elements of type UserClass
+// constructed from a string of comma-separated values
+UserClass*
+make_array (const UserClass*, const char *s, std::size_t *psize)
+{
+ std::size_t bufsize = 0; // capacity of buffer
+ std::size_t nelems = 0; // number of elements in buffer
+
+ if (psize)
+ *psize = 0;
+
+ if (0 == s)
+ s = "";
+
+ UserClass* buf = 0;
+
+ while (*s) {
+
+ // get the next value from the string
+ char *end = 0;
+ const double val = std::strtod (s, &end);
+
+ unsigned long repeat = 1;
+
+ if ('@' == *end) {
+ // process repeat directive (e.g., "[EMAIL PROTECTED]" expands into
+ // 5 copies of the number 123)
+ char *e = 0;
+ repeat = std::strtoul (++end, &e, 10);
+
+ // skip trailing whitespace
+ for (; ' ' == *end; ++end);
+
+ // the next character must be either a NUL or comma
+ RW_ASSERT ('\0' == *e || ',' == *e);
+
+ if (',' == *e)
+ ++e;
+
+ s = e;
+ }
+ else {
+ // skip trailing whitespace
+ for (; ' ' == *end; ++end);
+
+ // the next character must be NUL or a comma
+ RW_ASSERT ('\0' == *end || ',' == *end);
+
+ s = end;
+ if (*s)
+ ++s;
+ }
+
+ while (repeat--) {
+
+ if (nelems == bufsize) {
+ static const std::size_t size = sizeof (UserClass);
+
+ void* const raw = operator new ((bufsize + 1) * 2 * size);
+ UserClass* const tmp = _RWSTD_STATIC_CAST (UserClass*, raw);
+
+ for (std::size_t i = 0; i != nelems; ++i)
+ new (tmp +i) UserClass (buf [i]);
+
+ bufsize = (bufsize + 1) * 2;
+
+ delete_array (buf, nelems);
+ buf = tmp;
+ }
+
+ new (buf + nelems) UserClass ();
+ buf [nelems].data_.val_ = int (val);
+ ++nelems;
+ }
+ }
+
+ if (psize)
+ *psize = nelems;
+
+ return buf;
+}
+
+
+const std::size_t* count (const UserClass*) { return &UserClass::count_; }
+
+int value (const UserClass &val) { return val.data_.val_; }
+
+/**************************************************************************/
+
+template <class T>
+void
+test_op_assign (const T*,
+ std::valarray<T>&
+ (std::valarray<T>::*op_assign)(const std::valarray<T>&),
+ const char *tname, // T's type name
+ const char *opname, // which assignment operator
+ int line, // test case line number
+ const char *lhs_str, // left hand side of assignment
+ const char *rhs_str, // right hand side of assignment
+ const char *res_str) // result of assignment
+{
+ std::size_t nelems = 0;
+ std::size_t tmp;
+
+ // create an array of values of type T from the string lhs_str
+ // representing the left-hand side argument of the assignment
+ const T* const lhs_array = make_array ((const T*)0, lhs_str, &nelems);
+
+ // create an array of values of type T from the string rhs_str
+ // representing the right-hand side argument of the assignment
+ const T* const rhs_array = make_array ((const T*)0, rhs_str, &tmp);
+
+ // both arguments of the assignment must have the same size
+ RW_ASSERT (tmp == nelems);
+
+ // create an array of values of type T from the string res_str
+ // representing the result of the assignment
+ const T* const res_array = make_array ((const T*)0, res_str, &tmp);
+
+ // the result of the assignment must have the same size as both
+ // arguments
+ RW_ASSERT (tmp == nelems);
+
+ // construct valarray arguments from the arrays created above
+ /* const */ std::valarray<T> lhs_va (lhs_array, nelems);
+ const std::valarray<T> rhs_va (rhs_array, nelems);
+
+ char* fname = 0;
+ std::size_t size = 0;
+
+ // pointer to a counter keeping track of all objects of type T
+ // in existence (non-null only for T=UserClass)
+ const std::size_t* const pcounter = count ((const T*)0);
+
+ // get the number of objects of type T (only possible for user
+ // defined T) before invoking the operator
+ std::size_t nobjects = pcounter ? *pcounter : 0;
+
+ // format the name of the function call to be used in diagnostic
+ // messages below
+ rw_asnprintf (&fname, &size,
+ "valarray<%s>(%s) %s std::valarray<%1$s>(%s)",
+ tname, lhs_str, opname, rhs_str);
+
+ // invoke the assignment operator through the member pointer
+ std::valarray<T> &res = (lhs_va.*op_assign)(rhs_va);
+
+ // verify that the resturned reference refers to the assignee
+ rw_assert (&res == &lhs_va, 0, line,
+ "line %d == %#p, got %#p",
+ __LINE__, fname, &lhs_va, &res);
+
+
+ // verify the size of the array
+ rw_assert (lhs_va.size () == nelems, 0, line,
+ "line %d. %s.size() == %zu, got %zu",
+ __LINE__, fname, nelems, lhs_va.size ());
+
+ if (pcounter) {
+ // verify that the assignment didn't leak any objects
+ nobjects = *pcounter - nobjects;
+
+ rw_assert (0 == nobjects, 0, line,
+ "line %d. %s constucted %zu objects, expected %zu",
+ __LINE__, fname, nobjects, nelems);
+ }
+
+ // verify the element values
+ for (std::size_t i = 0; i != nelems; ++i) {
+ if (!rw_assert (lhs_va [i] == res_array [i], 0, line,
+ "line %d. %s: element at index %zu == %d, got %d",
+ __LINE__, fname, i, value (res_array [i]),
+ value (lhs_va [i])))
+ break;
+
+ }
+
+ delete_array (lhs_array, nelems);
+ delete_array (rhs_array, nelems);
+
+ std::free (fname);
+}
+
+
+/**************************************************************************/
+
+#define OP(lhs, rhs, res) \
+ test_op_assign ((T*)0, op, tname, opname, __LINE__, lhs, rhs, res)
+
+
+template <class T>
+void test_mul_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator*=;
+
+ OP ("", "", "");
+
+ OP ("0", "0", "0");
+ OP ("0", "1", "0");
+ OP ("1", "0", "0");
+ OP ("1", "1", "1");
+ OP ("1", "2", "2");
+
+ OP ("1,2", "1,1", "1,2");
+ OP ("1,2", "1,2", "1,4");
+ OP ("2,3", "4,5", "8,15");
+ OP ("3,4", "5,6", "15,24");
+
+ OP ("1,2,3", "4,5,6", "4,10,18");
+ OP ("-1,-2,-3", "-4,-5,-6", "4,10,18");
+ OP ("1,-2,3", "-4,5,-6", "-4,-10,-18");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_div_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator/=;
+
+ OP ("", "", "");
+
+ OP ("0", "1", "0");
+ OP ("1", "1", "1");
+ OP ("2", "1", "2");
+ OP ("2", "2", "1");
+ OP ("3", "1", "3");
+ OP ("3", "2", "1.5");
+ OP ("4", "2", "2");
+
+ OP ("0,1,2,3,4,5,6,7", "1,1,1,1,1,1,1,1", "0,1,2,3,4,5,6,7");
+ OP ("2,4,6,8,10,12,14,16", "2,2,2,2,2,2,2,2", "1,2,3,4,5,6,7,8");
+ OP ("2,4,6,8,10,12,14,16", "2,2,2,2,2,2,2,2", "1,2,3,4,5,6,7,8");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_mod_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator%=;
+
+ OP ("", "", "");
+
+ OP ("0", "1", "0");
+ OP ("1", "1", "0");
+ OP ("2", "1", "0");
+ OP ("2", "2", "0");
+ OP ("3", "1", "0");
+ OP ("3", "2", "1");
+ OP ("3", "3", "0");
+ OP ("4", "1", "0");
+ OP ("4", "2", "0");
+ OP ("4", "3", "1");
+ OP ("4", "4", "0");
+
+ OP ("0,1", "2,2", "0,1");
+ OP ("1,2,3", "4,4,4", "1,2,3");
+ OP ("2,3,4,5", "6,6,6,6", "2,3,4,5");
+
+ OP ("0,1,2,3,4,5,6,7,8,9", "10,9,8,7,6,5,4,3,2,1", "0,1,2,3,4,0,2,1,0,0");
+}
+
+#define CANNOT_TEST(T, name) \
+ void test_##name (const T*, const char*, const char*) { } \
+ typedef void swallow_semicolon
+
+
+CANNOT_TEST (float, mod_assign);
+CANNOT_TEST (double, mod_assign);
+CANNOT_TEST (UserClass, mod_assign);
+
+/**************************************************************************/
+
+template <class T>
+void test_add_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator+=;
+
+ OP ("", "", "");
+
+ OP ("0", "0", "0");
+ OP ("0", "1", "1");
+ OP ("1", "0", "1");
+ OP ("1", "-1", "0");
+ OP ("-1", "1", "0");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+
+ OP ("0,0", "0,0", "0,0");
+ OP ("0,0", "0,1", "0,1");
+ OP ("0,0", "1,0", "1,0");
+ OP ("0,0", "1,1", "1,1");
+ OP ("0,1", "0,1", "0,2");
+ OP ("0,1", "1,0", "1,1");
+ OP ("0,1", "1,1", "1,2");
+ OP ("1,0", "0,0", "1,0");
+ OP ("1,0", "0,1", "1,1");
+ OP ("1,0", "1,0", "2,0");
+ OP ("1,0", "1,1", "2,1");
+ OP ("1,1", "0,0", "1,1");
+ OP ("1,1", "0,1", "1,2");
+ OP ("1,1", "1,0", "2,1");
+ OP ("1,1", "1,1", "2,2");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_sub_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator-=;
+
+ OP ("", "", "");
+
+ OP (" 0", " 0", " 0");
+ OP (" 0", "+1", "-1");
+ OP ("+1", " 0", "+1");
+ OP ("+1", "-1", "+2");
+ OP ("-1", "+1", "-2");
+
+ OP (" [EMAIL PROTECTED]", " [EMAIL PROTECTED]", " [EMAIL PROTECTED]");
+ OP (" [EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", " [EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+}
+
+/**************************************************************************/
+
+template <class T>
+void test_xor_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator^=;
+
+ OP ("", "", "");
+
+ OP ("0", "0", "0");
+ OP ("0", "1", "1");
+ OP ("1", "0", "1");
+ OP ("1", "1", "0");
+ OP ("3", "0", "3");
+ OP ("3", "1", "2");
+ OP ("3", "2", "1");
+ OP ("3", "3", "0");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+}
+
+CANNOT_TEST (float, xor_assign);
+CANNOT_TEST (double, xor_assign);
+CANNOT_TEST (UserClass, xor_assign);
+
+/**************************************************************************/
+
+template <class T>
+void test_and_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator&=;
+
+ OP ("", "", "");
+
+ OP ("0", "0", "0");
+ OP ("0", "1", "0");
+ OP ("1", "0", "0");
+ OP ("1", "1", "1");
+ OP ("3", "0", "0");
+ OP ("3", "1", "1");
+ OP ("3", "2", "2");
+ OP ("3", "3", "3");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+}
+
+CANNOT_TEST (float, and_assign);
+CANNOT_TEST (double, and_assign);
+CANNOT_TEST (UserClass, and_assign);
+
+/**************************************************************************/
+
+template <class T>
+void test_or_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator|=;
+
+ OP ("", "", "");
+
+ OP ("0", "0", "0");
+ OP ("0", "1", "1");
+ OP ("1", "0", "1");
+ OP ("1", "1", "1");
+ OP ("3", "0", "3");
+ OP ("3", "1", "3");
+ OP ("3", "2", "3");
+ OP ("3", "3", "3");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+}
+
+CANNOT_TEST (float, or_assign);
+CANNOT_TEST (double, or_assign);
+CANNOT_TEST (UserClass, or_assign);
+
+/**************************************************************************/
+
+template <class T>
+void test_shl_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator<<=;
+
+ OP ("", "", "");
+
+ OP ("0", "0", "0");
+ OP ("0", "1", "0");
+ OP ("1", "0", "1");
+ OP ("1", "1", "2");
+ OP ("3", "0", "3");
+ OP ("3", "1", "6");
+ OP ("3", "2", "12");
+ OP ("3", "3", "24");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+}
+
+CANNOT_TEST (float, shl_assign);
+CANNOT_TEST (double, shl_assign);
+CANNOT_TEST (UserClass, shl_assign);
+
+/**************************************************************************/
+
+template <class T>
+void test_shr_assign (const T*, const char *tname, const char *opname)
+{
+ rw_info (0, 0, __LINE__,
+ "std::valarray<%s>::operator%s (const std::valarray<%1$s>&)",
+ tname, opname);
+
+ std::valarray<T>& (std::valarray<T>::*op)(const std::valarray<T>&) =
+ &std::valarray<T>::operator>>=;
+
+ OP ("", "", "");
+
+ OP ("0", "0", "0");
+ OP ("0", "1", "0");
+ OP ("1", "0", "1");
+ OP ("2", "1", "1");
+ OP ("3", "0", "3");
+ OP ("6", "1", "3");
+ OP ("12", "2", "3");
+ OP ("24", "3", "3");
+
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+ OP ("[EMAIL PROTECTED]", "[EMAIL PROTECTED]", "[EMAIL PROTECTED]");
+}
+
+CANNOT_TEST (float, shr_assign);
+CANNOT_TEST (double, shr_assign);
+CANNOT_TEST (UserClass, shr_assign);
+
+/**************************************************************************/
+
+enum {
+ inx_mul_assign,
+ inx_div_assign,
+ inx_mod_assign,
+ inx_add_assign,
+ inx_sub_assign,
+ inx_xor_assign,
+ inx_and_assign,
+ inx_or_assign,
+ inx_shl_assign,
+ inx_shr_assign,
+ n_assign_ops
+};
+
+static int opt_assign [n_assign_ops];
+
+
+template <class T>
+void test_op_assign (const T*, const char *tname)
+{
+ const std::size_t nassigns = sizeof opt_assign / sizeof *opt_assign;
+ for (std::size_t i = 0; i != nassigns; ++i) {
+ if (0 < opt_assign [i]) {
+ for (std::size_t j = 0; j != nassigns; ++j) {
+ if (0 == opt_assign [j])
+ opt_assign [j] = -1;
+ }
+ break;
+ }
+ }
+
+ if (rw_note (0 <= opt_assign [inx_mul_assign], 0, __LINE__,
+ "tests of operator*= disabled"))
+ test_mul_assign ((const T*)0, tname, "*=");
+
+ if (rw_note (0 <= opt_assign [inx_div_assign], 0, __LINE__,
+ "tests of operator/= disabled"))
+ test_div_assign ((const T*)0, tname, "/=");
+
+ if (rw_note (0 <= opt_assign [inx_mod_assign], 0, __LINE__,
+ "tests of operator%= disabled"))
+ test_mod_assign ((const T*)0, tname, "%=");
+
+ if (rw_note (0 <= opt_assign [inx_add_assign], 0, __LINE__,
+ "tests of operator+= disabled"))
+ test_add_assign ((const T*)0, tname, "+=");
+
+ if (rw_note (0 <= opt_assign [inx_sub_assign], 0, __LINE__,
+ "tests of operator-= disabled"))
+ test_sub_assign ((const T*)0, tname, "-=");
+
+ if (rw_note (0 <= opt_assign [inx_xor_assign], 0, __LINE__,
+ "tests of operator^= disabled"))
+ test_xor_assign ((const T*)0, tname, "^=");
+
+ if (rw_note (0 <= opt_assign [inx_and_assign], 0, __LINE__,
+ "tests of operator&= disabled"))
+ test_and_assign ((const T*)0, tname, "&=");
+
+ if (rw_note (0 <= opt_assign [inx_or_assign], 0, __LINE__,
+ "tests of operator|= disabled"))
+ test_or_assign ((const T*)0, tname, "|=");
+
+ if (rw_note (0 <= opt_assign [inx_shl_assign], 0, __LINE__,
+ "tests of operator<<= disabled"))
+ test_shr_assign ((const T*)0, tname, "<<=");
+
+ if (rw_note (0 <= opt_assign [inx_shr_assign], 0, __LINE__,
+ "tests of operator>>= disabled"))
+ test_shr_assign ((const T*)0, tname, ">>=");
+}
+
+/**************************************************************************/
+
+static int
+run_test (int, char**)
+{
+#undef TEST
+#define TEST(T) test_op_assign ((const T*)0, #T)
+ TEST (int);
+ TEST (double);
+
+ TEST (UserClass);
+
+ return 0;
+}
+
+/**************************************************************************/
+
+int main (int argc, char *argv[])
+{
+ // FIXME: add command line options to enable/disable each operator
+ return rw_test (argc, argv, __FILE__,
+ "valarray.cassign",
+ 0 /* no comment */,
+ run_test,
+ "|-times~ "
+ "|-divide~ "
+ "|-modulo~ "
+ "|-plus~ "
+ "|-minus~ "
+ "|-xor~ "
+ "|-and~ "
+ "|-or~ "
+ "|-shift_left~ "
+ "|-shift_right~",
+ opt_assign + inx_mul_assign,
+ opt_assign + inx_div_assign,
+ opt_assign + inx_mod_assign,
+ opt_assign + inx_add_assign,
+ opt_assign + inx_sub_assign,
+ opt_assign + inx_xor_assign,
+ opt_assign + inx_and_assign,
+ opt_assign + inx_or_assign,
+ opt_assign + inx_shl_assign,
+ opt_assign + inx_shr_assign,
+ (void*)0 /* sentinel */);
+}
Propchange: incubator/stdcxx/trunk/tests/numerics/26.valarray.cassign.cpp
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/stdcxx/trunk/tests/numerics/26.valarray.cassign.cpp
------------------------------------------------------------------------------
svn:keywords = Id
