regex_test_random.c File Reference

functions for creating random regular expressions and strings More...

#include "platform.h"
#include "regex_test_lib.h"
#include "gnunet_util_lib.h"
#include "regex_internal.h"

Include dependency graph for regex_test_random.c:

Go to the source code of this file.

Functions
static char	get_random_literal ()
	Get a (pseudo) random valid literal for building a regular expression. More...
char *	REGEX_TEST_generate_random_regex (size_t rx_length, char *matching_str)
	Generate a (pseudo) random regular expression of length 'rx_length', as well as a (optional) string that will be matched by the generated regex. More...
char *	REGEX_TEST_generate_random_string (size_t max_len)
	Generate a random string of maximum length 'max_len' that only contains literals allowed in a regular expression. More...

Detailed Description

functions for creating random regular expressions and strings

Author

Maximilian Szengel

Definition in file regex_test_random.c.

Function Documentation

get_random_literal()

static char get_random_literal ( )

static

Get a (pseudo) random valid literal for building a regular expression.

Returns

random valid literal

Definition at line 37 of file regex_test_random.c.

{
  uint32_t ridx;
 
  ridx =
    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                              (uint32_t) strlen (ALLOWED_LITERALS));
 
  return ALLOWED_LITERALS[ridx];
}

References ALLOWED_LITERALS, GNUNET_CRYPTO_QUALITY_WEAK, and GNUNET_CRYPTO_random_u32().

Referenced by REGEX_TEST_generate_random_regex(), and REGEX_TEST_generate_random_string().

Here is the call graph for this function:

Here is the caller graph for this function:

REGEX_TEST_generate_random_regex()

char* REGEX_TEST_generate_random_regex	(	size_t	rx_length,
		char *	matching_str
	)

Generate a (pseudo) random regular expression of length 'rx_length', as well as a (optional) string that will be matched by the generated regex.

The returned regex needs to be freed.

Parameters

rx_length	length of the random regex.
matching_str	(optional) pointer to a string that will contain a string that will be matched by the generated regex, if 'matching_str' pointer was not NULL. Make sure you allocated at least rx_length+1 bytes for this string.

Returns

NULL if 'rx_length' is 0, a random regex of length 'rx_length', which needs to be freed, otherwise.

Definition at line 64 of file regex_test_random.c.

{
  char *rx;
  char *rx_p;
  char *matching_strp;
  unsigned int i;
  unsigned int char_op_switch;
  unsigned int last_was_op;
  int rx_op;
  char current_char;
 
  if (0 == rx_length)
    return NULL;
 
  if (NULL != matching_str)
    matching_strp = matching_str;
  else
    matching_strp = NULL;
 
  rx = GNUNET_malloc (rx_length + 1);
  rx_p = rx;
  current_char = 0;
  last_was_op = 1;
 
  for (i = 0; i < rx_length; i++)
  {
    char_op_switch = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 2);
 
    if ((0 == char_op_switch) && ! last_was_op)
    {
      last_was_op = 1;
      rx_op = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 4);
 
      switch (rx_op)
      {
      case 0:
        current_char = '+';
        break;
 
      case 1:
        current_char = '*';
        break;
 
      case 2:
        current_char = '?';
        break;
 
      case 3:
        if (i < rx_length - 1)       /* '|' cannot be at the end */
          current_char = '|';
        else
          current_char = get_random_literal ();
        break;
      }
    }
    else
    {
      current_char = get_random_literal ();
      last_was_op = 0;
    }
 
    if ((NULL != matching_strp) &&
        ((current_char != '+') && (current_char != '*') && (current_char !=
                                                            '?') &&
         (current_char != '|') ))
    {
      *matching_strp = current_char;
      matching_strp++;
    }
 
    *rx_p = current_char;
    rx_p++;
  }
  *rx_p = '\0';
  if (NULL != matching_strp)
    *matching_strp = '\0';
 
  return rx;
}

References get_random_literal(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), and GNUNET_malloc.

Here is the call graph for this function:

REGEX_TEST_generate_random_string()

char* REGEX_TEST_generate_random_string

(

size_t

max_len

)

Generate a random string of maximum length 'max_len' that only contains literals allowed in a regular expression.

The string might be 0 chars long but is garantueed to be shorter or equal to 'max_len'.

Parameters

max_len

maximum length of the string that should be generated.

Returns

random string that needs to be freed.

Definition at line 155 of file regex_test_random.c.

{
  unsigned int i;
  char *str;
  size_t len;
 
  if (1 > max_len)
    return GNUNET_strdup ("");
 
  len = (size_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, max_len);
  str = GNUNET_malloc (len + 1);
 
  for (i = 0; i < len; i++)
  {
    str[i] = get_random_literal ();
  }
 
  str[i] = '\0';
 
  return str;
}

References get_random_literal(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_malloc, GNUNET_strdup, and len.

Here is the call graph for this function: