Exemple #1
0
int main()
{
    //Message 1
    assert_int_eq(sizeof(MSG1)-1, len_a = rtosc_message(buffer_a, 256,
                    "/flying-monkey", "s", "bannana"),
            "Creating Simple Message 1", __LINE__);
    assert_hex_eq(MSG1, buffer_a, sizeof(MSG1)-1, len_a,
            "Verifying Content of Message 1", __LINE__);
    assert_int_eq(0, rtosc_bundle_p(buffer_a),
            "Simple Message 1 Is Not A Bundle", __LINE__);

    //Message 2
    assert_int_eq(sizeof(MSG2)-1, len_b = rtosc_message(buffer_b, 256,
                    "/foobar-message", "iT", 42),
            "Creating Simple Message 2", __LINE__);
    assert_hex_eq(MSG2, buffer_b, sizeof(MSG2)-1, len_b,
            "Verifying Content of Message 2", __LINE__);
    assert_int_eq(0, rtosc_bundle_p(buffer_b),
            "Simple Message 2 Is Not A Bundle", __LINE__);

    //Bundle 1
    assert_int_eq(sizeof(RESULT)-1, len_c = rtosc_bundle(buffer_c, 256, 0, 2, buffer_a, buffer_b),
            "Creating Bundle 1", __LINE__);
    assert_int_eq(len_c, rtosc_message_length(buffer_c, len_c),
            "Verifying Bundle 1's Length", __LINE__);
    assert_hex_eq(RESULT, buffer_c, sizeof(RESULT)-1, len_c,
            "Verifying Bundle 1's Content", __LINE__);

    assert_int_eq(1, rtosc_bundle_p(buffer_c),
            "Verifying Bundle 1 Is A Bundle", __LINE__);
    assert_int_eq(2, rtosc_bundle_elements(buffer_c, 256),
            "Verifying Bundle 2 Has Two Messages", __LINE__);

    assert_str_eq("/flying-monkey", rtosc_bundle_fetch(buffer_c, 0),
            "Verifying Message 1 Path", __LINE__);
    assert_str_eq("/foobar-message", rtosc_bundle_fetch(buffer_c, 1),
            "Verifying Message 2 Path", __LINE__);

    //Check minimum bundle size #bundle + time tag
    assert_int_eq(8+8, rtosc_bundle(buffer_c, 256, 1, 0),
            "Verify Minimum Legal Bundle Size", __LINE__);

    //check message length support
    assert_int_eq(8+8, rtosc_message_length(buffer_c, 256),
            "Verify rtosc_message_length() on Minimum Bundle", __LINE__);

    //Verify that timetag can be fetched
    assert_int_eq(1, rtosc_bundle_timetag(buffer_c),
            "Verify rtosc_bundle_timetag() Works", __LINE__);

    return test_summary();
}
Exemple #2
0
/*
 * The OSC 1.0 spec provides two example messages at
 * http://opensoundcontrol.org/spec-1_0-examples
 * 
 * This test verifies that these messages are identically serialized
 */
