Author: vitek Date: Wed Jun 4 13:53:00 2008 New Revision: 663373 URL: http://svn.apache.org/viewvc?rev=663373&view=rev Log: 2008-06-04 Travis Vitek STDCXX-901 * include/valarray (gslice_array<>::operator=): Don't skip loop body if the slice is reset but has one element. (gslice_array<>::operator*=): Ditto. (gslice_array<>::operator/=): Ditto. (gslice_array<>::operator+=): Ditto. (gslice_array<>::operator-=): Ditto. (gslice_array<>::operator%=): Ditto. (gslice_array<>::operator^=): Ditto. (gslice_array<>::operator&=): Ditto. (gslice_array<>::operator|=): Ditto. (gslice_array<>::operator<<=): Ditto. (gslice_array<>::operator>>=): Ditto. (valarray<>::ctor): Ditto. (valarray<>::operator=): Ditto. * tests/numerics/26.gslice.array.cassign.cpp: New test for slice computed assignment operators. Added: stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp (with props) Modified: stdcxx/branches/4.2.x/include/valarray Modified: stdcxx/branches/4.2.x/include/valarray URL: http://svn.apache.org/viewvc/stdcxx/branches/4.2.x/include/valarray?rev=663373&r1=663372&r2=663373&view=diff ============================================================================== --- stdcxx/branches/4.2.x/include/valarray (original) +++ stdcxx/branches/4.2.x/include/valarray Wed Jun 4 13:53:00 2008 @@ -1856,7 +1856,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] = __rhs[__cpt]; __i= gsl->next_ind(); @@ -1869,11 +1869,13 @@ { gslice *gsl = _RWSTD_CONST_CAST (gslice*, &_C_slice); _RWSTD_SIZE_T __i = gsl->next_ind(); + _RWSTD_SIZE_T __cpt = 0; - while( !gsl->is_reseted() ) + while( !gsl->is_reseted() || !__cpt && gsl->ind_numb() ) { (*_C_array)[__i] = value; __i= gsl->next_ind(); + __cpt++; } } @@ -1887,7 +1889,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] *= __rhs[__cpt]; __i= gsl->next_ind(); @@ -1902,7 +1904,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] /= __rhs[__cpt]; __i= gsl->next_ind(); @@ -1917,7 +1919,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] += __rhs[__cpt]; __i= gsl->next_ind(); @@ -1932,7 +1934,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] -= __rhs[__cpt]; __i= gsl->next_ind(); @@ -1948,7 +1950,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] %= __rhs[__cpt]; __i= gsl->next_ind(); @@ -1963,7 +1965,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] ^= __rhs[__cpt]; __i= gsl->next_ind(); @@ -1978,7 +1980,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] &= __rhs[__cpt]; __i= gsl->next_ind(); @@ -1993,7 +1995,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] |= __rhs[__cpt]; __i= gsl->next_ind(); @@ -2008,7 +2010,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] <<= __rhs[__cpt]; __i= gsl->next_ind(); @@ -2023,7 +2025,7 @@ _RWSTD_SIZE_T __i = gsl->next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( (!gsl->is_reseted()) && (__cpt < __rhs.size()) ) + while( (!gsl->is_reseted() || !__cpt && gsl->ind_numb()) && __cpt < __rhs.size() ) { (*_C_array)[__i] >>= __rhs[__cpt]; __i= gsl->next_ind(); @@ -2146,13 +2148,15 @@ { gslice __sl(sl_ar._C_get_slice()); + const _RWSTD_SIZE_T __maxinx = __sl.ind_numb (); + _RW::__rw_array <_TypeT> __tmp = - _RW::__rw_array <_TypeT>(_TypeT (), __sl.ind_numb()); + _RW::__rw_array <_TypeT>(_TypeT (), __maxinx); _RWSTD_SIZE_T __i = __sl.next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( !__sl.is_reseted() ) + while( !__sl.is_reseted() || !__cpt && __maxinx ) { __tmp[__cpt] = (*(sl_ar.get_ref_mem_array()))[__i]; __i= __sl.next_ind(); @@ -2169,13 +2173,15 @@ { gslice __sl(sl_ar._C_get_slice()); + const _RWSTD_SIZE_T __maxinx = __sl.ind_numb (); + _RW::__rw_array <_TypeT> __tmp = - _RW::__rw_array <_TypeT>(_TypeT (), __sl.ind_numb()); + _RW::__rw_array <_TypeT>(_TypeT (), __maxinx); _RWSTD_SIZE_T __i = __sl.next_ind(); _RWSTD_SIZE_T __cpt = 0; - while( !__sl.is_reseted() ) + while( !__sl.is_reseted() || !__cpt && __maxinx ) { __tmp[__cpt] = (*(sl_ar.get_ref_mem_array()))[__i]; __i= __sl.next_ind(); Added: stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp URL: http://svn.apache.org/viewvc/stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp?rev=663373&view=auto ============================================================================== --- stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp (added) +++ stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp Wed Jun 4 13:53:00 2008 @@ -0,0 +1,558 @@ +/*************************************************************************** + * + * 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-2008 Rogue Wave Software, Inc. + * + **************************************************************************/ + +#include // for free(), strtod(), size_t +#include // for indirect_array, valarray + +//#include // for UserClass +#include // for rw_test() +#include // for rw_asnprintf() + +/**************************************************************************/ + +// returns an array of size elements of type T constructed from a string +// of comma-separated values +static std::valarray +make_array (const char *s) +{ + std::size_t buf [256]; + bool repeat = false; + + std::size_t i = 0; + while (s && *s) { + + char *end; + unsigned long val = std::strtoul (s, &end, 10); + + RW_ASSERT ('\0' == *end || ',' == *end || '@' == *end); + + if (!repeat) + { + buf [i++] = std::size_t (val); + } + else + { + const std::size_t n = buf [i-1]; + + for (std::size_t j = 0; j < (val - 1); ++j) + buf [i+j] = n; + i += (val - 1); + } + + if ('\0' == *end) + break; + + s = end + 1; + repeat = '@' == *end; + } + + return std::valarray(buf, i); +} + +/**************************************************************************/ + +void +test_op_assign (void*, + void (std::gslice_array::*op_assign)(const std::valarray&) const, + const char *tname, // T's type name + const char *opname, // which assignment operator + int line, // test case line number + std::size_t start, // start index of slice + const char *length_str,// number of strides + const char *stride_str,// length of stride + const char *lhs_str, // original array + const char *rhs_str, // right hand side of assignment + const char *res_str) // result of assignment +{ + // create an array of values from the string length_str + // representing the length array of the slice + const std::valarray lengths (make_array (length_str)); + + // create an array of values from the string stride_str + // representing the stride array of the slice + const std::valarray strides (make_array (stride_str)); + + // valarray(s)[gslice(start, length, stride)] op= rhs + + const std::gslice gsl (start, lengths, strides); + + // create an array of values from the string lhs_str + // representing the left-hand side array before slicing + /* const */ std::valarray lhs_va (make_array (lhs_str)); + + // create an array of values from the string rhs_str + // representing the right-hand side argument of the assignment + const std::valarray rhs_va (make_array (rhs_str)); + + // create an array of values from the string res_str + // representing the result of the assignment + const std::valarray res_va (make_array (res_str)); + + // verify sizes match + RW_ASSERT (lhs_va.size () == res_va.size ()); + + // take a gslice of lhs_va, this is the lhs of the assignment + std::gslice_array& lhs_ga = lhs_va [gsl]; + + char* fname = 0; + std::size_t size = 0; + + // format the name of the function call to be used in diagnostic + // messages below + rw_asnprintf (&fname, &size, + "gslice_array<%s>(%s) %s std::valarray<%1$s>(%s)", + tname, lhs_str, opname, rhs_str); + + // invoke the assignment operator through the member pointer + (lhs_ga.*op_assign)(rhs_va); + + // verify the element values + for (std::size_t i = 0; i != lhs_va.size (); ++i) { + if (!rw_assert (lhs_va [i] == res_va [i], 0, line, + "line %d. %s: element at index %zu == %zu, got %zu", + __LINE__, fname, i, res_va [i], lhs_va [i])) + break; + + } + + std::free (fname); +} + + +/**************************************************************************/ + +#define OP(start, lengths, strides, lhs, rhs, res) \ + test_op_assign ((T*)0, op, tname, opname, __LINE__, start, lengths, strides, lhs, rhs, res) + + +template +void test_mul_assign (const T*, const char *tname, const char *opname) +{ + rw_info (0, 0, __LINE__, + "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)", + tname, opname); + + void (std::gslice_array::*op)(const std::valarray&) const = + &std::gslice_array::operator*=; + + // +- start + // | +- lengths + // | | +- strides +- rhs + // | | | +- lhs | +- expect + // v v v v v v + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "1@4", "5", "5,1@3"); + OP (2, "1", "1", "1@4", "5", "1,1,5,1"); + + OP (1, "2", "1", "1@4", "3,4", "1,3,4,1"); + OP (1, "1", "2", "2@4", "2", "2,4,2,2"); + + OP (0, "2,1", "2,3", "2@4", "3,7", "6,2,14,2"); + OP (1, "1,0", "2,3", "3@4", "3", "3,9,3,3"); +} + +/**************************************************************************/ + +template +void test_div_assign (const T*, const char *tname, const char *opname) +{ + rw_info (0, 0, __LINE__, + "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)", + tname, opname); + + void (std::gslice_array::*op)(const std::valarray&) const = + &std::gslice_array::operator/=; + + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "10@4", "5", "2,10@3"); + OP (2, "1", "1", "12@4", "5", "12,12,2,12"); + + OP (1, "2", "1", "12@4", "3,4", "12,4,3,12"); + OP (1, "1", "2", "6@4", "2", "6,3,6,6"); + + OP (0, "2,1", "2,3", "42@4", "3,7", "14,42,6,42"); + OP (1, "1,0", "2,3", "3@4", "3", "3,1,3,3"); +} + +/**************************************************************************/ + +template +void test_mod_assign (const T*, const char *tname, const char *opname) +{ + rw_info (0, 0, __LINE__, + "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)", + tname, opname); + + void (std::gslice_array::*op)(const std::valarray&) const = + &std::gslice_array::operator%=; + + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "10@4", "5", "0,10@3"); + OP (2, "1", "1", "12@4", "5", "12,12,2,12"); + + OP (1, "2", "1", "12@4", "3,4", "12,0,0,12"); + OP (1, "1", "2", "7@4", "2", "7,1,7,7"); + + OP (0, "2,1", "2,3", "14@4", "3,7", "2,14,0,14"); + OP (1, "1,0", "2,3", "3@4", "3", "3,0,3,3"); +} + +/**************************************************************************/ + +template +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); + + void (std::gslice_array::*op)(const std::valarray&) const = + &std::gslice_array::operator+=; + + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "1@4", "5", "6,1@3"); + OP (2, "1", "1", "2@4", "5", "2,2,7,2"); + + OP (1, "2", "1", "3@4", "3,4", "3,6,7,3"); + OP (1, "1", "2", "7@4", "2", "7,9,7,7"); + + OP (0, "2,1", "2,3", "1@4", "3,7", "4,1,8,1"); + OP (1, "1,0", "2,3", "3@4", "3", "3,6,3,3"); +} + +/**************************************************************************/ + +template +void test_sub_assign (const T*, const char *tname, const char *opname) +{ + rw_info (0, 0, __LINE__, + "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)", + tname, opname); + + void (std::gslice_array::*op)(const std::valarray&) const = + &std::gslice_array::operator-=; + + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "9@4", "5", "4,9@3"); + OP (2, "1", "1", "7@4", "5", "7,7,2,7"); + + OP (1, "2", "1", "3@4", "3,2", "3,0,1,3"); + OP (1, "1", "2", "7@4", "2", "7,5,7,7"); + + OP (0, "2,1", "2,3", "7@4", "3,7", "4,7,0,7"); + OP (1, "1,0", "2,3", "3@4", "3", "3,0,3,3"); +} + +/**************************************************************************/ + +template +void test_xor_assign (const T*, const char *tname, const char *opname) +{ + rw_info (0, 0, __LINE__, + "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)", + tname, opname); + + void (std::gslice_array::*op)(const std::valarray&) const = + &std::gslice_array::operator^=; + + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "9@4", "5", "12,9@3"); + OP (2, "1", "1", "7@4", "5", "7,7,2,7"); + + OP (1, "2", "1", "3@4", "3,4", "3,0,7,3"); + OP (1, "1", "2", "7@4", "2", "7,5,7,7"); + + OP (0, "2,1", "2,3", "7@4", "3,7", "4,7,0,7"); + OP (1, "1,0", "2,3", "3@4", "3", "3,0,3,3"); +} + +/**************************************************************************/ + +template +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); + + void (std::gslice_array::*op)(const std::valarray&) const = + &std::gslice_array::operator&=; + + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "9@4", "5", "1,9@3"); + OP (2, "1", "1", "7@4", "5", "7,7,5,7"); + + OP (1, "2", "1", "3@4", "3,4", "3,3,0,3"); + OP (1, "1", "2", "7@4", "2", "7,2,7,7"); + + OP (0, "2,1", "2,3", "7@4", "3,2", "3,7,2,7"); + OP (1, "1,0", "2,3", "3@4", "1", "3,1,3,3"); +} + +/**************************************************************************/ + +template +void test_or_assign (const T*, const char *tname, const char *opname) +{ + rw_info (0, 0, __LINE__, + "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)", + tname, opname); + + void (std::gslice_array::*op)(const std::valarray&) const = + &std::gslice_array::operator|=; + + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "9@4", "5", "13,9@3"); + OP (2, "1", "1", "7@4", "5", "7,7,7,7"); + + OP (1, "2", "1", "3@4", "3,4", "3,3,7,3"); + OP (1, "1", "2", "7@4", "2", "7,7,7,7"); + + OP (0, "2,1", "2,3", "4@4", "3,7", "7,4,7,4"); + OP (1, "1,0", "2,3", "3@4", "4", "3,7,3,3"); +} + +/**************************************************************************/ + +template +void test_shl_assign (const T*, const char *tname, const char *opname) +{ + rw_info (0, 0, __LINE__, + "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)", + tname, opname); + + void (std::gslice_array::*op)(const std::valarray&) = + &std::gslice_array::operator<<=; + + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "1@4", "1", "2,1@3"); + OP (2, "1", "1", "2@4", "1", "2,2,4,2"); + + OP (1, "2", "1", "1@4", "3,4", "1,4,8,1"); + OP (1, "1", "2", "3@4", "2", "3,12,3,3"); + + OP (0, "2,1", "2,3", "1@4", "3,2", "8,1,4,1"); + OP (1, "1,0", "2,3", "5@4", "3", "5,20,5,5"); +} + +/**************************************************************************/ + +template +void test_shr_assign (const T*, const char *tname, const char *opname) +{ + rw_info (0, 0, __LINE__, + "std::gslice_array<%s>::operator%s (const std::valarray<%1$s>&)", + tname, opname); + + void (std::gslice_array::*op)(const std::valarray&) const = + &std::gslice_array::operator>>=; + + OP (0, "", "", "1@4", "2", "1@4"); + OP (0, "0", "1", "1@4", "2", "1@4"); + OP (2, "0", "9", "1@4", "2", "1@4"); + OP (3, "0", "2", "1@4", "7", "1@4"); + + OP (0, "1", "1", "1@4", "1", "0,1@3"); + OP (2, "1", "1", "2@4", "1", "2,2,1,2"); + + OP (1, "2", "1", "9@4", "3,4", "9,1,0,9"); + OP (1, "1", "2", "9@4", "2", "9,2,9,9"); + + OP (0, "2,1", "2,3", "14@4", "3,2", "1,14,3,14"); + OP (1, "1,0", "2,3", "5@4", "3", "5,0,5,5"); +} + +/**************************************************************************/ + +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 +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 (std::size_t); +// TEST (double); +// +//#if 0x04020100 >= _RWSTD_VER +// +// // test fails to compile with stdcxx 4.2.1 and prior due to +// // STDCXX-512: http://issues.apache.org/jira/browse/STDCXX-512 +// rw_warn (0, 0, __LINE__, +// "test of UserClass disabled in stdcxx 4.2.0 and prior " +// "due to STDCXX-512"); +// +//#else // stdcxx >= 4.2.1 +// +// //TEST (UserClass); +// +//#endif // stdcxx version + + return 0; +} + +/**************************************************************************/ + +int main (int argc, char *argv[]) +{ + // FIXME: add command line options to enable/disable each operator + return rw_test (argc, argv, __FILE__, + "gslice.array.comp.assign", + 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 */); +} \ No newline at end of file Propchange: stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp ------------------------------------------------------------------------------ svn:eol-style = native Propchange: stdcxx/branches/4.2.x/tests/numerics/26.gslice.array.cassign.cpp ------------------------------------------------------------------------------ svn:keywords = Id