Add testing support to vtkm, and add tests for primitive types.

vtkm/CMakeLists.txt

+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+include_directories(${Boost_INCLUDE_DIRS})
+
+set(headers
+  Types.h
+  TypeTraits.h
+  VectorTraits.h
+  )
+
+vtkm_declare_headers(${headers})
+
+#-----------------------------------------------------------------------------
+#first add all the components vtkm that are shared between control and exec
+add_subdirectory(testing)
+add_subdirectory(internal)
+
+#-----------------------------------------------------------------------------
+#add the control and exec folders
+# add_subdirectory(cont)
+

vtkm/internal/testing/CMakeLists.txt

+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+set(unit_tests
+  UnitTestConfigureFor32.cxx
+  UnitTestConfigureFor64.cxx
+  )
+vtkm_unit_tests(SOURCES ${unit_tests})

vtkm/internal/testing/UnitTestConfigureFor32.cxx

+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/internal/ConfigureFor32.h>
+
+#include <vtkm/Types.h>
+
+#include <vtkm/testing/Testing.h>
+
+// Size of 32 bits.
+#define EXPECTED_SIZE 4
+
+#if VTKM_SIZE_ID != EXPECTED_SIZE
+#error VTKM_SIZE_ID an unexpected size.
+#endif
+
+#if VTKM_SIZE_SCALAR != EXPECTED_SIZE
+#error VTKM_SIZE_SCALAR an unexpected size.
+#endif
+
+namespace {
+
+void TestTypeSizes()
+{
+  VTKM_TEST_ASSERT(VTKM_SIZE_ID == EXPECTED_SIZE,
+                  "VTKM_SIZE_ID an unexpected size.");
+  VTKM_TEST_ASSERT(sizeof(vtkm::Id) == EXPECTED_SIZE,
+                  "vtkm::Id an unexpected size.");
+  VTKM_TEST_ASSERT(VTKM_SIZE_SCALAR == EXPECTED_SIZE,
+                  "VTKM_SIZE_SCALAR an unexpected size.");
+  VTKM_TEST_ASSERT(sizeof(vtkm::Scalar) == EXPECTED_SIZE,
+                  "vtkm::Scalar an unexpected size.");
+}
+
+}
+
+int UnitTestConfigureFor32(int, char *[])
+{
+  return vtkm::testing::Testing::Run(TestTypeSizes);
+}

vtkm/internal/testing/UnitTestConfigureFor64.cxx

+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+#include <vtkm/internal/ConfigureFor64.h>
+
+#include <vtkm/Types.h>
+
+#include <vtkm/testing/Testing.h>
+
+// Size of 64 bits.
+#define EXPECTED_SIZE 8
+
+#if VTKM_SIZE_ID != EXPECTED_SIZE
+#error VTKM_SIZE_ID an unexpected size.
+#endif
+
+#if VTKM_SIZE_SCALAR != EXPECTED_SIZE
+#error VTKM_SIZE_SCALAR an unexpected size.
+#endif
+
+namespace {
+
+void TestTypeSizes()
+{
+  VTKM_TEST_ASSERT(VTKM_SIZE_ID == EXPECTED_SIZE,
+                  "VTKM_SIZE_ID an unexpected size.");
+  VTKM_TEST_ASSERT(sizeof(vtkm::Id) == EXPECTED_SIZE,
+                  "vtkm::Id an unexpected size.");
+  VTKM_TEST_ASSERT(VTKM_SIZE_SCALAR == EXPECTED_SIZE,
+                  "VTKM_SIZE_SCALAR an unexpected size.");
+  VTKM_TEST_ASSERT(sizeof(vtkm::Scalar) == EXPECTED_SIZE,
+                  "vtkm::Scalar an unexpected size.");
+}
+
+}
+
+int UnitTestConfigureFor64(int, char *[])
+{
+  return vtkm::testing::Testing::Run(TestTypeSizes);
+}

vtkm/testing/CMakeLists.txt

+##============================================================================
+##  Copyright (c) Kitware, Inc.
+##  All rights reserved.
+##  See LICENSE.txt for details.
+##  This software is distributed WITHOUT ANY WARRANTY; without even
+##  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+##  PURPOSE.  See the above copyright notice for more information.
+##
+##  Copyright 2014 Sandia Corporation.
+##  Copyright 2014 UT-Battelle, LLC.
+##  Copyright 2014. Los Alamos National Security
+##
+##  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+##  the U.S. Government retains certain rights in this software.
+##
+##  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+##  Laboratory (LANL), the U.S. Government retains certain rights in
+##  this software.
+##============================================================================
+
+set(headers
+  Testing.h
+  OptionParser.h
+  )
+
+VTKM_declare_headers(${headers})
+
+set(unit_tests
+  UnitTestTesting.cxx
+  UnitTestTypes.cxx
+  UnitTestTypeTraits.cxx
+  )
+
+VTKM_unit_tests(SOURCES ${unit_tests})