int main()
{
    check(rtosc_message(buffer, 256, "/oscillator/4/frequency", "f", 440.0f),
            "Failed message creation", __LINE__);
    check(!memcmp(buffer, message_one, sizeof(message_one)),
            "Message does not meet spec", __LINE__);

    check(rtosc_message(buffer, 256, "/foo", "iisff",
                1000, -1, "hello", 1.234f, 5.678f),
            "Failed message creation", __LINE__);
    check(!memcmp(buffer, message_two, sizeof(message_two)),
            "Message does not meet spec", __LINE__);
    return 0;
}
Exemple #3
0
int main()
{
    //Verify that given a null buffer, it does not segfault
    assert_int_eq(20, rtosc_message(0,0,"/page/poge","TIF"),
            "Build A Message With NULL Buffer", __LINE__);
    return 0;
}
Exemple #4
0
//verifies a message with all types included serializes and deserializes
int main()
{
    unsigned message_len;
    int32_t      i = 42;             //integer
    float        f = 0.25;           //float
    const char  *s = "string";       //string
    rtosc_blob_t b = {3,(uint8_t*)s};//blob
    int64_t      h = -125;           //long integer
    uint64_t     t = 22412;          //timetag
    double       d = 0.125;          //double
    const char  *S = "Symbol";       //symbol
    char         c = 25;             //character
    int32_t      r = 0x12345678;     //RGBA
    midi_t       m = {0x12,0x23,     //midi
                      0x34,0x45
                     };
    //true
    //false
    //nil
    //inf

    message_len = rtosc_message(buffer, 1024, "/dest",
                                "[ifsbhtdScrmTFNI]", i,f,s,b.len,b.data,h,t,d,S,c,r,m);

    assert_int_eq(96, message_len,
                  "Generating A Message With All Arg Types", __LINE__);


    rtosc_arg_t arg;
    assert_int_eq(i, rtosc_argument(buffer, 0).i,
                  "Checking 'i' Argument", __LINE__);
    CHECK(f,f,1);
    assert_str_eq(s, rtosc_argument(buffer, 2).s,
                  "Checking 's' Argument", __LINE__);
    CHECK(b.len,b.len,3);
    assert_hex_eq((char*)b.data, (char*)arg.b.data, 3, b.len,
                  "Checking 'b.data' Argument", __LINE__);
    CHECK(h,h,4);
    CHECK(t,t,5);
    CHECK(d,d,6);
    assert_str_eq(S,rtosc_argument(buffer, 7).s,
                  "Checking 'S' Argument", __LINE__);
    assert_char_eq(c,rtosc_argument(buffer, 8).i,
                   "Checking 'c' Argument", __LINE__);
    CHECK(r,i,9);
    CHECK(m,m,10);
    assert_char_eq('T', rtosc_type(buffer,11),
                   "Checking 'T' Argument", __LINE__);
    assert_char_eq('F', rtosc_type(buffer,12),
                   "Checking 'F' Argument", __LINE__);
    assert_char_eq('N', rtosc_type(buffer,13),
                   "Checking 'N' Argument", __LINE__);
    assert_char_eq('I', rtosc_type(buffer,14),
                   "Checking 'I' Argument", __LINE__);
    assert_true(rtosc_valid_message_p(buffer, message_len),
                "Verifying Message Is Valid", __LINE__);

    return test_summary();
}
Exemple #5
0
//verify that empty strings can be retreived
int main()
{
    size_t length = rtosc_message(buffer, 1024, "/path", "sss", "", "", "");
    // /pat h000 ,sss 0000 0000 0000 0000
    assert_int_eq(28, length, "Build Empty String Based Message", __LINE__);
    assert_non_null(rtosc_argument(buffer, 0).s, "Check Arg 1", __LINE__);
    assert_non_null(rtosc_argument(buffer, 1).s, "Check Arg 2", __LINE__);
    assert_non_null(rtosc_argument(buffer, 2).s, "Check Arg 3", __LINE__);
    return test_summary();
}
int main()
{
    int32_t      i = 42;             //integer
    float        f = 0.25;           //float
    const char  *s = "string";       //string
    size_t message_size = 32;
    CHECK(rtosc_message(buffer, 1024, "/dest",
                "ifs", i,f,s) == message_size);
    CHECK(rtosc_argument(buffer, 0).i == i);
    CHECK(rtosc_argument(buffer, 1).f == f);
    CHECK(!strcmp(rtosc_argument(buffer, 2).s, s));
    CHECK(rtosc_message_length(buffer,1024) == 32);

    memmove(buffer+1, buffer, message_size);
    CHECK(!strcmp(buffer+1, "/dest"));
    CHECK(rtosc_argument(buffer+1, 0).i == i);
    CHECK(rtosc_argument(buffer+1, 1).f == f);
    CHECK(!strcmp(rtosc_argument(buffer+1, 2).s, s));
    CHECK(rtosc_message_length(buffer+1,1024-1) == 32);

    memmove(buffer+2, buffer+1, message_size);
    CHECK(!strcmp(buffer+2, "/dest"));
    CHECK(rtosc_argument(buffer+2, 0).i == i);
    CHECK(rtosc_argument(buffer+2, 1).f == f);
    CHECK(!strcmp(rtosc_argument(buffer+2, 2).s, s));
    CHECK(rtosc_message_length(buffer+2,1024-2) == 32);

    memmove(buffer+3, buffer+2, message_size);
    CHECK(!strcmp(buffer+3, "/dest"));
    CHECK(rtosc_argument(buffer+3, 0).i == i);
    CHECK(rtosc_argument(buffer+3, 1).f == f);
    CHECK(!strcmp(rtosc_argument(buffer+3, 2).s, s));
    CHECK(rtosc_message_length(buffer+3,1024-3) == 32);

    memmove(buffer+4, buffer+3, message_size);
    CHECK(!strcmp(buffer+4, "/dest"));
    CHECK(rtosc_argument(buffer+4, 0).i == i);
    CHECK(rtosc_argument(buffer+4, 1).f == f);
    CHECK(!strcmp(rtosc_argument(buffer+4, 2).s, s));
    CHECK(rtosc_message_length(buffer+4,1024-4) == 32);

    for(int j=0; j<4; ++j) {
        fprintf(stderr, "offset %d\n", j);
        CHECK(rtosc_argument(buffer+4+j, 0).i == i);
        CHECK(rtosc_argument(buffer+4+j, 1).f == f);
        CHECK(!strcmp(rtosc_argument(buffer+4+j, 2).s, s));
        CHECK(rtosc_message_length(buffer+4+j,1024-4-j) == (unsigned)(32-j));
    }

    return err;
}
Exemple #7
0
void plot_data_cb(const char *msg, void*)
{
    const int samples = rtosc_argument(msg, 0).i;

    //Construct blob piecewise
    if(rtosc_message(dsp_osc_buf, 2048, "/ui/plot", "b", samples, NULL)) {

        //Fill reserved space
        float *data = (float*) rtosc_argument(dsp_osc_buf,0).b.data;
        for(int i=0; i < samples; ++i)
            data[i] = get_sample((float)i/samples);

    }
    gui_message(dsp_osc_buf);
}
Exemple #8
0
int main()
{
    //clean buffer
    memset(buffer1, 0xc3, sizeof(buffer1));

    //generate liblo message 1
    size_t len = 128;
    lo_message message = lo_message_new();
    assert_non_null(message, "Generating A Liblo Message 1 (int/float)", __LINE__);
    lo_message_add_float(message, 24.0);
    lo_message_add_int32(message, 42);
    lo_message_serialise(message, "/path", buffer1, &len);

    assert_str_eq("/path", buffer1, "Verifying Path From Message 1", __LINE__);
    assert_f32_eq(24.0f, rtosc_argument(buffer1, 0).f,
            "Verifying Float From Message 1", __LINE__);
    assert_int_eq(42, rtosc_argument(buffer1, 1).i,
            "Verifying Int From Message 1", __LINE__);
    assert_int_eq(20, rtosc_message_length(buffer1, 128),
            "Verifying Length From Message 1", __LINE__);


    //Message 2
    size_t len2 = rtosc_message(buffer2, 1024, "/li", "bb", 4, buffer1, 4, buffer1);
    assert_int_eq(24, len2, "Generate A Rtosc Message 2 (bb)", __LINE__);
    lo_message msg2 = lo_message_deserialise((void*)buffer2, len2, &result_var);
    if(assert_non_null(msg2, "Deserialize Message 2 To Liblo", __LINE__))
        printf("# Liblo Did Not Accept the Rtosc Message [error '%d']\n", result_var);

    //Message 3
    size_t len3 = rtosc_message(buffer3+4, 2048, "/close-ui", "");
    assert_int_eq(16, len3, "Generate A Rtosc Message 3 ()", __LINE__);
    lo_message msg3 = lo_message_deserialise((void*)(buffer3+4), len3, &result_var);
    if(assert_non_null(msg2, "Deserialize Message 3 To Liblo", __LINE__))
        printf("#Liblo Did Not Accept the Rtosc Message [error '%d']\n", result_var);

    //Bundle 4
    size_t len4 = rtosc_bundle(buffer4, 2048, 0xdeadbeefcafebaad, 3, buffer1, buffer2, buffer3+4);
    assert_int_eq(88, len4, "Generate A Bundle 4", __LINE__);

    //Bundle 5
    lo_timetag time;
    time.sec  = 0xdeadbeef;
    time.frac = 0xcafebaad;
    lo_bundle ms4 = lo_bundle_new(time);
    lo_bundle_add_message(ms4, "/path",     message);
    lo_bundle_add_message(ms4, "/li",       msg2);
    lo_bundle_add_message(ms4, "/close-ui", msg3);
    size_t len5 = 2048;
    lo_bundle_serialise(ms4,(void*)buffer5, &len5);

    //Verify 4 == 5
    assert_non_null(ms4, "Generate A Liblo Bundle 5", __LINE__);
    assert_hex_eq(buffer5, buffer4, len5, len4,
            "Verify Liblo Style Bundles", __LINE__);

    //Cleanup
    lo_message_free(message);
    lo_message_free(msg2);
    lo_message_free(msg3);
    lo_bundle_free(ms4);

    return test_summary();
}