1  /* Test of case-insensitive searching in a string.
       2     Copyright (C) 2007-2022 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 = mbscasestr (input, "");
      35      ASSERT (result == input);
      36    }
      37  
      38    {
      39      const char input[] = "foo";
      40      const char *result = mbscasestr (input, "O");
      41      ASSERT (result == input + 1);
      42    }
      43  
      44    {
      45      const char input[] = "ABC ABCDAB ABCDABCDABDE";
      46      const char *result = mbscasestr (input, "ABCDaBD");
      47      ASSERT (result == input + 15);
      48    }
      49  
      50    {
      51      const char input[] = "ABC ABCDAB ABCDABCDABDE";
      52      const char *result = mbscasestr (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        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA";
      65      char *haystack = (char *) malloc (m + 1);
      66      if (haystack != NULL)
      67        {
      68          memset (haystack, 'A', m);
      69          haystack[0] = 'B';
      70          haystack[m] = '\0';
      71  
      72          for (; repeat > 0; repeat--)
      73            {
      74              ASSERT (mbscasestr (haystack, needle) == haystack + 1);
      75            }
      76  
      77          free (haystack);
      78        }
      79    }
      80  
      81    /* Check that a very long needle is discarded quickly if the haystack is
      82       short.  */
      83    {
      84      size_t repeat = 10000;
      85      size_t m = 1000000;
      86      const char *haystack =
      87        "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
      88        "ABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABABAB";
      89      char *needle = (char *) malloc (m + 1);
      90      if (needle != NULL)
      91        {
      92          memset (needle, 'A', m);
      93          needle[m] = '\0';
      94  
      95          for (; repeat > 0; repeat--)
      96            {
      97              ASSERT (mbscasestr (haystack, needle) == NULL);
      98            }
      99  
     100          free (needle);
     101        }
     102    }
     103  
     104    /* Check that the asymptotic worst-case complexity is not quadratic.  */
     105    {
     106      size_t m = 1000000;
     107      char *haystack = (char *) malloc (2 * m + 2);
     108      char *needle = (char *) malloc (m + 2);
     109      if (haystack != NULL && needle != NULL)
     110        {
     111          const char *result;
     112  
     113          memset (haystack, 'A', 2 * m);
     114          haystack[2 * m] = 'B';
     115          haystack[2 * m + 1] = '\0';
     116  
     117          memset (needle, 'a', m);
     118          needle[m] = 'B';
     119          needle[m + 1] = '\0';
     120  
     121          result = mbscasestr (haystack, needle);
     122          ASSERT (result == haystack + m);
     123        }
     124      free (needle);
     125      free (haystack);
     126    }
     127  
     128    return 0;
     129  }