Merge branch 'leo/46-delta_aggr' into 'master'

Add test verifying delta aggregate support

See merge request eng/cov/gnatcoverage!236

Closes eng/cov/gnatcoverage!46

Author: leocreuse

testsuite/tests/Ada2022/delta_aggr/array/src/pkg.adb

@@ -0,0 +1,22 @@
+pragma Ada_2022;
+
+package body Pkg is
+
+   --------------------------
+   -- Copy_With_Abs_Update --
+   --------------------------
+
+   function Copy_With_Abs_Update
+     (Input     : Composite;
+      Item      : Item_Type;
+      Use_Cache : Boolean := False) return Composite
+   is
+      Elem : integer renames -- # st
+        Input (if Item = First then 1 else 2);  -- # comp_expr
+   begin
+      return  -- # st
+        [(if Use_Cache then Cached_Comp else Input) with delta  -- # base_expr_first
+         (if Item = First then 1 else 2) =>                     -- # comp_expr
+         (if Elem >= 0 then Elem else -Elem)];                  -- # value_expr_first
+   end Copy_With_Abs_Update;
+end Pkg;

testsuite/tests/Ada2022/delta_aggr/array/src/pkg.ads

@@ -0,0 +1,40 @@
+pragma Ada_2012;
+
+package Pkg is
+
+   type Item_Type is (First, Last);
+
+   type Composite is private;
+
+   Cached_Comp : constant Composite;
+
+   function Make (First, Last : Integer) return Composite;
+
+   function Eq (Comp : Composite; First, Last : Integer) return Boolean;
+
+   function Copy_With_Abs_Update
+     (Input     : Composite;
+      Item      : Item_Type;
+      Use_Cache : Boolean := False) return Composite;
+   --  Return a copy of Input or Cached_Comp depending on the value of
+   --  Use_Cache, with either the "First" or "Last" component being updated to
+   --  its absolute value.
+private
+   type Composite is array (1 .. 2) of Integer;
+
+   Cached_Comp : constant Composite := (0, 0);
+
+   ----------
+   -- Make --
+   ----------
+
+   function Make (First, Last : Integer) return Composite is ((First, Last));
+
+   --------
+   -- Eq --
+   --------
+
+   function Eq (Comp : Composite; First, Last : Integer) return Boolean is
+     (Comp (1) = First and then Comp (2) = Last);
+
+end Pkg;

testsuite/tests/Ada2022/delta_aggr/array/test.py

@@ -0,0 +1,11 @@
+"""
+Test the correct handling and instrumentation of array delta aggregates
+"""
+
+from SCOV.tc import TestCase
+from SCOV.tctl import CAT
+from SUITE.context import thistest
+
+
+TestCase(category=CAT.decision).run()
+thistest.result()

testsuite/tests/Ada2022/delta_aggr/record/src/pkg.adb

@@ -0,0 +1,30 @@
+pragma Ada_2022;
+
+package body Pkg is
+
+   --------------------------
+   -- Copy_With_Abs_Update --
+   --------------------------
+
+   function Copy_With_Abs_Update
+     (Input     : Composite;
+      Item      : Item_Type;
+      Use_Cache : Boolean := False) return Composite
+   is
+      Elem : constant integer := -- # st
+        (if Item = First then Input.First else Input.Last); -- # comp_expr
+   begin
+      --  We can't dynamically condition which component is used in a record
+      --  delta aggregate, so in order to emulate the behavior we need to
+      --  resort to two separate aggregates. This duplicates some decisions,
+      --  only one will be covered by the driver meant to exercise the
+      --  specific part of the aggregate.
+
+      return  -- # st
+        ((if Item = First                                              -- # comp_expr
+          then ((if Use_Cache then Cached_Comp else Input) with delta  -- # base_expr_first
+                First => (if Elem >= 0 then Elem else -Elem))          -- # value_expr_first
+          else ((if Use_Cache then Cached_Comp else Input) with delta  -- # base_expr_last
+                Last => (if Elem >= 0 then Elem else -Elem))));        -- # value_expr_last
+   end Copy_With_Abs_Update;
+end Pkg;

testsuite/tests/Ada2022/delta_aggr/record/src/pkg.ads

