Ejemplo n.º 1
0
END_TEST


static bool check_adjusted_tstamp(Streader* sr, int32_t index, void* userdata)
{
    fail_if(sr == NULL, "Callback did not get a Streader");
    fail_if(Streader_is_error_set(sr),
            "Callback was called with Streader error set: %s",
            Streader_get_error_desc(sr));
    fail_if(index < 0,
            "Callback got a negative item index (%" PRId32 ")",
            index);
    fail_if(index >= item_count,
            "Callback got too large an index (%" PRId32 ")",
            index);
    fail_if(userdata != NULL, "Callback got unexpected userdata");

    Tstamp* ts = TSTAMP_AUTO;
    fail_if(!Streader_read_tstamp(sr, ts),
            "Could not read timestamp from list index %" PRId32 ": %s",
            index, Streader_get_error_desc(sr));
    fail_if((Tstamp_get_beats(ts) != index + 10) ||
                (Tstamp_get_rem(ts) != index + 100),
            "Unexpected list item " PRIts " (expected (%d, %d))",
            PRIVALts(*ts), (int)index + 10, (int)index + 100);

    return true;
}
Ejemplo n.º 2
0
END_TEST


static bool fill_array_index(Streader* sr, const char* key, void* userdata)
{
    fail_if(sr == NULL, "Callback did not get a Streader");
    fail_if(Streader_is_error_set(sr),
            "Callback was called with Streader error set: %s",
            Streader_get_error_desc(sr));
    fail_if(key == NULL,
            "Callback did not get a key");
    fail_if(strlen(key) != 1 || strchr("0123", key[0]) == NULL,
            "Callback got an unexpected key `%s`",
            key);
    fail_if(userdata == NULL, "Callback did not get userdata");

    int arr_index = key[0] - '0';
    assert(arr_index >= 0);
    assert(arr_index < 4);
    int* array = userdata;

    int64_t num = 0;
    fail_if(!Streader_read_int(sr, &num),
            "Could not read integer from dictionary: %s",
            Streader_get_error_desc(sr));
    fail_if(num != arr_index + 10,
            "Unexpected value %" PRId64 " (expected %d)",
            num, arr_index + 10);

    array[arr_index] = (int)num;

    return true;
}
Ejemplo n.º 3
0
END_TEST


START_TEST(Whitespace_terminates_decimal_number)
{
    Streader* sr = init_with_cstr("- 1");
    double num = NAN;
    fail_if(Streader_read_float(sr, &num),
            "Streader accepted \"- 1\" as a float");

    sr = init_with_cstr("-1 .5");
    num = NAN;
    fail_if(!Streader_read_float(sr, &num),
            "Could not read float from \"-1 .5\": %s",
            Streader_get_error_desc(sr));
    fail_if(num != -1, "Streader read %f instead of -1 from \"-1 .5\"", num);

    sr = init_with_cstr("-1. 5");
    num = NAN;
    fail_if(Streader_read_float(sr, &num),
            "Streader accepted \"-1.\" as a float");

    sr = init_with_cstr("-1 e5");
    num = NAN;
    fail_if(!Streader_read_float(sr, &num),
            "Could not read float from \"-1 e5\": %s",
            Streader_get_error_desc(sr));
    fail_if(num != -1, "Streader read %f instead of -1 from \"-1 e5\"", num);

    sr = init_with_cstr("-1e 5");
    num = NAN;
    fail_if(Streader_read_float(sr, &num),
            "Streader accepted \"-1e\" as a float");
}
Ejemplo n.º 4
0
END_TEST


#define item_count 4

static bool inc_doubled_int(Streader* sr, int32_t index, void* userdata)
{
    fail_if(sr == NULL, "Callback did not get a Streader");
    fail_if(Streader_is_error_set(sr),
            "Callback was called with Streader error set: %s",
            Streader_get_error_desc(sr));
    fail_if(index < 0,
            "Callback got a negative item index (%" PRId32 ")",
            index);
    fail_if(index >= item_count,
            "Callback got too large an index (%" PRId32 ")",
            index);
    fail_if(userdata == NULL, "Callback did not get userdata");

    int64_t num = 0;
    fail_if(!Streader_read_int(sr, &num),
            "Could not read integer from list index %" PRId32 ": %s",
            index, Streader_get_error_desc(sr));
    fail_if(num != index * 2,
            "Unexpected list item %" PRId64 " (expected %" PRId32 ")",
            num, index * 2);

    int* nums = userdata;
    nums[index] = (int)num + 1;

    return true;
}
Ejemplo n.º 5
0
END_TEST


