token/tests/packetTest.c

/**
 * \file
 * packetTest.c: tests for my packet class
 * Copyright (C) 2011  Georg Hopp
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <stdio.h>
#include <stdlib.h>
#include <json/json.h>

#include "runtest.h"
#include "token/cclass.h"
#include "token/packet.h"
#include "token/dyntype.h"


const char testname[]  = "packetTest";
PACKET packet = NULL;


static
int
__setUp()
{
    packet = new(PACKET, NULL);

    ASSERT_INSTANCE_OF(PACKET, packet);
    return TEST_OK;
}
int (* const setUp)() = __setUp;

static
int
__tearDown()
{
    if (NULL != packet) {
        ASSERT_OBJECT(packet);
        delete(&packet);
    }

    return TEST_OK;
}
int (* const tearDown)() = __tearDown;

static
int
testDefaultInit()
{
    ASSERT_INSTANCE_OF(PACKET, packet);
    ASSERT_NULL(packet_getHeader(packet));
    ASSERT_NULL(packet_getData(packet));

    return TEST_OK;
}

static
int
testParamInit1()
{
    __tearDown();

    DYNTYPE header = dyntype_newInt(123);
    packet = new(PACKET, header, NULL);

    ASSERT_INSTANCE_OF(PACKET, packet);
    ASSERT_NULL(packet_getHeader(packet));
    ASSERT_NULL(packet_getData(packet));

    delete(&header);

    return TEST_OK;
}

static
int
testParamInit2()
{
    __tearDown();
    packet = new(PACKET, dyntype_newInt(123), dyntype_newInt(321));

    ASSERT_INSTANCE_OF(PACKET, packet);

    ASSERT_INSTANCE_OF(DYNTYPE, packet_getHeader(packet));
    ASSERT_INSTANCE_OF(DYNTYPE, packet_getData(packet));

    ASSERT_EQUAL(123, dyntype_getInt(packet_getHeader(packet)));
    ASSERT_EQUAL(321, dyntype_getInt(packet_getData(packet)));

    return TEST_OK;
}

static
int
testSetter()
{
    packet_setHeader(packet, dyntype_newInt(123));
    packet_setData(packet, dyntype_newInt(321));

    ASSERT_INSTANCE_OF(DYNTYPE, packet_getHeader(packet));

    ASSERT_INSTANCE_OF(DYNTYPE, packet_getHeader(packet));
    ASSERT_INSTANCE_OF(DYNTYPE, packet_getData(packet));

    ASSERT_EQUAL(123, dyntype_getInt(packet_getHeader(packet)));
    ASSERT_EQUAL(321, dyntype_getInt(packet_getData(packet)));

    return TEST_OK;
}

static
int
testNewFromJson() {
    struct json_object * json = json_tokener_parse("[123, 321]");

    __tearDown();
    packet = newFromJson(PACKET, json);
    json_object_put(json);

    ASSERT_INSTANCE_OF(DYNTYPE, packet_getHeader(packet));
    ASSERT_INSTANCE_OF(DYNTYPE, packet_getData(packet));

    ASSERT_EQUAL(123, dyntype_getInt(packet_getHeader(packet)));
    ASSERT_EQUAL(321, dyntype_getInt(packet_getData(packet)));

    return TEST_OK;
}

static
int
testNewFromJsonFail1() {
    struct json_object * json = json_tokener_parse("[123]");

    __tearDown();
    packet = newFromJson(PACKET, json);
    json_object_put(json);

    ASSERT_NULL(packet_getHeader(packet));
    ASSERT_NULL(packet_getData(packet));

    return TEST_OK;
}

static
int
testNewFromJsonFail2() {
    struct json_object * json = json_tokener_parse("123");

    __tearDown();
    packet = newFromJson(PACKET, json);
    json_object_put(json);

    ASSERT_NULL(packet_getHeader(packet));
    ASSERT_NULL(packet_getData(packet));

    return TEST_OK;
}

static
int
testToJson1() {
    struct json_object * json;
    char * json_str;

    toJson(packet, &json);
    json_str = calloc(
            strlen(json_object_to_json_string(json)) + 1,
            sizeof(char));
    memcpy(json_str,
            json_object_to_json_string(json),
            strlen(json_object_to_json_string(json)));

    ASSERT_STRING_EQUAL("[ null, null ]", json_str);

    json_object_put(json);
    free(json_str);

    return TEST_OK;
}

static
int
testToJson2() {
    struct json_object * json;
    char * json_str;

    testNewFromJson();
    toJson(packet, &json);
    json_str = calloc(
            strlen(json_object_to_json_string(json)) + 1,
            sizeof(char));
    memcpy(json_str,
            json_object_to_json_string(json),
            strlen(json_object_to_json_string(json)));

    ASSERT_STRING_EQUAL("[ 123, 321 ]", json_str);

    json_object_put(json);
    free(json_str);

    return TEST_OK;
}

const testfunc tests[] = {
    testDefaultInit,
    testParamInit1,
    testParamInit2,
    testSetter,
    testNewFromJson,
    testNewFromJsonFail1,
    testNewFromJsonFail2,
    testToJson1,
    testToJson2
};
const size_t count = FUNCS_COUNT(tests);

// vim: set et ts=4 sw=4: