Natools

Artifact [2173fb67d0]
Login

Artifact 2173fb67d0778b85ac6ef841fdfd2d687008b9aa:


------------------------------------------------------------------------------
-- Copyright (c) 2011, Natacha Porté                                        --
--                                                                          --
-- Permission to use, copy, modify, and distribute this software for any    --
-- purpose with or without fee is hereby granted, provided that the above   --
-- copyright notice and this permission notice appear in all copies.        --
--                                                                          --
-- THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES --
-- WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF         --
-- MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR  --
-- ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   --
-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN    --
-- ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF  --
-- OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.           --
------------------------------------------------------------------------------

with Ada.Characters.Handling;
with Ada.Characters.Latin_1;
with Ada.Exceptions;
with Ada.Strings;        use Ada.Strings;

procedure Natools.Chunked_Strings.Tests.CXA4030
  (Report : in out Natools.Tests.Reporter'Class)
is
   package NT renames Natools.Tests;
begin
   NT.Section (Report, "Port of ACATS CXA4030");

   declare
      package L1 renames Ada.Characters.Latin_1;

      New_Character_String : Chunked_String
        := To_Chunked_String (L1.LC_A_Grave          & L1.LC_A_Ring
                            & L1.LC_AE_Diphthong     & L1.LC_C_Cedilla
                            & L1.LC_E_Acute          & L1.LC_I_Circumflex
                            & L1.LC_Icelandic_Eth    & L1.LC_N_Tilde
                            & L1.LC_O_Oblique_Stroke & L1.LC_Icelandic_Thorn);

      TC_New_Character_String : constant Chunked_String
        := To_Chunked_String (L1.UC_A_Grave          & L1.UC_A_Ring
                            & L1.UC_AE_Diphthong     & L1.UC_C_Cedilla
                            & L1.UC_E_Acute          & L1.UC_I_Circumflex
                            & L1.UC_Icelandic_Eth    & L1.UC_N_Tilde
                            & L1.UC_O_Oblique_Stroke & L1.UC_Icelandic_Thorn);
      Map_To_Lower_Case_Ptr : constant Maps.Character_Mapping_Function
        := Ada.Characters.Handling.To_Lower'Access;
      Map_To_Upper_Case_Ptr : constant Maps.Character_Mapping_Function
        := Ada.Characters.Handling.To_Upper'Access;
   begin
      NT.Section (Report, "Function Index, Forward direction");
      declare
         Name : constant String := "Mixed case mapped to lower";
      begin
         Test (Report, Name,
               Index (Source  => To_Chunked_String
                                   ("The library package Strings.Unbounded"),
                      Pattern => "unb",
                      Going   => Ada.Strings.Forward,
                      Mapping => Map_To_Lower_Case_Ptr),
               29);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to lower";
      begin
         Test (Report, Name,
               Index (To_Chunked_String
                        ("THE RAIN IN SPAIN FALLS MAINLY ON THE PLAIN"),
                      "ain",
                      Mapping => Map_To_Lower_Case_Ptr),
               6);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Lower case mapped to lower";
      begin
         Test (Report, Name,
               Index (To_Chunked_String ("maximum number"),
                      "um",
                      Ada.Strings.Forward,
                      Ada.Characters.Handling.To_Lower'Access),
               6);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Mixed case mapped to upper";
      begin
         Test (Report, Name,
               Index (To_Chunked_String ("CoMpLeTeLy MiXeD CaSe StRiNg"),
                      "MIXED CASE STRING",
                      Ada.Strings.Forward,
                      Map_To_Upper_Case_Ptr),
               12);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to lower (no match)";
      begin
         Test (Report, Name,
               Index (To_Chunked_String
                        ("STRING WITH NO MATCHING PATTERNS"),
                      "WITH",
                      Mapping => Map_To_Lower_Case_Ptr),
               0);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to upper";
      begin
         Test (Report, Name,
               Index (To_Chunked_String ("THIS STRING IS IN UPPER CASE"),
                      "IS",
                      Ada.Strings.Forward,
                      Ada.Characters.Handling.To_Upper'Access),
               3);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Null string";
      begin
         Test (Report, Name,
               Index (Null_Chunked_String,
                      "is",
                      Mapping => Map_To_Lower_Case_Ptr),
               0);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to lower";
      begin
         Test (Report, Name,
               Index (To_Chunked_String ("AAABBBaaabbb"),
                      "aabb",
                      Mapping => Ada.Characters.Handling.To_Lower'Access),
               2);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      NT.End_Section (Report);

      NT.Section (Report, "Function Index, Backward direction");

      declare
         Name : constant String := "Mixed case mapped to lower";
      begin
         Test (Report, Name,
               Index (To_Chunked_String ("Case of a Mixed Case String"),
                      "case",
                      Ada.Strings.Backward,
                      Map_To_Lower_Case_Ptr),
               17);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Mixed case mapped to upper";
      begin
         Test (Report, Name,
               Index (To_Chunked_String ("Case of a Mixed Case String"),
                      "CASE",
                      Ada.Strings.Backward,
                      Mapping => Map_To_Upper_Case_Ptr),
               17);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to lower";
      begin
         Test (Report, Name,
               Index (To_Chunked_String ("rain, Rain, and more RAIN"),
                      "rain",
                      Ada.Strings.Backward,
                      Ada.Characters.Handling.To_Lower'Access),
               22);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Lower case mapped to upper";
      begin
         Test (Report, Name,
               Index (To_Chunked_String ("RIGHT place, right time"),
                      "RIGHT",
                      Going   => Ada.Strings.Backward,
                      Mapping => Ada.Characters.Handling.To_Upper'Access),
               14);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to lower (no match)";
      begin
         Test (Report, Name,
               Index (To_Chunked_String ("WOULD MATCH BUT FOR THE CASE"),
                      "WOULD MATCH BUT FOR THE CASE",
                      Going   => Ada.Strings.Backward,
                      Mapping => Map_To_Lower_Case_Ptr),
               0);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      NT.End_Section (Report);


      declare
         Null_String : constant String := "";
         TC_Natural  : Natural := 1000;
      begin
         TC_Natural
           := Index (To_Chunked_String ("A Valid Chunked String"),
                     Null_String,
                     Going   => Ada.Strings.Forward,
                     Mapping => Ada.Characters.Handling.To_Lower'Access);
         NT.Item (Report, "Pattern_Error raised in Index", NT.Fail);
         NT.Info (Report, "No exception has been raised.");
         NT.Info (Report, "Return value: " & Natural'Image (TC_Natural));
      exception
         when Pattern_Error =>
            NT.Item (Report, "Pattern_Error raised in Index", NT.Success);
         when Error : others =>
            NT.Item (Report, "Pattern_Error raised in Index", NT.Fail);
            NT.Info (Report, "Wrong exception "
                             & Ada.Exceptions.Exception_Name (Error)
                             & "has been raised.");
      end;


      NT.Section (Report, "Function Count with mapping function");

      declare
         Name : constant String := "Upper case mapped to lower";
      begin
         Test (Report, Name,
               Count (Source  => To_Chunked_String ("ABABABA"),
                      Pattern => "aba",
                      Mapping => Map_To_Lower_Case_Ptr),
               2);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to lower (no match)";
      begin
         Test (Report, Name,
               Count (To_Chunked_String ("ABABABA"),
                      "ABA",
                      Mapping => Map_To_Lower_Case_Ptr),
               0);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Mixed case mapped to lower";
      begin
         Test (Report, Name,
               Count (To_Chunked_String ("This IS a MISmatched issue"),
                      "is",
                      Ada.Characters.Handling.To_Lower'Access),
               4);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to upper";
      begin
         Test (Report, Name,
               Count (To_Chunked_String ("ABABABA"),
                      "ABA",
                      Map_To_Upper_Case_Ptr),
               2);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to upper (no match)";
      begin
         Test (Report, Name,
               Count (To_Chunked_String ("This IS a MISmatched issue"),
                      "is",
                      Mapping => Map_To_Upper_Case_Ptr),
               0);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Mixed case mapped to lower";
      begin
         Test (Report, Name,
               Count (To_Chunked_String
                        ("She sells sea shells by the sea shore"),
                      "s",
                      Ada.Characters.Handling.To_Lower'Access),
               8);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Empty string";
      begin
         Test (Report, Name,
               Count (Null_Chunked_String,
                      "match",
                      Map_To_Upper_Case_Ptr),
               0);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      NT.End_Section (Report);


      declare
         Null_Pattern_String : constant String := "";
         TC_Natural          : Natural := 1000;
      begin
         TC_Natural := Count (To_Chunked_String ("A Valid String"),
                              Null_Pattern_String,
                              Map_To_Lower_Case_Ptr);
         NT.Item (Report, "Pattern_Error raised in Count", NT.Fail);
         NT.Info (Report, "No exception has been raised.");
         NT.Info (Report, "Return value: " & Natural'Image (TC_Natural));
      exception
         when Pattern_Error =>
            NT.Item (Report, "Pattern_Error raised in Count", NT.Success);
         when Error : others =>
            NT.Item (Report, "Pattern_Error raised in Count", NT.Fail);
            NT.Info (Report, "Wrong exception "
                             & Ada.Exceptions.Exception_Name (Error)
                             & "has been raised.");
      end;


      NT.Section (Report, "Function Translate");

      declare
         Name : constant String := "Mixed case mapped to lower";
      begin
         Test (Report, Name,
               Translate (Source  => To_Chunked_String
                                       ("A Sample Mixed Case String"),
                          Mapping => Map_To_Lower_Case_Ptr),
               "a sample mixed case string");
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to lower";
      begin
         Test (Report, Name,
               Translate (To_Chunked_String ("ALL LOWER CASE"),
                          Ada.Characters.Handling.To_Lower'Access),
               "all lower case");
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Lower case mapped to lower";
      begin
         Test (Report, Name,
               Translate (To_Chunked_String ("end with lower case"),
                          Map_To_Lower_Case_Ptr),
               "end with lower case");
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Empty string";
      begin
         Test (Report, Name,
               Translate (Null_Chunked_String,
                          Ada.Characters.Handling.To_Lower'Access),
               Null_Chunked_String);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Lower case mapped to upper";
      begin
         Test (Report, Name,
               Translate (To_Chunked_String ("start with lower case"),
                          Map_To_Upper_Case_Ptr),
               "START WITH LOWER CASE");
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Upper case mapped to upper";
      begin
         Test (Report, Name,
               Translate (To_Chunked_String ("ALL UPPER CASE STRING"),
                          Ada.Characters.Handling.To_Upper'Access),
               "ALL UPPER CASE STRING");
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Mixed case mapped to upper";
      begin
         Test (Report, Name,
               Translate (To_Chunked_String
                            ("LoTs Of MiXeD CaSe ChArAcTeRs"),
                          Map_To_Upper_Case_Ptr),
               "LOTS OF MIXED CASE CHARACTERS");
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      declare
         Name : constant String := "Diacritics";
      begin
         Test (Report, Name,
               Translate (New_Character_String,
                          Ada.Characters.Handling.To_Upper'Access),
               TC_New_Character_String);
      exception
         when Error : others => NT.Report_Exception (Report, Name, Error);
      end;

      NT.End_Section (Report);


      NT.Section (Report, "Procedure Translate");

      declare
         use Ada.Characters.Handling;

         Str_1    : Chunked_String
           := To_Chunked_String ("AN ALL UPPER CASE STRING");
         Str_2    : Chunked_String
           := To_Chunked_String ("A Mixed Case String");
         Str_3    : Chunked_String
           := To_Chunked_String ("a string with lower case letters");
         TC_Str_1 : constant Chunked_String := Str_1;
         TC_Str_3 : constant Chunked_String := Str_3;
      begin
         declare
            Name : constant String := "Upper case mapped to lower";
         begin
            Translate (Source => Str_1, Mapping => Map_To_Lower_Case_Ptr);
            Test (Report, Name, Str_1,
                  To_Chunked_String ("an all upper case string"));
         exception
            when Error : others => NT.Report_Exception (Report, Name, Error);
         end;

         declare
            Name : constant String := "Lower case mapped back to upper";
         begin
            Translate (Source => Str_1, Mapping => Map_To_Upper_Case_Ptr);
            Test (Report, Name, Str_1, TC_Str_1);
         exception
            when Error : others => NT.Report_Exception (Report, Name, Error);
         end;

         declare
            Name : constant String := "Mixed case mapped to lower";
         begin
            Translate (Str_2, Mapping => Map_To_Lower_Case_Ptr);
            Test (Report, Name, Str_2,
                  To_Chunked_String ("a mixed case string"));
         exception
            when Error : others => NT.Report_Exception (Report, Name, Error);
         end;

         declare
            Name : constant String := "Lower case mapped to upper";
         begin
            Translate (Str_2, Mapping => To_Upper'Access);
            Test (Report, Name, Str_2,
                  To_Chunked_String ("A MIXED CASE STRING"));
         exception
            when Error : others => NT.Report_Exception (Report, Name, Error);
         end;

         declare
            Name : constant String := "Lower case mapped to lower";
         begin
            Translate (Str_3, To_Lower'Access);
            Test (Report, Name, Str_3, TC_Str_3);
         exception
            when Error : others => NT.Report_Exception (Report, Name, Error);
         end;

         declare
            Name : constant String := "Lower case mapped to upper";
         begin
            Translate (Str_3, To_Upper'Access);
            Test (Report, Name, Str_3,
                  To_Chunked_String ("A STRING WITH LOWER CASE LETTERS"));
         exception
            when Error : others => NT.Report_Exception (Report, Name, Error);
         end;

         declare
            Name : constant String := "Diacritics";
         begin
            Translate (New_Character_String, Map_To_Upper_Case_Ptr);
            Test (Report, Name, New_Character_String, TC_New_Character_String);
         exception
            when Error : others => NT.Report_Exception (Report, Name, Error);
         end;

      end;

      NT.End_Section (Report);
   exception
      when Error : others =>
         NT.Item (Report, "Preparation", NT.Error);
         NT.Info (Report, "Exception: "
                                     & Ada.Exceptions.Exception_Name (Error));
         NT.Info (Report, Ada.Exceptions.Exception_Message (Error));
   end;

   NT.End_Section (Report);

end Natools.Chunked_Strings.Tests.CXA4030;