generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move test into test/std subdirectory.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@224658 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2014-12-20 01:40:03 +00:00
parent 669a8a5a19
commit a90c6dd460
4817 changed files with 13 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp Normal file
View File

@@ -0,0 +1,159 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <complex>
// template<class T>
// complex<T>
// operator/(const complex<T>& lhs, const complex<T>& rhs);
#include <complex>
#include <cassert>
#include "../cases.h"
template <class T>
void
test(const std::complex<T>& lhs, const std::complex<T>& rhs, std::complex<T> x)
{
assert(lhs / rhs == x);
}
template <class T>
void
test()
{
std::complex<T> lhs(-4.0, 7.5);
std::complex<T> rhs(1.5, 2.5);
std::complex<T> x(1.5, 2.5);
test(lhs, rhs, x);
}
void test_edges()
{
const unsigned N = sizeof(x) / sizeof(x[0]);
for (unsigned i = 0; i < N; ++i)
{
for (unsigned j = 0; j < N; ++j)
{
std::complex<double> r = x[i] / x[j];
switch (classify(x[i]))
{
case zero:
switch (classify(x[j]))
{
case zero:
assert(classify(r) == NaN);
break;
case non_zero:
assert(classify(r) == zero);
break;
case inf:
assert(classify(r) == zero);
break;
case NaN:
assert(classify(r) == NaN);
break;
case non_zero_nan:
assert(classify(r) == NaN);
break;
}
break;
case non_zero:
switch (classify(x[j]))
{
case zero:
assert(classify(r) == inf);
break;
case non_zero:
assert(classify(r) == non_zero);
break;
case inf:
assert(classify(r) == zero);
break;
case NaN:
assert(classify(r) == NaN);
break;
case non_zero_nan:
assert(classify(r) == NaN);
break;
}
break;
case inf:
switch (classify(x[j]))
{
case zero:
assert(classify(r) == inf);
break;
case non_zero:
assert(classify(r) == inf);
break;
case inf:
assert(classify(r) == NaN);
break;
case NaN:
assert(classify(r) == NaN);
break;
case non_zero_nan:
assert(classify(r) == NaN);
break;
}
break;
case NaN:
switch (classify(x[j]))
{
case zero:
assert(classify(r) == NaN);
break;
case non_zero:
assert(classify(r) == NaN);
break;
case inf:
assert(classify(r) == NaN);
break;
case NaN:
assert(classify(r) == NaN);
break;
case non_zero_nan:
assert(classify(r) == NaN);
break;
}
break;
case non_zero_nan:
switch (classify(x[j]))
{
case zero:
assert(classify(r) == inf);
break;
case non_zero:
assert(classify(r) == NaN);
break;
case inf:
assert(classify(r) == NaN);
break;
case NaN:
assert(classify(r) == NaN);
break;
case non_zero_nan:
assert(classify(r) == NaN);
break;
}
break;
}
}
}
}
int main()
{
test<float>();
test<double>();
test<long double>();
test_edges();
}