Subversion Repositories openrisc

-- C452001.A

--

--                             Grant of Unlimited Rights

--

--     Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,

--     F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained

--     unlimited rights in the software and documentation contained herein.

--     Unlimited rights are defined in DFAR 252.227-7013(a)(19).  By making

--     this public release, the Government intends to confer upon all

--     recipients unlimited rights  equal to those held by the Government.

--     These rights include rights to use, duplicate, release or disclose the

--     released technical data and computer software in whole or in part, in

--     any manner and for any purpose whatsoever, and to have or permit others

--     to do so.

--

--                                    DISCLAIMER

--

--     ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR

--     DISCLOSED ARE AS IS.  THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED

--     WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE

--     SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE

--     OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A

--     PARTICULAR PURPOSE OF SAID MATERIAL.

--*

--

-- OBJECTIVE:

--      For a type extension, check that predefined equality is defined in

--      terms of the primitive equals operator of the parent type and any

--      tagged components of the extension part.

--

--      For other composite types, check that the primitive equality operator

--      of any matching tagged components is used to determine equality of the

--      enclosing type.

--

--      For private types, check that predefined equality is defined in

--      terms of the user-defined (primitive) operator of the full type if

--      the full type is tagged. The partial view of the type may be

--      tagged or untagged. Check that predefined equality for a private

--      type whose full view is untagged is defined in terms of the

--      predefined equality operator of its full type.

--

-- TEST DESCRIPTION:

--      Tagged types are declared and used as components in several

--      differing composite type declarations, both tagged and untagged.

--      To differentiate between predefined and primitive equality

--      operations, user-defined equality operators are declared for

--      each component type that is to contribute to the equality

--      operator of the composite type that houses it. All user-defined

--      equality operations are designed to yield the opposite result

--      from the predefined operator, given the same component values.

--

--      For cases where primitive equality is to be incorporated into

--      equality for the enclosing composite type, values are assigned

--      to the component type so that user-defined equality will return

--      True. If predefined equality is to be used instead, then the

--      same strategy results in the equality operator returning False.

--

--      When equality for a type incorporates the user-defined equality

--      operator of one of its component types, the resulting operator

--      is considered to be the predefined operator of the composite type.

--      This case is confirmed by defining an tagged component of an

--      untagged composite type, then using the resulting untagged type

--      as a component of another composite type. The user-defined operator

--      for the lowest level should still be called.

--

--      Three cases are set up to test private types:

--

--                        Case 1        Case 2      Case 3

--         partial view:  tagged       untagged    untagged

--         full view:     tagged        tagged     untagged

--

--      Types are declared for each of the above cases and user-defined

--      (primitive) operators are declared following the full type

--      declaration of each type (i.e., in the private part).

--

--      Values are assigned into objects of these types using the same

--      strategy outlined above. Cases 1 and 2 should execute the

--      user-defined operator. Case 3 should ignore the user-defined

--      operator and user predefined equality for the type.

--

--

-- CHANGE HISTORY:

--      06 Dec 94   SAIC    ACVC 2.0

--      19 Dec 94   SAIC    Removed RM references from objective text.

--      15 Nov 95   SAIC    Fixed for 2.0.1

--      04 NOV 96   SAIC    Typographical revision

--

--!

package c452001_0 is

   type Point is

      record

         X : Integer := 0;

         Y : Integer := 0;

      end record;

   type Circle is tagged

      record

         Center : Point;

         Radius : Integer;

      end record;

   function "=" (L, R : Circle) return Boolean;

   type Colors is (Red, Orange, Yellow, Green, Blue, Purple, Black, White);

   type Colored_Circle is new Circle

      with record

         Color : Colors := White;

      end record;

   function "=" (L, R : Colored_Circle) return Boolean;

   -- Override predefined equality for this tagged type. Predefined

   -- equality should incorporate user-defined (primitive) equality

   -- from type Circle. See C340001 for a test of that feature.

   -- Equality is overridden to ensure that predefined equality

   -- incorporates this user-defined function for

   -- any composite type with Colored_Circle as a component type.

   -- (i.e., the type extension is recognized as a tagged type for

   -- the purpose of defining predefined equality for the composite type).

