Add test for container aggregates and generalized array aggregates

The test for container aggregates does nothing useful, in a convoluted
way simply for the sake of introducing decisions in the expressions of
the keys of the aggregates. The test also fails as Libadalang doesn't
support the `[use Key_Expression]` syntax as of yet, so gnatcov fails to
instrument the source file.

Author: leocreuse

testsuite/tests/Ada2022/aggregates/arrays/src/pkg.adb

@@ -0,0 +1,20 @@
+pragma Ada_2022;
+
+package body Pkg is
+
+   function Absolute (Input : Int_Arr) return Int_Arr is
+   begin
+      if Input = [] then  -- # empty_aggr_guard
+         return [];  -- # empty_aggr_st
+      elsif Input'Length = 1 then  -- # single_elt_guard
+         return                                                 -- # single_elt_st
+           [(declare Elt : Integer renames Input (Input'First); -- # single_elt_st
+             begin (if Elt > 0 then Elt else -Elt))];           -- # single_elt_dc
+      else
+         return [for Idx in Input'Range =>  -- # multi_elt_st
+                   (declare Elt : Integer renames Input (Idx) ; -- # multi_elt_st
+                    begin (if Elt > 0 then Elt else -Elt))];   -- # multi_elt_dc
+      end if;
+   end Absolute;
+
+end Pkg;

testsuite/tests/Ada2022/aggregates/arrays/src/pkg.ads

@@ -0,0 +1,7 @@
+package Pkg is
+
+   type Int_Arr is array (Positive range <>) of Integer;
+
+   function Absolute (Input : Int_Arr) return Int_Arr;
+
+end Pkg;

testsuite/tests/Ada2022/aggregates/arrays/src/test_0.adb

@@ -0,0 +1,16 @@
+with Pkg; use Pkg;
+
+procedure Test_0 is
+begin
+   null;
+end Test_0;
+
+--# pkg.adb
+--
+-- /empty_aggr_guard/ l- ## s-
+-- /empty_aggr_st/    l- ## s-
+-- /single_elt_guard/ l- ## s-
+-- /single_elt_st/    l- ## s-
+-- /single_elt_dc/    l- ## 0
+-- /multi_elt_st/     l- ## s-
+-- /multi_elt_dc/     l- ## 0

testsuite/tests/Ada2022/aggregates/arrays/src/test_empty.adb

@@ -0,0 +1,20 @@
+pragma Ada_2022;
+
+with Pkg; use Pkg;
+
+with Support; use Support;
+
+procedure Test_Empty is
+begin
+   Assert (Absolute ([]) = []);
+end Test_Empty;
+
+--# pkg.adb
+--
+-- /empty_aggr_guard/ l! ## dF-
+-- /empty_aggr_st/    l+ ## 0
+-- /single_elt_guard/ l- ## s-
+-- /single_elt_st/    l- ## s-
+-- /single_elt_dc/    l- ## 0
+-- /multi_elt_st/     l- ## s-
+-- /multi_elt_dc/     l- ## 0

testsuite/tests/Ada2022/aggregates/arrays/src/test_full.adb

@@ -0,0 +1,23 @@
+pragma Ada_2022;
+
+with Pkg; use Pkg;
+
+with Support; use Support;
+
+procedure Test_Full is
+begin
+   Assert (Absolute ([]) = []);
+   Assert (Absolute ([9]) = [9]);
+   Assert (Absolute ([-8]) = [8]);
+   Assert (Absolute ([-3, 2]) = [3, 2]);
+end Test_Full;
+
+--# pkg.adb
+--
+-- /empty_aggr_guard/ l+ ## 0
+-- /empty_aggr_st/    l+ ## 0
+-- /single_elt_guard/ l+ ## 0
+-- /single_elt_st/    l+ ## 0
+-- /single_elt_dc/    l+ ## 0
+-- /multi_elt_st/     l+ ## 0
+-- /multi_elt_dc/     l+ ## 0

testsuite/tests/Ada2022/aggregates/arrays/src/test_multi.adb

@@ -0,0 +1,20 @@
+pragma Ada_2022;
+
+with Pkg; use Pkg;
+
+with Support; use Support;
+
+procedure Test_Multi is
+begin
+   Assert (Absolute ([9, 4]) = [9, 4]);
+end Test_Multi;
+
+--# pkg.adb
+--
+-- /empty_aggr_guard/ l! ## dT-
+-- /empty_aggr_st/    l- ## s-
+-- /single_elt_guard/ l! ## dT-
+-- /single_elt_st/    l- ## s-
+-- /single_elt_dc/    l- ## 0
+-- /multi_elt_st/     l+ ## 0
+-- /multi_elt_dc/     l! ## dF-

testsuite/tests/Ada2022/aggregates/arrays/src/test_single.adb

@@ -0,0 +1,20 @@
+pragma Ada_2022;
+
+with Pkg; use Pkg;
+
+with Support; use Support;
+
+procedure Test_Single is
+begin
+   Assert (Absolute ([9]) = [9]);
+end Test_Single;
+
+--# pkg.adb
+--
+-- /empty_aggr_guard/ l! ## dT-
+-- /empty_aggr_st/    l- ## s-
+-- /single_elt_guard/ l! ## dF-
+-- /single_elt_st/    l+ ## 0
+-- /single_elt_dc/    l! ## dF-
+-- /multi_elt_st/     l- ## s-
+-- /multi_elt_dc/     l- ## 0

testsuite/tests/Ada2022/aggregates/arrays/tc.rst

@@ -0,0 +1,17 @@
+** DC for decisions nested in generalized array aggregates **
+
+Check proper handling and decision coverage computing for decisions nested in
+generalized array aggregates. Pkg implements a function presenting three forms
+of generalized array aggregates, i.e. a positional empty aggregate, a single
+element positional aggregate and a iterated component association aggregate.
+
+The test drivers are articulated as follows:
+ - Test_0 ensures only statement violations are reported when the
+ function is not called,
+ - Test_Empty ensures that decision coverage can be computed on a decision
+ containing an empty generalized array aggregate,
+ - Test_Single ensures that decisions nested within a single element positional
+ aggregate are correctly processed,
+ - Test_Multi ensures that decisions nested within iterated component
+ associations in a generalized array aggregate are properly processed.
+ - Test_Full ensures all the above can be covered simultaneously.

testsuite/tests/Ada2022/aggregates/arrays/test.py

@@ -0,0 +1,13 @@
+"""
+Test correct support for generalized array aggregates, including iterated
+component associations.
+"""
+
+
+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/aggregates/containers/src/check.adb

@@ -0,0 +1,19 @@
+pragma Ada_2022;
+
+with Ada.Containers; use Ada.Containers;
+
+with Pkg; use Pkg;
+
+with Support; use Support;
+
+procedure Check (Input : Int_Set) is
+   use Int_Maps;
+   Res : constant Int_Map := Overly_Complex_Identity_Build (Input);
+begin
+   Assert (Input.Length = Res.Length);
+   Assert ((for all Val of Input =>
+               (declare Cur : constant Cursor := Res.Find (Val);
+               begin Has_Element (Cur)
+                     and then Key (Cur) = Val
+                     and then Element (Cur) = Val)));
+end Check;