


Testing MaskedArray Exceptions.

Test conformance, MaskedArray (Array, LogicalArray)
Caught an ArrayConformanceError:
MaskedArray<T>::MaskedArray(const Array<T> &, const LogicalArray &) - arrays do not conform

Test conformance, MaskedArray (MaskedArray, LogicalArray)
Caught an ArrayConformanceError:
MaskedArray<T>::MaskedArray (const MaskedArray<T> &, const LogicalArray &) - arrays do not conform

Test conformance, MaskedArray::operator= (Array)
Caught an ArrayConformanceError:
MaskedArray<T> & MaskedArray<T>::operator= (const Array<T> &inarray)- Conformance error.

Test conformance, MaskedArray::operator= (MaskedArray)
Caught an ArrayConformanceError:
MaskedArray<T> & MaskedArray<T>::operator= (const MaskedArray<T> &other)- Conformance error.

Test conformance, Array::operator= (MaskedArray)
Caught an ArrayConformanceError:
Array<T> & Array<T>::operator= (const MaskedArray<T> &marray)- Conformance error.

Test readonly MaskedArray, operator=(value)
Caught an ArrayError:
MaskedArray<T> & MaskedArray<T>::operator= (const T &val)- this is read only.

Test readonly MaskedArray, operator=(Array)
Caught an ArrayError:
MaskedArray<T> & MaskedArray<T>::operator= (const Array<T> &inarray)- this is read only.

Test readonly MaskedArray, operator=(MaskedArray)
Caught an ArrayError:
MaskedArray<T> & MaskedArray<T>::operator= (const MaskedArray<T> &other)- this is read only.

Test readonly MaskedArray, getRWArray()
Caught an ArrayError:
Array<T> & MaskedArray<T>::getRWArray () const- this is read only.

Test readonly MaskedArray, getRWArrayStorage()
Caught an ArrayError:
MaskedArray<T>::getRWArrayStorage (Bool &deleteIt) const- this is read only.

Test readonly MaskedArray, putArrayStorage()
Caught an ArrayError:
MaskedArray<T>::putArrayStorage (Bool deleteAndCopy) const- this is read only.

Test getCompressedArray (shape)
Caught an ArrayError:
void MaskedArray<T>::getCompressedArray (const IPosition & shape) - input shape will create Array with incorrect number of elements

Test getCompressedArray (Array)
Caught an ArrayError:
void MaskedArray<T>::getCompressedArray (Array<T> & inarr) - input Array number of elements is incorrect

Test setCompressedArray (Array)
Caught an ArrayError:
void MaskedArray<T>::setCompressedArray (const Array<T> & inarr) - input array number of elements is incorrect



Testing MaskArrMath Exceptions.

Test conformance, ::operator+= (MaskedArray, Array)
Caught an ArrayConformanceError:
::operator+=(const MaskedArray<T> &, const Array<T> &) - arrays do not conform

Test readonly, ::operator+= (MaskedArray, Array)
Caught an ArrayError:
MaskedArray<T>::getRWArrayStorage (Bool &deleteIt) const- this is read only.

Test conformance, ::operator+= (Array, MaskedArray)
Caught an ArrayConformanceError:
::operator+=(Array<T> &, const MaskedArray<T> &) - arrays do not conform

Test conformance, ::operator+= (MaskedArray, MaskedArray)
Caught an ArrayConformanceError:
::operator+=(const MaskedArray<T> &, const MaskedArray<T> &) - arrays do not conform

Test readonly, ::operator+= (MaskedArray, MaskedArray)
Caught an ArrayError:
MaskedArray<T>::getRWArrayStorage (Bool &deleteIt) const- this is read only.

Test conformance, ::operator+ (MaskedArray, Array)
Caught an ArrayConformanceError:
::operator+(const MaskedArray<T> &, const Array<T> &) - arrays do not conform

Test conformance, ::operator+ (Array, MaskedArray)
Caught an ArrayConformanceError:
::operator+(const Array<T> &, const MaskedArray<T> &) - arrays do not conform

Test conformance, ::operator+ (MaskedArray, MaskedArray)
Caught an ArrayConformanceError:
::operator+(const MaskedArray<T> &, const MaskedArray<T> &) - arrays do not conform

Test conformance, ::pow (MaskedArray, Array)
Caught an ArrayConformanceError:
::pow(const MaskedArray<T> &, const Array<T> &) - arrays do not conform

Test conformance, ::pow (Array, MaskedArray)
Caught an ArrayConformanceError:
::pow(const Array<T> &, const MaskedArray<U> &) - arrays do not conform

Test conformance, ::pow (MaskedArray, MaskedArray)
Caught an ArrayConformanceError:
::pow(const MaskedArray<T> &, const MaskedArray<T> &) - arrays do not conform

