nihilist/tor
1
0
Fork 0
mirror of https://gitlab.torproject.org/tpo/core/tor.git synced 2024-11-10 21:23:58 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'tor-github/pr/409'

Browse Source
This commit is contained in:
Nick Mathewson 2018-10-24 09:06:29 -04:00
commit c6d3bebb1e
5 changed files with 600 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
changes/ticket27625 Normal file
View File

@ -0,0 +1,4 @@
o Testing:
- Write some unit tests for tokenize_string() and
get_next_token() functions. Resolves ticket 27625.

1
src/test/include.am
View File

@ -182,6 +182,7 @@ src_test_test_SOURCES += \
src/test/test_x509.c \
src/test/test_helpers.c \
src/test/test_dns.c \
src/test/test_parsecommon.c \
src/test/testing_common.c \
src/test/testing_rsakeys.c \
src/ext/tinytest.c

1
src/test/test.c
View File

@ -926,5 +926,6 @@ struct testgroup_t testgroups[] = {
{ "util/thread/", thread_tests },
{ "util/handle/", handle_tests },
{ "dns/", dns_tests },
{ "parsecommon/", parsecommon_tests },
END_OF_GROUPS
};

1
src/test/test.h
View File

@ -266,6 +266,7 @@ extern struct testcase_t dns_tests[];
extern struct testcase_t handle_tests[];
extern struct testcase_t sr_tests[];
extern struct testcase_t x509_tests[];
extern struct testcase_t parsecommon_tests[];
extern struct testcase_t slow_crypto_tests[];
extern struct testcase_t slow_util_tests[];

593
src/test/test_parsecommon.c Normal file
View File

