LCOV - code coverage report
Current view: top level - gcc - selftest.c (source / functions) Hit Total Coverage
Test: gcc.info Lines: 141 174 81.0 %
Date: 2020-04-04 11:58:09 Functions: 20 23 87.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* A self-testing framework, for use by -fself-test.
       2                 :            :    Copyright (C) 2015-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it under
       7                 :            : the terms of the GNU General Public License as published by the Free
       8                 :            : Software Foundation; either version 3, or (at your option) any later
       9                 :            : version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12                 :            : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #include "config.h"
      21                 :            : #include "system.h"
      22                 :            : #include "coretypes.h"
      23                 :            : #include "selftest.h"
      24                 :            : #include "intl.h"
      25                 :            : 
      26                 :            : #if CHECKING_P
      27                 :            : 
      28                 :            : namespace selftest {
      29                 :            : 
      30                 :            : int num_passes;
      31                 :            : 
      32                 :            : /* Record the successful outcome of some aspect of a test.  */
      33                 :            : 
      34                 :            : void
      35                 :     146065 : pass (const location &/*loc*/, const char */*msg*/)
      36                 :            : {
      37                 :     146065 :   num_passes++;
      38                 :     146065 : }
      39                 :            : 
      40                 :            : /* Report the failed outcome of some aspect of a test and abort.  */
      41                 :            : 
      42                 :            : void
      43                 :          0 : fail (const location &loc, const char *msg)
      44                 :            : {
      45                 :          0 :   fprintf (stderr,"%s:%i: %s: FAIL: %s\n", loc.m_file, loc.m_line,
      46                 :          0 :            loc.m_function, msg);
      47                 :          0 :   abort ();
      48                 :            : }
      49                 :            : 
      50                 :            : /* As "fail", but using printf-style formatted output.  */
      51                 :            : 
      52                 :            : void
      53                 :          0 : fail_formatted (const location &loc, const char *fmt, ...)
      54                 :            : {
      55                 :          0 :   va_list ap;
      56                 :            : 
      57                 :          0 :   fprintf (stderr, "%s:%i: %s: FAIL: ", loc.m_file, loc.m_line,
      58                 :          0 :            loc.m_function);
      59                 :          0 :   va_start (ap, fmt);
      60                 :          0 :   vfprintf (stderr, fmt, ap);
      61                 :          0 :   va_end (ap);
      62                 :          0 :   fprintf (stderr, "\n");
      63                 :          0 :   abort ();
      64                 :            : }
      65                 :            : 
      66                 :            : /* Implementation detail of ASSERT_STREQ.
      67                 :            :    Compare val1 and val2 with strcmp.  They ought
      68                 :            :    to be non-NULL; fail gracefully if either or both are NULL.  */
      69                 :            : 
      70                 :            : void
      71                 :      12016 : assert_streq (const location &loc,
      72                 :            :               const char *desc_val1, const char *desc_val2,
      73                 :            :               const char *val1, const char *val2)
      74                 :            : {
      75                 :            :   /* If val1 or val2 are NULL, fail with a custom error message.  */
      76                 :      12016 :   if (val1 == NULL)
      77                 :          0 :     if (val2 == NULL)
      78                 :          0 :       fail_formatted (loc, "ASSERT_STREQ (%s, %s) val1=NULL val2=NULL",
      79                 :            :                       desc_val1, desc_val2);
      80                 :            :     else
      81                 :          0 :       fail_formatted (loc, "ASSERT_STREQ (%s, %s) val1=NULL val2=\"%s\"",
      82                 :            :                       desc_val1, desc_val2, val2);
      83                 :            :   else
      84                 :      12016 :     if (val2 == NULL)
      85                 :          0 :       fail_formatted (loc, "ASSERT_STREQ (%s, %s) val1=\"%s\" val2=NULL",
      86                 :            :                       desc_val1, desc_val2, val1);
      87                 :            :     else
      88                 :            :       {
      89                 :      12016 :         if (strcmp (val1, val2) == 0)
      90                 :      12016 :           pass (loc, "ASSERT_STREQ");
      91                 :            :         else
      92                 :          0 :           fail_formatted (loc, "ASSERT_STREQ (%s, %s) val1=\"%s\" val2=\"%s\"",
      93                 :            :                           desc_val1, desc_val2, val1, val2);
      94                 :            :       }
      95                 :      12016 : }
      96                 :            : 
      97                 :            : /* Implementation detail of ASSERT_STR_CONTAINS.
      98                 :            :    Use strstr to determine if val_needle is within val_haystack.
      99                 :            :    ::selftest::pass if it is found.
     100                 :            :    ::selftest::fail if it is not found.  */
     101                 :            : 
     102                 :            : void
     103                 :       1052 : assert_str_contains (const location &loc,
     104                 :            :                      const char *desc_haystack,
     105                 :            :                      const char *desc_needle,
     106                 :            :                      const char *val_haystack,
     107                 :            :                      const char *val_needle)
     108                 :            : {
     109                 :            :   /* If val_haystack is NULL, fail with a custom error message.  */
     110                 :       1052 :   if (val_haystack == NULL)
     111                 :          0 :     fail_formatted (loc, "ASSERT_STR_CONTAINS (%s, %s) haystack=NULL",
     112                 :            :                     desc_haystack, desc_needle);
     113                 :            : 
     114                 :            :   /* If val_needle is NULL, fail with a custom error message.  */
     115                 :       1052 :   if (val_needle == NULL)
     116                 :          0 :     fail_formatted (loc,
     117                 :            :                     "ASSERT_STR_CONTAINS (%s, %s) haystack=\"%s\" needle=NULL",
     118                 :            :                     desc_haystack, desc_needle, val_haystack);
     119                 :            : 
     120                 :       1052 :   const char *test = strstr (val_haystack, val_needle);
     121                 :       1052 :   if (test)
     122                 :       1052 :     pass (loc, "ASSERT_STR_CONTAINS");
     123                 :            :   else
     124                 :          0 :     fail_formatted
     125                 :          0 :         (loc, "ASSERT_STR_CONTAINS (%s, %s) haystack=\"%s\" needle=\"%s\"",
     126                 :            :          desc_haystack, desc_needle, val_haystack, val_needle);
     127                 :       1052 : }
     128                 :            : 
     129                 :            : /* Implementation detail of ASSERT_STR_STARTSWITH.
     130                 :            :    Determine if VAL_STR starts with VAL_PREFIX.
     131                 :            :    ::selftest::pass if VAL_STR does start with VAL_PREFIX.
     132                 :            :    ::selftest::fail if it does not, or either is NULL (using
     133                 :            :    DESC_STR and DESC_PREFIX in the error message).  */
     134                 :            : 
     135                 :            : void
     136                 :        164 : assert_str_startswith (const location &loc,
     137                 :            :                        const char *desc_str,
     138                 :            :                        const char *desc_prefix,
     139                 :            :                        const char *val_str,
     140                 :            :                        const char *val_prefix)
     141                 :            : {
     142                 :            :   /* If val_str is NULL, fail with a custom error message.  */
     143                 :        164 :   if (val_str == NULL)
     144                 :          0 :     fail_formatted (loc, "ASSERT_STR_STARTSWITH (%s, %s) str=NULL",
     145                 :            :                     desc_str, desc_prefix);
     146                 :            : 
     147                 :            :   /* If val_prefix is NULL, fail with a custom error message.  */
     148                 :        164 :   if (val_prefix == NULL)
     149                 :          0 :     fail_formatted (loc,
     150                 :            :                     "ASSERT_STR_STARTSWITH (%s, %s) str=\"%s\" prefix=NULL",
     151                 :            :                     desc_str, desc_prefix, val_str);
     152                 :            : 
     153                 :        164 :   const char *test = strstr (val_str, val_prefix);
     154                 :        164 :   if (test == val_str)
     155                 :        164 :     pass (loc, "ASSERT_STR_STARTSWITH");
     156                 :            :   else
     157                 :          0 :     fail_formatted
     158                 :          0 :         (loc, "ASSERT_STR_STARTSWITH (%s, %s) str=\"%s\" prefix=\"%s\"",
     159                 :            :          desc_str, desc_prefix, val_str, val_prefix);
     160                 :        164 : }
     161                 :            : 
     162                 :            : 
     163                 :            : /* Constructor.  Generate a name for the file.  */
     164                 :            : 
     165                 :       2760 : named_temp_file::named_temp_file (const char *suffix)
     166                 :            : {
     167                 :       2760 :   m_filename = make_temp_file (suffix);
     168                 :       2760 :   ASSERT_NE (m_filename, NULL);
     169                 :       2760 : }
     170                 :            : 
     171                 :            : /* Destructor.  Delete the tempfile.  */
     172                 :            : 
     173                 :       5520 : named_temp_file::~named_temp_file ()
     174                 :            : {
     175                 :       2760 :   unlink (m_filename);
     176                 :       2760 :   diagnostics_file_cache_forcibly_evict_file (m_filename);
     177                 :       2760 :   free (m_filename);
     178                 :       2760 : }
     179                 :            : 
     180                 :            : /* Constructor.  Create a tempfile using SUFFIX, and write CONTENT to
     181                 :            :    it.  Abort if anything goes wrong, using LOC as the effective
     182                 :            :    location in the problem report.  */
     183                 :            : 
     184                 :       2418 : temp_source_file::temp_source_file (const location &loc,
     185                 :            :                                     const char *suffix,
     186                 :       2418 :                                     const char *content)
     187                 :       2418 : : named_temp_file (suffix)
     188                 :            : {
     189                 :       2418 :   FILE *out = fopen (get_filename (), "w");
     190                 :       2418 :   if (!out)
     191                 :          0 :     fail_formatted (loc, "unable to open tempfile: %s", get_filename ());
     192                 :       2418 :   fprintf (out, "%s", content);
     193                 :       2418 :   fclose (out);
     194                 :       2418 : }
     195                 :            : 
     196                 :            : /* Avoid introducing locale-specific differences in the results
     197                 :            :    by hardcoding open_quote and close_quote.  */
     198                 :            : 
     199                 :         32 : auto_fix_quotes::auto_fix_quotes ()
     200                 :            : {
     201                 :         32 :   m_saved_open_quote = open_quote;
     202                 :         32 :   m_saved_close_quote = close_quote;
     203                 :         32 :   open_quote = "`";
     204                 :         32 :   close_quote = "'";
     205                 :         32 : }
     206                 :            : 
     207                 :            : /* Restore old values of open_quote and close_quote.  */
     208                 :            : 
     209                 :         32 : auto_fix_quotes::~auto_fix_quotes ()
     210                 :            : {
     211                 :         32 :   open_quote = m_saved_open_quote;
     212                 :         32 :   close_quote = m_saved_close_quote;
     213                 :         32 : }
     214                 :            : 
     215                 :            : /* Read the contents of PATH into memory, returning a 0-terminated buffer
     216                 :            :    that must be freed by the caller.
     217                 :            :    Fail (and abort) if there are any problems, with LOC as the reported
     218                 :            :    location of the failure.  */
     219                 :            : 
     220                 :            : char *
     221                 :         56 : read_file (const location &loc, const char *path)
     222                 :            : {
     223                 :         56 :   FILE *f_in = fopen (path, "r");
     224                 :         56 :   if (!f_in)
     225                 :          0 :     fail_formatted (loc, "unable to open file: %s", path);
     226                 :            : 
     227                 :            :   /* Read content, allocating FIXME.  */
     228                 :            :   char *result = NULL;
     229                 :            :   size_t total_sz = 0;
     230                 :            :   size_t alloc_sz = 0;
     231                 :        112 :   char buf[4096];
     232                 :        112 :   size_t iter_sz_in;
     233                 :            : 
     234                 :        112 :   while ( (iter_sz_in = fread (buf, 1, sizeof (buf), f_in)) )
     235                 :            :     {
     236                 :         56 :       gcc_assert (alloc_sz >= total_sz);
     237                 :         56 :       size_t old_total_sz = total_sz;
     238                 :         56 :       total_sz += iter_sz_in;
     239                 :            :       /* Allow 1 extra byte for 0-termination.  */
     240                 :         56 :       if (alloc_sz < (total_sz + 1))
     241                 :            :         {
     242                 :         56 :           size_t new_alloc_sz = alloc_sz ? alloc_sz * 2: total_sz + 1;
     243                 :         56 :           result = (char *)xrealloc (result, new_alloc_sz);
     244                 :         56 :           alloc_sz = new_alloc_sz;
     245                 :            :         }
     246                 :         56 :       memcpy (result + old_total_sz, buf, iter_sz_in);
     247                 :            :     }
     248                 :            : 
     249                 :         56 :   if (!feof (f_in))
     250                 :          0 :     fail_formatted (loc, "error reading from %s: %s", path,
     251                 :          0 :                     xstrerror (errno));
     252                 :            : 
     253                 :         56 :   fclose (f_in);
     254                 :            : 
     255                 :            :   /* 0-terminate the buffer.  */
     256                 :         56 :   gcc_assert (total_sz < alloc_sz);
     257                 :         56 :   result[total_sz] = '\0';
     258                 :            : 
     259                 :         56 :   return result;
     260                 :            : }
     261                 :            : 
     262                 :            : /* The path of SRCDIR/testsuite/selftests.  */
     263                 :            : 
     264                 :            : const char *path_to_selftest_files = NULL;
     265                 :            : 
     266                 :            : /* Convert a path relative to SRCDIR/testsuite/selftests
     267                 :            :    to a real path (either absolute, or relative to pwd).
     268                 :            :    The result should be freed by the caller.  */
     269                 :            : 
     270                 :            : char *
     271                 :         40 : locate_file (const char *name)
     272                 :            : {
     273                 :         40 :   ASSERT_NE (NULL, path_to_selftest_files);
     274                 :         40 :   return concat (path_to_selftest_files, "/", name, NULL);
     275                 :            : }
     276                 :            : 
     277                 :            : /* selftest::test_runner's ctor.  */
     278                 :            : 
     279                 :          3 : test_runner::test_runner (const char *name)
     280                 :            : : m_name (name),
     281                 :          3 :   m_start_time (get_run_time ())
     282                 :            : {
     283                 :          3 : }
     284                 :            : 
     285                 :            : /* selftest::test_runner's dtor.  Print a summary line to stderr.  */
     286                 :            : 
     287                 :          6 : test_runner::~test_runner ()
     288                 :            : {
     289                 :            :   /* Finished running tests.  */
     290                 :          3 :   long finish_time = get_run_time ();
     291                 :          3 :   long elapsed_time = finish_time - m_start_time;
     292                 :            : 
     293                 :          3 :   fprintf (stderr,
     294                 :            :            "%s: %i pass(es) in %ld.%06ld seconds\n",
     295                 :            :            m_name, num_passes,
     296                 :            :            elapsed_time / 1000000, elapsed_time % 1000000);
     297                 :          3 : }
     298                 :            : 
     299                 :            : /* Selftests for libiberty.  */
     300                 :            : 
     301                 :            : /* Verify that xstrndup generates EXPECTED when called on SRC and N.  */
     302                 :            : 
     303                 :            : static void
     304                 :         22 : assert_xstrndup_eq (const char *expected, const char *src, size_t n)
     305                 :            : {
     306                 :         22 :   char *buf = xstrndup (src, n);
     307                 :         22 :   ASSERT_STREQ (expected, buf);
     308                 :         22 :   free (buf);
     309                 :         22 : }
     310                 :            : 
     311                 :            : /* Verify that xstrndup works as expected.  */
     312                 :            : 
     313                 :            : static void
     314                 :          2 : test_xstrndup ()
     315                 :            : {
     316                 :          2 :   assert_xstrndup_eq ("", "test", 0);
     317                 :          2 :   assert_xstrndup_eq ("t", "test", 1);
     318                 :          2 :   assert_xstrndup_eq ("te", "test", 2);
     319                 :          2 :   assert_xstrndup_eq ("tes", "test", 3);
     320                 :          2 :   assert_xstrndup_eq ("test", "test", 4);
     321                 :          2 :   assert_xstrndup_eq ("test", "test", 5);
     322                 :            : 
     323                 :            :   /* Test on an string without zero termination.  */
     324                 :          2 :   const char src[4] = {'t', 'e', 's', 't'};
     325                 :          2 :   assert_xstrndup_eq ("", src, 0);
     326                 :          2 :   assert_xstrndup_eq ("t", src, 1);
     327                 :          2 :   assert_xstrndup_eq ("te", src, 2);
     328                 :          2 :   assert_xstrndup_eq ("tes", src, 3);
     329                 :          2 :   assert_xstrndup_eq ("test", src, 4);
     330                 :          2 : }
     331                 :            : 
     332                 :            : /* Run selftests for libiberty.  */
     333                 :            : 
     334                 :            : static void
     335                 :          2 : test_libiberty ()
     336                 :            : {
     337                 :          0 :   test_xstrndup ();
     338                 :          0 : }
     339                 :            : 
     340                 :            : /* Selftests for the selftest system itself.  */
     341                 :            : 
     342                 :            : /* Sanity-check the ASSERT_ macros with various passing cases.  */
     343                 :            : 
     344                 :            : static void
     345                 :          2 : test_assertions ()
     346                 :            : {
     347                 :          2 :   ASSERT_TRUE (true);
     348                 :          2 :   ASSERT_FALSE (false);
     349                 :          2 :   ASSERT_EQ (1, 1);
     350                 :          2 :   ASSERT_EQ_AT (SELFTEST_LOCATION, 1, 1);
     351                 :          2 :   ASSERT_NE (1, 2);
     352                 :          2 :   ASSERT_GT (2, 1);
     353                 :          2 :   ASSERT_GT_AT (SELFTEST_LOCATION, 2, 1);
     354                 :          2 :   ASSERT_LT (1, 2);
     355                 :          2 :   ASSERT_LT_AT (SELFTEST_LOCATION, 1, 2);
     356                 :          2 :   ASSERT_STREQ ("test", "test");
     357                 :          2 :   ASSERT_STREQ_AT (SELFTEST_LOCATION, "test", "test");
     358                 :          2 :   ASSERT_STR_CONTAINS ("foo bar baz", "bar");
     359                 :          2 : }
     360                 :            : 
     361                 :            : /* Verify named_temp_file.  */
     362                 :            : 
     363                 :            : static void
     364                 :          2 : test_named_temp_file ()
     365                 :            : {
     366                 :          4 :   named_temp_file t (".txt");
     367                 :          2 :   FILE *f = fopen (t.get_filename (), "w");
     368                 :          2 :   if (!f)
     369                 :          0 :     fail_formatted (SELFTEST_LOCATION,
     370                 :            :                     "unable to open %s for writing", t.get_filename ());
     371                 :          2 :   fclose (f);
     372                 :          2 : }
     373                 :            : 
     374                 :            : /* Verify read_file (and also temp_source_file).  */
     375                 :            : 
     376                 :            : static void
     377                 :          2 : test_read_file ()
     378                 :            : {
     379                 :          2 :   temp_source_file t (SELFTEST_LOCATION, "test1.s",
     380                 :          2 :                       "\tjmp\t.L2\n");
     381                 :          2 :   char *buf = read_file (SELFTEST_LOCATION, t.get_filename ());
     382                 :          2 :   ASSERT_STREQ ("\tjmp\t.L2\n", buf);
     383                 :          2 :   free (buf);
     384                 :          2 : }
     385                 :            : 
     386                 :            : /* Verify locate_file (and read_file).  */
     387                 :            : 
     388                 :            : static void
     389                 :          2 : test_locate_file ()
     390                 :            : {
     391                 :          2 :   char *path = locate_file ("example.txt");
     392                 :          2 :   char *buf = read_file (SELFTEST_LOCATION, path);
     393                 :          2 :   ASSERT_STREQ ("example of a selftest file\n", buf);
     394                 :          2 :   free (buf);
     395                 :          2 :   free (path);
     396                 :          2 : }
     397                 :            : 
     398                 :            : /* Run all of the selftests within this file.  */
     399                 :            : 
     400                 :            : void
     401                 :          2 : selftest_c_tests ()
     402                 :            : {
     403                 :          2 :   test_libiberty ();
     404                 :          2 :   test_assertions ();
     405                 :          2 :   test_named_temp_file ();
     406                 :          2 :   test_read_file ();
     407                 :          2 :   test_locate_file ();
     408                 :          2 : }
     409                 :            : 
     410                 :            : } // namespace selftest
     411                 :            : 
     412                 :            : #endif /* #if CHECKING_P */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.