{
char *regex;
int string_count;
- char **strings;
- enum Match_Result *expected_results;
+ char *strings[20];
+ enum Match_Result expected_results[20];
};
+static const char allowed_literals[] =
+ "0123456789" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz";
+
int
-test_random (unsigned int rx_length, unsigned int max_str_len, unsigned int str_count)
+test_random (unsigned int rx_length, unsigned int max_str_len,
+ unsigned int str_count)
{
int i;
+ int j;
int rx_exp;
- char rand_rx[rx_length+1];
- char matching_str[str_count][max_str_len+1];
+ char rand_rx[rx_length + 1];
+ char matching_str[str_count][max_str_len + 1];
char *rand_rxp;
char *matching_strp;
int char_op_switch;
struct GNUNET_REGEX_Automaton *dfa;
regex_t rx;
regmatch_t matchptr[1];
- int char_offset;
char error[200];
int result;
+ unsigned int str_len;
// At least one string is needed for matching
GNUNET_assert (str_count > 0);
rand_rxp = rand_rx;
matching_strp = matching_str[0];
+ current_char = 0;
+ last_was_op = 1;
// Generate random regex and a string that matches the regex
- for (i=0; i<rx_length; i++)
+ for (i = 0; i < rx_length; i++)
{
- char_op_switch = 0 + (int)(1.0 * rand() / (RAND_MAX + 1.0));
- char_offset = (rand()%2) ? 65 : 97;
+ char_op_switch = 0 + (int) (1.0 * rand () / (RAND_MAX + 1.0));
- if (0 == char_op_switch
- && !last_was_op)
+ if (0 == char_op_switch && !last_was_op)
{
last_was_op = 1;
- rx_exp = rand () % 3;
+ rx_exp = rand () % 4;
switch (rx_exp)
{
- case 0:
- current_char = '+';
- break;
- case 1:
- current_char = '*';
- break;
- case 2:
- if (i < rx_length -1)
- current_char = '|';
- else
- current_char = (char)(char_offset + (int)( 25.0 * rand() / (RAND_MAX + 1.0)));
- break;
+ 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 =
+ allowed_literals[rand () % (sizeof (allowed_literals) - 1)];
+ break;
}
}
else
{
- current_char = (char)(char_offset + (int)( 25.0 * rand() / (RAND_MAX + 1.0)));
+ current_char =
+ allowed_literals[rand () % (sizeof (allowed_literals) - 1)];
last_was_op = 0;
}
- if (current_char != '+'
- && current_char != '*'
- && current_char != '|')
+ if (current_char != '+' && current_char != '*' && current_char != '?' &&
+ current_char != '|')
{
*matching_strp = current_char;
matching_strp++;
*rand_rxp = '\0';
*matching_strp = '\0';
- result = 0;
+ // Generate some random strings for matching...
+ // Start at 1, because the first string is generated above during regex generation
+ for (i = 1; i < str_count; i++)
+ {
+ str_len = rand () % max_str_len;
+ for (j = 0; j < str_len; j++)
+ matching_str[i][j] =
+ allowed_literals[rand () % (sizeof (allowed_literals) - 1)];
+ matching_str[i][str_len] = '\0';
+ }
- for (i=0; i<str_count; i++)
+ // Now match
+ result = 0;
+ for (i = 0; i < str_count; i++)
{
// Match string using DFA
dfa = GNUNET_REGEX_construct_dfa (rand_rx, strlen (rand_rx));
// Match string using glibc regex
if (0 != regcomp (&rx, rand_rx, REG_EXTENDED))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not compile regex using regcomp\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Could not compile regex using regcomp\n");
return -1;
}
eval_check = regexec (&rx, matching_str[i], 1, matchptr, 0);
+ regfree (&rx);
// We only want to match the whole string, because that's what our DFA does, too.
- if (eval_check == 0 && (matchptr[0].rm_so != 0 || matchptr[0].rm_eo != strlen (matching_str[i])))
+ if (eval_check == 0 &&
+ (matchptr[0].rm_so != 0 ||
+ matchptr[0].rm_eo != strlen (matching_str[i])))
eval_check = 1;
// compare result
}
int
-test_automaton (struct GNUNET_REGEX_Automaton *a, regex_t *rx, struct Regex_String_Pair *rxstr)
+test_automaton (struct GNUNET_REGEX_Automaton *a, regex_t * rx,
+ struct Regex_String_Pair *rxstr)
{
int result;
int eval;
int eval_check;
char error[200];
+ regmatch_t matchptr[1];
int i;
if (NULL == a)
result = 0;
- for (i=0; i<rxstr->string_count; i++)
+ for (i = 0; i < rxstr->string_count; i++)
{
eval = GNUNET_REGEX_eval (a, rxstr->strings[i]);
- eval_check = regexec (rx, rxstr->strings[i], 0, NULL, 0);
+ eval_check = regexec (rx, rxstr->strings[i], 1, matchptr, 0);
+
+ // We only want to match the whole string, because that's what our DFA does, too.
+ if (eval_check == 0 &&
+ (matchptr[0].rm_so != 0 ||
+ matchptr[0].rm_eo != strlen (rxstr->strings[i])))
+ eval_check = 1;
- if ((rxstr->expected_results[i] == match
- && (0 != eval || 0 != eval_check))
- ||
- (rxstr->expected_results[i] == nomatch
- && (0 == eval || 0 == eval_check)))
+ if ((rxstr->expected_results[i] == match && (0 != eval || 0 != eval_check))
+ || (rxstr->expected_results[i] == nomatch &&
+ (0 == eval || 0 == eval_check)))
{
- result = 1;
- regerror (eval_check, rx, error, sizeof error);
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Unexpected result:\nregex: %s\nstring: %s\nexpected result: %i\ngnunet regex: %i\nglibc regex: %i\nglibc error: %s\n\n",
- rxstr->regex, rxstr->strings[i], rxstr->expected_results[i], eval, eval_check, error);
+ result = 1;
+ regerror (eval_check, rx, error, sizeof error);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Unexpected result:\nregex: %s\nstring: %s\nexpected result: %i\n"
+ "gnunet regex: %i\nglibc regex: %i\nglibc error: %s\nrm_so: %i\nrm_eo: %i\n\n",
+ rxstr->regex, rxstr->strings[i], rxstr->expected_results[i],
+ eval, eval_check, error, matchptr[0].rm_so,
+ matchptr[0].rm_eo);
}
}
return result;
#endif
NULL);
- int check_nfa;
- int check_dfa;
- int check_rand;
- struct Regex_String_Pair rxstr[3];
struct GNUNET_REGEX_Automaton *a;
regex_t rx;
int i;
+ int check_nfa;
+ int check_dfa;
+ int check_rand;
+
+ struct Regex_String_Pair rxstr[4] = {
+ {"ab(c|d)+c*(a(b|c)d)+", 5,
+ {"abcdcdcdcdddddabd", "abcd", "abcddddddccccccccccccccccccccccccabdacdabd",
+ "abccccca", "abcdcdcdccdabdabd"},
+ {match, nomatch, match, nomatch, match}},
+ {"ab+c*(a(bx|c)d)+", 5,
+ {"abcdcdcdcdddddabd", "abcd", "abcddddddccccccccccccccccccccccccabdacdabd",
+ "abccccca", "abcdcdcdccdabdabd"},
+ {nomatch, nomatch, nomatch, nomatch, nomatch}},
+ {"k|a+X*y+c|Q*e|p|R|Z*K*y*R+w|Y*6+n+h*k*w+V*F|W*B*e*g|N+V|t+L|P*j*3*9+X*h*J|J*6|b|E*i*f*R+S|Z|R|Y*Z|g*", 1,
+ {"kaXycQepRZKyRwY6nhkwVFWBegNVtLPj39XhJJ6bEifRSZRYZg"},
+ {nomatch}},
+ {"ab?(abcd)?", 5,
+ {"ababcd", "abab", "aabcd", "a", "abb"},
+ {match, nomatch, match, match, nomatch}}
+ };
check_nfa = 0;
check_dfa = 0;
check_rand = 0;
- rxstr[0].regex = "ab(c|d)+c*(a(b|c)d)+";
- rxstr[0].string_count = 5;
- rxstr[0].strings = GNUNET_malloc (sizeof (char *) * rxstr[0].string_count);
- rxstr[0].strings[0] = "abcdcdcdcdddddabd";
- rxstr[0].strings[1] = "abcd";
- rxstr[0].strings[2] = "abcddddddccccccccccccccccccccccccabdacdabd";
- rxstr[0].strings[3] = "abccccca";
- rxstr[0].strings[4] = "abcdcdcdccdabdabd";
- rxstr[0].expected_results = GNUNET_malloc (sizeof (enum Match_Result) * rxstr[0].string_count);
- rxstr[0].expected_results[0] = match;
- rxstr[0].expected_results[1] = nomatch;
- rxstr[0].expected_results[2] = match;
- rxstr[0].expected_results[3] = nomatch;
- rxstr[0].expected_results[4] = match;
-
- for (i=0; i<1; i++)
+ for (i = 0; i < 4; i++)
{
- if (0 != regcomp (&rx, rxstr->regex, REG_EXTENDED | REG_NOSUB))
+ if (0 != regcomp (&rx, rxstr[i].regex, REG_EXTENDED))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not compile regex using regcomp()\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Could not compile regex using regcomp()\n");
return 1;
}
regfree (&rx);
}
- srand (time(NULL));
- for (i=0; i< 100; i++)
- check_rand += test_random (100, 100, 1);
+ srand (time (NULL));
+ for (i = 0; i < 100; i++)
+ check_rand += test_random (200, 250, 20);
return check_nfa + check_dfa + check_rand;
}