[Polly][unittest] Translate isl tests to C++ bindings

[grosser]

Summary

For this translation we introduce two functions, valFromAPInt and APIntFromVal,
to convert between isl::Val and APInt. For now these are just proxies, but in
the future they will replace the current isl_val* based conversion functions.

The isl unit test cases benefit most from the new isl::Bool (from Michael
Kruse), which can be explicitly casted to bool and which -- as part of this cast

• emits a check that no error condition has been triggered so far. This allows

us to simplify

EXPECT_EQ(isl_bool_true, isl_val_is_zero(IslZero));

to

EXPECT_TRUE(IslZero.is_zero());

This simplification also becomes very clear in operator==, which changes from

auto IsEqual = isl_set_is_equal(LHS.keep(), RHS.keep());
EXPECT_NE(isl_bool_error, IsEqual);
return IsEqual;

to just

return bool(LHS.is_equal(RHS));

Some background for non-isl users. The isl C interface has an isl_bool type,
which can be either true, false, or error. Hence, whenever a function returns
a value of type isl_bool, an explicit error check should be considered. By
using isl::Bool, we can just cast the isl::Bool to 'bool' or simply use the
isl::Bool in a context where it will automatically be casted to bool (e.g., in
an if-condition). When doing so, the C++ bindings automatically add code that
verifies that the return value is not an error code. If it is, the program will
warn about this and abort. For cases where errors are expected, isl::Bool
provides checks such as Bool::isTrueOrError() or Bool::isTrueNoError() to
explicitly control program behavior in case of error conditions.

Thanks to the new automatic memory management, we also can avoid many calls to
isl_*_free. For code that had previously been managed by IslPtr<>, many calls
to give/take/copy are eliminated.

[Meinersbur]

include/polly/Support/GICHelper.h

73–76 ↗

