CVS difference for acats/b4/b457004.a

Differences between 1.1 and version 1.2
Log of other versions for file acats/b4/b457004.a

--- acats/b4/b457004.a	2016/05/12 02:23:59	1.1
+++ acats/b4/b457004.a	2017/12/14 02:48:09	1.2
@@ -45,10 +45,21 @@
 -- TEST DESCRIPTION:
 --     This test checks cases involving objects, ranges, and subtypes. Cases
 --     involving predicates are found in B457001.
+--
+--     For most case expression errors, we allow the error to be reported
+--     anywhere in the case expression, in order to allow the maximum
+--     flexibility for error handling. (Locating errors at the start, end, or
+--     on a particular label all may make sense for a particular
+--     implementation; it is not the job of the ACATS to emphasize one location
+--     over another.) The ERROR tag is found at the end of the case expression
+--     in this case, but the location indicator allows the entire case
+--     expression.
 
 -- CHANGE HISTORY:
 --      02 Jan 2015   RLB   Created test from predicate version (B457001).
 --      13 Mar 2015   RLB   Eliminate overlong lines.
+--      12 Dec 2017   RLB   Corrected two test errors and added location
+--                          indicators.
 --
 --!
 
@@ -98,49 +109,53 @@
    procedure Full_Coverage_1 (X : Integer; Y : Colors; Z : Score_Base) is
       -- Check 3.8.1(10.1/4) using 5.4(9/3) and 5.4(10) via 4.5.7(19/3).
    begin
-      Sink (case X is                            -- OK.
+      Sink (case X is
              when Zero => False,
-             when Negative | Positive => True);
-      Sink (case X is                            -- ERROR: Missing 0.
+             when Negative | Positive => True);  -- OK. {2:12;1}
+      Sink (case X is
              when Negative => False,
-             when Positive => True);
-      Sink (case X is                            -- ERROR: Missing negatives.
+             when Positive => True);             -- ERROR: Missing 0. {2:12;1}
+      Sink (case X is
              when Zero => False,
-             when Positive => True);
-      Sink (case X is                            -- ERROR: 1 specified twice.
+             when Positive => True);             -- ERROR: Missing  {2:12;1}
+                                                 --        negative values.
+      Sink (case X is
              when Negative | Positive => False,
-             when 0 | 1 => True);
-
-      Sink (case Y is                            -- OK.
+             when 0 | 1 => True);                -- ERROR: 1  {2:12;1}
+                                                 --        appears twice.
+      Sink (case Y is
              when White | Black => False,
-             when Rainbow => True);
-      Sink (case Y is                            -- ERROR: Missing Black.
+             when Rainbow => True);              -- OK.  {2:12;1}
+      Sink (case Y is
              when Warm_Color | Cool_Color => True,
-             when White => False);
-      Sink (case Y is                            -- ERROR: Red, Orange,
-                                                 --    Yellow specified twice.
+             when White => False);               -- ERROR: Missing  {2:12;1}
+                                                 --        Black.
+      Sink (case Y is
              when Warm_Color => False,
              when Rainbow => True,
-             when White | Black => False);
-      Sink (case Y is                            -- ERROR: Missing Orange.
+             when White | Black => False);       -- ERROR: Red,  {3:12;1}
+                                                 --    Orange, Yellow
+                                                 --    specified twice.
+      Sink (case Y is
              when Red | Yellow => False,
              when Cool_Color => True,
              when Black => False,
-             when White => False);
+             when White => False);               -- ERROR: Missing  {4:12;1}
+                                                 --        Orange.
 
-      Sink (case Z is                            -- ERROR: Many overlapping
-                                                 --             scores.
+      Sink (case Z is
              when Single => False,
              when Double => False,
              when Treble => False,
-             when others => True);
-      Sink (case Z is                            -- OK.
+             when others => True);               -- ERROR: Many  {4:12;1}
+                                                 --        overlapping scores.
+      Sink (case Z is
              when Single => False,
-             when 0 | 21 .. 63 => True);
-      Sink (case Z is                            -- ERROR: 21 missing.
+             when 0 | 21 .. 63 => True);         -- OK.  {2:12;1}
+      Sink (case Z is
              when Single => False,
              when Double_Only => False,
-             when 0 | 41 .. 63 => True);
+             when 0 | 41 .. 63 => True);         -- ERROR: 21 missing.{3:12;1}
    end Full_Coverage_1;
 
 
