root/lang/c/AutoUpdater/Test.cpp @ 23921

#include "AutoUpdater.h"

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <ctime>
#include <string>

#define CURRENT_VERSION 200
#define SOURCE_URL "http://www.google.co.jp"

char* get_random_data(size_t bytes) {
    using namespace std;
    size_t i = 0;
    char* data = (char*)malloc(bytes);
    if (!data) {
        assert(data);
        return NULL;
    }
    srand(time(NULL));
    for (i = 0; i < bytes; i++) {
        data[i] = (char)((255.0 * (double)rand() / (double)RAND_MAX) - 128);
    }
    return data;
}


void buffer_test() {
    using namespace std;
    assert(AU_BufferCreate(NULL));
    {
        AU_Buffer b;
        AU_Buffer* buffer;
        const char data[] = {'t','e','s','t','d','a','t','a'};
        const char data2[] = {'t','e','s','t','d','a','t','a','t','e','s','t','d','a','t','a','t','e','s','t','d','a','t','a'};

        memset(&b, 0, sizeof(b));
        assert(AU_BufferCreate(&buffer) == 0);
        assert(AU_BufferRelease(buffer) == 0);
        assert(AU_BufferCreate(&buffer) == 0);
        assert(AU_BufferAppend(buffer, data, sizeof(data)) == 0);
        assert(memcmp(data, buffer->begin, sizeof(data)) == 0);
        assert(AU_BufferAppend(buffer, data, sizeof(data)) == 0);
        assert(AU_BufferAppend(buffer, NULL, sizeof(data)));
        assert(AU_BufferAppend(&b, data, sizeof(data)));
        assert(AU_BufferAppend(buffer, data, sizeof(data)) == 0);
        assert(memcmp(data2, buffer->begin, sizeof(data2)) == 0);
        assert(AU_BufferAppend(&b, data, 0));
        assert(AU_BufferRelease(&b));
        assert(AU_BufferRelease(buffer) == 0);
    }
    {
        AU_Buffer* buffer;
        {
            std::string test;
            int i = 0;
            assert(AU_BufferCreate(&buffer) == 0);

            for (i = 1; i < 50; i++) {
                char* data = get_random_data(50 * i);
                test.append(data, 50 * i);
                assert(AU_BufferAppend(buffer, data, 50 * i) == 0);
                assert(memcmp(test.data(), buffer->begin, test.length()) == 0);
                free(data);
            }
            assert(AU_BufferRelease(buffer) == 0);
        }

        {
            std::string test;
            int i = 0;
            assert(AU_BufferCreate(&buffer) == 0);

            for (i = 1; i < 10; i++) {
                char* data = get_random_data(5000 * i);
                test.append(data, 5000 * i);
                assert(AU_BufferAppend(buffer, data, 5000 * i) == 0);
                assert(memcmp(test.data(), buffer->begin, test.length()) == 0);
                free(data);
            }
            assert(AU_BufferRelease(buffer) == 0);
        }
    }
}

int main() {
    using namespace std;
    assert(AU_CreateSource(NULL, CURRENT_VERSION, SOURCE_URL) == AU_ERROR_INVALID_SOURCE);

    {
        AU_Source* source;
        assert(AU_CreateSource(&source, CURRENT_VERSION, SOURCE_URL) == AU_OK);
        assert(AU_ReleaseSource(source) == AU_OK);
    }

    {
        AU_Source* source;
        assert(AU_CreateSource(&source, CURRENT_VERSION, "http://www.google.co.jp:12345/foo") == AU_OK);
        assert(AU_ReleaseSource(source) == AU_OK);
    }

    {
        AU_Source s;
        memset(&s, 0, sizeof(s));
        assert(AU_GetUpdateInformation(&s) == AU_ERROR_INVALID_SOURCE);
        assert(AU_ReleaseSource(&s) == AU_ERROR_INVALID_SOURCE);        
    }

    //{
    //    AU_Source* source;
    //    assert(AU_CreateSource(&source, CURRENT_VERSION, "http://www.google.co.jp:12345foo") == AU_ERROR_INVALID_URL_FORMAT);
    //    assert(AU_ReleaseSource(source) == AU_OK);
    //}

    //{
    //    assert(AU_CreateSource(NULL, CURRENT_VERSION, "http://www.google.co.jp:123 45 /foo") == AU_ERROR_INVALID_URL_FORMAT);        
    //}

    //{
    //    AU_Source* source;
    //    assert(AU_CreateSource(&source, CURRENT_VERSION, "http://www.google.co.jp:123 45 /foo") == AU_ERROR_INVALID_URL_FORMAT);
    //    assert(AU_ReleaseSource(source) == AU_OK);
    //}

    {
        AU_Source* source;
        AU_Result result;
        result = AU_CreateSource(&source, CURRENT_VERSION, SOURCE_URL);
        assert(result == AU_OK);
        result = AU_GetUpdateInformation(source);
        assert(AU_ReleaseSource(source) == AU_OK);
    }

    buffer_test();

    return 0;
}