end C452001_0;

package body c452001_0 is

   function "=" (L, R : Circle) return Boolean is

   begin

      return L.Radius = R.Radius; -- circles are same size

   end "=";

   function "=" (L, R : Colored_Circle) return Boolean is

   begin

      return Circle(L) = Circle(R);

   end "=";

end C452001_0;

with C452001_0;

package C452001_1 is

   type Planet is tagged record

      Name : String (1..15);

      Representation : C452001_0.Colored_Circle;

   end record;

   -- Type Planet will be used to check that predefined equality

   -- for a tagged type with a tagged component incorporates

   -- user-defined equality for the component type.

   type TC_Planet is new Planet with null record;

   -- A "copy" of Planet. Used to create a type extension. An "="

   -- operator will be defined for this type that should be

   -- incorporated by the type extension.

   function "=" (Arg1, Arg2 : in TC_Planet) return Boolean;

   type Craters is array (1..3) of C452001_0.Colored_Circle;

   -- An array type (untagged) with tagged components

   type Moon is new TC_Planet

     with record

        Crater : Craters;

     end record;

   -- A tagged record type. Extended component type is untagged,

   -- but its predefined equality operator should incorporate

   -- the user-defined operator of its tagged component type.

end C452001_1;

package body C452001_1 is

   function "=" (Arg1, Arg2 : in TC_Planet) return Boolean is

   begin

      return Arg1.Name = Arg2.Name;

   end "=";

end C452001_1;

package C452001_2 is

   -- Untagged record types

   -- Equality should not be incorporated

   type Spacecraft_Design is (Mariner, Pioneer, Viking, Voyager);

   type Spacecraft is record

     Design      : Spacecraft_Design;

     Operational : Boolean;

   end record;

   function "=" (L : in Spacecraft; R : in Spacecraft) return Boolean;

   type Mission is record

      Craft       : Spacecraft;

      Launch_Date : Natural;

   end record;

   type Inventory is array (Positive range <>) of Spacecraft;

end C452001_2;

package body C452001_2 is

   function "=" (L : in Spacecraft; R : in Spacecraft) return Boolean is

   begin

      return L.Design = R.Design;

   end "=";

end C452001_2;

package C452001_3 is

   type Tagged_Partial_Tagged_Full is tagged private;

   procedure Change (Object : in out Tagged_Partial_Tagged_Full;

                    Value  : in Boolean);

   type Untagged_Partial_Tagged_Full is private;

   procedure Change (Object : in out Untagged_Partial_Tagged_Full;

                    Value  : in Integer);

   type Untagged_Partial_Untagged_Full is private;

   procedure Change (Object : in out Untagged_Partial_Untagged_Full;

                    Value  : in Duration);

private

   type Tagged_Partial_Tagged_Full is

      tagged record

         B : Boolean := True;

         C : Character := ' ';

      end record;

   -- predefined equality checks that all components are equal

   function "=" (L, R : in Tagged_Partial_Tagged_Full) return Boolean;

   -- primitive equality checks that records equate in component C only

   type Untagged_Partial_Tagged_Full is

      tagged record

         I : Integer := 0;

         P : Positive := 1;

      end record;

   -- predefined equality checks that all components are equal

   function "=" (L, R : in Untagged_Partial_Tagged_Full) return Boolean;

   -- primitive equality checks that records equate in component P only

   type Untagged_Partial_Untagged_Full is

      record

         D : Duration := 0.0;

         S : String (1..12) := "Ada 9X rules";

      end record;

   -- predefined equality checks that all components are equal

   function "=" (L, R : in Untagged_Partial_Untagged_Full) return Boolean;

   -- primitive equality checks that records equate in component S only

end C452001_3;

with Report;

package body C452001_3 is

   procedure Change (Object : in out Tagged_Partial_Tagged_Full;

                    Value  : in Boolean) is

   begin

      Object := (Report.Ident_Bool(Value), Object.C);

   end Change;

   procedure Change (Object : in out Untagged_Partial_Tagged_Full;

                    Value  : in Integer) is

   begin

      Object := (Report.Ident_Int(Value), Object.P);

   end Change;

   procedure Change (Object : in out Untagged_Partial_Untagged_Full;

                    Value  : in Duration) is

   begin

      Object := (Value, Report.Ident_Str(Object.S));

   end Change;

   function "=" (L, R : in Tagged_Partial_Tagged_Full) return Boolean is

   begin

      return L.C = R.C;

   end "=";

   function "=" (L, R : in Untagged_Partial_Tagged_Full) return Boolean is

   begin

      return L.P = R.P;

   end "=";

   function "=" (L, R : in Untagged_Partial_Untagged_Full) return Boolean is

   begin

      return R.S = L.S;

   end "=";

end C452001_3;

with C452001_0;

with C452001_1;

with C452001_2;

with C452001_3;

with Report;

procedure C452001 is

   Mars_Aphelion : C452001_1.Planet :=

      (Name           => "Mars           ",

       Representation => (Center => (Report.Ident_Int(20),

                                     Report.Ident_Int(0)),

                          Radius => Report.Ident_Int(4),

                          Color  => C452001_0.Red));

   Mars_Perihelion : C452001_1.Planet :=

      (Name           => "Mars           ",

       Representation => (Center => (Report.Ident_Int(-20),

                                     Report.Ident_Int(0)),

                          Radius => Report.Ident_Int(4),

                          Color  => C452001_0.Red));

   -- Mars_Perihelion = Mars_Aphelion if user-defined equality from

   -- the tagged type Colored_Circle was incorporated into

   -- predefined equality for the tagged type Planet. User-defined

   -- equality for Colored_Circle checks only that the Radii are equal.

   Blue_Mars : C452001_1.Planet :=

      (Name           => "Mars           ",

       Representation => (Center => (Report.Ident_Int(10),

                                     Report.Ident_Int(10)),

                          Radius => Report.Ident_Int(4),

                          Color  => C452001_0.Blue));

   -- Blue_Mars should equal Mars_Perihelion, because Names and

   -- Radii are equal (all other components are not).

   Green_Mars : C452001_1.Planet :=

      (Name           => "Mars           ",

       Representation => (Center => (Report.Ident_Int(10),

                                     Report.Ident_Int(10)),

                          Radius => Report.Ident_Int(4),

                          Color  => C452001_0.Green));

   -- Blue_Mars should equal Green_Mars. They differ only in the

   -- Color component. All user-defined equality operations return

   -- True, but records are not equal by predefined equality.

   -- Blue_Mars should equal Mars_Perihelion, because Names and

   -- Radii are equal (all other components are not).

   Moon_Craters : C452001_1.Craters :=

      ((Center => (Report.Ident_Int(9), Report.Ident_Int(11)),

        Radius => Report.Ident_Int(1),

        Color  => C452001_0.Black),

       (Center => (Report.Ident_Int(10), Report.Ident_Int(10)),

        Radius => Report.Ident_Int(1),

        Color  => C452001_0.Black),

       (Center => (Report.Ident_Int(11), Report.Ident_Int(9)),

        Radius => Report.Ident_Int(1),

        Color  => C452001_0.Black));

   Alternate_Moon_Craters : C452001_1.Craters :=

      ((Center => (Report.Ident_Int(9), Report.Ident_Int(9)),

        Radius => Report.Ident_Int(1),

        Color  => C452001_0.Yellow),

       (Center => (Report.Ident_Int(10), Report.Ident_Int(10)),

        Radius => Report.Ident_Int(1),

        Color  => C452001_0.Purple),

       (Center => (Report.Ident_Int(11), Report.Ident_Int(11)),

        Radius => Report.Ident_Int(1),

        Color  => C452001_0.Purple));

   -- Moon_Craters = Alternate_Moon_Craters if user-defined equality from

   -- the tagged type Colored_Circle was incorporated into

   -- predefined equality for the untagged type Craters. User-defined

   -- equality checks only that the Radii are equal.

   New_Moon : C452001_1.Moon :=

      (Name           => "Moon           ",

       Representation => (Center => (Report.Ident_Int(10),

                                     Report.Ident_Int(8)),

                          Radius => Report.Ident_Int(3),

                          Color  => C452001_0.Black),

       Crater         => Moon_Craters);

   Full_Moon : C452001_1.Moon :=

      (Name           => "Moon           ",

       Representation => (Center => (Report.Ident_Int(10),

                                     Report.Ident_Int(8)),

                          Radius => Report.Ident_Int(3),

                          Color  => C452001_0.Black),

       Crater         => Alternate_Moon_Craters);

   -- New_Moon = Full_Moon if user-defined equality from

   -- the tagged type Colored_Circle was incorporated into

   -- predefined equality for the untagged type Craters. This

   -- equality test should call user-defined equality for type

   -- TC_Planet (checks that Names are equal), then predefined

   -- equality for Craters (ultimately calls user-defined equality

   -- for type Circle, checking that Radii of craters are equal).

   Mars_Moon : C452001_1.Moon :=

      (Name           => "Phobos         ",

       Representation => (Center => (Report.Ident_Int(10),

                                     Report.Ident_Int(8)),

                          Radius => Report.Ident_Int(3),

                          Color  => C452001_0.Black),

       Crater         => Alternate_Moon_Craters);

   -- Mars_Moon /= Full_Moon since the Names differ.

   Alternate_Moon_Craters_2 : C452001_1.Craters :=

      ((Center => (Report.Ident_Int(10), Report.Ident_Int(10)),

        Radius => Report.Ident_Int(1),

        Color  => C452001_0.Red),

       (Center => (Report.Ident_Int(9), Report.Ident_Int(9)),

        Radius => Report.Ident_Int(1),

        Color  => C452001_0.Red),

       (Center => (Report.Ident_Int(10), Report.Ident_Int(9)),

        Radius => Report.Ident_Int(1),

        Color  => C452001_0.Red));

   Harvest_Moon : C452001_1.Moon :=

      (Name           => "Moon           ",

       Representation => (Center => (Report.Ident_Int(11),

                                     Report.Ident_Int(7)),

                          Radius => Report.Ident_Int(4),

                          Color  => C452001_0.Orange),

       Crater         => Alternate_Moon_Craters_2);

   -- Only the fields that are employed by the user-defined equality

   -- operators are the same. Everything else differs. Equality should

   -- still return True.

   Viking_1_Orbiter : C452001_2.Mission :=

      (Craft => (Design      => C452001_2.Viking,

                 Operational => Report.Ident_Bool(False)),

       Launch_Date => 1975);

   Viking_1_Lander : C452001_2.Mission :=

      (Craft => (Design      => C452001_2.Viking,

                 Operational => Report.Ident_Bool(True)),

       Launch_Date => 1975);

   -- Viking_1_Orbiter /= Viking_1_Lander if predefined equality

   -- from the untagged type Spacecraft is used for equality

   -- of matching components in type Mission. If user-defined

   -- equality for type Spacecraft is incorporated, which it

   -- should not be by 4.5.2(21), then Viking_1_Orbiter = Viking_1_Lander.

   Voyagers : C452001_2.Inventory (1..2):=

    ((C452001_2.Voyager, Operational => Report.Ident_Bool(True)),

     (C452001_2.Voyager, Operational => Report.Ident_Bool(False)));

   Jupiter_Craft : C452001_2.Inventory (1..2):=

    ((C452001_2.Voyager, Operational => Report.Ident_Bool(True)),

     (C452001_2.Voyager, Operational => Report.Ident_Bool(True)));

   -- Voyagers /= Jupiter_Craft if predefined equality

   -- from the untagged type Spacecraft is used for equality

   -- of matching components in type Inventory. If user-defined

   -- equality for type Spacecraft is incorporated, which it

   -- should not be by 4.5.2(21), then Voyagers = Jupiter_Craft.

   TPTF_1 : C452001_3.Tagged_Partial_Tagged_Full;

   TPTF_2 : C452001_3.Tagged_Partial_Tagged_Full;

   -- With differing values for Boolean component, user-defined

   -- (primitive) equality returns True, predefined equality

   -- returns False. Since full type is tagged, primitive equality

   -- should be used.

   UPTF_1 : C452001_3.Untagged_Partial_Tagged_Full;

   UPTF_2 : C452001_3.Untagged_Partial_Tagged_Full;

   -- With differing values for Boolean component, user-defined

   -- (primitive) equality returns True, predefined equality

   -- returns False. Since full type is tagged, primitive equality

   -- should be used.

   UPUF_1 : C452001_3.Untagged_Partial_Untagged_Full;

   UPUF_2 : C452001_3.Untagged_Partial_Untagged_Full;

   -- With differing values for Duration component, user-defined

   -- (primitive) equality returns True, predefined equality

   -- returns False. Since full type is untagged, predefined equality

   -- should be used.

   -- Use type clauses make "=" and "/=" operators directly visible

   use type C452001_1.Planet;

   use type C452001_1.Craters;

   use type C452001_1.Moon;

   use type C452001_2.Mission;

   use type C452001_2.Inventory;

   use type C452001_3.Tagged_Partial_Tagged_Full;

   use type C452001_3.Untagged_Partial_Tagged_Full;

   use type C452001_3.Untagged_Partial_Untagged_Full;

begin

   Report.Test ("C452001", "Equality of private types and " &

                           "composite types with tagged components");

   -------------------------------------------------------------------

   -- Tagged type with tagged component.

   -------------------------------------------------------------------

   if not (Mars_Aphelion = Mars_Perihelion) then

      Report.Failed ("User-defined equality for tagged component " &

                     "was not incorporated into predefined equality " &

                     "for enclosing tagged record type");

   end if;

   if Mars_Aphelion /= Mars_Perihelion then

      Report.Failed ("User-defined equality for tagged component " &

                     "was not incorporated into predefined inequality " &

                     "for enclosing tagged record type");

   end if;

   if not (Blue_Mars = Mars_Perihelion) then

      Report.Failed ("Equality test for tagged record type " &

                     "incorporates record components " &

                     "other than those used by user-defined equality");

   end if;

   if Blue_Mars /= Mars_Perihelion then

      Report.Failed ("Inequality test for tagged record type " &

                     "incorporates record components " &

                     "other than those used by user-defined equality");

   end if;

   if Blue_Mars /= Green_Mars then

      Report.Failed ("Records are unequal even though they only differ " &

                     "in a component not used by user-defined equality");

   end if;

   if not (Blue_Mars = Green_Mars) then

      Report.Failed ("Records are not equal even though they only differ " &

                     "in a component not used by user-defined equality");

   end if;

   -------------------------------------------------------------------

   -- Untagged (array) type with tagged component.

   -------------------------------------------------------------------

   if not (Moon_Craters = Alternate_Moon_Craters) then

      Report.Failed ("User-defined equality for tagged component " &

                     "was not incorporated into predefined equality " &

                     "for enclosing array type");

   end if;

   if Moon_Craters /= Alternate_Moon_Craters then

      Report.Failed ("User-defined equality for tagged component " &

                     "was not incorporated into predefined inequality " &

                     "for enclosing array type");

   end if;

   -------------------------------------------------------------------

   -- Tagged type with untagged composite component. Untagged

   -- component itself has tagged components.

   -------------------------------------------------------------------

   if not (New_Moon = Full_Moon) then

      Report.Failed ("User-defined equality for tagged component " &

                     "was not incorporated into predefined equality " &

                     "for array component of tagged record type");

   end if;

   if New_Moon /= Full_Moon then

      Report.Failed ("User-defined equality for tagged component " &

                     "was not incorporated into predefined inequality " &

                     "for array component of tagged record type");

   end if;

   if Mars_Moon = Full_Moon then

      Report.Failed ("User-defined equality for tagged component " &

                     "was not incorporated into predefined equality " &

                     "for array component of tagged record type");

   end if;

   if not (Mars_Moon /= Full_Moon) then

      Report.Failed ("User-defined equality for tagged component " &

                     "was not incorporated into predefined inequality " &

                     "for array component of tagged record type");

   end if;

   if not (Harvest_Moon = Full_Moon) then

      Report.Failed ("Equality test for record with array of tagged " &

                     "components incorporates record components " &

                     "other than those used by user-defined equality");

   end if;

   if Harvest_Moon /= Full_Moon then

      Report.Failed ("Inequality test for record with array of tagged " &

                     "components incorporates record components " &

                     "other than those used by user-defined equality");

   end if;

   -------------------------------------------------------------------

   -- Untagged types with no tagged components.

   -------------------------------------------------------------------

   -- Record type

   if Viking_1_Orbiter = Viking_1_Lander then

      Report.Failed ("User-defined equality for untagged composite " &

                     "component was incorporated into predefined " &

                     "equality for " &

                     "untagged record type");

   end if;

   if not (Viking_1_Orbiter /= Viking_1_Lander) then

      Report.Failed ("User-defined equality for untagged composite " &

                     "component was incorporated into predefined " &

                     "inequality for " &

                     "untagged record type");

   end if;

   -- Array type

   if Voyagers = Jupiter_Craft then

      Report.Failed ("User-defined equality for untagged composite " &

                     "component was incorporated into predefined " &

                     "equality for " &

                     "array type");

   end if;

   if not (Voyagers /= Jupiter_Craft) then

      Report.Failed ("User-defined equality for untagged composite " &

                     "component was incorporated into predefined " &

                     "inequality for " &

                     "array type");

   end if;

   -------------------------------------------------------------------

   -- Private types tests.

   -------------------------------------------------------------------

   -- Make objects differ from one another

   C452001_3.Change (TPTF_1, False);

   C452001_3.Change (UPTF_1, 999);

   C452001_3.Change (UPUF_1, 40.0);

   -------------------------------------------------------------------

   -- Partial type and full type are tagged. (Full type must be tagged

   -- if partial type is tagged)

   -------------------------------------------------------------------

   if not (TPTF_1 = TPTF_2) then

      Report.Failed ("Predefined equality for full type " &

                     "was used to determine equality of " &

                     "tagged private type " &

                     "instead of user-defined (primitive) equality");

   end if;

   if TPTF_1 /= TPTF_2 then

      Report.Failed ("Predefined equality for full type " &

                     "was used to determine inequality of " &

                     "tagged private type " &

                     "instead of user-defined (primitive) equality");

   end if;

   -------------------------------------------------------------------

   -- Partial type untagged, full type tagged.

   -------------------------------------------------------------------

   if not (UPTF_1 = UPTF_2) then

      Report.Failed ("Predefined equality for full type " &

                     "was used to determine equality of " &

                     "private type (untagged partial view, " &

                     "tagged full view) " &

                     "instead of user-defined (primitive) equality");

   end if;

   if UPTF_1 /= UPTF_2 then

      Report.Failed ("Predefined equality for full type " &

                     "was used to determine inequality of " &

                     "private type (untagged partial view, " &

                     "tagged full view) " &

                     "instead of user-defined (primitive) equality");

   end if;

   -------------------------------------------------------------------

   -- Partial type and full type are both untagged.

   -------------------------------------------------------------------

   if UPUF_1 = UPUF_2 then

      Report.Failed ("User-defined (primitive) equality for full type " &

                     "was used to determine equality of " &

                     "private type (untagged partial view, " &

                     "untagged full view) " &

                     "instead of predefined equality");

   end if;

   if not (UPUF_1 /= UPUF_2) then

      Report.Failed ("User-defined (primitive) equality for full type " &

                     "was used to determine inequality of " &

                     "private type (untagged partial view, " &

                     "untagged full view) " &

                     "instead of predefined equality");

   end if;

   -------------------------------------------------------------------

   Report.Result;

end C452001;