tests/test-immutable.c

   1 /* Test of immutable data.
   2    Copyright (C) 2021-2024 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2021.  */
  18
  19 #include <config.h>
  20
  21 #include "immutable.h"
  22
  23 #include <signal.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #include "macros.h"
  28
  29 struct data
  30 {
  31   int x;
  32   long y;
  33 };
  34
  35 #if IMMUTABLE_EFFECTIVE
  36
  37 static _GL_ASYNC_SAFE _Noreturn void
  38 segv_handler (int signo)
  39 {
  40   _Exit (0);
  41 }
  42
  43 static void
  44 install_segv_handler (void)
  45 {
  46   signal (SIGSEGV, segv_handler);
  47 # if (defined __APPLE__ && defined __MACH__) || defined __FreeBSD__
  48   signal (SIGBUS, segv_handler);
  49 # endif
  50 }
  51
  52 #endif
  53
  54 int
  55 main (int argc, char *argv[])
  56 {
  57   if (argc != 2)
  58     {
  59       fprintf (stderr, "%s: need 1 argument\n", argv[0]);
  60       return 1;
  61     }
  62   int test = atoi (argv[1]);
  63   switch (test)
  64     {
  65     case 0:
  66       /* Indicates whether the implementation effectively rejects writes to
  67          immutable data.  */
  68       #if !IMMUTABLE_EFFECTIVE
  69       fputs ("Skipping test: immutability cannot be enforced\n", stderr);
  70       return 77;
  71       #else
  72       break;
  73       #endif
  74
  75     case 1:
  76       /* Correct use of immmalloc.  */
  77       {
  78         struct data *wp;
  79         struct data const *p;
  80
  81         wp = (struct data *) immmalloc (sizeof (struct data));
  82         ASSERT (wp != NULL);
  83         wp->x = 7;
  84         wp->y = 42;
  85         p = immfreeze (wp);
  86         ASSERT (p->x == 7);
  87         ASSERT (p->y == 42);
  88         immfree (p);
  89       }
  90       break;
  91
  92     case 2:
  93       /* Catch invalid write access.  */
  94       {
  95         struct data *wp;
  96         struct data const *p;
  97
  98         wp = (struct data *) immmalloc (sizeof (struct data));
  99         ASSERT (wp != NULL);
 100         wp->x = 7;
 101         wp->y = 42;
 102         p = immfreeze (wp);
 103         #if IMMUTABLE_EFFECTIVE
 104         install_segv_handler ();
 105         #endif
 106         /* This assignment should crash.  */
 107         ((struct data *) p)->y = 77;
 108         #if IMMUTABLE_EFFECTIVE
 109         return 1;
 110         #endif
 111       }
 112       break;
 113
 114     case 3:
 115       /* Catch invalid write access while another data object is not frozen.  */
 116       {
 117         struct data *wp;
 118         struct data const *p;
 119         struct data *wp2;
 120
 121         wp = (struct data *) immmalloc (sizeof (struct data));
 122         ASSERT (wp != NULL);
 123         wp->x = 7;
 124         wp->y = 42;
 125         p = immfreeze (wp);
 126         ASSERT (p->x == 7);
 127         ASSERT (p->y == 42);
 128
 129         wp2 = (struct data *) immmalloc (sizeof (struct data));
 130         ASSERT (wp2 != NULL);
 131         wp2->x = 7;
 132         #if IMMUTABLE_EFFECTIVE
 133         install_segv_handler ();
 134         #endif
 135         /* This assignment should crash.  */
 136         ((struct data *) p)->y = 42;
 137         #if IMMUTABLE_EFFECTIVE
 138         return 1;
 139         #endif
 140       }
 141       break;
 142
 143     case 4:
 144       /* Correct use of immstrdup.  */
 145       {
 146         const char *s = immstrdup ("Hello");
 147         ASSERT (strlen (s) == 5);
 148         ASSERT (strcmp (s, "Hello") == 0);
 149         immfree (s);
 150       }
 151       break;
 152
 153     default:
 154       ASSERT (false);
 155     }
 156   return test_exit_status;
 157 }