@ -0,0 +1,593 @@
/* Copyright (c) 2001-2004, Roger Dingledine.
* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
* Copyright (c) 2007-2018, The Tor Project, Inc. */
/* See LICENSE for licensing information */
#include "core/or/or.h"
#include "test/test.h"
#include "lib/memarea/memarea.h"
#include "lib/encoding/binascii.h"
#include "feature/dirparse/parsecommon.h"
#include "test/log_test_helpers.h"
static void
test_parsecommon_tokenize_string_null(void *arg)
{
memarea_t *area = memarea_new();
smartlist_t *tokens = smartlist_new();
(void)arg;
const char *str_with_null = "a\0bccccccccc";
int retval =
tokenize_string(area, str_with_null,
str_with_null + 3,
tokens, NULL, 0);
tt_int_op(retval, OP_EQ, -1);
done:
memarea_drop_all(area);
smartlist_free(tokens);
return;
}
static void
test_parsecommon_tokenize_string_multiple_lines(void *arg)
{
memarea_t *area = memarea_new();
smartlist_t *tokens = smartlist_new();
(void)arg;
token_rule_t table[] = {
T01("uptime", K_UPTIME, GE(1), NO_OBJ),
T01("hibernating", K_HIBERNATING, GE(1), NO_OBJ),
T1( "published", K_PUBLISHED, CONCAT_ARGS, NO_OBJ),
END_OF_TABLE,
};
char *str = tor_strdup(
"hibernating 0\nuptime 1024\n"
"published 2018-10-15 10:00:00\n");
int retval =
tokenize_string(area, str, NULL,
tokens, table, 0);
tt_int_op(smartlist_len(tokens), OP_EQ, 3);
directory_token_t *token = smartlist_get(tokens, 0);
tt_int_op(token->tp, OP_EQ, K_HIBERNATING);
token = smartlist_get(tokens, 1);
tt_int_op(token->tp, OP_EQ, K_UPTIME);
token = smartlist_get(tokens, 2);
tt_int_op(token->tp, OP_EQ, K_PUBLISHED);
tt_int_op(retval, OP_EQ, 0);
done:
tor_free(str);
memarea_drop_all(area);
smartlist_free(tokens);
return;
}
static void
test_parsecommon_tokenize_string_min_cnt(void *arg)
{
memarea_t *area = memarea_new();
smartlist_t *tokens = smartlist_new();
(void)arg;
token_rule_t table[] = {
T01("uptime", K_UPTIME, EQ(2), NO_OBJ),
T01("hibernating", K_HIBERNATING, GE(1), NO_OBJ),
END_OF_TABLE,
};
// Missing "uptime"
char *str = tor_strdup("uptime 1024\nhibernating 0\n");
int retval =
tokenize_string(area, str, NULL,
tokens, table, 0);
tt_int_op(retval, OP_EQ, -1);
done:
tor_free(str);
memarea_drop_all(area);
smartlist_free(tokens);
return;
}
static void
test_parsecommon_tokenize_string_max_cnt(void *arg)
{
memarea_t *area = memarea_new();
smartlist_t *tokens = smartlist_new();
(void)arg;
token_rule_t table[] = {
T01("uptime", K_UPTIME, EQ(1), NO_OBJ),
T01("hibernating", K_HIBERNATING, GE(1), NO_OBJ),
END_OF_TABLE,
};
// "uptime" expected once, but occurs twice in input.
char *str = tor_strdup(
"uptime 1024\nuptime 2048\nhibernating 0\n");
int retval =
tokenize_string(area, str, NULL,
tokens, table, 0);
tt_int_op(retval, OP_EQ, -1);
done:
tor_free(str);
memarea_drop_all(area);
smartlist_free(tokens);
return;
}
static void
test_parsecommon_tokenize_string_at_start(void *arg)
{
memarea_t *area = memarea_new();
smartlist_t *tokens = smartlist_new();
(void)arg;
token_rule_t table[] = {
T1_START("client-name", C_CLIENT_NAME, CONCAT_ARGS, NO_OBJ),
T01("uptime", K_UPTIME, EQ(1), NO_OBJ),
END_OF_TABLE,
};
// "client-name" is not the first line.
char *str = tor_strdup(
"uptime 1024\nclient-name Alice\n");
int retval =
tokenize_string(area, str, NULL, tokens, table, 0);
tt_int_op(retval, OP_EQ, -1);
done:
tor_free(str);
memarea_drop_all(area);
smartlist_free(tokens);
return;
}
static void
test_parsecommon_tokenize_string_at_end(void *arg)
{
memarea_t *area = memarea_new();
smartlist_t *tokens = smartlist_new();
(void)arg;
token_rule_t table[] = {
T1_END("client-name", C_CLIENT_NAME, CONCAT_ARGS, NO_OBJ),
T01("uptime", K_UPTIME, EQ(1), NO_OBJ),
END_OF_TABLE,
};
// "client-name" is not the last line.
char *str = tor_strdup(
"client-name Alice\nuptime 1024\n");
int retval =
tokenize_string(area, str, NULL, tokens, table, 0);
tt_int_op(retval, OP_EQ, -1);
done:
tor_free(str);
memarea_drop_all(area);
smartlist_free(tokens);
return;
}
static void
test_parsecommon_tokenize_string_no_annotations(void *arg)
{
memarea_t *area = memarea_new();
smartlist_t *tokens = smartlist_new();
(void)arg;
token_rule_t table[] = {
A01("@last-listed", A_LAST_LISTED, CONCAT_ARGS, NO_OBJ),
END_OF_TABLE,
};
char *str = tor_strdup("@last-listed 2018-09-21 15:30:03\n");
int retval =
tokenize_string(area, str, NULL, tokens, table, 0);
tt_int_op(retval, OP_EQ, -1);
done:
tor_free(str);
memarea_drop_all(area);
smartlist_free(tokens);
return;
}
static void
test_parsecommon_get_next_token_success(void *arg)
{
memarea_t *area = memarea_new();
const char *str = "uptime 1024";
const char *end = str + strlen(str);
const char **s = &str;
token_rule_t table = T01("uptime", K_UPTIME, GE(1), NO_OBJ);
(void)arg;
directory_token_t *token = get_next_token(area, s, end, &table);
tt_int_op(token->tp, OP_EQ, K_UPTIME);
tt_int_op(token->n_args, OP_EQ, 1);
tt_str_op(*(token->args), OP_EQ, "1024");
tt_assert(!token->object_type);
tt_int_op(token->object_size, OP_EQ, 0);
tt_assert(!token->object_body);
tt_ptr_op(*s, OP_EQ, end);
done:
memarea_drop_all(area);
return;
}
static void
test_parsecommon_get_next_token_concat_args(void *arg)
{
memarea_t *area = memarea_new();
const char *str = "proto A=1 B=2";
const char *end = str + strlen(str);
const char **s = &str;
token_rule_t rule = T01("proto", K_PROTO, CONCAT_ARGS, NO_OBJ);
(void)arg;
directory_token_t *token = get_next_token(area, s, end, &rule);
tt_int_op(token->tp, OP_EQ, K_PROTO);
tt_int_op(token->n_args, OP_EQ, 1);
tt_str_op(*(token->args), OP_EQ, "A=1 B=2");
done:
memarea_drop_all(area);
}
static void
test_parsecommon_get_next_token_parse_keys(void *arg)
{
(void)arg;
memarea_t *area = memarea_new();
const char *str =
"onion-key\n"
"-----BEGIN RSA PUBLIC KEY-----\n"
"MIGJAoGBAMDdIya33BfNlHOkzoTKSTT8EjD64waMfUr372syVHiFjHhObwKwGA5u\n"
"sHaMIe9r+Ij/4C1dKyuXkcz3DOl6gWNhTD7dZ89I+Okoh1jWe30jxCiAcywC22p5\n"
"XLhrDkX1A63Z7XCH9ltwU2WMqWsVM98N2GR6MTujP7wtqdLExYN1AgMBAAE=\n"
"-----END RSA PUBLIC KEY-----\n";
const char *end = str + strlen(str);
const char **s = (const char **)&str;
directory_token_t *token = NULL;
directory_token_t *token2 = NULL;
token_rule_t rule = T1("onion-key", R_IPO_ONION_KEY, NO_ARGS, NEED_KEY_1024);
token = get_next_token(area, s, end, &rule);
tt_int_op(token->tp, OP_EQ, R_IPO_ONION_KEY);
tt_int_op(token->n_args, OP_EQ, 0);
tt_str_op(token->object_type, OP_EQ, "RSA PUBLIC KEY");
tt_int_op(token->object_size, OP_EQ, 0);
tt_assert(!token->object_body);
tt_assert(token->key);
tt_assert(!token->error);
const char *str2 =
"client-key\n"
"-----BEGIN RSA PRIVATE KEY-----\n"
"MIICXAIBAAKBgQCwS810a2auH2PQchOBz9smNgjlDu31aq0IYlUohSYbhcv5AJ+d\n"
"DY0nfZWzS+mZPwzL3UiEnTt6PVv7AgoZ5V9ZJWJTKIURjJpkK0mstfJKHKIZhf84\n"
"pmFfRej9GQViB6NLtp1obOXJgJixSlMfw9doDI4NoAnEISCyH/tD77Qs2wIDAQAB\n"
"AoGAbDg8CKkdQOnX9c7xFpCnsE8fKqz9eddgHHNwXw1NFTwOt+2gDWKSMZmv2X5S\n"
"CVZg3owZxf5W0nT0D6Ny2+6nliak7foYAvkD0BsCiBhgftwC0zAo6k5rIbUKB3PJ\n"
"QLFXgpJhqWuXkODyt/hS/GTernR437WVSEGp1bnALqiFabECQQDaqHOxzoWY/nvH\n"
"KrfUi8EhqCnqERlRHwrW0MQZ1RPvF16OPPma+xa+ht/amfh3vYN5tZY82Zm43gGl\n"
"XWL5cZhNAkEAzmdSootYVnqLLLRMfHKXnO1XbaEcA/08MDNKGlSclBJixFenE8jX\n"
"iQsUbHwMJuGONvzWpRGPBP2f8xBd28ZtxwJARY+LZshtpfNniz/ixYJESaHG28je\n"
"xfjbKOW3TQSFV+2WTifFvHEeljQwKMoMyoMGvYRwLCGJjs9JtMLVxsdFjQJBAKwD\n"
"3BBvBQ39TuPQ1zWX4tb7zjMlY83HTFP3Sriq71tP/1QWoL2SUl56B2lp8E6vB/C3\n"
"wsMK4SCNprHRYAd7VZ0CQDKn6Zhd11P94PLs0msybFEh1VXr6CEW/BrxBgbL4ls6\n"
"dbX5XO0z4Ra8gYXgObgimhyMDYO98Idt5+Z3HIdyrSc=\n"
"-----END RSA PRIVATE KEY-----\n";
const char *end2 = str2 + strlen(str2);
const char **s2 = (const char **)&str2;
token_rule_t rule2 = T01("client-key", C_CLIENT_KEY, NO_ARGS,
NEED_SKEY_1024);
token2 = get_next_token(area, s2, end2, &rule2);
tt_int_op(token2->tp, OP_EQ, C_CLIENT_KEY);
tt_int_op(token2->n_args, OP_EQ, 0);
tt_str_op(token2->object_type, OP_EQ, "RSA PRIVATE KEY");
tt_int_op(token2->object_size, OP_EQ, 0);
tt_assert(!token2->object_body);
tt_assert(token2->key);
tt_assert(!token->error);
done:
if (token) token_clear(token);
if (token2) token_clear(token2);
memarea_drop_all(area);
}
static void
test_parsecommon_get_next_token_object(void *arg)
{
memarea_t *area = memarea_new();
const char *str =
"directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
"CD1FD971855430880D3C31E0331C5C55800C2F79\n"
"-----BEGIN SIGNATURE-----\n"
"dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
"A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
"cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
"uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
"I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
"Ua9DEZB9KbJHVX1rGShrLA==\n"
"-----END SIGNATURE-----\n";
const char *end = str + strlen(str);
const char **s = &str;
token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
GE(2), NEED_OBJ);
(void)arg;
directory_token_t *token = get_next_token(area, s, end, &rule);
tt_int_op(token->tp, OP_EQ, K_DIRECTORY_SIGNATURE);
tt_int_op(token->n_args, OP_EQ, 2);
tt_str_op(token->args[0], OP_EQ,
"0232AF901C31A04EE9848595AF9BB7620D4C5B2E");
tt_str_op(token->args[1], OP_EQ,
"CD1FD971855430880D3C31E0331C5C55800C2F79");
tt_assert(!token->error);
char decoded[256];
const char *signature =
"dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
"A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
"cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
"uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
"I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
"Ua9DEZB9KbJHVX1rGShrLA==\n";
tt_assert(signature);
size_t signature_len = strlen(signature);
base64_decode(decoded, sizeof(decoded), signature, signature_len);
tt_str_op(token->object_type, OP_EQ, "SIGNATURE");
tt_int_op(token->object_size, OP_EQ, 256);
tt_mem_op(token->object_body, OP_EQ, decoded, 256);
tt_assert(!token->key);
done:
memarea_drop_all(area);
}
static void
test_parsecommon_get_next_token_err_too_many_args(void *arg)
{
memarea_t *area = memarea_new();
const char *str = "uptime 1024 1024 1024";
const char *end = str + strlen(str);
const char **s = &str;
token_rule_t table = T01("uptime", K_UPTIME, EQ(1), NO_OBJ);
(void)arg;
directory_token_t *token = get_next_token(area, s, end, &table);
tt_int_op(token->tp, OP_EQ, ERR_);
tt_str_op(token->error, OP_EQ, "Too many arguments to uptime");
done:
memarea_drop_all(area);
return;
}
static void
test_parsecommon_get_next_token_err_too_few_args(void *arg)
{
memarea_t *area = memarea_new();
const char *str = "uptime";
const char *end = str + strlen(str);
const char **s = &str;
token_rule_t table = T01("uptime", K_UPTIME, EQ(1), NO_OBJ);
(void)arg;
directory_token_t *token = get_next_token(area, s, end, &table);
tt_int_op(token->tp, OP_EQ, ERR_);
tt_str_op(token->error, OP_EQ, "Too few arguments to uptime");
done:
memarea_drop_all(area);
return;
}
static void
test_parsecommon_get_next_token_err_obj_missing_endline(void *arg)
{
memarea_t *area = memarea_new();
const char *str =
"directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
"CD1FD971855430880D3C31E0331C5C55800C2F79\n"
"-----BEGIN SIGNATURE-----\n"
"dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
"A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
"cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
"uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
"I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
"Ua9DEZB9KbJHVX1rGShrLA==\n";
const char *end = str + strlen(str);
const char **s = &str;
token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
GE(2), NEED_OBJ);
(void)arg;
directory_token_t *token = get_next_token(area, s, end, &rule);
tt_int_op(token->tp, OP_EQ, ERR_);
tt_str_op(token->error, OP_EQ, "Malformed object: missing object end line");
done:
memarea_drop_all(area);
return;
}
static void
test_parsecommon_get_next_token_err_bad_beginline(void *arg)
{
memarea_t *area = memarea_new();
const char *str =
"directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
"CD1FD971855430880D3C31E0331C5C55800C2F79\n"
"-----BEGIN SIGNATURE-Z---\n"
"dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
"A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
"cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
"uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
"I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
"Ua9DEZB9KbJHVX1rGShrLA==\n"
"-----END SIGNATURE-----\n";
const char *end = str + strlen(str);
const char **s = &str;
token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
GE(2), NEED_OBJ);
(void)arg;
directory_token_t *token = get_next_token(area, s, end, &rule);
tt_int_op(token->tp, OP_EQ, ERR_);
tt_str_op(token->error, OP_EQ, "Malformed object: bad begin line");
done:
memarea_drop_all(area);
return;
}
static void
test_parsecommon_get_next_token_err_tag_mismatch(void *arg)
{
memarea_t *area = memarea_new();
const char *str =
"directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
"CD1FD971855430880D3C31E0331C5C55800C2F79\n"
"-----BEGIN SIGNATURE-----\n"
"dLTbc1Lad/OWKBJhA/dERzDHumswTAzBFAWAz2vnQhLsebs1SOm0W/vceEsiEkiF\n"
"A+JJSzIyfywJc6Mnk7aKMEIFjOO/MaxuAp4zv+q+JonJkF0ExjMqvKR0D6pSFmfN\n"
"cnemnxGHxNuPDnKl0imbWKmWDsHtwgi4zWeTq3MekfMOXKi6gIh+bDFzCs9/Vquh\n"
"uNKJI1jW/A2DEKeaSAODEv9VoCsYSvbVVEuHCBWjeNAurd5aL26BrAolW6m7pkD6\n"
"I+cQ8dQG6Wa/Zt6gLXtBbOP2o/iDI7ahDP9diNkBI/rm4nfp9j4piTwsqpi7xz9J\n"
"Ua9DEZB9KbJHVX1rGShrLA==\n"
"-----END SOMETHINGELSE-----\n";
const char *end = str + strlen(str);
const char **s = &str;
token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
GE(2), NEED_OBJ);
(void)arg;
directory_token_t *token = get_next_token(area, s, end, &rule);
tt_int_op(token->tp, OP_EQ, ERR_);
tt_str_op(token->error, OP_EQ,
"Malformed object: mismatched end tag SIGNATURE");
done:
memarea_drop_all(area);
return;
}
static void
test_parsecommon_get_next_token_err_bad_base64(void *arg)
{
memarea_t *area = memarea_new();
const char *str =
"directory-signature 0232AF901C31A04EE9848595AF9BB7620D4C5B2E "
"CD1FD971855430880D3C31E0331C5C55800C2F79\n"
"-----BEGIN SIGNATURE-----\n"
"%%@%%%%%%%!!!'\n"
"-----END SIGNATURE-----\n";
const char *end = str + strlen(str);
const char **s = &str;
token_rule_t rule = T("directory-signature", K_DIRECTORY_SIGNATURE,
GE(2), NEED_OBJ);
(void)arg;
directory_token_t *token = get_next_token(area, s, end, &rule);
tt_int_op(token->tp, OP_EQ, ERR_);
tt_str_op(token->error, OP_EQ, "Malformed object: bad base64-encoded data");
done:
memarea_drop_all(area);
return;
}
#define PARSECOMMON_TEST(name) \
{ #name, test_parsecommon_ ## name, 0, NULL, NULL }
struct testcase_t parsecommon_tests[] = {
PARSECOMMON_TEST(tokenize_string_null),
PARSECOMMON_TEST(tokenize_string_multiple_lines),
PARSECOMMON_TEST(tokenize_string_min_cnt),
PARSECOMMON_TEST(tokenize_string_max_cnt),
PARSECOMMON_TEST(tokenize_string_at_start),
PARSECOMMON_TEST(tokenize_string_at_end),
PARSECOMMON_TEST(tokenize_string_no_annotations),
PARSECOMMON_TEST(get_next_token_success),
PARSECOMMON_TEST(get_next_token_concat_args),
PARSECOMMON_TEST(get_next_token_parse_keys),
PARSECOMMON_TEST(get_next_token_object),
PARSECOMMON_TEST(get_next_token_err_too_many_args),
PARSECOMMON_TEST(get_next_token_err_too_few_args),
PARSECOMMON_TEST(get_next_token_err_obj_missing_endline),
PARSECOMMON_TEST(get_next_token_err_bad_beginline),
PARSECOMMON_TEST(get_next_token_err_tag_mismatch),
PARSECOMMON_TEST(get_next_token_err_bad_base64),
END_OF_TESTCASES
};