Beispiel #1
0
void test_parse_with_prefix() {
    struct raw_event* raw;

    raw = lst_parse(":prefix TEST This is a message test with prefix");

    mu_assert(s_eq(raw->prefix, "prefix"), "test_parse_with_prefix: prefix should be 'prefix'"); 
    mu_assert(s_eq(raw->type, "TEST"), "test_parse_with_prefix: type should be 'TEST'"); 
    mu_assert(raw->num_params == 7, "test_parse_with_prefix: there should be 7 parameters");

    evt_raw_destroy(raw);   /* Cleanup */
}
Beispiel #2
0
void test_parse_with_prefix_and_last_param() {
    char* last_param;
    struct raw_event* raw;

    raw = lst_parse(":prefix TEST This is a message test with a :last parameter");
    last_param = raw->params[raw->num_params - 1];

    mu_assert(s_eq(raw->prefix, "prefix"), "test_parse_with_prefix_and_last_param: prefix should be 'prefix'"); 
    mu_assert(s_eq(raw->type, "TEST"), "test_parse_with_prefix_and_last_param: type should be 'TEST'"); 
    mu_assert(raw->num_params == 8, "test_parse_with_prefix_and_last_param: there should be 8 parameters");
    mu_assert(s_eq(last_param, "last parameter"), "test_parse_with_prefix_and_last_param: last parameter should be 'last parameter'");

    evt_raw_destroy(raw);   /* Cleanup */
}
Beispiel #3
0
void test_parse_with_prefix_only_last_param() {
    char* last_param;
    struct raw_event* raw;

    raw = lst_parse(":prefix TEST :only last parameter");
    last_param = raw->params[raw->num_params - 1];

    mu_assert(s_eq(raw->prefix, "prefix"), "test_parse_with_prefix_only_last_param: prefix should be 'prefix'"); 
    mu_assert(s_eq(raw->type, "TEST"), "test_parse_with_prefix_only_last_param: type should be 'TEST'"); 
    mu_assert(raw->num_params == 1, "test_parse_with_prefix_only_last_param: there should be 1 parameters");
    mu_assert(s_eq(last_param, "only last parameter"), "test_parse_with_prefix_only_last_param: last parameter should be 'only last parameter'");

    evt_raw_destroy(raw);   /* Cleanup */
}
Beispiel #4
0
/// Parse `name = value`.
static bool parseNameValuePair(ASTSetQuery::Change & change, IParser::Pos & pos, IParser::Pos end, IParser::Pos & max_parsed_pos, Expected & expected)
{
    ParserIdentifier name_p;
    ParserLiteral value_p;
    ParserWhiteSpaceOrComments ws;
    ParserString s_eq("=");

    ASTPtr name;
    ASTPtr value;

    ws.ignore(pos, end);

    if (!name_p.parse(pos, end, name, max_parsed_pos, expected))
        return false;

    ws.ignore(pos, end);

    if (!s_eq.ignore(pos, end, max_parsed_pos, expected))
        return false;

    ws.ignore(pos, end);

    if (!value_p.parse(pos, end, value, max_parsed_pos, expected))
        return false;

    ws.ignore(pos, end);

    change.name = typeid_cast<const ASTIdentifier &>(*name).name;
    change.value = typeid_cast<const ASTLiteral &>(*value).value;

    return true;
}
Beispiel #5
0
void test_irc_nick() {
    char msg[READ_BUF];

    irc_nick("circus");
    read_mock(msg);

    mu_assert(s_eq(msg, "NICK circus\r\n"), "test_irc_nick: msg should be 'NICK circus\\r\\n'");
}
Beispiel #6
0
void test_irc_topic() {
    char msg[READ_BUF];

    irc_topic("#circus", "The topic");
    read_mock(msg);

    mu_assert(s_eq(msg, "TOPIC #circus :The topic\r\n"), "test_irc_topic: msg should be 'TOPIC #circus :The topic\\r\\n'");
}
Beispiel #7
0
void test_irc_pong() {
    char msg[READ_BUF];

    irc_pong("irc.freenode.net");
    read_mock(msg);

    mu_assert(s_eq(msg, "PONG irc.freenode.net\r\n"), "test_irc_pong: msg should be 'PONG irc.freenode.net\\r\\n'");
}
Beispiel #8
0
void test_irc_names() {
    char msg[READ_BUF];

    irc_names("#circus");
    read_mock(msg);

    mu_assert(s_eq(msg, "NAMES #circus\r\n"), "test_irc_names: msg should be 'NAMES #circus\\r\\n'");
}
Beispiel #9
0
void test_irc_channel_unset() {
    char msg[READ_BUF];

    irc_channel_unset("#circus", CH_PRIVATE | CH_SECRET);
    read_mock(msg);

    mu_assert(s_eq(msg, "MODE #circus -ps\r\n"), "test_irc_channel_unset: msg should be 'MODE #circus -ps\\r\\n'");
}
Beispiel #10
0
void test_irc_part() {
    char msg[READ_BUF];

    irc_part("#circus");
    read_mock(msg);

    mu_assert(s_eq(msg, "PART #circus\r\n"), "test_irc_part: msg should be 'PART #circus\\r\\n'");
}
Beispiel #11
0
void test_irc_raw() {
    char msg[READ_BUF];

    irc_raw("prefix", "type", "message");
    read_mock(msg);

    mu_assert(s_eq(msg, ":prefix type message\r\n"), "test_irc_raw: msg should be ':prefix type message\\r\\n'");
}
Beispiel #12
0
void test_irc_join_pass() {
    char msg[READ_BUF];

    irc_join_pass("#circus", "foo");
    read_mock(msg);

    mu_assert(s_eq(msg, "JOIN #circus foo\r\n"), "test_irc_join_pass: msg should be 'JOIN #circus foo\\r\\n'");
}
Beispiel #13
0
void test_irc_join() {
    char msg[READ_BUF];

    irc_join("#circus");
    read_mock(msg);

    mu_assert(s_eq(msg, "JOIN #circus\r\n"), "test_irc_join: msg should be 'JOIN #circus\\r\\n'");
}
Beispiel #14
0
void test_irc_quit() {
    char msg[READ_BUF];

    irc_quit("Bye");
    read_mock(msg);

    mu_assert(s_eq(msg, "QUIT :Bye\r\n"), "test_irc_quit: msg should be 'QUIT :Bye\\r\\n'");
}
Beispiel #15
0
void test_irc_invite() {
    char msg[READ_BUF];

    irc_invite("circus", "#circus");
    read_mock(msg);

    mu_assert(s_eq(msg, "INVITE circus #circus\r\n"), "test_irc_invite: msg should be 'INVITE circus #circus\\r\\n'");
}
Beispiel #16
0
void test_irc_user_unset() {
    char msg[READ_BUF];

    irc_user_unset("circus", USR_INVISIBLE | USR_OPERATOR);
    read_mock(msg);

    mu_assert(s_eq(msg, "MODE circus -io\r\n"), "test_irc_user_unset: msg should be 'MODE circus -io\\r\\n'");
}
Beispiel #17
0
void test_irc_channel_key() {
    char msg[READ_BUF];

    irc_channel_key("#circus", "Foo");
    read_mock(msg);

    mu_assert(s_eq(msg, "MODE #circus +k Foo\r\n"), "test_irc_channel_key: msg should be 'MODE #circus +k Foo\\r\\n'");
}
Beispiel #18
0
void test_irc_limit() {
    char msg[READ_BUF];

    irc_limit("#circus", 10);
    read_mock(msg);

    mu_assert(s_eq(msg, "MODE #circus +l 10\r\n"), "test_irc_limit: msg should be 'MODE #circus +l 10\\r\\n'");
}
Beispiel #19
0
void test_irc_list() {
    char msg[READ_BUF];

    irc_list();
    read_mock(msg);

    mu_assert(s_eq(msg, "LIST\r\n"), "test_irc_list: msg should be 'LIST\\r\\n'");
}
Beispiel #20
0
void test_irc_ban_list() {
    char msg[READ_BUF];

    irc_ban_list("#circus");
    read_mock(msg);

    mu_assert(s_eq(msg, "MODE #circus +b\r\n"), "test_irc_ban_list: msg should be 'MODE #circus +b\\r\\n'");
}
Beispiel #21
0
void test_irc_unban() {
    char msg[READ_BUF];

    irc_unban("#circus", "*!*@*");
    read_mock(msg);

    mu_assert(s_eq(msg, "MODE #circus -b *!*@*\r\n"), "test_irc_unban: msg should be 'MODE #circus -b *!*@*\\r\\n'");
}
Beispiel #22
0
void test_irc_kick() {
    char msg[READ_BUF];

    irc_kick("#circus", "circus", "Foo");
    read_mock(msg);

    mu_assert(s_eq(msg, "KICK #circus circus :Foo\r\n"), "test_irc_kick: msg should be 'KICK #circus circus :Foo\\r\\n'");
}
Beispiel #23
0
void test_irc_devoice() {
    char msg[READ_BUF];

    irc_devoice("#circus", "circus");
    read_mock(msg);

    mu_assert(s_eq(msg, "MODE #circus -v circus\r\n"), "test_irc_devoice: msg should be 'MODE #circus -v circus\\r\\n'");
}
Beispiel #24
0
void test_irc_user() {
    char msg[READ_BUF];

    irc_user("Circus", "Circus IRC");
    read_mock(msg);

    mu_assert(s_eq(msg, "USER Circus hostname server :Circus IRC\r\n"),
            "test_irc_user: msg should be 'USER Circus hostname server :Circus IRC\\r\\n'");
}
Beispiel #25
0
void test_irc_message() {
    char msg[READ_BUF];

    irc_message("#circus", "Foo bar");
    read_mock(msg);

    mu_assert(s_eq(msg, "PRIVMSG #circus :Foo bar\r\n"),
            "test_irc_message: msg should be 'PRIVMSG #circus :Foo bar\\r\\n'");
}
Beispiel #26
0
void test_parse() {
    struct raw_event* raw;

    raw = lst_parse("TEST This is a message test without prefix");

    mu_assert(raw->prefix == NULL, "test_parse: prefix should be NULL"); 
    mu_assert(s_eq(raw->type, "TEST"), "test_parse: type should be TEST"); 
    mu_assert(raw->num_params == 7, "test_parse: there should be 7 parameters");

    evt_raw_destroy(raw);   /* Cleanup */
}
Beispiel #27
0
ListEvent evt_list(struct raw_event *raw) {
    ListEvent event;
    event.timestamp = &raw->timestamp;
    event.channel = NULL;
    event.num_users = 0;
    event.topic = NULL;
    event.finished = s_eq(raw->type, RPL_LISTEND);
    if (!event.finished) {
        event.channel = raw->params[1];
        event.num_users = atoi(raw->params[2]);
        event.topic = raw->params[3];
    }
    return event;
}
Beispiel #28
0
NamesEvent evt_names(struct raw_event *raw) {
    char* token, *next = NULL;
    NamesEvent event;
    event.timestamp = &raw->timestamp;
    event.finished = s_eq(raw->type, RPL_ENDOFNAMES);
    event.channel = raw->params[event.finished? 1 : 2];
    event.num_names = 0;
    if (!event.finished) {
        token = strtok_r(raw->params[3], " ", &next);
        while(token != NULL) {
            event.names[event.num_names++] = token;
            token = strtok_r(NULL, " ", &next);
        }
    }
    return event;
}
bool ParserInsertQuery::parseImpl(Pos & pos, Pos end, ASTPtr & node, Pos & max_parsed_pos, Expected & expected)
{
	Pos begin = pos;

	ParserWhiteSpaceOrComments ws;
	ParserString s_insert("INSERT", true, true);
	ParserString s_into("INTO", true, true);
	ParserString s_dot(".");
	ParserString s_id("ID");
	ParserString s_eq("=");
	ParserStringLiteral id_p;
	ParserString s_values("VALUES", true, true);
	ParserString s_format("FORMAT", true, true);
	ParserString s_select("SELECT", true, true);
	ParserString s_lparen("(");
	ParserString s_rparen(")");
	ParserIdentifier name_p;
	ParserList columns_p(std::make_unique<ParserCompoundIdentifier>(), std::make_unique<ParserString>(","), false);

	ASTPtr database;
	ASTPtr table;
	ASTPtr columns;
	ASTPtr format;
	ASTPtr select;
	ASTPtr id;
	/// Данные для вставки
	const char * data = nullptr;

	ws.ignore(pos, end);

	/// INSERT INTO
	if (!s_insert.ignore(pos, end, max_parsed_pos, expected)
		|| !ws.ignore(pos, end)
		|| !s_into.ignore(pos, end, max_parsed_pos, expected))
		return false;

	ws.ignore(pos, end);

	if (!name_p.parse(pos, end, table, max_parsed_pos, expected))
		return false;

	ws.ignore(pos, end);

	if (s_dot.ignore(pos, end, max_parsed_pos, expected))
	{
		database = table;
		if (!name_p.parse(pos, end, table, max_parsed_pos, expected))
			return false;

		ws.ignore(pos, end);
	}

	ws.ignore(pos, end);

	if (s_id.ignore(pos, end, max_parsed_pos, expected))
	{
		if (!s_eq.ignore(pos, end, max_parsed_pos, expected))
			return false;

		ws.ignore(pos, end);

		if (!id_p.parse(pos, end, id, max_parsed_pos, expected))
			return false;
	}

	ws.ignore(pos, end);

	/// Есть ли список столбцов
	if (s_lparen.ignore(pos, end, max_parsed_pos, expected))
	{
		ws.ignore(pos, end);

		if (!columns_p.parse(pos, end, columns, max_parsed_pos, expected))
			return false;

		ws.ignore(pos, end);

		if (!s_rparen.ignore(pos, end, max_parsed_pos, expected))
			return false;
	}

	ws.ignore(pos, end);

	Pos before_select = pos;

	/// VALUES или FORMAT или SELECT
	if (s_values.ignore(pos, end, max_parsed_pos, expected))
	{
		ws.ignore(pos, end);
		data = pos;
		pos = end;
	}
	else if (s_format.ignore(pos, end, max_parsed_pos, expected))
	{
		ws.ignore(pos, end);

		if (!name_p.parse(pos, end, format, max_parsed_pos, expected))
			return false;

		/// Данные начинаются после первого перевода строки, если такой есть, или после всех пробельных символов, иначе.
		ParserWhiteSpaceOrComments ws_without_nl(false);

		ws_without_nl.ignore(pos, end);
		if (pos != end && *pos == ';')
			throw Exception("You have excessive ';' symbol before data for INSERT.\n"
				"Example:\n\n"
				"INSERT INTO t (x, y) FORMAT TabSeparated\n"
				"1\tHello\n"
				"2\tWorld\n"
				"\n"
				"Note that there is no ';' in first line.", ErrorCodes::SYNTAX_ERROR);

		if (pos != end && *pos == '\n')
			++pos;

		data = pos;
		pos = end;
	}
	else if (s_select.ignore(pos, end, max_parsed_pos, expected))
	{
		pos = before_select;
		ParserSelectQuery select_p;
		select_p.parse(pos, end, select, max_parsed_pos, expected);
	}
	else
	{
		expected = "VALUES or FORMAT or SELECT";
		return false;
	}

	auto query = std::make_shared<ASTInsertQuery>(StringRange(begin, data ? data : pos));
	node = query;

	if (database)
		query->database = typeid_cast<ASTIdentifier &>(*database).name;

	query->table = typeid_cast<ASTIdentifier &>(*table).name;

	if (id)
		query->insert_id = safeGet<const String &>(typeid_cast<ASTLiteral &>(*id).value);

	if (format)
		query->format = typeid_cast<ASTIdentifier &>(*format).name;

	query->columns = columns;
	query->select = select;
	query->data = data != end ? data : NULL;
	query->end = end;

	if (columns)
		query->children.push_back(columns);
	if (select)
		query->children.push_back(select);

	return true;
}
Beispiel #30
0
int main(int argc, char** argv) {
    int error = 1;

    printf("Set Testing Framework\n");
    printf("\n");

    // Test equality first so we can use it in later tests
    printf("Phase 0: Testing equality methods.\n");
    {
        set *s1 = malloc(sizeof(set));
        set *s2 = malloc(sizeof(set));
        int numbers[8] = { -1, 5, 8, 2, 3, 5, 9, 10 };
        int order1 [8] = { 0, 7, 3, 2, 4, 5, 6, 1 };
        int order2 [8] = { 6, 2, 7, 3, 1, 0, 5, 4 };
        int i;
        for (i = 0; i < 8; i++) {
            s_add(s1, numbers[order1[i]]);
            s_add(s2, numbers[order2[i]]);
        }
        bool eq = s_eq(s1, s2);
        if (!eq) {
            return error;
        }
        printf("Equal sets are equal.\n");
        error++;

        bool seq = s_subseteq(s1, s2) && s_subseteq(s2, s1);
        if (!seq) {
            return error;
        }
        printf("Subset works both ways.\n");
        error++;
    }

    printf("\n");
    printf("Phase I: Testing single-set operations.\n");
    {
        set *s = malloc(sizeof(set));
        printf("Set created.\n");
        error++;

        printf("Adding numbers.\n");
        s_add(s, 1);
        s_add(s, 0);
        s_add(s, 6);
        s_add(s, 6);
        s_add(s, 1);
        s_add(s, -1);
        // set is now { 1, 0, 6, -1 }

        if (s_size(s) != 4) {
            return error;
        }
        printf("Size correct.\n");
        error++;

        printf("Removing numbers.\n");
        s_remove(s, 3); // nothing
        s_remove(s, 1); // -1
        s_remove(s, 6); // -2
        // set is now { 0, -1 }

        if (s_size(s) != 2) {
            return error;
        }
        printf("Size still correct.\n");
        error++;

        printf("Testing s_contains.\n");
        {
            bool okay = true;
            okay &= s_contains(s, 0);
            okay &= (!s_contains(s, 1));
            okay &= s_contains(s, -1);
            okay &+ (!s_contains(s, 8));
            if (!okay) {
                return error;
            }
        }
        printf("s_contains works as intended.\n");
        error++;

    }

    printf("\n");
    printf("Phase II: Testing Multi-Set Operations\n");
    {
        set *s1 = malloc(sizeof(set)), *s2 = malloc(sizeof(set));
        printf("Two sets created.\n");
        error++;

        s_add(s1, 1);
        s_add(s1, 3);
        s_add(s1, 7);

        s_add(s2, 5);
        s_add(s2, -2);
        s_add(s2, 3);

        printf("Two sets filled.\n");
        error++;

        {
            set *sr_union = s_union(s1, s2);
            printf("Union created.\n");
            error++;

            int shouldBe[5] = { -2, 1, 3, 5, 7 };
            int size = sizeof(shouldBe) / sizeof(int);
            if (s_size(sr_union) != size) {
                node *n = sr_union -> first;
                while (n != NULL ) {
                    printf("%d ", n -> value);
                    n = n -> next;
                }
                printf("\n");
                printf("Size is %d but should be %d!\n", s_size(sr_union), size);
                return error;
            }
            printf("Size correct (getting good at this).\n");
            error++;

            int i;
            for (i = 0; i < size; i++) {
                if (!s_contains(sr_union, shouldBe[i])) {
                    return error;
                }
            }
            printf("Union set contains all required elements.\n");
            error++;

        }{
            set *sr_isect = s_isect(s1, s2);
            printf("Intersection created.\n");
            error++;

            int shouldBe[1] = { 3 };
            int size = sizeof(shouldBe) / sizeof(int);
            if (s_size(sr_isect) != size) {
                return error;
            }
            printf("Size correct (again).\n");
            error++;

            int i;
            for (i = 0; i < size; i++) {
                if (!s_contains(sr_isect, shouldBe[i])) {
                    return error;
                }
            }
            printf("Intersection set contains all required elements.\n");
            error++;

        }{
            set *sr_diff = s_diff(s1, s2);
            printf("Difference created.\n");
            error++;

            int shouldBe[2] = { 1, 7 };
            int size = sizeof(shouldBe) / sizeof(int);
            if (s_size(sr_diff) != size) {
                return error;
            }
            printf("Size correct (miraculously).\n");
            error++;

            int i;
            for (i = 0; i < size; i++) {
                if (!s_contains(sr_diff, shouldBe[i])) {
                    return error;
                }
            }
            printf("Difference set contains all required elements.\n");
            error++;

        }
    }

    printf("\n");
    printf("Phase III: Testing Specification");
    {
        set *s = malloc(sizeof(set));
        printf("Set created.\n");
        error++;

        int list[6] = { -2, -1, 1, 4, 8, 9 };
        int size = sizeof(list) / sizeof(int);

        int i;
        for (i = 0; i < size; i++) {
            s_add(s, list[i]);
        }
        printf("Set filled.\n");
        error++;

        printf("Testing specification with p(x) = (x >= 3).\n");
        {
            set *sr_p1 = s_spec(s, p1);
            printf("Specification complete.\n");
            error++;

            int expected[3] = { 4, 8, 9 };
            int expectedSize = sizeof(expected) / sizeof(int);

            if (s_size(sr_p1) != expectedSize) {
                return error;
            }
            printf("Specification size correct - phew!\n");
            error++;

            int j;
            for (j = 0; j < expectedSize; j++) {
                if (!s_contains(sr_p1, expected[j])) {
                    return error;
                }
            }
            printf("Set contains all required elements.\n");
        }

        printf("Testing specification with p(x) = (x %% 2 == 0).\n");
        {
            set *sr_p1 = s_spec(s, p2);
            printf("Specification complete.\n");
            error++;

            int expected[3] = { -2, 4, 8 };
            int expectedSize = sizeof(expected) / sizeof(int);

            if (s_size(sr_p1) != expectedSize) {
                return error;
            }
            printf("Specification size correct; what a surprise.\n");
            error++;

            int j;
            for (j = 0; j < expectedSize; j++) {
                if (!s_contains(sr_p1, expected[j])) {
                    return error;
                }
            }
            printf("Set contains all required elements.\n");
        }

    }
    printf("\n");
    printf("Phase IV: Testing Image\n");
    {
        set *s = malloc(sizeof(set));
        set *control  = malloc(sizeof(set));
        set *control2 = malloc(sizeof(set)); // image with predicate lambda x: x >= 3
        int toadd[6]     = { -1,  3,  5, 2, 0, 1 };
        int expected[6]  = {  3, 11, 27, 6, 2, 3 };
        int expected2[6] = {     11, 27          };
        int i;
        for (i = 0; i< 6; i++) {
            s_add(s, toadd[i]);
            s_add(control, expected[i]);
            if (i < 2) s_add(control2, expected2[i]);
        }
        set *image = s_fullimage(s, f);
        bool eq = s_eq(image, control);
        if (!eq) {
            return error;
        }
        printf("Full image set matches control set.\n");
        error++;

        set *pimage = s_image(s, p1, f);
        bool peq = s_eq(pimage, control2);
        if (!peq) {
            return error;
        }
        printf("Partial image set matches control set.\n");
        error++;
    }

    printf("\n");
    printf("Completed without error.\n");
    return 0;
}