Exemple #1
0
inline ::testing::AssertionResult AssertArrayNear(const char *expected_expr, const char *actual_expr,
                                                  const char *rel_error_max_expr, const dynd::nd::array &expected,
                                                  const dynd::nd::array &actual, double rel_error_max)
{
  const dynd::ndt::type &expected_tp = expected.get_type();
  const dynd::ndt::type &actual_tp = actual.get_type();
  if (expected_tp.get_type_id() == dynd::cuda_device_type_id && actual_tp.get_type_id() == dynd::cuda_device_type_id) {
    return AssertArrayNear(expected_expr, actual_expr, rel_error_max_expr, expected.to_host(), actual.to_host(),
                           rel_error_max);
  }

  std::unique_ptr<test_class<dynd::complex<double>>> c(new test_class<dynd::complex<double>>(rel_error_max));

  dynd::nd::callable af = dynd::nd::functional::elwise(dynd::nd::functional::apply(c.get()));
  af(expected, actual);

  bool res = c->flag;

  if (res) {
    return ::testing::AssertionSuccess();
  }

  return ::testing::AssertionFailure() << "the values do not match";
}
Exemple #2
0
inline ::testing::AssertionResult CompareDyNDArrays(const char *expr1, const char *expr2, const dynd::nd::array &val1,
                                                    const dynd::nd::array &val2)
{
  using namespace dynd;

  if (val1.get_type().get_type_id() == cuda_device_type_id && val2.get_type().get_type_id() == cuda_device_type_id) {
    return CompareDyNDArrays(expr1, expr2, val1.to_host(), val2.to_host());
  }

  if (val1.equals_exact(val2)) {
    return ::testing::AssertionSuccess();
  }
  else {
    if (val1.get_type() != val2.get_type()) {
      return ::testing::AssertionFailure() << "The types of " << expr1 << " and " << expr2 << " do not match\n" << expr1
                                           << " has type " << val1.get_type() << ",\n" << expr2 << " has type "
                                           << val2.get_type() << ".";
    }
    else if (val1.get_shape() != val2.get_shape()) {
      return ::testing::AssertionFailure() << "The shapes of " << expr1 << " and " << expr2 << " do not match\n"
                                           << expr1 << " has shape " << ShapeFormatter(val1.get_shape()) << ",\n"
                                           << expr2 << " has shape " << ShapeFormatter(val2.get_shape()) << ".";
    }
    else if (val1.get_type().get_kind() == struct_kind) {
      const ndt::struct_type *bsd = val1.get_type().extended<ndt::struct_type>();
      intptr_t field_count = bsd->get_field_count();
      for (intptr_t i = 0; i < field_count; ++i) {
        nd::array field1 = val1(i), field2 = val2(i);
        if (!field1.equals_exact(field2)) {
          return ::testing::AssertionFailure()
                 << "The values of " << expr1 << " and " << expr2 << " do not match at field index " << i << ", name \""
                 << bsd->get_field_name(i) << "\"\n" << expr1 << " has field value " << field1 << ",\n" << expr2
                 << " has field value " << field2 << ".";
        }
      }
      return ::testing::AssertionFailure() << "DYND ASSERTION INTERNAL ERROR: One of the struct fields "
                                              "should have compared unequal";
    }
    else if (val1.get_type().get_kind() == tuple_kind) {
      const ndt::tuple_type *bsd = val1.get_type().extended<ndt::tuple_type>();
      intptr_t field_count = bsd->get_field_count();
      for (intptr_t i = 0; i < field_count; ++i) {
        nd::array field1 = val1(i), field2 = val2(i);
        if (!field1.equals_exact(field2)) {
          return ::testing::AssertionFailure()
                 << "The values of " << expr1 << " and " << expr2 << " do not match at field index " << i << "\"\n"
                 << expr1 << " has field value " << field1 << ",\n" << expr2 << " has field value " << field2 << ".";
        }
      }
      return ::testing::AssertionFailure() << "DYND ASSERTION INTERNAL ERROR: One of the tuple fields "
                                              "should have compared unequal";
    }
    else if (val1.get_ndim() > 0) {
      intptr_t dim_size = val1.get_dim_size();
      for (intptr_t i = 0; i < dim_size; ++i) {
        nd::array sub1 = val1(i), sub2 = val2(i);
        if (!sub1.equals_exact(sub2)) {
          return ::testing::AssertionFailure()
                 << "The values of " << expr1 << " and " << expr2 << " do not match at index " << i << "\"\n" << expr1
                 << " has subarray value " << sub1 << ",\n" << expr2 << " has subarray value " << sub2 << ".";
        }
      }
      return ::testing::AssertionFailure() << "DYND ASSERTION INTERNAL ERROR: One of the subarrays "
                                              "should have compared unequal\n"
                                           << expr1 << " has value " << val1 << ",\n" << expr2 << " has value " << val2
                                           << ".";
    }
    else {
      return ::testing::AssertionFailure() << "The values of " << expr1 << " and " << expr2 << " do not match\n"
                                           << expr1 << " has value " << val1 << ",\n" << expr2 << " has value " << val2
                                           << ".";
    }
  }
}