[Polly] Introduce unittests.

[Meinersbur]

Summary

Add the infrastructure for unittests to Polly and two simple tests for conversion between isl_val and APInt.

Clang's unittest mechanism served as as a blueprint which then was adapted to Polly.

In addition, a build target check-polly-unittests is added to run only the unittests but not the regression tests.

[Meinersbur]

Currently testing whether out-of-tree builds and non-assert builds work.

[grosser]

Very cool. I have been looking forward to this since a while!

CMakeLists.txt

208

Good idea to check formatting here as well.

unittests/Isl/IslTest.cpp

2

DeLICMTest.cpp - This seems to be a leftover?

28

​
22 ​ {
23 ​ APInt APNOne(32, -1, true);
24 ​ auto *IslNOne = isl_valFromAPInt(IslCtx, APNOne, false);

with 'false' in valFromAPInt might also be an interesting test case.

62

Very interesting observation. Do you have an idea why this is working today? Or does this indeed result in a bug that can be triggered externally?

[Meinersbur]

unittests/Isl/IslTest.cpp

28

I am not sure what the result even should be as the test was specifically designed to get negative one. Currently it returns '4294967295'. If this is the indented result, we should test

APInt APNOne(32, 4294967295, false);
auto *IslNOne = isl_valFromAPInt(IslCtx, APNOne, false);
EXPECT_EQ(isl_val_cmp_si(IslNOne , 4294967295), 0);

The APInt is equal to APInt(32, -1, true). The third argument only matters if first argument >64

62

I don't know.

[grosser]

unittests/Isl/IslTest.cpp

28

I wanted to test how negative one is converted if interpreted as unsigned in isl_valFromAPInt. 4294967295 is the answer I would expect. However, it is probably more readable if written as "1 << 32 - 1". As you noted APInt(32, 1 << 32 -1, false) should be equal to APInt(32, -1, true), so which of the two is used to construct the APInt probably does not matter.

If you agree such a test case is useful, I would it would be great if you could add it. Feel free to choose whichever constructor you prefer in APInt.

62

That's fair. We can work on this after the unit-test infrastructure is in place.

[Meinersbur]

Out-of-tree unit tests are not easy as it requires gtest from the LLVM source tree. Polly up to now only requires the LLVM_INSTALL_ROOT. llvm-config can be queried for the source dir, but then we need to compile gtest ourselves.

Clang has a different approach: It requires the source tree and broadly imports all cmake files such that it can use the LLVM functions to build the files.

[Meinersbur]

Fix lit.site.cfg.in configuration; support out-of-tree indepdendent builds.

[grosser]

Nice. Thank you for fixing the out-of-tree build. It seems there is just a minor problem with unnecessary executable flags on some files left. Otherwise, this looks good.g

test/Unit/lit.cfg

2

It seems these files have accidentally the +x flag set.

[Meinersbur]

test/Unit/lit.cfg

2

This is due to Lint running on a Windows filesystem which has no executable flags and therefore the flag is always set (otherwise one couldn't execute anything).

Git knows how to behave on Windows filesystems, so this won't be part of the commit.

CMakeLists.txt

if( NOT MSVC )
         if( LLVM_ENABLE_THREADS AND HAVE_LIBPTHREAD )
           set(system_libs ${system_libs} pthread)
         endif()
       endif( MINGW )
     endif( NOT MSVC )
     set(${return_var} ${system_libs} PARENT_SCOPE)
   endfunction(get_system_libs)
 
+  execute_process(COMMAND "${LLVM_INSTALL_ROOT}/bin/llvm-config" --libdir
+                  OUTPUT_VARIABLE LLVM_LIBRARY_DIR
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  link_directories("${LLVM_LIBRARY_DIR}")
+
   # Now set the header paths.
   execute_process(COMMAND "${LLVM_INSTALL_ROOT}/bin/llvm-config" --includedir
                   OUTPUT_VARIABLE LLVM_INCLUDE_DIR
                   OUTPUT_STRIP_TRAILING_WHITESPACE)
   include_directories( ${LLVM_INCLUDE_DIR} )
 
   # Get the TARGET_TRIPLE
   execute_process(COMMAND "${LLVM_INSTALL_ROOT}/bin/llvm-config" --host-target
if( NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "DEBUG" )
           CMAKE_C_FLAGS_RELWITHDEBINFO
           CMAKE_C_FLAGS_MINSIZEREL)
         string (REGEX REPLACE "(^| )[/-]D *NDEBUG($| )" " "
           "${flags_var_to_scrub}" "${${flags_var_to_scrub}}")
       endforeach()
     endif()
   endif()
 
+  # Sources available, too?
+  execute_process(COMMAND "${LLVM_INSTALL_ROOT}/bin/llvm-config" --src-root
+                  OUTPUT_VARIABLE MAIN_SRC_DIR
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  set(LLVM_SOURCE_ROOT ${MAIN_SRC_DIR} CACHE PATH "Path to LLVM source tree")
+
+  # Enable unit tests if available
+  set(UNITTEST_DIR ${LLVM_SOURCE_ROOT}/utils/unittest)
+  if(EXISTS ${UNITTEST_DIR}/googletest/include/gtest/gtest.h)  
+
+    add_library(gtest ${UNITTEST_DIR}/googletest/src/gtest-all.cc)
+    target_include_directories(gtest PUBLIC "${UNITTEST_DIR}/googletest/include" PRIVATE "${UNITTEST_DIR}/googletest")
+    if( NOT MSVC )
+      target_link_libraries(gtest pthread tinfo dl)
+    endif ()
+
+    add_library(gtest_main ${UNITTEST_DIR}/UnitTestMain/TestMain.cpp)
+    target_link_libraries(gtest_main gtest)
+
+    set(POLLY_GTEST_AVAIL 1)
+  endif()
+
   # Make sure the isl c files are built as fPIC
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
-endif(NOT DEFINED LLVM_MAIN_SRC_DIR)
+else ()
+  set(LLVM_SOURCE_ROOT "${LLVM_MAIN_SRC_DIR}")
+  set(POLLY_GTEST_AVAIL 1)
+endif ()
 
 set(POLLY_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 set(POLLY_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 # Add path for custom modules
 set(CMAKE_MODULE_PATH
   ${CMAKE_MODULE_PATH}
   "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
install(DIRECTORY ${POLLY_BINARY_DIR}/include/
     )
 endif()
 
 add_definitions( -D_GNU_SOURCE )
 
 add_subdirectory(docs)
 add_subdirectory(lib)
 add_subdirectory(test)
+if (POLLY_GTEST_AVAIL)
+  add_subdirectory(unittests)
+endif ()
 add_subdirectory(tools)
 # TODO: docs.
 
 
 configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/include/polly/Config/config.h.cmake
                 ${POLLY_BINARY_DIR}/include/polly/Config/config.h )
 
 # Add target to check formatting of polly files
-file( GLOB_RECURSE files *.h lib/*.cpp lib/*.c tools/*.cpp tools/*.c tools/*.h)
+file( GLOB_RECURSE files *.h lib/*.cpp lib/*.c tools/*.cpp tools/*.c tools/*.h unittests/*.cpp)
 file( GLOB_RECURSE jsonfiles lib/JSON/*.h lib/JSON/*.cpp)
 file( GLOB_RECURSE external lib/External/*.h lib/External/*.c)
 list( REMOVE_ITEM files ${jsonfiles} ${external})
 
 set(check_format_depends)
 set(update_format_depends)
 set(i 0)
 foreach (file IN LISTS files)

test/CMakeLists.txt

 set(LLVM_SHLIBEXT "${CMAKE_SHARED_MODULE_SUFFIX}")
 
 if (NOT DEFINED LLVM_MAIN_SRC_DIR)
 
   # We are building polly out of tree, adjust the settings.
   # FIXME: FileCheck is not available in llvm install directory at the moment.
   set(LLVM_LIT ${LLVM_INSTALL_ROOT}/bin/llvm-lit)
   set(POLLY_TEST_DEPS LLVMPolly)
+  if (POLLY_GTEST_AVAIL)
+    list(APPEND POLLY_TEST_DEPS PollyUnitTests)
+  endif ()
 
   set(LLVM_BINARY_DIR "${LLVM_INSTALL_ROOT}")
   set(LLVM_TOOLS_DIR "${LLVM_INSTALL_ROOT}/bin")
   set(LLVM_LIBS_DIR "${LLVM_INSTALL_ROOT}/lib")
   set(POLLY_LIB_DIR "${POLLY_BINARY_DIR}/lib")
 
   include(FindPythonInterp)
   if(PYTHONINTERP_FOUND)
     option(POLLY_TEST_DISABLE_BAR "Run Polly tests with --no-progress-bar" OFF)
     set(POLLY_TEST_EXTRA_ARGS)
     if (MSVC OR XCODE OR POLLY_TEST_DISABLE_BAR)
       set(POLLY_TEST_EXTRA_ARGS "--no-progress-bar")
     endif()
 
     option(POLLY_TEST_USE_VG "Run Polly tests under Valgrind" OFF)
     if(POLLY_TEST_USE_VG)
       set(POLLY_TEST_EXTRA_ARGS ${POLLY_TEST_EXTRA_ARGS} "--vg")
     endif ()
 
+    # Parameters required for lit.site.cfg.in
+    set(LLVM_SOURCE_DIR ${LLVM_SOURCE_ROOT})
+    if (CMAKE_CFG_INTDIR STREQUAL ".")
+      set(LLVM_BUILD_MODE ".")
+    else ()
+      set(LLVM_BUILD_MODE "%(build_mode)s")
+    endif ()
+    set(ENABLE_SHARED "1")
+    set(SHLIBDIR "${LLVM_BINARY_DIR}/bin")
+    set(LINK_POLLY_INTO_TOOLS "OFF")
+
     foreach(testdir ${POLLY_TEST_DIRECTORIES})
       add_custom_target(polly-test-${testdir}
         COMMAND ${LLVM_LIT}
                     --param polly_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
                     --param build_config=${CMAKE_CFG_INTDIR}
                     -sv ${POLLY_TEST_EXTRA_ARGS}
                     ${CMAKE_CURRENT_BINARY_DIR}/${testdir}
                     DEPENDS ${POLLY_TEST_DEPS}
                     COMMENT "Running Polly regression tests in ${testdir}")
       set_target_properties(polly-test-${testdir} PROPERTIES FOLDER "Polly")
     endforeach()
 
     add_custom_target(check-polly
       COMMAND ${LLVM_LIT}
                   --param polly_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+                  --param polly_unit_site_config=${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
                   --param build_config=${CMAKE_CFG_INTDIR}
                   -sv ${POLLY_TEST_EXTRA_ARGS}
                   ${CMAKE_CURRENT_BINARY_DIR}
                   DEPENDS ${POLLY_TEST_DEPS}
-                  COMMENT "Running Polly regression tests")
+                  COMMENT "Running Polly regression/unit tests")
     set_target_properties(check-polly PROPERTIES FOLDER "Polly")
+
+    configure_file(
+      ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+      ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
+
+    if (POLLY_GTEST_AVAIL)
+      add_custom_target(check-polly-unittests
+        COMMAND ${LLVM_LIT}
+                  --param polly_site_config=${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
+                  --param build_config=${CMAKE_CFG_INTDIR}
+                  -sv ${POLLY_TEST_EXTRA_ARGS}
+                  ${CMAKE_CURRENT_BINARY_DIR}/Unit
+                  DEPENDS PollyUnitTests
+                  COMMENT "Running Polly unit tests")
+      set_target_properties(check-polly-unittests PROPERTIES FOLDER "Polly")
+
+      configure_file(
+        ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
+        ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg)
+    endif ()
   endif()
 
 else (NOT DEFINED LLVM_MAIN_SRC_DIR)
 
   set(LLVM_LIT ${LLVM_TOOLS_BINARY_DIR}/llvm-lit)
   set(POLLY_TEST_DEPS llvm-config opt LLVMPolly FileCheck not)
+  if (POLLY_GTEST_AVAIL)
+    list(APPEND POLLY_TEST_DEPS PollyUnitTests)
+  endif ()
 
   set(LLVM_BINARY_DIR "${LLVM_BINARY_DIR}")
   set(LLVM_TOOLS_DIR "${LLVM_TOOLS_BINARY_DIR}")
   set(LLVM_LIBS_DIR "${LLVM_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX}")
   set(POLLY_LIB_DIR "${LLVM_LIBS_DIR}")
 
+  # Run regression and unit tests
   add_lit_testsuite(check-polly "Running polly regression tests"
     ${CMAKE_CURRENT_BINARY_DIR}
     PARAMS polly_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
+           polly_unit_site_config=${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
     DEPENDS ${POLLY_TEST_DEPS}
     )
-
   set_target_properties(check-polly PROPERTIES FOLDER "Polly")
 
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
+
+  if (POLLY_GTEST_AVAIL)
+    # Run only unit tests
+    add_lit_testsuite(check-polly-unittests "Running polly unit tests only"
+      ${CMAKE_CURRENT_BINARY_DIR}/Unit
+      PARAMS polly_site_config=${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
+      DEPENDS PollyUnitTests
+      )
+    set_target_properties(check-polly-unittests PROPERTIES FOLDER "Polly")
+
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/Unit/lit.site.cfg.in
+    ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg
+  )
+  
+  endif ()
+
   # Run polly-check-format as part of polly-check only if we are compiling with
   # clang, so clang-format is availbale.
   # if (TARGET clang-format) would be preferable, but this target is only added
   # after Polly, i.e. there is no such target yet at this point. The CMake cache
   # entry LLVM_TOOL_CLANG_BUILD will only be defined after clang has been
   # configured at least once, i.e. format will be checked only after a rerun of
   # CMake's configure.
   if (LLVM_TOOL_CLANG_BUILD)
     add_dependencies(check-polly polly-check-format)
   endif ()
 
 endif (NOT DEFINED LLVM_MAIN_SRC_DIR)
 
 configure_file(
-  ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
-  ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
-
-configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/update_check.py
   ${CMAKE_CURRENT_BINARY_DIR}/update_check.py)
 file(COPY ${CMAKE_CURRENT_BINARY_DIR}/update_check.py
   DESTINATION ${LLVM_TOOLS_DIR}
   FILE_PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ
   GROUP_EXECUTE WORLD_READ WORLD_EXECUTE)
 
 # Add a legacy target spelling: polly-test
 add_custom_target(polly-test)
 set_target_properties(polly-test PROPERTIES FOLDER "Polly")
 add_dependencies(polly-test check-polly)

test/Unit/lit.cfg

+# -*- Python -*-
+
+# Configuration file for the 'lit' test runner.
+
+import os
+import platform
+
+import lit.formats
+import lit.util
+
+# name: The name of this test suite.
+config.name = 'Polly-Unit'
+
+# suffixes: A list of file extensions to treat as test files.
+config.suffixes = []
+
+# test_source_root: The root path where tests are located.
+# test_exec_root: The root path where tests should be run.
+polly_obj_root = getattr(config, 'polly_obj_root', None)
+if polly_obj_root is not None:
+    config.test_exec_root = os.path.join(polly_obj_root, 'unittests')
+    config.test_source_root = config.test_exec_root
+
+# testFormat: The test format to use to interpret tests.
+llvm_build_mode = getattr(config, 'llvm_build_mode', "Debug")
+config.test_format = lit.formats.GoogleTest(llvm_build_mode, 'Tests')
+
+# Propagate the temp directory. Windows requires this because it uses \Windows\
+# if none of these are present.
+if 'TMP' in os.environ:
+    config.environment['TMP'] = os.environ['TMP']
+if 'TEMP' in os.environ:
+    config.environment['TEMP'] = os.environ['TEMP']
+
+# Propagate path to symbolizer for ASan/MSan.
+for symbolizer in ['ASAN_SYMBOLIZER_PATH', 'MSAN_SYMBOLIZER_PATH']:
+    if symbolizer in os.environ:
+        config.environment[symbolizer] = os.environ[symbolizer]
+
+###
+
+# Check that the object root is known.
+if config.test_exec_root is None:
+    # Otherwise, we haven't loaded the site specific configuration (the user is
+    # probably trying to run on a test file directly, and either the site
+    # configuration hasn't been created by the build system, or we are in an
+    # out-of-tree build situation).
+
+    # Check for 'polly_unit_site_config' user parameter, and use that if available.
+    site_cfg = lit_config.params.get('polly_unit_site_config', None)
+    if site_cfg and os.path.exists(site_cfg):
+        lit_config.load_config(config, site_cfg)
+        raise SystemExit
+
+    # Try to detect the situation where we are using an out-of-tree build by
+    # looking for 'llvm-config'.
+    #
+    # FIXME: I debated (i.e., wrote and threw away) adding logic to
+    # automagically generate the lit.site.cfg if we are in some kind of fresh
+    # build situation. This means knowing how to invoke the build system
+    # though, and I decided it was too much magic.
+
+    llvm_config = lit.util.which('llvm-config', config.environment['PATH'])
+    if not llvm_config:
+        lit_config.fatal('No site specific configuration available!')
+
+    # Get the source and object roots.
+    llvm_src_root = lit.util.capture(['llvm-config', '--src-root']).strip()
+    llvm_obj_root = lit.util.capture(['llvm-config', '--obj-root']).strip()
+    polly_src_root = os.path.join(llvm_src_root, "tools", "polly")
+    polly_obj_root = os.path.join(llvm_obj_root, "tools", "polly")
+
+    # Validate that we got a tree which points to here, using the standard
+    # tools/clang layout.
+    this_src_root = os.path.join(os.path.dirname(__file__),'..','..')
+    if os.path.realpath(polly_src_root) != os.path.realpath(this_src_root):
+        lit_config.fatal('No site specific configuration available!')
+
+    # Check that the site specific configuration exists.
+    site_cfg = os.path.join(polly_obj_root, 'test', 'Unit', 'lit.site.cfg')
+    if not os.path.exists(site_cfg):
+        lit_config.fatal('No site specific configuration available!')
+
+    # Okay, that worked. Notify the user of the automagic, and reconfigure.
+    lit_config.note('using out-of-tree build at %r' % polly_obj_root)
+    lit_config.load_config(config, site_cfg)
+    raise SystemExit
+
+shlibpath_var = ''
+if platform.system() == 'Linux':
+    shlibpath_var = 'LD_LIBRARY_PATH'
+elif platform.system() == 'Darwin':
+    shlibpath_var = 'DYLD_LIBRARY_PATH'
+elif platform.system() == 'Windows':
+    shlibpath_var = 'PATH'
+
+# Point the dynamic loader at dynamic libraries in 'lib'.
+llvm_libs_dir = getattr(config, 'llvm_libs_dir', None)
+if not llvm_libs_dir:
+    lit_config.fatal('No LLVM libs dir set!')
+shlibpath = os.path.pathsep.join((llvm_libs_dir,
+                                 config.environment.get(shlibpath_var,'')))
+
+# Win32 seeks DLLs along %PATH%.
+if sys.platform in ['win32', 'cygwin'] and os.path.isdir(config.shlibdir):
+    shlibpath = os.path.pathsep.join((config.shlibdir, shlibpath))
+
+config.environment[shlibpath_var] = shlibpath

test/Unit/lit.site.cfg.in

+@LIT_SITE_CFG_IN_HEADER@
+
+import sys
+
+config.llvm_src_root = "@LLVM_SOURCE_DIR@"
+config.llvm_obj_root = "@LLVM_BINARY_DIR@"
+config.llvm_tools_dir = "@LLVM_TOOLS_DIR@"
+config.llvm_libs_dir = "@LLVM_LIBS_DIR@"
+config.llvm_build_mode = "@LLVM_BUILD_MODE@"
+config.polly_obj_root = "@POLLY_BINARY_DIR@"
+config.polly_lib_dir = "@POLLY_LIB_DIR@"
+config.enable_shared = @ENABLE_SHARED@
+config.shlibdir = "@SHLIBDIR@"
+config.target_triple = "@TARGET_TRIPLE@"
+config.enable_gpgpu_codegen = "@GPU_CODEGEN@"
+config.link_polly_into_tools = "@LINK_POLLY_INTO_TOOLS@"
+
+# Support substitution of the tools_dir, libs_dirs, and build_mode with user
+# parameters. This is used when we can't determine the tool dir at
+# configuration time.
+try:
+    config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
+    config.llvm_libs_dir = config.llvm_libs_dir % lit_config.params
+    config.llvm_build_mode = config.llvm_build_mode % lit_config.params
+except KeyError:
+    e = sys.exc_info()[1]
+    key, = e.args
+    lit_config.fatal("unable to find %r parameter, use '--param=%s=VALUE'" % (key,key))
+
+# Let the main config do the real work.
+lit_config.load_config(config, "@POLLY_SOURCE_DIR@/test/Unit/lit.cfg")

unittests/CMakeLists.txt

+add_custom_target(PollyUnitTests)
+set_target_properties(PollyUnitTests PROPERTIES FOLDER "Polly")
+
+# add_polly_unittest(test_dirname file1.cpp file2.cpp)
+#
+# Will compile the list of files together and link against Polly and its dependences.
+function(add_polly_unittest test_name)
+  if(COMMAND add_unittest)
+    add_unittest(PollyUnitTests ${test_name} ${ARGN})
+  else()
+    add_executable(${test_name} ${ARGN})
+    set_target_properties(${test_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}})
+
+    target_link_libraries(${test_name} gtest_main gtest)
+    add_dependencies(PollyUnitTests ${test_name})
+
+    set_property(TARGET ${test_name} PROPERTY FOLDER "Polly")
+  endif()
+  target_link_libraries(${test_name} Polly LLVMCore LLVMSupport)
+endfunction()
+
+add_subdirectory(Isl)

unittests/Isl/CMakeLists.txt

+add_polly_unittest(IslTests
+  IslTest.cpp
+  )

unittests/Isl/IslTest.cpp

+//===- IslTest.cpp ----------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "polly/Support/GICHelper.h"
+#include "gtest/gtest.h"
+#include "isl/val.h"
+
+using namespace llvm;
+using namespace polly;
+
+namespace {
+
+TEST(Isl, APIntToIslVal) {
+  isl_ctx *IslCtx = isl_ctx_alloc();
+
+  {
+    APInt APNOne(32, -1, true);
+    auto *IslNOne = isl_valFromAPInt(IslCtx, APNOne, true);
+    EXPECT_EQ(isl_bool_true, isl_val_is_negone(IslNOne));
+    isl_val_free(IslNOne);
+  }
+
+  {
+    APInt APZero(32, 0, false);
+    auto *IslZero = isl_valFromAPInt(IslCtx, APZero, false);
+    EXPECT_EQ(isl_val_is_zero(IslZero), isl_bool_true);
+    isl_val_free(IslZero);
+  }
+
+  {
+    APInt APOne(32, 1, false);
+    auto *IslOne = isl_valFromAPInt(IslCtx, APOne, false);
+    EXPECT_EQ(isl_val_is_one(IslOne), isl_bool_true);
+    isl_val_free(IslOne);
+  }
+
+  {
+    APInt APTwo(32, 2, false);
+    auto *IslTwo = isl_valFromAPInt(IslCtx, APTwo, false);
+    EXPECT_EQ(isl_val_cmp_si(IslTwo, 2), 0);
+    isl_val_free(IslTwo);
+  }
+
+  {
+    APInt APNOne(32, (1ull << 32) - 1, false);
+    auto *IslNOne = isl_valFromAPInt(IslCtx, APNOne, false);
+    auto *IslRef = isl_val_int_from_ui(IslCtx, (1ull << 32) - 1);
+    EXPECT_EQ(isl_val_eq(IslNOne, IslRef), isl_bool_true);
+    isl_val_free(IslNOne);
+    isl_val_free(IslRef);
+  }
+
+  isl_ctx_free(IslCtx);
+}
+
+TEST(Isl, IslValToAPInt) {
+  isl_ctx *IslCtx = isl_ctx_alloc();
+
+  {
+    auto *IslNOne = isl_val_int_from_si(IslCtx, -1);
+    auto APNOne = APIntFromVal(IslNOne);
+    // APInt has no sign bit, so never equals to a negative number.
+    // FIXME: The canonical representation of a negative APInt is two's
+    // complement.
+    EXPECT_EQ(APNOne, 1);
+  }
+
+  {
+    auto *IslZero = isl_val_int_from_ui(IslCtx, 0);
+    auto APZero = APIntFromVal(IslZero);
+    EXPECT_EQ(APZero, 0);
+  }
+
+  {
+    auto *IslOne = isl_val_int_from_ui(IslCtx, 1);
+    auto APOne = APIntFromVal(IslOne);
+    EXPECT_EQ(APOne, 1);
+  }
+
+  {
+    auto *IslTwo = isl_val_int_from_ui(IslCtx, 2);
+    auto APTwo = APIntFromVal(IslTwo);
+    EXPECT_EQ(APTwo, 2);
+  }
+
+  {
+    auto *IslNOne = isl_val_int_from_ui(IslCtx, (1ull << 32) - 1);
+    auto APNOne = APIntFromVal(IslNOne);
+    EXPECT_EQ(APNOne, (1ull << 32) - 1);
+  }
+
+  isl_ctx_free(IslCtx);
+}
+
+} // anonymous namespace