Line data    Source code

       1             : /**  \file  suite_oomstub.c
       2             :  *  \brief  Unit testing for malloc/free/realloc stubs
       3             :  * \author  François Cerbelle (Fanfan), francois@cerbelle.net
       4             :  *
       5             :  * \internal
       6             :  *       Created:  07/07/2024
       7             :  *      Revision:  none
       8             :  * Last modified:  2024-12-11 15:55
       9             :  *      Compiler:  gcc
      10             :  *  Organization:  Cerbelle.net
      11             :  *     Copyright:  Copyright (c) 2024, François Cerbelle
      12             :  *
      13             :  *  This source code is released for free distribution under the terms of the
      14             :  *  GNU General Public License as published by the Free Software Foundation.
      15             :  */
      16             : 
      17             : #ifdef HAVE_CONFIG_H
      18             : #include "config.h"
      19             : #endif
      20             : 
      21             : #include "liboom/oomstub.h"                        /* OOM simulation */
      22             : #include "checktools.inc"
      23             : #include <check.h>
      24             : #include <stdlib.h>                             /* abort() */
      25             : 
      26           3 : START_TEST(oomstub_malloc) {
      27           3 :     char* a=NULL;
      28             :     int d1,d2;
      29             : 
      30           3 :     oomstub_setcountdown(0);
      31           3 :     d1 = oomstub_getcountdown();
      32           3 :     a = malloc(1);
      33           3 :     d2 = oomstub_getcountdown();
      34           3 :     oomstub_setcountdown(0);
      35           3 :     ck_assert(0==d1);
      36           3 :     ck_assert(0==d2);
      37           3 :     ck_assert(NULL!=a);
      38           3 :     free(a);
      39             : 
      40           3 :     oomstub_setcountdown(1);
      41           3 :     d1 = oomstub_getcountdown();
      42           3 :     a = malloc(1);
      43           3 :     d2 = oomstub_getcountdown();
      44           3 :     oomstub_setcountdown(0);
      45           3 :     ck_assert(1==d1);
      46           3 :     ck_assert(0==d2);
      47           3 :     ck_assert(NULL==a);
      48             : 
      49           3 :     oomstub_setcountdown(2);
      50           3 :     d1 = oomstub_getcountdown();
      51           3 :     a = malloc(1); /* cppcheck-suppress memleak */
      52           3 :     d2 = oomstub_getcountdown();
      53           3 :     oomstub_setcountdown(0);
      54           3 :     ck_assert(2==d1);
      55           3 :     ck_assert(1==d2);
      56           3 :     ck_assert(NULL!=a);
      57           3 :     free(a);
      58           3 : }
      59             : END_TEST
      60             : 
      61           3 : START_TEST(oomstub_calloc) {
      62           3 :     char* a=NULL;
      63             :     int d1,d2;
      64             : 
      65           3 :     oomstub_setcountdown(0);
      66           3 :     d1 = oomstub_getcountdown();
      67           3 :     a = calloc(5,2);
      68           3 :     d2 = oomstub_getcountdown();
      69           3 :     oomstub_setcountdown(0);
      70           3 :     ck_assert(0==d1);
      71           3 :     ck_assert(0==d2);
      72           3 :     ck_assert(NULL!=a);
      73           3 :     free(a);
      74             : 
      75           3 :     oomstub_setcountdown(1);
      76           3 :     d1 = oomstub_getcountdown();
      77           3 :     a = calloc(5,2);
      78           3 :     d2 = oomstub_getcountdown();
      79           3 :     oomstub_setcountdown(0);
      80           3 :     ck_assert(1==d1);
      81           3 :     ck_assert(0==d2);
      82           3 :     ck_assert(NULL==a);
      83             : 
      84           3 :     oomstub_setcountdown(2);
      85           3 :     d1 = oomstub_getcountdown();
      86           3 :     a = calloc(5,2); /* cppcheck-suppress memleak */
      87           3 :     d2 = oomstub_getcountdown();
      88           3 :     oomstub_setcountdown(0);
      89           3 :     ck_assert(2==d1);
      90           3 :     ck_assert(1==d2);
      91           3 :     ck_assert(NULL!=a);
      92           3 :     free(a);
      93           3 : }
      94             : END_TEST
      95             : 
      96             : /* Using NULL as a pointer to reallocate means malloc behavior */
      97           3 : START_TEST(oomstub_realloc_malloc) {
      98             :     void* newptr;
      99             :     int d1,d2;
     100             : 
     101           3 :     oomstub_setcountdown(0); /* No failure */
     102           3 :     d1 = oomstub_getcountdown();
     103           3 :     newptr = realloc(NULL,1);
     104           3 :     d2 = oomstub_getcountdown();
     105           3 :     oomstub_setcountdown(0);
     106           3 :     ck_assert(0==d1);
     107           3 :     ck_assert(0==d2);
     108           3 :     ck_assert(NULL!=newptr);
     109           3 :     free(newptr);
     110             : 
     111           3 :     oomstub_setcountdown(1); /* Immediate failure */
     112           3 :     d1 = oomstub_getcountdown();
     113           3 :     newptr = realloc(NULL,1);
     114           3 :     d2 = oomstub_getcountdown();
     115           3 :     oomstub_setcountdown(0);
     116           3 :     ck_assert(1==d1);
     117           3 :     ck_assert(0==d2);
     118           3 :     ck_assert(NULL==newptr);
     119             : 
     120           3 :     oomstub_setcountdown(2); /* Success first before failure */
     121           3 :     d1 = oomstub_getcountdown();
     122           3 :     newptr = realloc(NULL,1); /* cppcheck-suppress memleak */
     123           3 :     d2 = oomstub_getcountdown();
     124           3 :     oomstub_setcountdown(0);
     125           3 :     ck_assert(2==d1);
     126           3 :     ck_assert(1==d2);
     127           3 :     ck_assert(NULL!=newptr);
     128           3 :     free(newptr);
     129           3 : }
     130             : END_TEST
     131             : 
     132             : /* Using 0 as a size to reallocate means free behavior */
     133           3 : START_TEST(oomstub_realloc_free) {
     134             :     void* oldptr;
     135             :     void* newptr;
     136             :     int d1,d2;
     137             : 
     138           3 :     oldptr = malloc(1);
     139           3 :     oomstub_setcountdown(0); /* No failure */
     140           3 :     d1 = oomstub_getcountdown();
     141           3 :     newptr = realloc(oldptr,0);
     142           3 :     d2 = oomstub_getcountdown();
     143           3 :     oomstub_setcountdown(0);
     144           3 :     ck_assert(0==d1);
     145           3 :     ck_assert(0==d2);
     146           3 :     ck_assert(NULL==newptr);
     147           3 :     free(newptr);
     148             : 
     149           3 :     oldptr = malloc(1);
     150           3 :     oomstub_setcountdown(1); /* Immediate failure */
     151           3 :     d1 = oomstub_getcountdown();
     152           3 :     newptr = realloc(oldptr,0);
     153           3 :     d2 = oomstub_getcountdown();
     154           3 :     oomstub_setcountdown(0);
     155           3 :     ck_assert(1==d1);
     156           3 :     ck_assert(0==d2);
     157           3 :     ck_assert(NULL!=newptr);
     158           3 :     free(newptr); /* Not actually freed because of simulated failure */
     159             : 
     160           3 :     oldptr = malloc(1);
     161           3 :     oomstub_setcountdown(2); /* Success first before failure */
     162           3 :     d1 = oomstub_getcountdown();
     163           3 :     newptr = realloc(oldptr,0);
     164           3 :     d2 = oomstub_getcountdown();
     165           3 :     oomstub_setcountdown(0);
     166           3 :     ck_assert(2==d1);
     167           3 :     ck_assert(1==d2);
     168           3 :     ck_assert(NULL==newptr);
     169           3 :     free(newptr);
     170           3 : }
     171             : END_TEST
     172             : 
     173           3 : START_TEST(oomstub_realloc_downsize) {
     174             :     void* oldptr;
     175             :     void* newptr;
     176             :     int d1,d2;
     177             : 
     178           3 :     oldptr = malloc(1000);
     179           3 :     oomstub_setcountdown(0); /* No failure */
     180           3 :     d1 = oomstub_getcountdown();
     181           3 :     newptr = realloc(oldptr,10);
     182           3 :     d2 = oomstub_getcountdown();
     183           3 :     oomstub_setcountdown(0);
     184           3 :     ck_assert(0==d1);
     185           3 :     ck_assert(0==d2);
     186           3 :     ck_assert(NULL!=newptr);
     187           3 :     free(newptr);
     188             : 
     189           3 :     oldptr = malloc(1000);
     190           3 :     oomstub_setcountdown(1); /* Immediate failure */
     191           3 :     d1 = oomstub_getcountdown();
     192           3 :     newptr = realloc(oldptr,10);
     193           3 :     d2 = oomstub_getcountdown();
     194           3 :     oomstub_setcountdown(0);
     195           3 :     ck_assert(1==d1);
     196           3 :     ck_assert(0==d2);
     197           3 :     ck_assert(NULL==newptr);
     198           3 :     free(oldptr); /* cppcheck-suppress doubleFree */
     199             : 
     200           3 :     oldptr = malloc(1000);
     201           3 :     oomstub_setcountdown(2); /* Success first before failure */
     202           3 :     d1 = oomstub_getcountdown();
     203           3 :     newptr = realloc(oldptr,10); /* cppcheck-suppress memleak */
     204           3 :     d2 = oomstub_getcountdown();
     205           3 :     oomstub_setcountdown(0);
     206           3 :     ck_assert(2==d1);
     207           3 :     ck_assert(1==d2);
     208           3 :     ck_assert(NULL!=newptr);
     209           3 :     free(newptr);
     210           3 : }
     211             : END_TEST
     212             : 
     213           3 : START_TEST(oomstub_realloc_upsize) {
     214             :     void* oldptr;
     215             :     void* newptr;
     216             :     int d1,d2;
     217             : 
     218           3 :     oldptr = malloc(1000);
     219           3 :     oomstub_setcountdown(0); /* No failure */
     220           3 :     d1 = oomstub_getcountdown();
     221           3 :     newptr = realloc(oldptr,2000);
     222           3 :     d2 = oomstub_getcountdown();
     223           3 :     oomstub_setcountdown(0);
     224           3 :     ck_assert(0==d1);
     225           3 :     ck_assert(0==d2);
     226           3 :     ck_assert(NULL!=newptr);
     227           3 :     free(newptr);
     228             : 
     229           3 :     oldptr = malloc(1000);
     230           3 :     oomstub_setcountdown(1); /* Immediate failure */
     231           3 :     d1 = oomstub_getcountdown();
     232           3 :     newptr = realloc(oldptr,2000);
     233           3 :     d2 = oomstub_getcountdown();
     234           3 :     oomstub_setcountdown(0);
     235           3 :     ck_assert(1==d1);
     236           3 :     ck_assert(0==d2);
     237           3 :     ck_assert(NULL==newptr);
     238           3 :     free(oldptr); /* cppcheck-suppress doubleFree */
     239             : 
     240           3 :     oldptr = malloc(1000);
     241           3 :     oomstub_setcountdown(2); /* Success first before failure */
     242           3 :     d1 = oomstub_getcountdown();
     243           3 :     newptr = realloc(oldptr,2000); /* cppcheck-suppress memleak */
     244           3 :     d2 = oomstub_getcountdown();
     245           3 :     oomstub_setcountdown(0);
     246           3 :     ck_assert(2==d1);
     247           3 :     ck_assert(1==d2);
     248           3 :     ck_assert(NULL!=newptr);
     249           3 :     free(newptr);
     250           3 : }
     251             : END_TEST
     252             : 
     253             : /************************************************************************/
     254             : /* Begining of test (potentially in child) */
     255          18 : void oomstub_checked_uninitialized_setup() {
     256          18 :     signals_catch();
     257          18 :     forktest_gprofdir();
     258          18 : }
     259             : 
     260             : /* End of test (potentially in child) */
     261          18 : void oomstub_checked_uninitialized_teardown() {
     262          18 :     signals_release();
     263          18 : }
     264             : /************************************************************************/
     265             : /* Begining of test case */
     266          15 : void oomstub_unchecked_setup() {
     267          15 :     forktest_init();
     268          15 : }
     269             : /* End of testcase */
     270           3 : void oomstub_unchecked_teardown() {
     271           3 : }
     272             : /************************************************************************/
     273         367 : Suite* oomstub_suite() {
     274             :     Suite *s;
     275             :     TCase *tc;
     276             : 
     277         367 :     s = suite_create("OOMStub");
     278             : 
     279         367 :     tc = tcase_create("Uninitialized");
     280         367 :     tcase_set_tags(tc,"oom");
     281             :     /* tcase_set_timeout(tc,5); */ /* seconds */
     282         367 :     tcase_add_checked_fixture(tc, oomstub_checked_uninitialized_setup, oomstub_checked_uninitialized_teardown);
     283         367 :     tcase_add_unchecked_fixture(tc, oomstub_unchecked_setup, oomstub_unchecked_teardown);
     284         367 :     suite_add_tcase(s, tc);
     285             : 
     286         367 :     tcase_add_test(tc, oomstub_malloc);
     287         367 :     tcase_add_test(tc, oomstub_calloc);
     288         367 :     tcase_add_test(tc, oomstub_realloc_malloc);
     289         367 :     tcase_add_test(tc, oomstub_realloc_free);
     290         367 :     tcase_add_test(tc, oomstub_realloc_downsize);
     291         367 :     tcase_add_test(tc, oomstub_realloc_upsize);
     292         367 :     return s;
     293             : }
     294             : /* vim: set tw=80: */