miniyuan
单元测试
任务为对 complexmatrix 类进行单元测试。
构造函数测试
// 测试默认构造函数
TEST(ComplexMatrixTest, DefaultConstructor) {
ComplexMatrix m;
EXPECT_EQ(m.nr, 0);
EXPECT_EQ(m.nc, 0);
EXPECT_EQ(m.size, 0);
EXPECT_EQ(m.c, nullptr);
}
// 测试带参数的构造函数（flag_zero=1）
TEST(ComplexMatrixTest, ParameterizedConstructorWithZero) {
ComplexMatrix m(3, 4, true);
EXPECT_EQ(m.nr, 3);
EXPECT_EQ(m.nc, 4);
EXPECT_EQ(m.size, 12);
EXPECT_NE(m.c, nullptr);
// 检查是否初始化为0
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 4; ++j) {
EXPECT_EQ(m(i, j), std::complex<double>(0.0, 0.0));
}
}
}
// 测试带参数的构造函数（flag_zero=0）
TEST(ComplexMatrixTest, ParameterizedConstructorWithoutZero) {
ComplexMatrix m(2, 2, false);
EXPECT_EQ(m.nr, 2);
EXPECT_EQ(m.nc, 2);
EXPECT_EQ(m.size, 4);
EXPECT_NE(m.c, nullptr);
}
// 测试拷贝构造函数
TEST(ComplexMatrixTest, CopyConstructor) {
ComplexMatrix m1(2, 2);
m1(0, 0) = std::complex<double>(1.0, 2.0);
m1(0, 1) = std::complex<double>(3.0, 4.0);
m1(1, 0) = std::complex<double>(5.0, 6.0);
m1(1, 1) = std::complex<double>(7.0, 8.0);
ComplexMatrix m2(m1);
EXPECT_EQ(m2.nr, 2);
EXPECT_EQ(m2.nc, 2);
EXPECT_EQ(m2.size, 4);
EXPECT_NE(m2.c, nullptr);
EXPECT_NE(m2.c, m1.c); // 确保深拷贝
// 验证数据复制正确
EXPECT_EQ(m2(0, 0), m1(0, 0));
EXPECT_EQ(m2(0, 1), m1(0, 1));
EXPECT_EQ(m2(1, 0), m1(1, 0));
EXPECT_EQ(m2(1, 1), m1(1, 1));
// 修改m2不应影响m1
m2(0, 0) = std::complex<double>(100.0, 200.0);
EXPECT_EQ(m1(0, 0), std::complex<double>(1.0, 2.0));
}
// 测试移动构造函数
TEST(ComplexMatrixTest, MoveConstructor) {
ComplexMatrix m1(2, 3);
m1(0, 0) = std::complex<double>(1.0, 1.0);
std::complex<double>* old_ptr = m1.c;
ComplexMatrix m2(std::move(m1));
EXPECT_EQ(m2.nr, 2);
EXPECT_EQ(m2.nc, 3);
EXPECT_EQ(m2.c, old_ptr);
EXPECT_EQ(m2(0, 0), std::complex<double>(1.0, 1.0));
// m1应该被置空
EXPECT_EQ(m1.nr, 0);
EXPECT_EQ(m1.nc, 0);
EXPECT_EQ(m1.size, 0);
EXPECT_EQ(m1.c, nullptr);
}赋值运算测试
// 测试拷贝赋值运算符
TEST(ComplexMatrixTest, CopyAssignment) {
ComplexMatrix m1(2, 2);
m1(0, 0) = std::complex<double>(1.0, 2.0);
m1(1, 1) = std::complex<double>(3.0, 4.0);
ComplexMatrix m2;
m2 = m1;
EXPECT_EQ(m2.nr, 2);
EXPECT_EQ(m2.nc, 2);
EXPECT_EQ(m2(0, 0), std::complex<double>(1.0, 2.0));
EXPECT_EQ(m2(1, 1), std::complex<double>(3.0, 4.0));
EXPECT_NE(m2.c, m1.c);
}
// 测试移动赋值运算符
TEST(ComplexMatrixTest, MoveAssignment) {
ComplexMatrix m1(3, 3);
m1(1, 1) = std::complex<double>(5.0, 5.0);
std::complex<double>* old_ptr = m1.c;
ComplexMatrix m2;
m2 = std::move(m1);
EXPECT_EQ(m2.nr, 3);
EXPECT_EQ(m2.nc, 3);
EXPECT_EQ(m2.c, old_ptr);
EXPECT_EQ(m1.c, nullptr);
EXPECT_EQ(m1.nr, 0);
}元素访问测试
// 测试非const元素访问和修改
TEST(ComplexMatrixTest, ElementAccess) {
ComplexMatrix m(2, 3);
// 写入数据
m(0, 0) = std::complex<double>(1.0, 2.0);
m(1, 2) = std::complex<double>(3.0, 4.0);
// 读取验证
EXPECT_EQ(m(0, 0).real(), 1.0);
EXPECT_EQ(m(0, 0).imag(), 2.0);
EXPECT_EQ(m(1, 2).real(), 3.0);
EXPECT_EQ(m(1, 2).imag(), 4.0);
}
// 测试const元素访问
TEST(ComplexMatrixTest, ConstElementAccess) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(1.0, 2.0);
const ComplexMatrix& cm = m;
EXPECT_EQ(cm(0, 0), std::complex<double>(1.0, 2.0));
}运算符重载测试
// 测试+运算符
TEST(ComplexMatrixTest, MatrixAddition) {
ComplexMatrix m1(2, 2);
m1(0, 0) = std::complex<double>(1.0, 1.0);
m1(0, 1) = std::complex<double>(2.0, 2.0);
m1(1, 0) = std::complex<double>(3.0, 3.0);
m1(1, 1) = std::complex<double>(4.0, 4.0);
ComplexMatrix m2(2, 2);
m2(0, 0) = std::complex<double>(1.0, 0.0);
m2(0, 1) = std::complex<double>(0.0, 1.0);
m2(1, 0) = std::complex<double>(1.0, 1.0);
m2(1, 1) = std::complex<double>(0.0, 0.0);
ComplexMatrix m3 = m1 + m2;
EXPECT_EQ(m3(0, 0), std::complex<double>(2.0, 1.0));
EXPECT_EQ(m3(0, 1), std::complex<double>(2.0, 3.0));
EXPECT_EQ(m3(1, 0), std::complex<double>(4.0, 4.0));
EXPECT_EQ(m3(1, 1), std::complex<double>(4.0, 4.0));
}
// 测试+=运算符
TEST(ComplexMatrixTest, PlusEqualsOperator) {
ComplexMatrix m1(2, 2);
m1(0, 0) = std::complex<double>(1.0, 1.0);
ComplexMatrix m2(2, 2);
m2(0, 0) = std::complex<double>(2.0, 3.0);
m1 += m2;
EXPECT_EQ(m1(0, 0), std::complex<double>(3.0, 4.0));
}
// 测试-运算符
TEST(ComplexMatrixTest, MatrixSubtraction) {
ComplexMatrix m1(2, 2);
m1(0, 0) = std::complex<double>(5.0, 5.0);
m1(0, 1) = std::complex<double>(3.0, 2.0);
ComplexMatrix m2(2, 2);
m2(0, 0) = std::complex<double>(2.0, 3.0);
m2(0, 1) = std::complex<double>(1.0, 1.0);
ComplexMatrix m3 = m1 - m2;
EXPECT_EQ(m3(0, 0), std::complex<double>(3.0, 2.0));
EXPECT_EQ(m3(0, 1), std::complex<double>(2.0, 1.0));
}
// 测试-=运算符
TEST(ComplexMatrixTest, MinusEqualsOperator) {
ComplexMatrix m1(2, 2);
m1(0, 0) = std::complex<double>(5.0, 5.0);
ComplexMatrix m2(2, 2);
m2(0, 0) = std::complex<double>(2.0, 3.0);
m1 -= m2;
EXPECT_EQ(m1(0, 0), std::complex<double>(3.0, 2.0));
}
// 测试*运算符（矩阵乘）
TEST(ComplexMatrixTest, MatrixMultiplication) {
ComplexMatrix m1(2, 3);
m1(0, 0) = std::complex<double>(1.0, 0.0);
m1(0, 1) = std::complex<double>(2.0, 0.0);
m1(0, 2) = std::complex<double>(3.0, 0.0);
m1(1, 0) = std::complex<double>(4.0, 0.0);
m1(1, 1) = std::complex<double>(5.0, 0.0);
m1(1, 2) = std::complex<double>(6.0, 0.0);
ComplexMatrix m2(3, 2);
m2(0, 0) = std::complex<double>(7.0, 0.0);
m2(0, 1) = std::complex<double>(8.0, 0.0);
m2(1, 0) = std::complex<double>(9.0, 0.0);
m2(1, 1) = std::complex<double>(10.0, 0.0);
m2(2, 0) = std::complex<double>(11.0, 0.0);
m2(2, 1) = std::complex<double>(12.0, 0.0);
ComplexMatrix m3 = m1 * m2;
EXPECT_EQ(m3.nr, 2);
EXPECT_EQ(m3.nc, 2);
EXPECT_EQ(m3(0, 0), std::complex<double>(58.0, 0.0));
EXPECT_EQ(m3(0, 1), std::complex<double>(64.0, 0.0));
EXPECT_EQ(m3(1, 0), std::complex<double>(139.0, 0.0));
EXPECT_EQ(m3(1, 1), std::complex<double>(154.0, 0.0));
}
// 测试*运算符（复数标量左乘）
TEST(ComplexMatrixTest, ComplexScalarMultiplicationLeft) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(1.0, 2.0);
m(0, 1) = std::complex<double>(3.0, 0.0);
m(1, 0) = std::complex<double>(0.0, 1.0);
m(1, 1) = std::complex<double>(2.0, 2.0);
std::complex<double> s(2.0, 1.0);
ComplexMatrix result = s * m;
// (2+i)*(1+2i) = 2+4i+i+2i^2 = 2+5i-2 = 5i
EXPECT_NEAR(result(0, 0).real(), 0.0, 1e-10);
EXPECT_NEAR(result(0, 0).imag(), 5.0, 1e-10);
}
// 测试*运算符（复数标量右乘）
TEST(ComplexMatrixTest, ComplexScalarMultiplicationRight) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(1.0, 2.0);
std::complex<double> s(2.0, 1.0);
ComplexMatrix result = m * s;
EXPECT_NEAR(result(0, 0).real(), 0.0, 1e-10);
EXPECT_NEAR(result(0, 0).imag(), 5.0, 1e-10);
}
// 测试*运算符（实数标量乘）
TEST(ComplexMatrixTest, DoubleScalarMultiplication) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(1.0, 2.0);
m(0, 1) = std::complex<double>(3.0, -1.0);
ComplexMatrix result = 2.0 * m;
EXPECT_EQ(result(0, 0), std::complex<double>(2.0, 4.0));
EXPECT_EQ(result(0, 1), std::complex<double>(6.0, -2.0));
ComplexMatrix result2 = m * 3.0;
EXPECT_EQ(result2(0, 0), std::complex<double>(3.0, 6.0));
}
// 测试*=运算符
TEST(ComplexMatrixTest, TimesEqualsOperator) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(1.0, 2.0);
std::complex<double> s(2.0, 0.0);
m *= s;
EXPECT_EQ(m(0, 0), std::complex<double>(2.0, 4.0));
}功能函数测试
// 测试zero_out函数
TEST(ComplexMatrixTest, ZeroOut) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(1.0, 2.0);
m(0, 1) = std::complex<double>(3.0, 4.0);
m(1, 0) = std::complex<double>(5.0, 6.0);
m(1, 1) = std::complex<double>(7.0, 8.0);
m.zero_out();
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j) {
EXPECT_EQ(m(i, j), std::complex<double>(0.0, 0.0));
}
}
}
// 测试set_as_identity_matrix函数
TEST(ComplexMatrixTest, SetAsIdentityMatrix) {
ComplexMatrix m(3, 3);
m(0, 0) = std::complex<double>(999.0, 999.0);
m.set_as_identity_matrix();
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 3; ++j) {
if (i == j) {
EXPECT_EQ(m(i, j), std::complex<double>(1.0, 0.0));
} else {
EXPECT_EQ(m(i, j), std::complex<double>(0.0, 0.0));
}
}
}
}
// 测试trace函数
TEST(ComplexMatrixTest, TraceCalculation) {
ComplexMatrix m(3, 3);
m(0, 0) = std::complex<double>(1.0, 1.0);
m(1, 1) = std::complex<double>(2.0, 2.0);
m(2, 2) = std::complex<double>(3.0, 3.0);
std::complex<double> tr = trace(m);
EXPECT_EQ(tr, std::complex<double>(6.0, 6.0));
}
// 测试transpose函数(conjugate=0)
TEST(ComplexMatrixTest, TransposeWithoutConjugate) {
ComplexMatrix m(2, 3);
m(0, 0) = std::complex<double>(1.0, 2.0);
m(0, 1) = std::complex<double>(3.0, 4.0);
m(0, 2) = std::complex<double>(5.0, 6.0);
m(1, 0) = std::complex<double>(7.0, 8.0);
m(1, 1) = std::complex<double>(9.0, 10.0);
m(1, 2) = std::complex<double>(11.0, 12.0);
ComplexMatrix mt = transpose(m, false);
EXPECT_EQ(mt.nr, 3);
EXPECT_EQ(mt.nc, 2);
EXPECT_EQ(mt(0, 0), m(0, 0));
EXPECT_EQ(mt(0, 1), m(1, 0));
EXPECT_EQ(mt(1, 0), m(0, 1));
EXPECT_EQ(mt(2, 1), m(1, 2));
}
// 测试transpose函数(conjugate=1)
TEST(ComplexMatrixTest, TransposeWithConjugate) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(1.0, 2.0);
m(0, 1) = std::complex<double>(3.0, 4.0);
m(1, 0) = std::complex<double>(5.0, 6.0);
m(1, 1) = std::complex<double>(7.0, 8.0);
ComplexMatrix mt = transpose(m, true);
EXPECT_EQ(mt(0, 0), std::complex<double>(1.0, -2.0));
EXPECT_EQ(mt(1, 0), std::complex<double>(3.0, -4.0));
EXPECT_EQ(mt(0, 1), std::complex<double>(5.0, -6.0));
}
// 测试conj函数
TEST(ComplexMatrixTest, ConjugateFunction) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(1.0, 2.0);
m(0, 1) = std::complex<double>(-3.0, -4.0);
ComplexMatrix mc = conj(m);
EXPECT_EQ(mc(0, 0), std::complex<double>(1.0, -2.0));
EXPECT_EQ(mc(0, 1), std::complex<double>(-3.0, 4.0));
}
// 测试real函数
TEST(ComplexMatrixTest, RealFunction) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(3.0, 4.0);
m(0, 1) = std::complex<double>(5.0, -6.0);
m(1, 0) = std::complex<double>(-1.0, 2.0);
m(1, 1) = std::complex<double>(0.0, 0.0);
matrix mr = m.real();
EXPECT_EQ(mr.nr, 2);
EXPECT_EQ(mr.nc, 2);
EXPECT_DOUBLE_EQ(mr(0, 0), 3.0);
EXPECT_DOUBLE_EQ(mr(0, 1), 5.0);
EXPECT_DOUBLE_EQ(mr(1, 0), -1.0);
EXPECT_DOUBLE_EQ(mr(1, 1), 0.0);
}
// 测试abs2函数
TEST(ComplexMatrixTest, Abs2Function) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(3.0, 4.0);
m(0, 1) = std::complex<double>(1.0, 0.0);
m(1, 0) = std::complex<double>(0.0, 1.0);
m(1, 1) = std::complex<double>(0.0, 0.0);
double result = abs2(m);
EXPECT_DOUBLE_EQ(result, 27.0);
}
// 测试abs2_row函数
TEST(ComplexMatrixTest, Abs2RowFunction) {
ComplexMatrix m(2, 3);
m(0, 0) = std::complex<double>(3.0, 4.0);
m(0, 1) = std::complex<double>(1.0, 0.0);
m(0, 2) = std::complex<double>(0.0, 1.0);
m(1, 0) = std::complex<double>(1.0, 1.0);
double result = abs2_row(m, 0);
EXPECT_DOUBLE_EQ(result, 27.0);
}
// 测试abs2_column函数
TEST(ComplexMatrixTest, Abs2ColumnFunction) {
ComplexMatrix m(3, 2);
m(0, 0) = std::complex<double>(3.0, 4.0);
m(1, 0) = std::complex<double>(1.0, 0.0);
m(2, 0) = std::complex<double>(0.0, 1.0);
m(0, 1) = std::complex<double>(1.0, 1.0);
double result = abs2_column(m, 0);
EXPECT_DOUBLE_EQ(result, 27.0);
}
// 测试checkreal函数
TEST(ComplexMatrixTest, CheckRealFunction) {
ComplexMatrix m1(2, 2);
m1(0, 0) = std::complex<double>(1.0, 1e-13);
m1(0, 1) = std::complex<double>(2.0, 0.0);
m1(1, 0) = std::complex<double>(3.0, 0.0);
m1(1, 1) = std::complex<double>(4.0, 0.0);
EXPECT_TRUE(m1.checkreal());
ComplexMatrix m2(2, 2);
m2(0, 0) = std::complex<double>(1.0, 1e-11);
m2(0, 1) = std::complex<double>(2.0, 0.0);
m2(1, 0) = std::complex<double>(3.0, 0.0);
m2(1, 1) = std::complex<double>(4.0, 0.0);
EXPECT_FALSE(m2.checkreal());
}
// 测试scale_accumulate函数
TEST(ComplexMatrixTest, ScaleAccumulate) {
ComplexMatrix min(2, 2);
min(0, 0) = std::complex<double>(1.0, 1.0);
min(0, 1) = std::complex<double>(2.0, 0.0);
min(1, 0) = std::complex<double>(0.0, 2.0);
min(1, 1) = std::complex<double>(3.0, 3.0);
ComplexMatrix mout(2, 2);
mout(0, 0) = std::complex<double>(1.0, 0.0);
mout(0, 1) = std::complex<double>(0.0, 1.0);
mout(1, 0) = std::complex<double>(1.0, 1.0);
mout(1, 1) = std::complex<double>(0.0, 0.0);
std::complex<double> s(2.0, 0.0);
scale_accumulate(s, min, mout);
EXPECT_EQ(mout(0, 0), std::complex<double>(3.0, 2.0));
EXPECT_EQ(mout(0, 1), std::complex<double>(4.0, 1.0));
}
// 测试scaled_sum函数
TEST(ComplexMatrixTest, ScaledSum) {
ComplexMatrix m1(2, 2);
m1(0, 0) = std::complex<double>(1.0, 0.0);
m1(0, 1) = std::complex<double>(0.0, 1.0);
ComplexMatrix m2(2, 2);
m2(0, 0) = std::complex<double>(0.0, 1.0);
m2(0, 1) = std::complex<double>(1.0, 0.0);
ComplexMatrix mout(2, 2);
std::complex<double> s1(2.0, 0.0);
std::complex<double> s2(3.0, 0.0);
scaled_sum(s1, m1, s2, m2, mout);
EXPECT_EQ(mout(0, 0), std::complex<double>(2.0, 3.0));
EXPECT_EQ(mout(0, 1), std::complex<double>(3.0, 2.0));
}
// 测试create函数
TEST(ComplexMatrixTest, CreateReuseMemory) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(999.0, 999.0);
m.create(2, 2, true);
EXPECT_EQ(m(0, 0), std::complex<double>(0.0, 0.0));
m.create(3, 3);
EXPECT_EQ(m.nr, 3);
EXPECT_EQ(m.nc, 3);
}边界情况测试
// 测试空矩阵
TEST(ComplexMatrixTest, EmptyMatrixOperations) {
ComplexMatrix m1;
ComplexMatrix m2(0, 0);
EXPECT_EQ(m1.nr, 0);
EXPECT_EQ(m1.nc, 0);
EXPECT_EQ(m1.size, 0);
EXPECT_EQ(m1.c, nullptr);
// 测试create为0
m1.create(0, 0);
EXPECT_EQ(m1.c, nullptr);
}
// 测试单元素矩阵
TEST(ComplexMatrixTest, SingleRowColumnMatrix) {
ComplexMatrix m(1, 1);
m(0, 0) = std::complex<double>(5.0, 5.0);
EXPECT_EQ(m.nr, 1);
EXPECT_EQ(m.nc, 1);
EXPECT_EQ(trace(m), std::complex<double>(5.0, 5.0));
ComplexMatrix m2(1, 5);
m2(0, 0) = std::complex<double>(1.0, 0.0);
m2(0, 4) = std::complex<double>(0.0, 1.0);
double r = abs2_row(m2, 0);
EXPECT_DOUBLE_EQ(r, 2.0);
}输出测试
// 测试print函数
TEST(ComplexMatrixTest, PrintFunction) {
ComplexMatrix m(2, 2);
m(0, 0) = std::complex<double>(1.5, 0.0);
m(0, 1) = std::complex<double>(0.0, 2.5);
m(1, 0) = std::complex<double>(0.001, 0.0);
m(1, 1) = std::complex<double>(3.0, 0.0000001);
std::ostringstream oss;
m.print(oss, 0.01, 0.001);
std::string output = oss.str();
EXPECT_NE(output.find("1.5"), std::string::npos);
EXPECT_NE(output.find("(0,2.5)"), std::string::npos);
EXPECT_NE(output.find("0"), std::string::npos);
}编译脚本
注意必需使用 -D__NORMAL 在编译时定义宏，因为 complexmatrix.cpp 中必须定义该宏避免外部依赖。
#!/bin/bash
set -e
echo "========================================="
echo "开始编译 ComplexMatrix 单元测试..."
echo "========================================="
GTEST_CFLAGS="-I/usr/include"
GTEST_LIBS="-lgtest -lgtest_main -pthread"
# 编译选项
CXX=g++
CXXFLAGS="-std=c++11 -O2 -g ${GTEST_CFLAGS} -D__NORMAL"
LDFLAGS="${GTEST_LIBS} -pthread"
# 源文件
TEST_SRC="complexmatrix_test.cpp"
IMPL_SRC="complexmatrix.cpp"
MATRIX_SRC="matrix.cpp"
OUTPUT="complexmatrix_test"
echo "编译选项:"
echo " CXXFLAGS: $CXXFLAGS"
echo " LDFLAGS: $LDFLAGS"
echo ""
# 编译
if $CXX $CXXFLAGS $TEST_SRC $IMPL_SRC $MATRIX_SRC -o $OUTPUT $LDFLAGS; then
echo ""
echo "编译成功! 生成可执行文件: ./$OUTPUT"
echo ""
echo "运行测试:"
echo " ./$OUTPUT # 运行所有测试"
echo " ./$OUTPUT --gtest_filter=ComplexMatrixTest.DefaultConstructor # 运行特定测试"
echo " ./$OUTPUT --gtest_list_tests # 列出所有测试"
echo ""
else
echo "编译失败"
exit 1
fi测试结果
[==========] Running 35 tests from 1 test suite.
[----------] Global test environment set-up.
[----------] 35 tests from ComplexMatrixTest
[ RUN ] ComplexMatrixTest.DefaultConstructor
[ OK ] ComplexMatrixTest.DefaultConstructor (0 ms)
[ RUN ] ComplexMatrixTest.ParameterizedConstructorWithZero
[ OK ] ComplexMatrixTest.ParameterizedConstructorWithZero (0 ms)
[ RUN ] ComplexMatrixTest.ParameterizedConstructorWithoutZero
[ OK ] ComplexMatrixTest.ParameterizedConstructorWithoutZero (0 ms)
[ RUN ] ComplexMatrixTest.CopyConstructor
[ OK ] ComplexMatrixTest.CopyConstructor (0 ms)
[ RUN ] ComplexMatrixTest.MoveConstructor
[ OK ] ComplexMatrixTest.MoveConstructor (0 ms)
[ RUN ] ComplexMatrixTest.CopyAssignment
[ OK ] ComplexMatrixTest.CopyAssignment (0 ms)
[ RUN ] ComplexMatrixTest.MoveAssignment
[ OK ] ComplexMatrixTest.MoveAssignment (0 ms)
[ RUN ] ComplexMatrixTest.ElementAccess
[ OK ] ComplexMatrixTest.ElementAccess (0 ms)
[ RUN ] ComplexMatrixTest.ConstElementAccess
[ OK ] ComplexMatrixTest.ConstElementAccess (0 ms)
[ RUN ] ComplexMatrixTest.MatrixAddition
[ OK ] ComplexMatrixTest.MatrixAddition (0 ms)
[ RUN ] ComplexMatrixTest.PlusEqualsOperator
[ OK ] ComplexMatrixTest.PlusEqualsOperator (0 ms)
[ RUN ] ComplexMatrixTest.MatrixSubtraction
[ OK ] ComplexMatrixTest.MatrixSubtraction (0 ms)
[ RUN ] ComplexMatrixTest.MinusEqualsOperator
[ OK ] ComplexMatrixTest.MinusEqualsOperator (0 ms)
[ RUN ] ComplexMatrixTest.MatrixMultiplication
[ OK ] ComplexMatrixTest.MatrixMultiplication (0 ms)
[ RUN ] ComplexMatrixTest.ComplexScalarMultiplicationLeft
[ OK ] ComplexMatrixTest.ComplexScalarMultiplicationLeft (0 ms)
[ RUN ] ComplexMatrixTest.ComplexScalarMultiplicationRight
[ OK ] ComplexMatrixTest.ComplexScalarMultiplicationRight (0 ms)
[ RUN ] ComplexMatrixTest.DoubleScalarMultiplication
[ OK ] ComplexMatrixTest.DoubleScalarMultiplication (0 ms)
[ RUN ] ComplexMatrixTest.TimesEqualsOperator
[ OK ] ComplexMatrixTest.TimesEqualsOperator (0 ms)
[ RUN ] ComplexMatrixTest.ZeroOut
[ OK ] ComplexMatrixTest.ZeroOut (0 ms)
[ RUN ] ComplexMatrixTest.SetAsIdentityMatrix
[ OK ] ComplexMatrixTest.SetAsIdentityMatrix (0 ms)
[ RUN ] ComplexMatrixTest.TraceCalculation
[ OK ] ComplexMatrixTest.TraceCalculation (0 ms)
[ RUN ] ComplexMatrixTest.TransposeWithoutConjugate
[ OK ] ComplexMatrixTest.TransposeWithoutConjugate (0 ms)
[ RUN ] ComplexMatrixTest.TransposeWithConjugate
[ OK ] ComplexMatrixTest.TransposeWithConjugate (0 ms)
[ RUN ] ComplexMatrixTest.ConjugateFunction
[ OK ] ComplexMatrixTest.ConjugateFunction (0 ms)
[ RUN ] ComplexMatrixTest.RealFunction
[ OK ] ComplexMatrixTest.RealFunction (0 ms)
[ RUN ] ComplexMatrixTest.Abs2Function
[ OK ] ComplexMatrixTest.Abs2Function (0 ms)
[ RUN ] ComplexMatrixTest.Abs2RowFunction
[ OK ] ComplexMatrixTest.Abs2RowFunction (0 ms)
[ RUN ] ComplexMatrixTest.Abs2ColumnFunction
[ OK ] ComplexMatrixTest.Abs2ColumnFunction (0 ms)
[ RUN ] ComplexMatrixTest.CheckRealFunction
[ OK ] ComplexMatrixTest.CheckRealFunction (0 ms)
[ RUN ] ComplexMatrixTest.ScaleAccumulate
[ OK ] ComplexMatrixTest.ScaleAccumulate (0 ms)
[ RUN ] ComplexMatrixTest.ScaledSum
[ OK ] ComplexMatrixTest.ScaledSum (0 ms)
[ RUN ] ComplexMatrixTest.CreateReuseMemory
[ OK ] ComplexMatrixTest.CreateReuseMemory (0 ms)
[ RUN ] ComplexMatrixTest.EmptyMatrixOperations
[ OK ] ComplexMatrixTest.EmptyMatrixOperations (0 ms)
[ RUN ] ComplexMatrixTest.SingleRowColumnMatrix
[ OK ] ComplexMatrixTest.SingleRowColumnMatrix (0 ms)
[ RUN ] ComplexMatrixTest.PrintFunction
[ OK ] ComplexMatrixTest.PrintFunction (0 ms)
[----------] 35 tests from ComplexMatrixTest (0 ms total)
[----------] Global test environment tear-down
[==========] 35 tests from 1 test suite ran. (0 ms total)
[ PASSED ] 35 tests.