aboutsummaryrefslogtreecommitdiffstats
path: root/tests/check_nick.c
blob: 6c4267cd204f622d12866a5dfb3f0bef4ac1553f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <stdlib.h>
#include <glib.h>
#include <gmodule.h>
#include <check.h>
#include <string.h>
#include "irc.h"
#include "set.h"
#include "misc.h"

START_TEST(test_nick_strip)
{
	int i;
	const char *get[] = { "test:", "test", "test\n", 
		"thisisaveryveryveryverylongnick", 
		"thisisave:ryveryveryverylongnick",
		"t::::est",
		"test123",
		"123test",
		"123",
		NULL };
	const char *expected[] = { "test", "test", "test", 
		"thisisaveryveryveryveryl", 
		"thisisaveryveryveryveryl", 
		"test",
		"test123",
		"_123test",
		"_123",
		NULL };

	for (i = 0; get[i]; i++) {
		char copy[60];
		strcpy(copy, get[i]);
		nick_strip(copy);
		fail_unless (strcmp(copy, expected[i]) == 0, 
					 "(%d) nick_strip broken: %s -> %s (expected: %s)", 
					 i, get[i], copy, expected[i]);
	}
}
END_TEST

START_TEST(test_nick_ok_ok)
{
	const char *nicks[] = { "foo", "bar123", "bla[", "blie]", "BreEZaH",
	                        "\\od^~", "_123", "_123test", NULL };
	int i;

	for (i = 0; nicks[i]; i++) {
		fail_unless (nick_ok(nicks[i]) == 1,
					 "nick_ok() failed: %s", nicks[i]);
	}
}
END_TEST

START_TEST(test_nick_ok_notok)
{
	const char *nicks[] = { "thisisaveryveryveryveryveryveryverylongnick",
		                    "\nillegalchar", "", "nick%", "123test", NULL };
	int i;

	for (i = 0; nicks[i]; i++) {
		fail_unless (nick_ok(nicks[i]) == 0,
					 "nick_ok() succeeded for invalid: %s", nicks[i]);
	}
}
END_TEST

Suite *nick_suite (void)
{
	Suite *s = suite_create("Nick");
	TCase *tc_core = tcase_create("Core");
	suite_add_tcase (s, tc_core);
	tcase_add_test (tc_core, test_nick_ok_ok);
	tcase_add_test (tc_core, test_nick_ok_notok);
	tcase_add_test (tc_core, test_nick_strip);
	return s;
}
next; } set_t *last_next = s->next; s->next = g_new0(set_t, 1); s = s->next; s->next = last_next; } } else { s = *head = g_new0(set_t, 1); } s->key = g_strdup(key); } if (s->def) { g_free(s->def); s->def = NULL; } if (def) { s->def = g_strdup(def); } s->eval = eval; s->data = data; return s; } set_t *set_find(set_t **head, const char *key) { set_t *s = *head; while (s) { if (g_strcasecmp(s->key, key) == 0 || (s->old_key && g_strcasecmp(s->old_key, key) == 0)) { break; } s = s->next; } return s; } char *set_getstr(set_t **head, const char *key) { set_t *s = set_find(head, key); if (!s || (!s->value && !s->def)) { return NULL; } return set_value(s); } int set_getint(set_t **head, const char *key) { char *s = set_getstr(head, key); int i = 0; if (!s) { return 0; } if (sscanf(s, "%d", &i) != 1) { return 0; } return i; } int set_getbool(set_t **head, const char *key) { char *s = set_getstr(head, key); if (!s) { return 0; } return bool2int(s); } int set_isvisible(set_t *set) { /* the default value is not stored in value, only in def */ return !((set->flags & SET_HIDDEN) || ((set->flags & SET_HIDDEN_DEFAULT) && (set->value == NULL))); } int set_setstr(set_t **head, const char *key, char *value) { set_t *s = set_find(head, key); char *nv = value; if (!s) { /* Used to do this, but it never really made sense. s = set_add( head, key, NULL, NULL, NULL ); */ return 0; } if (value == NULL && (s->flags & SET_NULL_OK) == 0) { return 0; } /* Call the evaluator. For invalid values, evaluators should now return SET_INVALID, but previously this was NULL. Try to handle that too if NULL is not an allowed value for this setting. */ if (s->eval && ((nv = s->eval(s, value)) == SET_INVALID || ((s->flags & SET_NULL_OK) == 0 && nv == NULL))) { return 0; } if (s->value) { g_free(s->value); s->value = NULL; } /* If there's a default setting and it's equal to what we're trying to set, stick with s->value = NULL. Otherwise, remember the setting. */ if (!s->def || (strcmp(nv, s->def) != 0)) { s->value = g_strdup(nv); } if (nv != value) { g_free(nv); } return 1; } int set_setint(set_t **head, const char *key, int value) { char *s = g_strdup_printf("%d", value); int retval = set_setstr(head, key, s); g_free(s); return retval; } void set_del(set_t **head, const char *key) { set_t *s = *head, *t = NULL; while (s) { if (g_strcasecmp(s->key, key) == 0) { break; } s = (t = s)->next; } if (s) { if (t) { t->next = s->next; } else { *head = s->next; } g_free(s->key); g_free(s->old_key); g_free(s->value); g_free(s->def); g_free(s); } } int set_reset(set_t **head, const char *key) { set_t *s; s = set_find(head, key); if (s) { return set_setstr(head, key, s->def); } return 0; } char *set_eval_int(set_t *set, char *value) { char *s = value; /* Allow a minus at the first position. */ if (*s == '-') { s++; } for (; *s; s++) { if (!g_ascii_isdigit(*s)) { return SET_INVALID; } } return value; } char *set_eval_bool(set_t *set, char *value) { return is_bool(value) ? value : SET_INVALID; } char *set_eval_list(set_t *set, char *value) { GSList *options = set->eval_data, *opt; for (opt = options; opt; opt = opt->next) { if (strcmp(value, opt->data) == 0) { return value; } } /* TODO: It'd be nice to show the user a list of allowed values, but we don't have enough context here to do that. May want to fix that. */ return NULL; } char *set_eval_to_char(set_t *set, char *value) { char *s = g_new(char, 3); if (*value == ' ') { strcpy(s, " "); } else { sprintf(s, "%c ", *value); } return s; } char *set_eval_oauth(set_t *set, char *value) { account_t *acc = set->data; if (bool2int(value) && strcmp(acc->pass, PASSWORD_PENDING) == 0) { *acc->pass = '\0'; } return set_eval_bool(set, value); }