1  /* Test of searching in a string.
       2     Copyright (C) 2007-2023 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>, 2007.  */
      18  
      19  #include <config.h>
      20  
      21  #include <string.h>
      22  
      23  #include <stdlib.h>
      24  
      25  #include "macros.h"
      26  
      27  int
      28  main ()
      29  {
      30    /* This test is executed in the C locale.  */
      31  
      32    {
      33      const char input[] = "foo";
      34      const char *result = mbsstr (input, "");
      35      ASSERT (result == input);
      36    }
      37  
      38    {
      39      const char input[] = "foo";
      40      const char *result = mbsstr (input, "o");
      41      ASSERT (result == input + 1);
      42    }
      43  
      44    {
      45      const char input[] = "ABC ABCDAB ABCDABCDABDE";
      46      const char *result = mbsstr (input, "ABCDABD");
      47      ASSERT (result == input + 15);
      48    }
      49  
      50    {
      51      const char input[] = "ABC ABCDAB ABCDABCDABDE";
      52      const char *result = mbsstr (input, "ABCDABE");
      53      ASSERT (result == NULL);
      54    }
      55  
      56    /* Check that a very long haystack is handled quickly if the needle is
      57       short and occurs near the beginning.  */
      58    {
      59      size_t repeat = 10000;
      60      size_t m = 1000000;
      61      const char *needle =
      62        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
      63        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
      64      char *haystack = (char *) malloc (m + 1);
      65      if (haystack != NULL)
      66        {
      67          memset (haystack, 'A', m);
      68          haystack[0] = 'B';
      69          haystack[m] = '\0';
      70  
      71          for (; repeat > 0; repeat--)
      72            {
      73              ASSERT (mbsstr (haystack, needle) == haystack + 1);
      74            }
      75  
      76          free (haystack);
      77        }
      78    }
      79  
      80    /* Check that a very long needle is discarded quickly if the haystack is
      81       short.  */
      82    {
      83      size_t repeat = 10000;
      84      size_t m = 1000000;
      85      const char *haystack =
      86        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
      87        "ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB";
      88      char *needle = (char *) malloc (m + 1);
      89      if (needle != NULL)
      90        {
      91          memset (needle, 'A', m);
      92          needle[m] = '\0';
      93  
      94          for (; repeat > 0; repeat--)
      95            {
      96              ASSERT (mbsstr (haystack, needle) == NULL);
      97            }
      98  
      99          free (needle);
     100        }
     101    }
     102  
     103    /* Check that the asymptotic worst-case complexity is not quadratic.  */
     104    {
     105      size_t m = 1000000;
     106      char *haystack = (char *) malloc (2 * m + 2);
     107      char *needle = (char *) malloc (m + 2);
     108      if (haystack != NULL && needle != NULL)
     109        {
     110          const char *result;
     111  
     112          memset (haystack, 'A', 2 * m);
     113          haystack[2 * m] = 'B';
     114          haystack[2 * m + 1] = '\0';
     115  
     116          memset (needle, 'A', m);
     117          needle[m] = 'B';
     118          needle[m + 1] = '\0';
     119  
     120          result = mbsstr (haystack, needle);
     121          ASSERT (result == haystack + m);
     122        }
     123      free (needle);
     124      free (haystack);
     125    }
     126  
     127    return 0;
     128  }