@@ -150,39 +165,41 @@
       -- Check 5.4(7/4) via 4.5.7(19/3), all of the values of the case
       -- selecting expression must be covered.
    begin
-      Sink (case X is                            -- OK.
+      Sink (case X is
              when 11 | 12 | 14 | 16 => False,
              when 13 | 15 | 17 | 19 => False,
-             when 18 | 20 => True);
-      Sink (case X is                            -- ERROR: 15, 17, and 20
-                                                 --             missing.
+             when 18 | 20 => True);              -- OK. {3:12;1}
+      Sink (case X is
              when 16 | 19 => False,
-             when 11 .. 14 | 18 => True);
-
-      Sink (case Y is                            -- ERROR: Indigo missing.
+             when 11 .. 14 | 18 => True);        -- ERROR: 15, 17,  {2:12;1}
+                                                 --        and 20 missing.
+      Sink (case Y is
              when Blue => False,
              when Green => False,
              when Violet => False,
-             when Warm_Color => True);
-      Sink (case Y is                            -- ERROR: Orange missing.
+             when Warm_Color => True);           -- ERROR: Indigo  {4:12;1}
+                                                 --        missing.
+      Sink (case Y is
              when Cool_Color => False,
              when Red => True,
-             when Yellow => True);
-      Sink (case Y is                            -- ERROR: Green missing.
+             when Yellow => True);               -- ERROR: Orange  {3:12;1}
+                                                 --        missing.
+      Sink (case Y is
              when Red .. Yellow => False,
-             when Blue .. Violet => True);
-
-      Sink (case Z is                            -- OK.
+             when Blue .. Violet => True);       -- ERROR: Green  {2:12;1}
+                                                 --        missing.
+      Sink (case Z is
              when Treble_Only => True,
-             when 3 .. 20 => False);
-      Sink (case Z is                            -- ERROR: 4, 5, 7, 8 missing.
+             when 3 .. 20 => False);             -- OK.  {2:12;1}
+      Sink (case Z is
              when 3 | 6 | 9 => False,
              when Treble_Only => True,
-             when 10 .. 20 => False);
-      Sink (case Z is                            -- ERROR: Values over 40
+             when 10 .. 20 => False);            -- ERROR: 4, 5, 7, 8 {3:12;1}
                                                  --        missing.
+      Sink (case Z is
              when 3 .. 21 => False,
-             when Double_Only => True);
+             when Double_Only => True);          -- ERROR: Values   {2:12;1}
+                                                 --        over 40 missing.
    end Full_Coverage_2;
 
 
@@ -192,63 +209,64 @@
       -- Check 5.4(7/4), no extra values outside of the subtype of the
       -- the case selecting expression.
    begin
-      Sink (case X is                            -- OK.
+      Sink (case X is
              when 0 .. 9 => False,
-             when 10 => True);
+             when 10 => True);                   -- OK.  {2:12;1}
       Sink (case X is
-             when 0 .. 7 | 9 => True,            -- ERROR: 16 not in Small_Low.
-             when 8 | 16 => False);
+             when 0 .. 7 | 9 => True,
+             when 8 | 16 => False);              -- ERROR: 16 not in  {19;11}
+                                                 --        Small_Low.
       Sink (case X is
              when 0 .. 4 => True,
-             when 5 .. 12 => False);             -- ERROR: 11, 12 not in
-                                                 --     Small_Low.
+             when 5 .. 12 => False);             -- ERROR: 11, 12    {19;11}
+                                                 --     not in Small_Low.
       Sink (case X is
-             when Small_High => False,           -- ERROR: Many not allowed
-                                                 --     values.
+             when Small_High => False,           -- ERROR: Many not {19;10}
+                                                 --     not allowed values.
              when others => True);
       Sink (case X is
-             when 1 | 2 | 4 | 8 => True,         -- OK.
+             when 1 | 2 | 4 | 8 => True,         -- OK. {19;9}
              when others => False);
 