Test conformance, ::atan2 (MaskedArray, Array)
Caught an ArrayConformanceError:
::atan2(const MaskedArray<T> &, const Array<T> &) - arrays do not conform

Test conformance, ::atan2 (Array, MaskedArray)
Caught an ArrayConformanceError:
::atan2(const Array<T> &, const MaskedArray<T> &) - arrays do not conform

Test conformance, ::atan2 (MaskedArray, MaskedArray)
Caught an ArrayConformanceError:
::atan2(const MaskedArray<T> &, const MaskedArray<T> &) - arrays do not conform

Test insufficient elements, ::minMax (T &minVal, T &maxVal, IPosition &minPos, IPosition &maxPos, const MaskedArray &)
Caught an ArrayError:
void ::minMax(T &minVal, T &maxVal, IPosition &minPos, IPosition &maxPos, const MaskedArray<T> &marray) - Need at least 1 unmasked element

Test insufficient elements, ::min (MaskedArray)
Caught an ArrayError:
T ::min(const MaskedArray<T> &left) - Need at least 1 unmasked element

Test conformance, ::min (MaskedArray, Array)
Caught an ArrayConformanceError:
::min(const MaskedArray<T> &, const Array<T> &) - arrays do not conform

Test conformance, ::min (Array, MaskedArray)
Caught an ArrayConformanceError:
::min(const Array<T> &, const MaskedArray<T> &) - arrays do not conform

Test conformance, ::min (MaskedArray, MaskedArray)
Caught an ArrayConformanceError:
MaskedArray<T> ::min(const MaskedArray<T> &, const MaskedArray<T> &) - arrays do not conform

Test conformance, ::min (Array, Array, MaskedArray)
Caught an ArrayConformanceError:
ArrayMath/Logical function min: array shapes [11] and [10] differ

Test conformance, ::min (Array, Array, MaskedArray)
Caught an ArrayConformanceError:
ArrayMath/Logical function min: array shapes [10] and [11] differ

Test insufficient elements, ::sum (const MaskedArray &)
Caught an ArrayError:
T ::sum(const MaskedArray<T> &left) - Need at least 1 unmasked element

Test insufficient elements, ::sumsquares (const MaskedArray &)
Caught an ArrayError:
T ::sumsquares(const MaskedArray<T> &left) - Need at least 1 unmasked element

Test insufficient elements, ::product (const MaskedArray &)
Caught an ArrayError:
T ::product(const MaskedArray<T> &left) - Need at least 1 unmasked element

Test insufficient elements, ::mean (const MaskedArray &)
Caught an ArrayError:
T ::mean(const MaskedArray<T> &left) - Need at least 1 unmasked element

Test insufficient elements, ::variance (const MaskedArray &, T)
Caught an ArrayError:
::variance(const MaskedArray<T> &) - Need at least 2 unmasked elements

Test insufficient elements, ::avdev (const MaskedArray &, T)
Caught an ArrayError:
T ::avdev(const MaskedArray<T> &, T) - Need at least 1 unmasked element

Test insufficient elements, ::median (const MaskedArray &, Bool)
Caught an ArrayError:
T ::median(const MaskedArray<T> &) - Need at least 1 unmasked element



Testing MaskArrLogi Exceptions.

Test conformance, ::allLE (MaskedArray, Array)
Caught an ArrayConformanceError:
Bool ::allLE(const MaskedArray<T> &, const Array<T> &) - arrays do not conform

Test insufficient elements, ::allLE (MaskedArray, Array)
Caught an ArrayError:
Bool ::allLE(const MaskedArray<T> &, const Array<T> &) - Need at least 1 unmasked element

Test conformance, ::allLE (Array, MaskedArray)
Caught an ArrayConformanceError:
Bool ::allLE(Array<T> &, const MaskedArray<T> &) - arrays do not conform

Test insuficient elements, ::allLE (Array, MaskedArray)
Caught an ArrayError:
Bool ::allLE(const Array<T> &, const MaskedArray<T> &) - Need at least 1 unmasked element

Test conformance, ::allLE (MaskedArray, MaskedArray)
Caught an ArrayConformanceError:
Bool ::allLE(const MaskedArray<T> &, const MaskedArray<T> &) - arrays do not conform

Test insufficient elements, ::allLE (MaskedArray, MaskedArray)
Caught an ArrayError:
Bool ::allLE(const MaskedArray<T> &, const MaskedArray<T> &) - AND of MaskedArray masks must have at least 1 element

Test conformance, ::anyAND (MaskedArray, Array)
Caught an ArrayConformanceError:
Bool ::anyAND(const MaskedArray<T> &, const Array<T> &) - arrays do not conform

Test insufficient elements, ::anyAND (MaskedArray, Array)
Caught an ArrayError:
Bool ::anyAND(const MaskedArray<T> &, const Array<T> &) - Need at least 1 unmasked element