START_TEST(Read_zero_float)
{
    const char* zeros[] =
    {
        "0 x",
        "0.0 x",
        "0e0 x",
        "0.0e0 x",
        "0.0e+0 x",
        "0.0e-0 x",
    };

    for (size_t i = 0; i < arr_size(zeros); ++i)
    {
        Streader* sr = init_with_cstr(zeros[i]);
        double num = NAN;
        fail_if(!Streader_read_float(sr, &num),
                "Could not read 0 from \"%s\": %s",
                zeros[i], Streader_get_error_desc(sr));
        fail_if(num != 0,
                "Streader stored %f instead of 0 from \"%s\"",
                num, zeros[i]);
        fail_if(!Streader_match_char(sr, 'x'),
                "Streader did not consume 0 from \"%s\" correctly: %s",
                zeros[i], Streader_get_error_desc(sr));
    }

    // TODO: The code below does not test the sign of negative zero
    //       as C99 doesn't guarantee it.
    //       Revisit when migrating to emulated floats.

    const char* neg_zeros[] =
    {
        "-0 x",
        "-0.0 x",
        "-0e0 x",
        "-0.0e0 x",
        "-0.0e+0 x",
        "-0.0e-0 x",
    };

    for (size_t i = 0; i < arr_size(neg_zeros); ++i)
    {
        Streader* sr = init_with_cstr(neg_zeros[i]);
        double num = NAN;
        fail_if(!Streader_read_float(sr, &num),
                "Could not read -0 from \"%s\": %s",
                neg_zeros[i], Streader_get_error_desc(sr));
        fail_if(num != 0,
                "Streader stored %f instead of -0 from \"%s\"",
                num, neg_zeros[i]);
        fail_if(!Streader_match_char(sr, 'x'),
                "Streader did not consume -0 from \"%s\" correctly",
                neg_zeros[i]);
    }
}
Ejemplo n.º 6
0
END_TEST

#undef make_str


START_TEST(Read_empty_list)
{
    static const char* lists[] =
    {
        "[] x",
        "[ ]x",
        "[ ] x",
    };

    for (size_t i = 0; i < arr_size(lists); ++i)
    {
        Streader* sr = init_with_cstr(lists[i]);
        fail_if(!Streader_read_list(sr, NULL, NULL),
                "Could not read empty list from `%s`: %s",
                lists[i],
                Streader_get_error_desc(sr));
        fail_if(!Streader_match_char(sr, 'x'),
                "Streader did not consume empty list from `%s` correctly",
                lists[i]);
    }
}
Ejemplo n.º 7
0
END_TEST


START_TEST(Read_nonzero_float)
{
    const double nums[] = { 0.5, 1.0, 1.5, -0.5, -1.0, -1.5, 0.0625, 10.0, };
    const char* formats[] =
    {
        "%.4f x",
        "%f x",
        "%e x",
    };

    for (size_t i = 0; i < arr_size(nums); ++i)
    {
        for (size_t k = 0; k < arr_size(formats); ++k)
        {
            char data[128] = "";
            sprintf(data, formats[k], nums[i]);

            Streader* sr = init_with_cstr(data);
            double num = NAN;
            fail_if(!Streader_read_float(sr, &num),
                    "Could not read float from \"%s\": %s",
                    data, Streader_get_error_desc(sr));
            fail_if(num != nums[i],
                    "Streader stored %f instead of %.6f from \"%s\"",
                    num, nums[i]);
            fail_if(!Streader_match_char(sr, 'x'),
                    "Streader did not consume float from \"%s\" correctly",
                    data);
        }
    }
}
Ejemplo n.º 8
0
END_TEST


