Line data    Source code

       1             : /*
       2             :  *  intern.c
       3             :  *  Patater GUI Kit
       4             :  *
       5             :  *  Created by Jaeden Amero on 2019-05-06.
       6             :  *  Copyright 2019. SPDX-License-Identifier: AGPL-3.0-or-later
       7             :  */
       8             : 
       9             : #include "guikit/intern.h"
      10             : #include "ptest/test.h"
      11             : 
      12           1 : static int test_initial_state(void)
      13             : {
      14           1 :     TEST_EQ(intern_num_hits(), 0);
      15           1 :     TEST_EQ(intern_num_interned(), 0);
      16             : 
      17           1 :     return 0;
      18             : }
      19             : 
      20           1 : static int test_after_first_string_added(void)
      21             : {
      22             :     const char *oldstr1;
      23             : 
      24             :     /* Add first string. */
      25           1 :     oldstr1 = intern("hello");
      26             : 
      27           1 :     TEST_EQ(intern_num_hits(), 0);
      28           1 :     TEST_EQ(intern_num_interned(), 1);
      29           1 :     TEST_EQS(oldstr1, "hello");
      30             : 
      31           1 :     intern_free();
      32             : 
      33           1 :     return 0;
      34             : }
      35             : 
      36           1 : static int test_after_same_string_added(void)
      37             : {
      38             :     const char *oldstr1;
      39             :     const char *newstr1;
      40             : 
      41             :     /* Add same string. */
      42           1 :     oldstr1 = intern("hello");
      43           1 :     newstr1 = intern("hello");
      44             : 
      45           1 :     TEST_EQ(intern_num_hits(), 1);
      46           1 :     TEST_EQ(intern_num_interned(), 1);
      47           1 :     TEST_EQS(newstr1, "hello");
      48           1 :     TEST_EQP(newstr1, oldstr1);
      49             : 
      50           1 :     intern_free();
      51             : 
      52           1 :     return 0;
      53             : }
      54             : 
      55           1 : static int test_after_different_string_added(void)
      56             : {
      57             :     const char *oldstr1;
      58             :     const char *newstr1;
      59             :     const char *newstr2;
      60             : 
      61             :     /* Add different string. */
      62           1 :     oldstr1 = intern("hello");
      63           1 :     newstr1 = intern("hello");
      64           1 :     newstr2 = intern("world");
      65             : 
      66           1 :     TEST_EQ(intern_num_hits(), 1);
      67           1 :     TEST_EQ(intern_num_interned(), 2);
      68           1 :     TEST_EQP(newstr1, oldstr1);
      69           1 :     TEST_EQS(newstr2, "world");
      70           1 :     TEST_NEP(newstr2, oldstr1);
      71             : 
      72           1 :     intern_free();
      73             : 
      74           1 :     return 0;
      75             : }
      76             : 
      77           1 : static int test_copy_semantics(void)
      78             : {
      79             :     static const char *base = "hello";
      80             :     const char *copy;
      81             : 
      82             :     /* Add a string */
      83           1 :     copy = intern(base);
      84             : 
      85             :     /* Ensure that the copy returned is different memory than the base */
      86           1 :     TEST_NEP(copy, base);
      87             : 
      88           1 :     intern_free();
      89             : 
      90           1 :     return 0;
      91             : }
      92             : 
      93           1 : static int test_copy_semantics_value(void)
      94             : {
      95             :     const char *copy;
      96             : 
      97             :     {
      98           1 :         char base[] = "hello";
      99           1 :         copy = intern(base);
     100             : 
     101           1 :         TEST_NEP(copy, base);
     102             : 
     103             :         /* Ensure that base goes out of scope here by ending the block. */
     104             :     }
     105             : 
     106             :     /* Ensure that the copy is a true copy. This may crash if the memory used
     107             :      * for the base went out of scope. */
     108           1 :     TEST_EQS(copy, "hello");
     109             : 
     110           1 :     intern_free();
     111             : 
     112           1 :     return 0;
     113             : }
     114             : 
     115             : const test_fn tests[] =
     116             : {
     117             :     test_initial_state,
     118             :     test_after_first_string_added,
     119             :     test_after_same_string_added,
     120             :     test_after_different_string_added,
     121             :     test_copy_semantics,
     122             :     test_copy_semantics_value,
     123             :     0
     124             : };