-      Sink (case Y is                            -- OK.
+      Sink (case Y is
              when Yellow => True,
              when Orange => False,
-             when Red => False);
+             when Red => False);                 -- OK.   {3:12;1}
       Sink (case Y is
              when Yellow => False,
              when Orange => False,
              when Red => False,
-             when Green => True,                 -- ERROR: Not a warm color.
-             when others => False);
+             when Green => True,                 -- ERROR: Not a warm  {19;9}
+             when others => False);              --        color.
       Sink (case Y is
-             when Warm_Color => False);          -- OK.
+             when Warm_Color => False);          -- OK.  {19;11}
       Sink (case Y is
-             when Orange .. Green => False,      -- ERROR: Green not a warm
-                                                 --        color.
+             when Orange .. Green => False,      -- ERROR: Green not a  {19;10}
+                                                 --        warm color.
              when Red => False);
       Sink (case Y is
-             when Red .. Blue => False,          -- ERROR: Blue & Green not a
-                                                 --        primary color.
+             when Red .. Blue => False,          -- ERROR: Blue & Green {19;10}
+                                                 --        not a primary color.
              when others => False);
       Sink (case Y is
              when Yellow .. Red => False,
-             when Rainbow => True);              -- ERROR: Not all warm colors.
-
+             when Rainbow => True);              -- ERROR: Not all  {19;10}
+                                                 --        warm colors.
       Sink (case Z is
-             when Single => False,               -- ERROR: 1 not double.
-             when Double_Only => False,
+             when Single => False,               -- ERROR: 1 not   {19;10}
+             when Double_Only => False,          --        double.
              when others => True);
       Sink (case Z is
-             when 25 | 50 => True,               -- ERROR: 50 not double.
-             when 30 .. 40 => False,
+             when 25 | 50 => True,               -- ERROR: 50 not  {19;9}
+             when 30 .. 40 => False,             --        double.
              when others => False);
       Sink (case Z is
-             when 2 .. 40 => True,               -- OK.
+             when 2 .. 40 => True,               -- OK.  {19;9}
              when others => False);
       Sink (case Z is
              when 2 => True,
-             when Treble => False,               -- ERROR: 41 .. 60 not double.
-             when others => False);
+             when Treble => False,               -- ERROR: 41 .. 60 not {19;10}
+             when others => False);              --        double.
    end No_Extra_Values;
 
 
@@ -257,43 +275,43 @@
       -- for the case of dynamic subtypes.
    begin
       Sink (case X is
-             when Dyn_Low => True,               -- ERROR: Not static.
+             when Dyn_Low => True,               -- ERROR: Not static.  {19;9}
              when others => False);
       Sink (case Small_Low'(X) is
-             when Dyn_Low_Half  => True,         -- ERROR: Not static.
+             when Dyn_Low_Half  => True,         -- ERROR: Not static.  {19;10}
              when 6 .. 10       => False);
       Sink (case Small_Low'(X) is
-             when 7 .. Dyn_Ten => True,          -- ERROR: Not static.
+             when 7 .. Dyn_Ten => True,          -- ERROR: Not static.  {19;9}
              when 0 | 1 .. 6   => False);
 
       Sink (case Y is
              when White | Black => False,
-             when Dyn_Rainbow => True);          -- ERROR: Not static.
+             when Dyn_Rainbow => True);          -- ERROR: Not static.  {19;10}
       Sink (case Y is
              when White | Black => False,
-             when Dyn_Warm    => True,           -- ERROR: Not static.
+             when Dyn_Warm    => True,           -- ERROR: Not static.  {19;12}
              when Cool_Color  => False);
       Sink (case Y is
              when White | Black => False,
-             when Green .. V    => True,         -- ERROR: Not static.
+             when Green .. V    => True,         -- ERROR: Not static.  {19;12}
              when Warm_Color    => False);
       Sink (case Y is
              when White | Black   => False,
-             when Green .. Indigo => True,       -- ERROR: Not static.
-             when V               => True,       -- ERROR: Not static.
+             when Green .. Indigo => True,
+             when V               => True,       -- ERROR: Not static.  {19;23}
              when Warm_Color      => False);
 
       Sink (case Z is
-             when Dyn_Not_Single => False,       -- ERROR: Not static.
+             when Dyn_Not_Single => False,       -- ERROR: Not static.  {19;10}
              when others => True);
       Sink (case Z is
-             when 0 .. Single_Highest => True,   -- ERROR: Not static.
+             when 0 .. Single_High => True,      -- ERROR: Not static.  {19;9}
              when Treble_Only => False,
              when others => False);
       Sink (case Z is
              when Single => True,
              when 0 | Treble_Only => False,
-             when Highest+1 | 62 | 63 => False); -- ERROR: Not static.
+             when Highest+1 | 62 | 63 => False); -- ERROR: Not static.  {19;11}
    end Non_Static;
 
 begin

Questions? Ask the ACAA Technical Agent