Test conformance, ::anyAND (Array, MaskedArray)
Caught an ArrayConformanceError:
Bool ::anyAND(Array<T> &, const MaskedArray<T> &) - arrays do not conform

Test insufficient elements, ::anyAND (Array, MaskedArray)
Caught an ArrayError:
Bool ::anyAND(const Array<T> &, const MaskedArray<T> &) - Need at least 1 unmasked element

Test conformance, ::anyAND (MaskedArray, MaskedArray)
Caught an ArrayConformanceError:
Bool ::anyAND(const MaskedArray<T> &, const MaskedArray<T> &) - arrays do not conform

Test insufficient elements, ::anyAND (MaskedArray, MaskedArray)
Caught an ArrayError:
Bool ::anyAND(const MaskedArray<T> &, const MaskedArray<T> &) - AND of MaskedArray masks must have at least 1 element

Test conformance, ::anyOR (MaskedArray, Array)
Caught an ArrayConformanceError:
Bool ::anyOR(const MaskedArray<T> &, const Array<T> &) - arrays do not conform

Test insufficient elements, ::anyOR (MaskedArray, Array)
Caught an ArrayError:
Bool ::anyOR(const MaskedArray<T> &, const Array<T> &) - Need at least 1 unmasked element

Test conformance, ::anyOR (Array, MaskedArray)
Caught an ArrayConformanceError:
Bool ::anyOR(Array<T> &, const MaskedArray<T> &) - arrays do not conform

Test insufficient elements, ::anyOR (Array, MaskedArray)
Caught an ArrayError:
Bool ::anyOR(const Array<T> &, const MaskedArray<T> &) - Need at least 1 unmasked element

Test conformance, ::anyOR (MaskedArray, MaskedArray)
Caught an ArrayConformanceError:
Bool ::anyOR(const MaskedArray<T> &, const MaskedArray<T> &) - arrays do not conform

Test insufficient elements ::anyOR (MaskedArray, MaskedArray)
Caught an ArrayError:
Bool ::anyOR(const MaskedArray<T> &, const MaskedArray<T> &) - AND of MaskedArray masks must have at least 1 element

Test conformance, ::operator<= (MaskedArray, Array)
Caught an ArrayConformanceError:
MaskedLogicalArray ::<=(const MaskedArray<T> &, const Array<T> &) - arrays do not conform

Test conformance, ::operator<= (Array, MaskedArray)
Caught an ArrayConformanceError:
MaskLogicalArray ::<=(const Array<T> &, const MaskedArray<T> &) - arrays do not conform

Test conformance, ::operator<= (MaskedArray, MaskedArray)
Caught an ArrayConformanceError:
MaskLogicalArray ::<=(const MaskedArray<T> &, const MaskedArray<T> &) - arrays do not conform

Test insufficient elements, ::allAND (MaskedArray, scalar)
Caught an ArrayError:
Bool ::allAND(const MaskedArray<T> &, const T) - Need at least 1 unmasked element

Test insufficient elements, ::allAND (scalar, MaskedArray)
Caught an ArrayError:
Bool ::allAND(const T, const MaskedArray<T> &) - Need at least 1 unmasked element

Test insufficient elements, ::allOR (MaskedArray, scalar)
Caught an ArrayError:
Bool ::allOR(const MaskedArray<T> &, const T) - Need at least 1 unmasked element

Test insufficient elements, ::allOR (scalar, MaskedArray)
Caught an ArrayError:
Bool ::allOR(const T, const MaskedArray<T> &) - Need at least 1 unmasked element

Test insufficient elements, ::allLE (MaskedArray, scalar)
Caught an ArrayError:
Bool ::allLE(const MaskedArray<T> &, const T) - Need at least 1 unmasked element

Test insuficient elements, ::allLE (scalar, MaskedArray)
Caught an ArrayError:
Bool ::allLE(const T, const MaskedArray<T> &) - Need at least 1 unmasked element

Test insufficient elements, ::anyAND (MaskedArray, scalar)
Caught an ArrayError:
Bool ::anyAND(const MaskedArray<T> &, const T) - Need at least 1 unmasked element

Test insufficient elements, ::anyAND (scalar, MaskedArray)
Caught an ArrayError:
Bool ::anyAND(const T, const MaskedArray<T> &) - Need at least 1 unmasked element

Test insufficient elements, ::anyOR (MaskedArray, scalar)
Caught an ArrayError:
Bool ::anyOR(const MaskedArray<T> &, const T) - Need at least 1 unmasked element

Test insufficient elements, ::anyOR (scalar, MaskedArray)
Caught an ArrayError:
Bool ::anyOR(const T, const MaskedArray<T> &) - Need at least 1 unmasked element

OK