vtkm/testing/Testing.h

+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+#ifndef vtkm_testing_Testing_h
+#define vtkm_testing_Testing_h
+
+#include <vtkm/Types.h>
+#include <vtkm/TypeTraits.h>
+#include <vtkm/VectorTraits.h>
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include <math.h>
+
+// Try to enforce using the correct testing version. (Those that include the
+// control environment have more possible exceptions.) This is not guaranteed
+// to work. To make it more likely, place the Testing.h include last.
+#ifdef vtkm_cont_Error_h
+#ifndef vtkm_cont_testing_Testing_h
+#error Use vtkm::cont::testing::Testing instead of vtkm::testing::Testing.
+#else
+#define VTKM_TESTING_IN_CONT
+#endif
+#endif
+
+/// \def VTKM_TEST_ASSERT(condition, message)
+///
+/// Asserts a condition for a test to pass. A passing condition is when \a
+/// condition resolves to true. If \a condition is false, then the test is
+/// aborted and failure is returned.
+
+#define VTKM_TEST_ASSERT(condition, message) \
+  ::vtkm::testing::Testing::Assert( \
+      condition, __FILE__, __LINE__, message, #condition)
+
+/// \def VTKM_TEST_FAIL(message)
+///
+/// Causes a test to fail with the given \a message.
+
+#define VTKM_TEST_FAIL(message) \
+  throw ::vtkm::testing::Testing::TestFailure(__FILE__, __LINE__, message)
+
+namespace vtkm {
+namespace testing {
+
+struct Testing
+{
+public:
+  class TestFailure
+  {
+  public:
+    VTKM_CONT_EXPORT TestFailure(const std::string &file,
+                                vtkm::Id line,
+                                const std::string &message)
+      : File(file), Line(line), Message(message) { }
+
+    VTKM_CONT_EXPORT TestFailure(const std::string &file,
+                                vtkm::Id line,
+                                const std::string &message,
+                                const std::string &condition)
+      : File(file), Line(line)
+    {
+      this->Message.append(message);
+      this->Message.append(" (");
+      this->Message.append(condition);
+      this->Message.append(")");
+    }
+
+    VTKM_CONT_EXPORT const std::string &GetFile() const { return this->File; }
+    VTKM_CONT_EXPORT vtkm::Id GetLine() const { return this->Line; }
+    VTKM_CONT_EXPORT const std::string &GetMessage() const {
+      return this->Message;
+    }
+  private:
+    std::string File;
+    vtkm::Id Line;
+    std::string Message;
+  };
+
+  static VTKM_CONT_EXPORT void Assert(bool condition,
+                                     const std::string &file,
+                                     vtkm::Id line,
+                                     const std::string &message,
+                                     const std::string &conditionString)
+  {
+    if (condition)
+      {
+      // Do nothing.
+      }
+    else
+      {
+      throw TestFailure(file, line, message, conditionString);
+      }
+  }
+
+#ifndef VTKM_TESTING_IN_CONT
+  /// Calls the test function \a function with no arguments. Catches any errors
+  /// generated by VTKM_TEST_ASSERT or VTKM_TEST_FAIL, reports the error, and
+  /// returns "1" (a failure status for a program's main). Returns "0" (a
+  /// success status for a program's main).
+  ///
+  /// The intention is to implement a test's main function with this. For
+  /// example, the implementation of UnitTestFoo might look something like
+  /// this.
+  ///
+  /// \code
+  /// #include <vtkm/testing/Testing.h>
+  ///
+  /// namespace {
+  ///
+  /// void TestFoo()
+  /// {
+  ///    // Do actual test, which checks in VTKM_TEST_ASSERT or VTKM_TEST_FAIL.
+  /// }
+  ///
+  /// } // anonymous namespace
+  ///
+  /// int UnitTestFoo(int, char *[])
+  /// {
+  ///   return vtkm::testing::Testing::Run(TestFoo);
+  /// }
+  /// \endcode
+  ///
+  template<class Func>
+  static VTKM_CONT_EXPORT int Run(Func function)
+  {
+    try
+      {
+      function();
+      }
+    catch (TestFailure error)
+      {
+      std::cout << "***** Test failed @ "
+                << error.GetFile() << ":" << error.GetLine() << std::endl
+                << error.GetMessage() << std::endl;
+      return 1;
+      }
+    catch (...)
+      {
+      std::cout << "***** Unidentified exception thrown." << std::endl;
+      return 1;
+      }
+    return 0;
+  }
+#endif
+
+  /// Check functors to be used with the TryAllTypes method.
+  ///
+  struct TypeCheckAlwaysTrue {
+    template <typename T, class Functor>
+    void operator()(T t, Functor function) const { function(t); }
+  };
+  struct TypeCheckInteger {
+    template <typename T, class Functor>
+    void operator()(T t, Functor function) const {
+      this->DoInteger(typename vtkm::TypeTraits<T>::NumericTag(), t, function);
+    }
+  private:
+    template <class Tag, typename T, class Functor>
+    void DoInteger(Tag, T, const Functor&) const {  }
+    template <typename T, class Functor>
+    void DoInteger(vtkm::TypeTraitsIntegerTag, T t, Functor function) const {
+      function(t);
+    }
+  };
+  struct TypeCheckReal {
+    template <typename T, class Functor>
+    void operator()(T t, Functor function) const {
+      this->DoReal(typename vtkm::TypeTraits<T>::NumericTag(), t, function);
+    }
+  private:
+    template <class Tag, typename T, class Functor>
+    void DoReal(Tag, T, const Functor&) const {  }
+    template <typename T, class Functor>
+    void DoReal(vtkm::TypeTraitsRealTag, T t, Functor function) const {
+      function(t);
+    }
+  };
+  struct TypeCheckScalar {
+    template <typename T, class Functor>
+    void operator()(T t, Functor func) const {
+      this->DoScalar(typename vtkm::TypeTraits<T>::DimensionalityTag(), t, func);
+    }
+  private:
+    template <class Tag, typename T, class Functor>
+    void DoScalar(Tag, const T &, const Functor &) const {  }
+    template <typename T, class Functor>
+    void DoScalar(vtkm::TypeTraitsScalarTag, T t, Functor function) const {
+      function(t);
+    }
+  };
+  struct TypeCheckVector {
+    template <typename T, class Functor>
+    void operator()(T t, Functor func) const {
+      this->DoVector(typename vtkm::TypeTraits<T>::DimensionalityTag(), t, func);
+    }
+  private:
+    template <class Tag, typename T, class Functor>
+    void DoVector(Tag, const T &, const Functor &) const {  }
+    template <typename T, class Functor>
+    void DoVector(vtkm::TypeTraitsVectorTag, T t, Functor function) const {
+      function(t);
+    }
+  };
+
+  template<class FunctionType>
+  struct InternalPrintOnInvoke {
+    InternalPrintOnInvoke(FunctionType function, std::string toprint)
+      : Function(function), ToPrint(toprint) { }
+    template <typename T> void operator()(T t) {
+      std::cout << this->ToPrint << std::endl;
+      this->Function(t);
+    }
+  private:
+    FunctionType Function;
+    std::string ToPrint;
+  };
+
+  /// Runs templated \p function on all the basic types defined in VTKm. This is
+  /// helpful to test templated functions that should work on all types. If the
+  /// function is supposed to work on some subset of types, then \p check can
+  /// be set to restrict the types used. This Testing class contains several
+  /// helpful check functors.
+  ///
+  template<class FunctionType, class CheckType>
+  static void TryAllTypes(FunctionType function, CheckType check)
+  {
+    vtkm::Id id = 0;
+    check(id, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Id ***************"));
+
+    vtkm::Id3 id3 = vtkm::make_Id3(0, 0, 0);
+    check(id3, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Id3 **************"));
+
+    vtkm::Scalar scalar = 0.0;
+    check(scalar, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Scalar ***********"));
+
+    vtkm::Vector2 vector2 = vtkm::make_Vector2(0.0, 0.0);
+    check(vector2, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Vector2 **********"));
+
+    vtkm::Vector3 vector3 = vtkm::make_Vector3(0.0, 0.0, 0.0);
+    check(vector3, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Vector3 **********"));
+
+    vtkm::Vector4 vector4 = vtkm::make_Vector4(0.0, 0.0, 0.0, 0.0);
+    check(vector4, InternalPrintOnInvoke<FunctionType>(
+            function, "*** vtkm::Vector4 **********"));
+  }
+  template<class FunctionType>
+  static void TryAllTypes(FunctionType function)
+  {
+    TryAllTypes(function, TypeCheckAlwaysTrue());
+  }
+
+};
+
+}
+} // namespace vtkm::internal
+
+/// Helper function to test two quanitites for equality accounting for slight
+/// variance due to floating point numerical inaccuracies.
+///
+template<typename VectorType>
+VTKM_EXEC_CONT_EXPORT bool test_equal(VectorType vector1,
+                                      VectorType vector2,
+                                      vtkm::Scalar tolerance = 0.0001)
+{
+  typedef typename vtkm::VectorTraits<VectorType> Traits;
+  for (int component = 0; component < Traits::NUM_COMPONENTS; component++)
+    {
+    vtkm::Scalar value1 = Traits::GetComponent(vector1, component);
+    vtkm::Scalar value2 = Traits::GetComponent(vector2, component);
+    if ((fabs(value1) < 2*tolerance) && (fabs(value2) < 2*tolerance))
+      {
+      continue;
+      }
+    vtkm::Scalar ratio = value1/value2;
+    if ((ratio > vtkm::Scalar(1.0) - tolerance)
+        && (ratio < vtkm::Scalar(1.0) + tolerance))
+      {
+      // This component is OK. The condition is checked in this way to
+      // correctly handle non-finites that fail all comparisons. Thus, if a
+      // non-finite is encountered, this condition will fail and false will be
+      // returned.
+      }
+    else
+      {
+      return false;
+      }
+    }
+  return true;
+}
+
+/// Helper function for printing out vectors during testing.
+///
+template<typename T, int Size>
+VTKM_EXEC_CONT_EXPORT
+std::ostream &operator<<(std::ostream &stream, const vtkm::Tuple<T,Size> &tuple)
+{
+  stream << "[";
+  for (int component = 0; component < Size-1; component++)
+    {
+    stream << tuple[component] << ",";
+    }
+  return stream << tuple[Size-1] << "]";
+}
+
+#endif //vtkm_testing_Testing_h

vtkm/testing/UnitTestTesting.cxx

+//============================================================================
+//  Copyright (c) Kitware, Inc.
+//  All rights reserved.
+//  See LICENSE.txt for details.
+//  This software is distributed WITHOUT ANY WARRANTY; without even
+//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+//  PURPOSE.  See the above copyright notice for more information.
+//
+//  Copyright 2014 Sandia Corporation.
+//  Copyright 2014 UT-Battelle, LLC.
+//  Copyright 2014. Los Alamos National Security
+//
+//  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
+//  the U.S. Government retains certain rights in this software.
+//
+//  Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
+//  Laboratory (LANL), the U.S. Government retains certain rights in
+//  this software.
+//============================================================================
+
+// This meta-test makes sure that the testing environment is properly reporting
+// errors.
+
+#include <vtkm/testing/Testing.h>
+
+namespace {
+
+void Fail()
+{
+  VTKM_TEST_FAIL("I expect this error.");
+}
+
+void BadAssert()
+{
+  VTKM_TEST_ASSERT(0 == 1, "I expect this error.");
+}
+
+void GoodAssert()
+{
+  VTKM_TEST_ASSERT(1 == 1, "Always true.");
+}
+
+void TestTestEqual()
+{
+  VTKM_TEST_ASSERT(test_equal(vtkm::Scalar(2.0), vtkm::Scalar(1.9999999)),
+                  "These should be close enough.");
+  VTKM_TEST_ASSERT(!test_equal(vtkm::Scalar(2.0), vtkm::Scalar(1.999)),
+                  "These should not be close enough.");
+}
+
+// All tests that should not raise a failure.
+void CleanTests()
+{
+  GoodAssert();
+  TestTestEqual();
+}
+
+} // anonymous namespace
+
+int UnitTestTesting(int, char *[])
+{
+  std::cout << "This call should fail." << std::endl;
+  if (vtkm::testing::Testing::Run(Fail) == 0)
+    {
+    std::cout << "Did not get expected fail!" << std::endl;
+    return 1;
+    }
+  std::cout << "This call should fail." << std::endl;
+  if (vtkm::testing::Testing::Run(BadAssert) == 0)
+    {
+    std::cout << "Did not get expected fail!" << std::endl;
+    return 1;
+    }