@@ -0,0 +1,43 @@
+pragma Ada_2012;
+
+package Pkg is
+
+   type Item_Type is (First, Last);
+
+   type Composite is private;
+
+   Cached_Comp : constant Composite;
+
+   function Make (First, Last : Integer) return Composite;
+
+   function Eq (Comp : Composite; First, Last : Integer) return Boolean;
+
+   function Copy_With_Abs_Update
+     (Input     : Composite;
+      Item      : Item_Type;
+      Use_Cache : Boolean := False) return Composite;
+   --  Return a copy of Input or Cached_Comp depending on the value of
+   --  Use_Cache, with either the "First" or "Last" component being updated to
+   --  its absolute value.
+private
+   type Composite is record
+      First : Integer;
+      Last  : Integer;
+   end record;
+
+   Cached_Comp : constant Composite := (0, 0);
+
+   ----------
+   -- Make --
+   ----------
+
+   function Make (First, Last : Integer) return Composite is ((First, Last));
+
+   --------
+   -- Eq --
+   --------
+
+   function Eq (Comp : Composite; First, Last : Integer) return Boolean is
+     (Comp.First = First and then Comp.Last = Last);
+
+end Pkg;

testsuite/tests/Ada2022/delta_aggr/record/test.py

@@ -0,0 +1,11 @@
+"""
+Test the correct handling and instrumentation of record delta aggregates
+"""
+
+from SCOV.tc import TestCase
+from SCOV.tctl import CAT
+from SUITE.context import thistest
+
+
+TestCase(category=CAT.decision).run()
+thistest.result()

testsuite/tests/Ada2022/delta_aggr/src/test_pkg_0.adb

@@ -0,0 +1,13 @@
+with Pkg; use Pkg;
+
+procedure Test_Pkg_0 is
+begin
+   null;
+end Test_Pkg_0;
+
+--# pkg.adb
+--
+-- /st/         l- ## s-
+-- /base_expr/  l- ## 0
+-- /comp_expr/  l- ## 0
+-- /value_expr/ l- ## 0

testsuite/tests/Ada2022/delta_aggr/src/test_pkg_base.adb

@@ -0,0 +1,19 @@
+with Pkg; use Pkg;
+
+with Support; use Support;
+
+procedure Test_Pkg_Base is
+   Comp : Composite := Cached_Comp;
+begin
+   Assert (Eq (Copy_With_Abs_Update (Comp, First, True), 0, 0));
+   Assert (Eq (Copy_With_Abs_Update (Comp, First, False), 0, 0));
+end Test_Pkg_Base;
+
+--# pkg.adb
+--
+-- /st/               l+ ## 0
+-- /base_expr_last/   l! ## d-
+-- /base_expr_first/  l+ ## 0
+-- /comp_expr/        l! ## dF-
+-- /value_expr_last/  l! ## d-
+-- /value_expr_first/ l! ## dF-

testsuite/tests/Ada2022/delta_aggr/src/test_pkg_comp.adb

@@ -0,0 +1,17 @@
+with Pkg; use Pkg;
+
+with Support; use Support;
+
+procedure Test_Pkg_Comp is
+   Comp : Composite := Cached_Comp;
+begin
+   Assert (Eq (Copy_With_Abs_Update (Comp, First, False), 0, 0));
+   Assert (Eq (Copy_With_Abs_Update (Comp, Last, False), 0, 0));
+end Test_Pkg_Comp;
+
+--# pkg.adb
+--
+-- /st/         l+ ## 0
+-- /base_expr/  l! ## dT-
+-- /comp_expr/  l+ ## 0
+-- /value_expr/ l! ## dF-

testsuite/tests/Ada2022/delta_aggr/src/test_pkg_full.adb

@@ -0,0 +1,24 @@
+with Pkg; use Pkg;
+
+with Support; use Support;
+
+procedure Test_Pkg_Full is
+   Comp : Composite := Cached_Comp;
+begin
+   Assert (Eq (Copy_With_Abs_Update (Comp, First, True), 0, 0));
+   Assert (Eq (Copy_With_Abs_Update (Comp, Last, True), 0, 0));
+   Assert (Eq (Copy_With_Abs_Update (Comp, First, False), 0, 0));
+   Assert (Eq (Copy_With_Abs_Update (Comp, Last, False), 0, 0));
+   Comp := Make (-1, 0);
+   Assert (Eq (Copy_With_Abs_Update (Comp, First, False), 1, 0));
+   Comp := Make (0, -1);
+   Assert (Eq (Copy_With_Abs_Update (Comp, Last, False), 0, 1));
+
+end Test_Pkg_Full;
+
+--# pkg.adb
+--
+-- /st/         l+ ## 0
+-- /base_expr/  l+ ## 0
+-- /comp_expr/  l+ ## 0
+-- /value_expr/ l+ ## 0