START_TEST(Read_valid_piref)
{
    static const struct
    {
        const char* data;
        const Pat_inst_ref expected;
    }
    pirefs[] =
    {
        { "[0, 0]", { 0, 0 } },
        { "[2,5]",  { 2, 5 } },
        { " [2,5]", { 2, 5 } },
        { "[ 2,5]", { 2, 5 } },
        { "[2 ,5]", { 2, 5 } },
        { "[2, 5]", { 2, 5 } },
        { "[2,5 ]", { 2, 5 } },
        { "[0, 1023]", { 0, KQT_PAT_INSTANCES_MAX - 1 } },
        { "[1023, 0]", { KQT_PATTERNS_MAX - 1, 0 } },
        { "[1023, 1023]", { KQT_PATTERNS_MAX - 1, KQT_PAT_INSTANCES_MAX - 1 } },
    };

    for (size_t i = 0; i < arr_size(pirefs); ++i)
    {
        char data[128] = "";
        sprintf(data, "%s x", pirefs[i].data);

        Streader* sr = init_with_cstr(data);
        Pat_inst_ref* result = PAT_INST_REF_AUTO;

        fail_if(!Streader_read_piref(sr, result),
                "Could not read pattern instance refernce " PRIpi
                    " from `%s`: %s",
                PRIVALpi(pirefs[i].expected),
                data,
                Streader_get_error_desc(sr));
        fail_if(Pat_inst_ref_cmp(result, &pirefs[i].expected) != 0,
                "Streader stored " PRIpi " instead of " PRIpi
                    " when reading `%s`",
                PRIVALpi(*result),
                PRIVALpi(pirefs[i].expected),
                data);
        fail_if(!Streader_match_char(sr, 'x'),
                "Streader did not consume pattern instance from `%s` correctly",
                data);
    }
}
Ejemplo n.º 9
0
END_TEST


START_TEST(Fire_with_complex_bind_can_be_processed_with_multiple_receives)
{
    set_mix_volume(0);
    setup_debug_instrument();
    setup_debug_single_pulse();

    const int event_count = 2048;
    setup_complex_bind(event_count);

    pause();
    kqt_Handle_fire_event(handle, 0, "[\"#\", \"\"]");
    check_unexpected_error();

    // Receive and make sure all events are found
    const char* events = kqt_Handle_receive_events(handle);
    int32_t expected = 0;
    int loop_count = 0;
    while (strcmp("[]", events) != 0)
    {
        Streader* sr = Streader_init(STREADER_AUTO, events, (int64_t)strlen(events));
        fail_if(!Streader_read_list(sr, read_received_events_bind, &expected),
                "Event list reading failed: %s",
                Streader_get_error_desc(sr));

        events = kqt_Handle_receive_events(handle);
        ++loop_count;
    }

    fail_if(loop_count <= 1,
            "Test did not fill the event buffer, increase event count!");

    fail_if(expected != event_count,
            "Read %" PRId32 " instead of %d events",
            expected, event_count);

    // Continue playing
    kqt_Handle_play(handle, 10);
    fail_if(kqt_Handle_get_frames_available(handle) != 10,
            "Kunquat handle rendered %ld instead of 10 frames",
            kqt_Handle_get_frames_available(handle));

    // FIXME: We can only check for 512 notes as we run out of voices :-P
    const float expected_buf[10] = { min((float)event_count, 512) };
    const float* actual_buf = kqt_Handle_get_audio(handle, 0);
    check_buffers_equal(expected_buf, actual_buf, 10, 0.0f);
}
Ejemplo n.º 10
0
END_TEST


START_TEST(Read_valid_string)
{
    static const struct
    {
        const char* data;
        const char* expected;
    }
    strings[] =
    {
        { "\"\"", "" },
        { "\" \"", " " },
        { "\"  \"", "  " },
        { "\"\\\"\"", "\"" },
        { "\"\\\\\"", "\\" },
        { "\"\\/\"", "/" },
        { "\"/\"", "/" },
        /*
        { "\"\\b\"", "\b" },
        { "\"\\f\"", "\f" },
        { "\"\\n\"", "\n" },
        { "\"\\r\"", "\r" },
        { "\"\\t\"", "\t" },
        */
        { "\"abc def\"", "abc def" },
    };

    for (size_t i = 0; i < arr_size(strings); ++i)
    {
        char data[128] = "";
        sprintf(data, "%s x", strings[i].data);

        Streader* sr = init_with_cstr(data);
        char result[128] = "zzz";

        fail_if(!Streader_read_string(sr, 128, result),
                "Could not read string `%s`: %s",
                data, Streader_get_error_desc(sr));
        fail_if(strcmp(result, strings[i].expected) != 0,
                "Streader stored `%s` instead of `%s`",
                result, strings[i].expected);
        fail_if(!Streader_match_char(sr, 'x'),
                "Streader did not consume string `%s` correctly");
    }
}
Ejemplo n.º 11
0
END_TEST