(On Diff #90612)

The function will look uncommented in Doxygen because it cannot associate the previous comment to both methods.

I don't really complain, just wondering whether our commenting policy is ok with this.

There is also [[http://www.stack.nl/~dimitri/doxygen/manual/commands.html#cmdoverload|\overload]]

unittests/Isl/IslTest.cpp

51 ↗

(On Diff #90612)

is_equal in D30616 already returns bool.

285–286 ↗

(On Diff #90612)

It would be nice to have something to replace this in the C++ binding, such as an owning isl_ctx.

303 ↗

(On Diff #90612)

Not a literal translation, but very nice.

[Meinersbur]

LGTM

polly/trunk/include/polly/Support/GICHelper.h

 /// @param Ctx      The isl_ctx to create the isl_val in.
 /// @param Int      The integer value to translate.
 /// @param IsSigned If the APInt should be interpreted as signed or unsigned
 ///                 value.
 ///
 /// @return The isl_val corresponding to @p Int.
 __isl_give isl_val *isl_valFromAPInt(isl_ctx *Ctx, const llvm::APInt Int,
                                      bool IsSigned);
+inline isl::val valFromAPInt(isl_ctx *Ctx, const llvm::APInt Int,
+                             bool IsSigned) {
+  return isl::manage(isl_valFromAPInt(Ctx, Int, IsSigned));
+}
 
 /// Translate isl_val to llvm::APInt.
 ///
 /// This function can only be called on isl_val values which are integers.
 /// Calling this function with a non-integral rational, NaN or infinity value
 /// is not allowed.
 ///
 /// As the input isl_val may be negative, the APInt that this function returns

 ///       3 ->    011         3         3
 ///      -4 ->    100        -4         3
 ///       4 ->   0100         4         4
 ///
 /// @param Val The isl val to translate.
 ///
 /// @return The APInt value corresponding to @p Val.
 llvm::APInt APIntFromVal(__isl_take isl_val *Val);
+inline llvm::APInt APIntFromVal(isl::val V) {
+  return APIntFromVal(V.release());
+}
 
 /// Get c++ string from Isl objects.
 //@{
 std::string stringFromIslObj(__isl_keep isl_map *map);
 std::string stringFromIslObj(__isl_keep isl_union_map *umap);
 std::string stringFromIslObj(__isl_keep isl_set *set);
 std::string stringFromIslObj(__isl_keep isl_union_set *uset);
 std::string stringFromIslObj(__isl_keep isl_schedule *schedule);

polly/trunk/unittests/Isl/IslTest.cpp

static isl::space parseSpace(isl_ctx *Ctx, const char *Str) {
   isl_stream_free(Stream);
   if (Obj.type)
     Obj.type->free(Obj.v);
   return Result;
 }
 
 #define SPACE(Str) parseSpace(Ctx.get(), Str)
 
-#define SET(Str) give(isl_set_read_from_str(Ctx.get(), Str))
-#define MAP(Str) give(isl_map_read_from_str(Ctx.get(), Str))
+#define SET(Str) isl::set(Ctx.get(), Str)
+#define MAP(Str) isl::map(Ctx.get(), Str)
 
-#define USET(Str) give(isl_union_set_read_from_str(Ctx.get(), Str))
-#define UMAP(Str) give(isl_union_map_read_from_str(Ctx.get(), Str))
+#define USET(Str) isl::union_set(Ctx.get(), Str)
+#define UMAP(Str) isl::union_map(Ctx.get(), Str)
 
 namespace isl {
 inline namespace noexceptions {
 
 static bool operator==(const isl::space &LHS, const isl::space &RHS) {
-  auto IsEqual = isl_space_is_equal(LHS.keep(), RHS.keep());
-  EXPECT_NE(isl_bool_error, IsEqual);
-  return IsEqual;
+  return bool(LHS.is_equal(RHS));
+}
+
+static bool operator==(const isl::basic_set &LHS, const isl::basic_set &RHS) {
+  return bool(LHS.is_equal(RHS));
 }
 
 static bool operator==(const isl::set &LHS, const isl::set &RHS) {
-  auto IsEqual = isl_set_is_equal(LHS.keep(), RHS.keep());
-  EXPECT_NE(isl_bool_error, IsEqual);
-  return IsEqual;
+  return bool(LHS.is_equal(RHS));
+}
+
+static bool operator==(const isl::basic_map &LHS, const isl::basic_map &RHS) {
+  return bool(LHS.is_equal(RHS));
 }
 
 static bool operator==(const isl::map &LHS, const isl::map &RHS) {
-  auto IsEqual = isl_map_is_equal(LHS.keep(), RHS.keep());
-  EXPECT_NE(isl_bool_error, IsEqual);
-  return IsEqual;
+  return bool(LHS.is_equal(RHS));
 }
 
 static bool operator==(const isl::union_set &LHS, const isl::union_set &RHS) {
-  auto IsEqual = isl_union_set_is_equal(LHS.keep(), RHS.keep());
-  EXPECT_NE(isl_bool_error, IsEqual);
-  return IsEqual;
+  return bool(LHS.is_equal(RHS));
 }
 
 static bool operator==(const isl::union_map &LHS, const isl::union_map &RHS) {
-  auto IsEqual = isl_union_map_is_equal(LHS.keep(), RHS.keep());
-  EXPECT_NE(isl_bool_error, IsEqual);
-  return IsEqual;
+  return bool(LHS.is_equal(RHS));
+}
+
+static bool operator==(const isl::val &LHS, const isl::val &RHS) {
+  return bool(LHS.eq(RHS));
 }
 } // namespace noexceptions
 } // namespace isl
 
 namespace {
 
 TEST(Isl, APIntToIslVal) {
   isl_ctx *IslCtx = isl_ctx_alloc();
 
   {
     APInt APZero(1, 0, true);
-    auto *IslZero = isl_valFromAPInt(IslCtx, APZero, true);
-    EXPECT_EQ(isl_bool_true, isl_val_is_zero(IslZero));
-    isl_val_free(IslZero);
+    auto IslZero = valFromAPInt(IslCtx, APZero, true);
+    EXPECT_TRUE(IslZero.is_zero());
   }
 
   {
     APInt APNOne(1, -1, true);
-    auto *IslNOne = isl_valFromAPInt(IslCtx, APNOne, true);
-    EXPECT_EQ(isl_bool_true, isl_val_is_negone(IslNOne));
-    isl_val_free(IslNOne);
+    auto IslNOne = valFromAPInt(IslCtx, APNOne, true);
+    EXPECT_TRUE(IslNOne.is_negone());
   }
 
   {
     APInt APZero(1, 0, false);
-    auto *IslZero = isl_valFromAPInt(IslCtx, APZero, false);
-    EXPECT_EQ(isl_bool_true, isl_val_is_zero(IslZero));
-    isl_val_free(IslZero);
+    auto IslZero = valFromAPInt(IslCtx, APZero, false);
+    EXPECT_TRUE(IslZero.is_zero());
   }
 
   {
     APInt APOne(1, 1, false);
-    auto *IslOne = isl_valFromAPInt(IslCtx, APOne, false);
-    EXPECT_EQ(isl_bool_true, isl_val_is_one(IslOne));
-    isl_val_free(IslOne);
+    auto IslOne = valFromAPInt(IslCtx, APOne, false);
+    EXPECT_TRUE(IslOne.is_one());
   }
 
   {
     APInt APNTwo(2, -2, true);
-    auto *IslNTwo = isl_valFromAPInt(IslCtx, APNTwo, true);
-    auto *IslNTwoCmp = isl_val_int_from_si(IslCtx, -2);
-    EXPECT_EQ(isl_bool_true, isl_val_eq(IslNTwo, IslNTwoCmp));
-    isl_val_free(IslNTwo);
-    isl_val_free(IslNTwoCmp);
+    auto IslNTwo = valFromAPInt(IslCtx, APNTwo, true);
+    auto IslNTwoCmp = isl::val(IslCtx, -2);
+    EXPECT_EQ(IslNTwo, IslNTwoCmp);
   }
 
   {
     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);
+    auto IslNOne = valFromAPInt(IslCtx, APNOne, true);
+    EXPECT_TRUE(IslNOne.is_negone());
   }
 
   {
     APInt APZero(32, 0, false);
-    auto *IslZero = isl_valFromAPInt(IslCtx, APZero, false);
-    EXPECT_EQ(isl_bool_true, isl_val_is_zero(IslZero));
-    isl_val_free(IslZero);
+    auto IslZero = valFromAPInt(IslCtx, APZero, false);
+    EXPECT_TRUE(IslZero.is_zero());
   }
 
   {
     APInt APOne(32, 1, false);
-    auto *IslOne = isl_valFromAPInt(IslCtx, APOne, false);
-    EXPECT_EQ(isl_bool_true, isl_val_is_one(IslOne));
-    isl_val_free(IslOne);
+    auto IslOne = valFromAPInt(IslCtx, APOne, false);
+    EXPECT_TRUE(IslOne.is_one());
   }
 
   {
     APInt APTwo(32, 2, false);
-    auto *IslTwo = isl_valFromAPInt(IslCtx, APTwo, false);
-    EXPECT_EQ(0, isl_val_cmp_si(IslTwo, 2));
-    isl_val_free(IslTwo);
+    auto IslTwo = valFromAPInt(IslCtx, APTwo, false);
+    EXPECT_EQ(0, IslTwo.cmp_si(2));
   }
 
   {
     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_bool_true, isl_val_eq(IslNOne, IslRef));
-    isl_val_free(IslNOne);
-    isl_val_free(IslRef);
+    auto IslNOne = valFromAPInt(IslCtx, APNOne, false);
+    auto IslRef = isl::val(IslCtx, (1ull << 32) - 1);
+    EXPECT_EQ(IslNOne, IslRef);
   }
 
   {
     APInt APLarge(130, 2, false);
     APLarge = APLarge.shl(70);
-    auto *IslLarge = isl_valFromAPInt(IslCtx, APLarge, false);
-    auto *IslRef = isl_val_int_from_ui(IslCtx, 71);
-    IslRef = isl_val_2exp(IslRef);
-    EXPECT_EQ(isl_bool_true, isl_val_eq(IslLarge, IslRef));
-    isl_val_free(IslLarge);
-    isl_val_free(IslRef);
+    auto IslLarge = valFromAPInt(IslCtx, APLarge, false);
+    auto IslRef = isl::val(IslCtx, 71);
+    IslRef = IslRef.two_exp();
+    EXPECT_EQ(IslLarge, IslRef);
   }
 
   isl_ctx_free(IslCtx);
 }
 
 TEST(Isl, IslValToAPInt) {
   isl_ctx *IslCtx = isl_ctx_alloc();
 
   {
-    auto *IslNOne = isl_val_int_from_si(IslCtx, -1);
+    auto IslNOne = isl::val(IslCtx, -1);
     auto APNOne = APIntFromVal(IslNOne);
     // Compare with the two's complement of -1 in a 1-bit integer.
     EXPECT_EQ(1, APNOne);
     EXPECT_EQ(1u, APNOne.getBitWidth());
   }
 
   {
-    auto *IslNTwo = isl_val_int_from_si(IslCtx, -2);
+    auto IslNTwo = isl::val(IslCtx, -2);
     auto APNTwo = APIntFromVal(IslNTwo);
     // Compare with the two's complement of -2 in a 2-bit integer.
     EXPECT_EQ(2, APNTwo);
     EXPECT_EQ(2u, APNTwo.getBitWidth());
   }
 
   {
-    auto *IslNThree = isl_val_int_from_si(IslCtx, -3);
+    auto IslNThree = isl::val(IslCtx, -3);
     auto APNThree = APIntFromVal(IslNThree);
     // Compare with the two's complement of -3 in a 3-bit integer.
     EXPECT_EQ(5, APNThree);
     EXPECT_EQ(3u, APNThree.getBitWidth());
   }
 
   {
-    auto *IslNFour = isl_val_int_from_si(IslCtx, -4);
+    auto IslNFour = isl::val(IslCtx, -4);
     auto APNFour = APIntFromVal(IslNFour);
     // Compare with the two's complement of -4 in a 3-bit integer.
     EXPECT_EQ(4, APNFour);
     EXPECT_EQ(3u, APNFour.getBitWidth());
   }
 
   {
-    auto *IslZero = isl_val_int_from_ui(IslCtx, 0);
+    auto IslZero = isl::val(IslCtx, 0);
     auto APZero = APIntFromVal(IslZero);
     EXPECT_EQ(0, APZero);
     EXPECT_EQ(1u, APZero.getBitWidth());
   }
 
   {
-    auto *IslOne = isl_val_int_from_ui(IslCtx, 1);
+    auto IslOne = isl::val(IslCtx, 1);
     auto APOne = APIntFromVal(IslOne);
     EXPECT_EQ(1, APOne);
     EXPECT_EQ(2u, APOne.getBitWidth());
   }
 
   {
-    auto *IslTwo = isl_val_int_from_ui(IslCtx, 2);
+    auto IslTwo = isl::val(IslCtx, 2);
     auto APTwo = APIntFromVal(IslTwo);
     EXPECT_EQ(2, APTwo);
     EXPECT_EQ(3u, APTwo.getBitWidth());
   }
 
   {
-    auto *IslThree = isl_val_int_from_ui(IslCtx, 3);
+    auto IslThree = isl::val(IslCtx, 3);
     auto APThree = APIntFromVal(IslThree);
     EXPECT_EQ(3, APThree);
     EXPECT_EQ(3u, APThree.getBitWidth());
   }
 
   {
-    auto *IslFour = isl_val_int_from_ui(IslCtx, 4);
+    auto IslFour = isl::val(IslCtx, 4);
     auto APFour = APIntFromVal(IslFour);
     EXPECT_EQ(4, APFour);
     EXPECT_EQ(4u, APFour.getBitWidth());
   }
 
   {
-    auto *IslNOne = isl_val_int_from_ui(IslCtx, (1ull << 32) - 1);
+    auto IslNOne = isl::val(IslCtx, (1ull << 32) - 1);
     auto APNOne = APIntFromVal(IslNOne);
     EXPECT_EQ((1ull << 32) - 1, APNOne);
     EXPECT_EQ(33u, APNOne.getBitWidth());
   }
 
   {
-    auto *IslLargeNum = isl_val_int_from_ui(IslCtx, 60);
-    IslLargeNum = isl_val_2exp(IslLargeNum);
-    IslLargeNum = isl_val_sub_ui(IslLargeNum, 1);
+    auto IslLargeNum = isl::val(IslCtx, 60);
+    IslLargeNum = IslLargeNum.two_exp();
+    IslLargeNum = IslLargeNum.sub_ui(1);
     auto APLargeNum = APIntFromVal(IslLargeNum);
     EXPECT_EQ((1ull << 60) - 1, APLargeNum);
     EXPECT_EQ(61u, APLargeNum.getBitWidth());
   }
 
   {
-    auto *IslExp = isl_val_int_from_ui(IslCtx, 500);
-    auto *IslLargePow2 = isl_val_2exp(IslExp);
+    auto IslExp = isl::val(IslCtx, 500);
+    auto IslLargePow2 = IslExp.two_exp();
     auto APLargePow2 = APIntFromVal(IslLargePow2);
     EXPECT_TRUE(APLargePow2.isPowerOf2());
     EXPECT_EQ(502u, APLargePow2.getBitWidth());
     EXPECT_EQ(502u, APLargePow2.getMinSignedBits());
   }
 
   {
-    auto *IslExp = isl_val_int_from_ui(IslCtx, 500);
-    auto *IslLargeNPow2 = isl_val_neg(isl_val_2exp(IslExp));
+    auto IslExp = isl::val(IslCtx, 500);
+    auto IslLargeNPow2 = IslExp.two_exp().neg();
     auto APLargeNPow2 = APIntFromVal(IslLargeNPow2);
     EXPECT_EQ(501u, APLargeNPow2.getBitWidth());
     EXPECT_EQ(501u, APLargeNPow2.getMinSignedBits());
     EXPECT_EQ(500, (-APLargeNPow2).exactLogBase2());
   }
 
   {
-    auto *IslExp = isl_val_int_from_ui(IslCtx, 512);
-    auto *IslLargePow2 = isl_val_2exp(IslExp);
+    auto IslExp = isl::val(IslCtx, 512);
+    auto IslLargePow2 = IslExp.two_exp();
     auto APLargePow2 = APIntFromVal(IslLargePow2);
     EXPECT_TRUE(APLargePow2.isPowerOf2());
     EXPECT_EQ(514u, APLargePow2.getBitWidth());
     EXPECT_EQ(514u, APLargePow2.getMinSignedBits());
   }
 
   {
-    auto *IslExp = isl_val_int_from_ui(IslCtx, 512);
-    auto *IslLargeNPow2 = isl_val_neg(isl_val_2exp(IslExp));
+    auto IslExp = isl::val(IslCtx, 512);
+    auto IslLargeNPow2 = IslExp.two_exp().neg();
     auto APLargeNPow2 = APIntFromVal(IslLargeNPow2);
     EXPECT_EQ(513u, APLargeNPow2.getBitWidth());
     EXPECT_EQ(513u, APLargeNPow2.getMinSignedBits());
     EXPECT_EQ(512, (-APLargeNPow2).exactLogBase2());
   }
 
   isl_ctx_free(IslCtx);
 }
 
 TEST(Isl, Foreach) {
   std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(),
                                                         &isl_ctx_free);
 
-  auto MapSpace = give(isl_space_alloc(Ctx.get(), 0, 1, 1));
-  auto TestBMap = give(isl_basic_map_universe(MapSpace.copy()));
-  TestBMap = give(isl_basic_map_fix_si(TestBMap.take(), isl_dim_in, 0, 0));
-  TestBMap = give(isl_basic_map_fix_si(TestBMap.take(), isl_dim_out, 0, 0));
-  auto TestMap = give(isl_map_from_basic_map(TestBMap.copy()));
-  auto TestUMap = give(isl_union_map_from_map(TestMap.copy()));
-
-  auto SetSpace = give(isl_space_set_alloc(Ctx.get(), 0, 1));
-  auto TestBSet =
-      give(isl_basic_set_from_point(isl_point_zero(SetSpace.copy())));
-  auto TestSet = give(isl_set_from_basic_set(TestBSet.copy()));
-  auto TestUSet = give(isl_union_set_from_set(TestSet.copy()));
+  auto MapSpace = isl::space(Ctx.get(), 0, 1, 1);
+  auto TestBMap = isl::basic_map::universe(MapSpace);
+  TestBMap = TestBMap.fix_si(isl::dim::out, 0, 0);
+  TestBMap = TestBMap.fix_si(isl::dim::out, 0, 0);
+  isl::map TestMap = TestBMap;
+  isl::union_map TestUMap = TestMap;
+
+  auto SetSpace = isl::space(Ctx.get(), 0, 1);
+  isl::basic_set TestBSet = isl::point(SetSpace);
+  isl::set TestSet = TestBSet;
+  isl::union_set TestUSet = TestSet;
 
   {
     auto NumBMaps = 0;
     foreachElt(TestMap, [&](isl::basic_map BMap) {
-      EXPECT_EQ(isl_bool_true,
-                isl_basic_map_is_equal(BMap.keep(), TestBMap.keep()));
+      EXPECT_EQ(BMap, TestBMap);
       NumBMaps++;
     });
     EXPECT_EQ(1, NumBMaps);
   }
 
   {
     auto NumBSets = 0;
     foreachElt(TestSet, [&](isl::basic_set BSet) {
-      EXPECT_EQ(isl_bool_true,
-                isl_basic_set_is_equal(BSet.keep(), TestBSet.keep()));
+      EXPECT_EQ(BSet, TestBSet);
       NumBSets++;
     });
     EXPECT_EQ(1, NumBSets);
   }
 
   {
     auto NumMaps = 0;
     foreachElt(TestUMap, [&](isl::map Map) {
-      EXPECT_EQ(isl_bool_true, isl_map_is_equal(Map.keep(), TestMap.keep()));
+      EXPECT_EQ(Map, TestMap);
       NumMaps++;
     });
     EXPECT_EQ(1, NumMaps);
   }
 
   {
     auto NumSets = 0;
     foreachElt(TestUSet, [&](isl::set Set) {
-      EXPECT_EQ(isl_bool_true, isl_set_is_equal(Set.keep(), TestSet.keep()));
+      EXPECT_EQ(Set, TestSet);
       NumSets++;
     });
     EXPECT_EQ(1, NumSets);
   }
 
   {
-    auto UPwAff = give(isl_union_pw_aff_val_on_domain(TestUSet.copy(),
-                                                      isl_val_zero(Ctx.get())));
+    auto UPwAff = isl::union_pw_aff(TestUSet, isl::val::zero(Ctx.get()));
     auto NumPwAffs = 0;
     foreachElt(UPwAff, [&](isl::pw_aff PwAff) {
-      EXPECT_EQ(isl_bool_true, isl_pw_aff_is_cst(PwAff.keep()));
+      EXPECT_TRUE(PwAff.is_cst());
       NumPwAffs++;
     });
     EXPECT_EQ(1, NumPwAffs);
   }
 
   {
     auto NumBMaps = 0;
     EXPECT_EQ(
         isl_stat_error,
         foreachEltWithBreak(TestMap, [&](isl::basic_map BMap) -> isl_stat {
-          EXPECT_EQ(isl_bool_true,
-                    isl_basic_map_is_equal(BMap.keep(), TestBMap.keep()));
+          EXPECT_EQ(BMap, TestBMap);
           NumBMaps++;
           return isl_stat_error;
         }));
     EXPECT_EQ(1, NumBMaps);
   }
 
   {
     auto NumMaps = 0;
     EXPECT_EQ(isl_stat_error,
               foreachEltWithBreak(TestUMap, [&](isl::map Map) -> isl_stat {
-                EXPECT_EQ(isl_bool_true,
-                          isl_map_is_equal(Map.keep(), TestMap.keep()));
+                EXPECT_EQ(Map, TestMap);
                 NumMaps++;
                 return isl_stat_error;
               }));
     EXPECT_EQ(1, NumMaps);
   }
 
   {
-    auto TestPwAff =
-        give(isl_pw_aff_val_on_domain(TestSet.copy(), isl_val_zero(Ctx.get())));
+    auto TestPwAff = isl::pw_aff(TestSet, isl::val::zero(Ctx.get()));
     auto NumPieces = 0;
-    foreachPieceWithBreak(
-        TestPwAff, [&](isl::set Domain, isl::aff Aff) -> isl_stat {
-          EXPECT_EQ(isl_bool_true,
-                    isl_set_is_equal(Domain.keep(), TestSet.keep()));
-          EXPECT_EQ(isl_bool_true, isl_aff_is_cst(Aff.keep()));
+    foreachPieceWithBreak(TestPwAff,
+                          [&](isl::set Domain, isl::aff Aff) -> isl_stat {
+                            EXPECT_EQ(Domain, TestSet);
+                            EXPECT_TRUE(Aff.is_cst());
                             NumPieces++;
                             return isl_stat_error;
                           });
     EXPECT_EQ(1, NumPieces);
   }
 }
 
 TEST(ISLTools, beforeScatter) {
   std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(),
                                                         &isl_ctx_free);