START_TEST(Read_valid_tstamp)
{
    static const struct
    {
        const char* data;
        const Tstamp expected;
    }
    tstamps[] =
    {
        { "[0, 0]", { 0, 0 } },
        { "[2,5]",  { 2, 5 } },
        { " [2,5]", { 2, 5 } },
        { "[ 2,5]", { 2, 5 } },
        { "[2 ,5]", { 2, 5 } },
        { "[2, 5]", { 2, 5 } },
        { "[2,5 ]", { 2, 5 } },
        { "[-1, 3]", { -1, 3 } },
        { "[0, 882161279]", { 0, KQT_TSTAMP_BEAT - 1 } },
    };

    for (size_t i = 0; i < arr_size(tstamps); ++i)
    {
        char data[128] = "";
        sprintf(data, "%s x", tstamps[i].data);

        Streader* sr = init_with_cstr(data);
        Tstamp* result = Tstamp_set(TSTAMP_AUTO, 99, 99);

        fail_if(!Streader_read_tstamp(sr, result),
                "Could not read timestamp " PRIts " from `%s`: %s",
                PRIVALts(tstamps[i].expected),
                data,
                Streader_get_error_desc(sr));
        fail_if(Tstamp_cmp(result, &tstamps[i].expected) != 0,
                "Streader stored " PRIts " instead of " PRIts
                    " when reading `%s`",
                PRIVALts(*result),
                PRIVALts(tstamps[i].expected),
                data);
        fail_if(!Streader_match_char(sr, 'x'),
                "Streader did not consume timestamp from `%s` correctly", data);
    }
}
Ejemplo n.º 12
0
END_TEST


static bool fail_at_index_2(Streader* sr, int32_t index, void* userdata)
{
    (void)sr;
    (void)userdata;

    fail_if(index > 2, "List processing continued after failure");

    if (index == 2)
        return false;

    fail_if(!Streader_read_int(sr, NULL),
            "Could not read an integer from list: %s",
            Streader_get_error_desc(sr));

    return true;
}
Ejemplo n.º 13
0
END_TEST


static bool fail_at_key_2(Streader* sr, const char* key, void* userdata)
{
    (void)sr;
    (void)userdata;

    fail_if(strcmp(key, "2") > 0,
            "Dictionary processing continued after failure");

    if (strcmp(key, "2") == 0)
        return false;

    fail_if(!Streader_read_float(sr, NULL),
            "Could not read a float from dictionary: %s",
            Streader_get_error_desc(sr));

    return true;
}
Ejemplo n.º 14
0
int kqt_Handle_fire_event(kqt_Handle handle, int channel, const char* event)
{
    check_handle(handle, 0);

    Handle* h = get_handle(handle);
    check_data_is_valid(h, 0);
    check_data_is_validated(h, 0);

    if (channel < 0 || channel >= KQT_COLUMNS_MAX)
    {
        Handle_set_error(h, ERROR_ARGUMENT, "Invalid channel number: %d", channel);
        return 0;
    }
    if (event == NULL)
    {
        Handle_set_error(h, ERROR_ARGUMENT, "No event description given");
        return 0;
    }

    const size_t length = strlen(event);
    if (length > 4096)
    {
        Handle_set_error(h, ERROR_ARGUMENT, "Event description is too long");
        return 0;
    }

    Streader* sr = Streader_init(STREADER_AUTO, event, (int64_t)length);
    if (!Player_fire(h->player, channel, sr))
    {
        rassert(Streader_is_error_set(sr));
        Handle_set_error(
                h,
                ERROR_ARGUMENT,
                "Invalid event description `%s`: %s",
                event, Streader_get_error_desc(sr));
        return 0;
    }

    return 1;
}
Ejemplo n.º 15
0
END_TEST


START_TEST(Read_empty_dict)
{
    static const char* dicts[] =
    {
        "{} x",
        "{ }x",
        "{ } x",
    };

    for (size_t i = 0; i < arr_size(dicts); ++i)
    {
        Streader* sr = init_with_cstr(dicts[i]);
        fail_if(!Streader_read_dict(sr, NULL, NULL),
                "Could not read empty dictionary from `%s`: %s",
                dicts[i],
                Streader_get_error_desc(sr));
        fail_if(!Streader_match_char(sr, 'x'),
                "Streader did not consume empty dictionary from `%s` correctly",
                dicts[i]);
    }
}