/*
* Copyright (C) 2020 Linux Studio Plugins Project
* (C) 2020 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 21 мая 2019 г.
*
* lsp-runtime-lib is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* any later version.
*
* lsp-runtime-lib 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with lsp-runtime-lib. If not, see .
*/
#include
#include
#include
#include
#include
#include
namespace lsp
{
static uint8_t simple_message[] =
{
'/', 'o', 's', 'c',
'i', 'l', 'l', 'a',
't', 'o', 'r', '/',
'4', '/', 'f', 'r',
'e', 'q', 'u', 'e',
'n', 'c', 'y', 0,
',', 'f', 0, 0,
0x43, 0xdc, 0, 0
};
static uint8_t legacy_message[] =
{
'/', 't', 'e', 's',
't', 0, 0, 0
};
#pragma pack(push, 1)
typedef struct parameter_message_t
{
char address[12];
char types[32];
int32_t int32;
float float32;
char string[8];
uint32_t blob_len;
char blob[8];
int64_t int64;
double double64;
uint64_t time_tag;
char type[8];
uint32_t ascii;
uint32_t rgba;
uint8_t midi[4];
uint8_t raw_midi[4];
struct {
int32_t int32;
struct {
char string[8];
uint32_t blob_size;
char blob[8];
int32_t int32;
} array;
float float32;
} array;
} parameter_message_t;
#pragma pack(pop)
#pragma pack(push, 1)
typedef struct message_bundle_t
{
char signature[8];
uint64_t time_tag;
uint32_t bundle1_size;
struct
{
char signature[8];
uint64_t time_tag;
uint32_t message1_size;
struct
{
char address[4];
char types[4];
int32_t int32;
} message1;
uint32_t message2_size;
struct
{
char address[8];
char types[8];
int32_t int32;
float float32;
} message2;
} bundle1;
uint32_t bundle2_size;
struct
{
char signature[8];
uint64_t time_tag;
uint32_t message1_size;
struct
{
char address[4];
char types[4];
int32_t int32;
} message1;
uint32_t message2_size;
struct
{
char address[4];
char types[8];
} message2;
} bundle2;
uint32_t message_size;
struct
{
char address[8];
char types[8];
int32_t int32;
} message;
} message_bundle_t;
#pragma pack(pop)
#pragma pack(push, 1)
typedef struct format_message_t
{
char address[12];
char types[16];
int32_t int32;
float float32;
char string[12];
int64_t int64;
uint64_t time_tag;
double double64;
char type[12];
uint32_t ascii;
uint32_t rgba;
} format_message_t;
#pragma pack(pop)
#pragma pack(push, 1)
typedef struct special_message_t
{
char address[12];
char types[24];
} special_message_t;
#pragma pack(pop)
static const char *valid_patterns[] =
{
"/a",
"/1/2/3/4",
"/???",
"/***",
"/[abcde]",
"/[a-zA-Z0-9]",
"/[!abc0-9]",
"/{}",
"/{,,,}",
"/{foo,bar,}",
"/{foo,bar,baz}",
"/{foo,bar,}?/test",
"/a/?*/{foo,bar,}[0-9]xx?",
NULL
};
static const char *invalid_patterns[] =
{
"",
"/",
"/#",
"//",
"///",
"/\n",
"/[",
"/]",
"/[a-]",
"/[a-zA-Z0-9-#]",
"/[!]",
"/[?]",
"/[*]",
"/{",
"/}",
"/{[}",
"/{#}",
"/{foo,bar,}}",
"/{foo,bar,{}}",
"/{foo,bar,}/test#",
"/a/?*/{foo,bar,}[0-9]xx?}",
NULL
};
typedef struct pattern_match_t
{
const char *pattern;
const char *address;
bool match;
} pattern_match_t;
static const pattern_match_t match_pattern[] =
{
{ "/one", "/one", true},
{ "/one", "/two", false},
{ "/one", "/one/two", false},
{ "/one", "//one", false},
{ "/one/two", "/one/two", true},
{ "/one/two", "/one/two/", false},
{ "/one/two", "/one/two/three", false},
{ "/one/two", "//one/two/three", false},
{ "/one/two", "/one//two/three", false},
{ "/*", "/one", true },
{ "/*", "/two", true },
{ "/*", "/", false },
{ "/*", "//", false },
{ "/*", "", false },
{ "/*", "/one/two", false },
{ "/?", "/1", true },
{ "/?", "/2", true },
{ "/?", "/", false },
{ "/?", "/12", false },
{ "/?", "/1/2", false },
{ "/??", "/12", true },
{ "/??", "/123", false },
{ "/??", "/12/34", false },
{ "/a", "/a", true },
{ "/a", "/b", false },
{ "/a", "/ab", false },
{ "/a", "/a/b", false },
{ "/[abc]?", "/a1", true },
{ "/[abc]?", "/b1", true },
{ "/[abc]?", "/c1", true },
{ "/[abc]?", "/d1", false },
{ "/[abc]?", "/a1/", false },
{ "/[abc]?", "/a1/b", false },
{ "/[a-c]?", "/a2", true },
{ "/[a-c]?", "/b2", true },
{ "/[a-c]?", "/c2", true },
{ "/[a-c]?", "/d2", false },
{ "/[a-c]*", "/c", true },
{ "/[a-c]*", "/c1", true },
{ "/[a-c]*", "/c12", true },
{ "/[a-c]*", "/c123", true },
{ "/[a-c]*", "/c/", false },
{ "/[a-c]*", "/c/1", false },
{ "/{foo,bar,baz}", "/foo", true },
{ "/{foo,bar,baz}", "/bar", true },
{ "/{foo,bar,baz}", "/baz", true },
{ "/{foo,bar,baz}", "/foo/bar", false },
{ "/{foo,bar,baz}", "//bar", false },
{ "/{foo,}?", "/x", true },
{ "/{foo,}", "/", false },
{ "/{foo,}*", "/", false },
{ "/{foo,}*", "/bar", true },
{ "/{foo,}*", "/foo/bar", false },
{ "/*foo*{bar,baz}/[a-bB-A]one?", "/foobar/AoneX", true },
{ "/*foo*{bar,baz}/[a-bB-A]one?", "/foobar/Aone?", false },
{ "/*foo*{bar,baz}/[a-bB-A]one?", "/foobar/Aone#", false },
{ "/*foo*{bar,baz}/[a-bB-A]one?", "/fooXXXbar/Bone+", true },
{ "/*foo*{bar,baz}/[a-bB-A]one?", "/XXXfooXXXbar/aone_", true },
{ "/*foo*{bar,baz}/[a-bB-A]one?", "/XXXfooXXXbarXXX/aone_", false },
{ "/*foo*{bar,baz}/[a-bB-A]one?", "/XXX/fooXXXbar/aone_", false}
};
}
UTEST_BEGIN("runtime.protocol", osc)
void test_forge_simple_message()
{
osc::packet_t packet;
osc::forge_t forge;
osc::forge_frame_t frame, message, other;
// Curly braces are used for visualization of nested structures
UTEST_ASSERT(osc::forge_begin_dynamic(&frame, &forge) == STATUS_OK);
{
// Perform some 'dumb' error checks
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_BAD_STATE);
UTEST_ASSERT(osc::forge_begin_message(&frame, &frame, "/fail") == STATUS_BAD_ARGUMENTS);
UTEST_ASSERT(osc::forge_float32(&frame, 440.0f) == STATUS_BAD_STATE);
// Start message
UTEST_ASSERT(osc::forge_begin_message(&message, &frame, "/oscillator/4/frequency") == STATUS_OK);
{
// Perform some 'dumb' error checks
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_BAD_STATE);
UTEST_ASSERT(osc::forge_end(&frame) == STATUS_BAD_STATE);
UTEST_ASSERT(osc::forge_begin_message(&other, &frame, "/fail") == STATUS_BAD_STATE);
UTEST_ASSERT(osc::forge_begin_message(&other, &message, "/fail") == STATUS_BAD_STATE);
UTEST_ASSERT(osc::forge_begin_bundle(&other, &message, 0) == STATUS_BAD_STATE);
// Emit parameter
UTEST_ASSERT(osc::forge_float32(&message, 440.0f) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&message) == STATUS_OK);
// Perform some 'dump' error checks
UTEST_ASSERT(osc::forge_end(&message) == STATUS_BAD_STATE);
UTEST_ASSERT(osc::forge_begin_message(&message, &frame, "/fail") == STATUS_BAD_STATE);
UTEST_ASSERT(osc::forge_begin_bundle(&message, &frame, 0) == STATUS_BAD_STATE);
UTEST_ASSERT(osc::forge_float32(&frame, 440.0f) == STATUS_BAD_STATE);
}
UTEST_ASSERT(osc::forge_end(&frame) == STATUS_OK);
UTEST_ASSERT(osc::forge_end(&frame) == STATUS_BAD_STATE); // 'dumb' check
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_BAD_STATE); // 'dumb' check
UTEST_ASSERT(osc::forge_destroy(&forge) == STATUS_OK);
// Validate output data
UTEST_ASSERT(packet.data != NULL);
bool matches = (packet.size == sizeof(simple_message)) && (::memcmp(packet.data, simple_message, sizeof(simple_message)) == 0);
if (!matches)
{
dump_bytes("src", simple_message, sizeof(simple_message));
dump_bytes("dst", packet.data, packet.size);
UTEST_FAIL_MSG("Source and destination messages differ");
}
osc::forge_free(packet.data);
}
void test_forge_parameters()
{
// Initialize parametrized message
parameter_message_t m;
bzero(&m, sizeof(m));
strcpy(m.address, "/address/01");
strcpy(m.types, ",ifsbhdtScrmm[iT[sbiI]f]TFNI");
m.int32 = CPU_TO_BE(int32_t(0xdeadbeef));
m.float32 = CPU_TO_BE(float(M_PI));
strcpy(m.string, "string1");
m.blob_len = CPU_TO_BE(uint32_t(5));
strcpy(m.blob, "BLOB1");
m.int64 = CPU_TO_BE(uint64_t(0x1234567855aacc33ULL));
m.double64 = CPU_TO_BE(double(M_E));
m.time_tag = CPU_TO_BE(uint64_t(0xff00cc01aa028803ULL));
strcpy(m.type, "type01");
m.ascii = CPU_TO_BE(uint32_t(uint8_t('\n')));
m.rgba = CPU_TO_BE(uint32_t(0x8080ff40));
m.midi[0] = 0x94;
m.midi[1] = 51;
m.midi[2] = 0x7f;
m.raw_midi[0] = 0x84;
m.raw_midi[1] = 51;
m.raw_midi[2] = 0x5f;
m.array.int32 = CPU_TO_BE(int32_t(0xfffefcfd));
strcpy(m.array.array.string, "string2");
m.array.array.blob_size = CPU_TO_BE(uint32_t(6));
strcpy(m.array.array.blob, "BLOB02");
m.array.array.int32 = CPU_TO_BE(int32_t(0xcafeface));
m.array.float32 = CPU_TO_BE(float(440.0f));
midi::event_t midi;
midi.timestamp = 0;
midi.type = midi::MIDI_MSG_NOTE_ON;
midi.channel = 4;
midi.note.pitch = 51;
midi.note.velocity = 0x7f;
uint8_t raw_midi[4];
raw_midi[0] = midi::MIDI_MSG_NOTE_OFF | 4;
raw_midi[1] = 51;
raw_midi[2] = 0x5f;
// Forge the same message using OSC serializer
osc::packet_t packet;
osc::forge_t forge;
osc::forge_frame_t frame, message, array1, array2;
UTEST_ASSERT(osc::forge_begin_dynamic(&frame, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_message(&message, &frame, "/address/01") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_int32(&message, 0xdeadbeef) == STATUS_OK);
UTEST_ASSERT(osc::forge_float32(&message, float(M_PI)) == STATUS_OK);
UTEST_ASSERT(osc::forge_string(&message, "string1") == STATUS_OK);
UTEST_ASSERT(osc::forge_blob(&message, "BLOB1", 5) == STATUS_OK);
UTEST_ASSERT(osc::forge_int64(&message, uint64_t(0x1234567855aacc33ULL)) == STATUS_OK);
UTEST_ASSERT(osc::forge_double64(&message, double(M_E)) == STATUS_OK);
UTEST_ASSERT(osc::forge_time_tag(&message, uint64_t(0xff00cc01aa028803ULL)) == STATUS_OK);
UTEST_ASSERT(osc::forge_type(&message, "type01") == STATUS_OK);
UTEST_ASSERT(osc::forge_ascii(&message, '\n') == STATUS_OK);
UTEST_ASSERT(osc::forge_rgba(&message, 0x8080ff40) == STATUS_OK);
UTEST_ASSERT(osc::forge_midi(&message, &midi) == STATUS_OK);
UTEST_ASSERT(osc::forge_midi_raw(&message, raw_midi, 3) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_array(&array1, &message) == STATUS_OK);
{
UTEST_ASSERT(osc::forge_int32(&array1, int32_t(0xfffefcfd)) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&array1, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_array(&array2, &array1) == STATUS_OK);
{
UTEST_ASSERT(osc::forge_string(&array2, "string2") == STATUS_OK);
UTEST_ASSERT(osc::forge_blob(&array2, "BLOB02", 6) == STATUS_OK);
UTEST_ASSERT(osc::forge_int32(&array2, int32_t(0xcafeface)) == STATUS_OK);
UTEST_ASSERT(osc::forge_inf(&array2) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&array2) == STATUS_OK);
UTEST_ASSERT(osc::forge_float32(&array1, float(440.0f)) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&array1) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&message, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&message, false) == STATUS_OK);
UTEST_ASSERT(osc::forge_null(&message) == STATUS_OK);
UTEST_ASSERT(osc::forge_inf(&message) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&message) == STATUS_OK);
UTEST_ASSERT(osc::forge_end(&frame) == STATUS_OK);
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_destroy(&forge) == STATUS_OK);
// Validate output data
UTEST_ASSERT(packet.data != NULL);
bool matches = (packet.size == sizeof(m)) && (::memcmp(packet.data, &m, sizeof(m)) == 0);
if (!matches)
{
dump_bytes("src", &m, sizeof(m));
dump_bytes("dst", packet.data, packet.size);
UTEST_FAIL_MSG("Source and destination messages differ");
}
osc::forge_free(packet.data);
}
void test_forge_message_bundle()
{
// Initialize message bundle
message_bundle_t b;
bzero(&b, sizeof(b));
strcpy(b.signature, "#bundle");
b.time_tag = CPU_TO_BE(uint64_t(0x1122334455667788ULL));
b.bundle1_size = CPU_TO_BE(uint32_t(sizeof(b.bundle1)));
{
strcpy(b.bundle1.signature, "#bundle");
b.bundle1.time_tag = CPU_TO_BE(uint64_t(0x2233445566778899ULL));
b.bundle1.message1_size = CPU_TO_BE(uint32_t(sizeof(b.bundle1.message1)));
{
strcpy(b.bundle1.message1.address, "/a0");
strcpy(b.bundle1.message1.types, ",i");
b.bundle1.message1.int32 = CPU_TO_BE(int32_t(0xdeadbeef));
}
b.bundle1.message2_size = CPU_TO_BE(uint32_t(sizeof(b.bundle1.message2)));
{
strcpy(b.bundle1.message2.address, "/addr0");
strcpy(b.bundle1.message2.types, ",TFif");
b.bundle1.message2.int32 = CPU_TO_BE(int32_t(0xcafeface));
b.bundle1.message2.float32 = CPU_TO_BE(float(440.0f));
}
}
b.bundle2_size = CPU_TO_BE(uint32_t(sizeof(b.bundle2)));
{
strcpy(b.bundle2.signature, "#bundle");
b.bundle2.time_tag = CPU_TO_BE(uint64_t(0x5566778899aabbccULL));
b.bundle2.message1_size = CPU_TO_BE(uint32_t(sizeof(b.bundle2.message1)));
{
strcpy(b.bundle2.message1.address, "/b0");
strcpy(b.bundle2.message1.types, ",Ii");
b.bundle2.message1.int32 = CPU_TO_BE(int32_t(0xf00dfeed));
}
b.bundle2.message2_size = CPU_TO_BE(uint32_t(sizeof(b.bundle2.message2)));
{
strcpy(b.bundle2.message2.address, "/c0");
strcpy(b.bundle2.message2.types, ",TFN");
}
}
b.message_size = CPU_TO_BE(uint32_t(sizeof(b.message)));
{
strcpy(b.message.address, "/addr1");
strcpy(b.message.types, ",TFiNI");
b.message.int32 = CPU_TO_BE(int32_t(0x55aacc33));
}
// Serialize message
osc::packet_t packet;
osc::forge_t forge;
osc::forge_frame_t frame, bundle1, bundle2, message;
UTEST_ASSERT(osc::forge_begin_dynamic(&frame, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_bundle(&bundle1, &frame, uint64_t(0x1122334455667788ULL)) == STATUS_OK);
{
// Sub-bundle 1
UTEST_ASSERT(osc::forge_begin_bundle(&bundle2, &bundle1, uint64_t(0x2233445566778899ULL)) == STATUS_OK);
{
UTEST_ASSERT(osc::forge_begin_message(&message, &bundle2, "/a0") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_int32(&message, int32_t(0xdeadbeef)) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&message) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_message(&message, &bundle2, "/addr0") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_bool(&message, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&message, false) == STATUS_OK);
UTEST_ASSERT(osc::forge_int32(&message, int32_t(0xcafeface)) == STATUS_OK);
UTEST_ASSERT(osc::forge_float32(&message, float(440.0f)) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&message) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&bundle2) == STATUS_OK);
// Sub-bundle 2
UTEST_ASSERT(osc::forge_begin_bundle(&bundle2, &bundle1, uint64_t(0x5566778899aabbccULL)) == STATUS_OK);
{
UTEST_ASSERT(osc::forge_begin_message(&message, &bundle2, "/b0") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_inf(&message) == STATUS_OK);
UTEST_ASSERT(osc::forge_int32(&message, int32_t(0xf00dfeed)) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&message) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_message(&message, &bundle2, "/c0") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_bool(&message, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&message, false) == STATUS_OK);
UTEST_ASSERT(osc::forge_null(&message) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&message) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&bundle2) == STATUS_OK);
// Sub-message
UTEST_ASSERT(osc::forge_begin_message(&message, &bundle1, "/addr1") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_bool(&message, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&message, false) == STATUS_OK);
UTEST_ASSERT(osc::forge_int32(&message, int32_t(0x55aacc33)) == STATUS_OK);
UTEST_ASSERT(osc::forge_null(&message) == STATUS_OK);
UTEST_ASSERT(osc::forge_inf(&message) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&message) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&bundle1) == STATUS_OK);
UTEST_ASSERT(osc::forge_end(&frame) == STATUS_OK);
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_destroy(&forge) == STATUS_OK);
// Validate output data
UTEST_ASSERT(packet.data != NULL);
bool matches = (packet.size == sizeof(b)) && (::memcmp(packet.data, &b, sizeof(b)) == 0);
if (!matches)
{
dump_bytes("src", &b, sizeof(b));
dump_bytes("dst", packet.data, packet.size);
UTEST_FAIL_MSG("Source and destination messages differ");
}
osc::forge_free(packet.data);
}
void test_forge_overflow()
{
uint8_t buf[22];
struct
{
char addr[12];
char types[4];
int32_t int32;
} m;
bzero(&m, sizeof(m));
strcpy(m.addr, "/message");
strcpy(m.types, ",i");
m.int32 = CPU_TO_BE(uint32_t(0xdeadcafe));
osc::packet_t packet;
osc::forge_t forge;
osc::forge_frame_t frame, message;
UTEST_ASSERT(osc::forge_begin_fixed(&frame, &forge, buf, sizeof(buf)) == STATUS_OK);
{
UTEST_ASSERT(osc::forge_begin_message(&message, &frame, "/message") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_int32(&message, 0xdeadcafe) == STATUS_OK);
UTEST_ASSERT(osc::forge_int32(&message, 0xdeadbeef) == STATUS_OVERFLOW);
}
UTEST_ASSERT(osc::forge_end(&message) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&frame) == STATUS_OK);
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_destroy(&forge) == STATUS_OK);
// Validate output data
UTEST_ASSERT(packet.data != NULL);
bool matches = (packet.size == sizeof(m)) && (::memcmp(packet.data, &m, sizeof(m)) == 0);
if (!matches)
{
dump_bytes("src", &m, sizeof(m));
dump_bytes("dst", packet.data, packet.size);
UTEST_FAIL_MSG("Source and destination messages differ");
}
}
void test_format()
{
format_message_t m;
bzero(&m, sizeof(m));
strcpy(m.address, "/test/msg");
strcpy(m.types, ",ifshtdScrFNNI");
m.int32 = CPU_TO_BE(uint32_t(0xdeadbeef));
m.float32 = CPU_TO_BE(float(440.0f));
strcpy(m.string, "some_string");
m.int64 = CPU_TO_BE(int64_t(0x1122334455667788ULL));
m.time_tag = CPU_TO_BE(uint64_t(0xcafebabecafefaceULL));
m.double64 = CPU_TO_BE(double(M_PI));
strcpy(m.type, "some_type");
m.ascii = CPU_TO_BE(uint32_t('\n'));
m.rgba = CPU_TO_BE(uint32_t(0xccffee44));
osc::packet_t packet;
osc::forge_t forge;
osc::forge_frame_t sframe;
UTEST_ASSERT(osc::forge_begin_dynamic(&sframe, &forge) == STATUS_OK);
{
status_t res = osc::forge_message(&sframe, "/test/msg", "ifshtdScrTsSf",
uint32_t(0xdeadbeef),
float(440.0f),
"some_string",
int64_t(0x1122334455667788ULL),
uint64_t(0xcafebabecafefaceULL),
double(M_PI),
"some_type",
'\n',
uint32_t(0xccffee44),
false,
NULL,
NULL,
INFINITY
);
UTEST_ASSERT(res == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&sframe) == STATUS_OK);
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_destroy(&forge) == STATUS_OK);
// Validate output data
UTEST_ASSERT(packet.data != NULL);
bool matches = (packet.size == sizeof(m)) && (::memcmp(packet.data, &m, sizeof(m)) == 0);
if (!matches)
{
dump_bytes("src", &m, sizeof(m));
dump_bytes("dst", packet.data, packet.size);
UTEST_FAIL_MSG("Source and destination messages differ");
}
// Parse packet data
osc::parser_t parser;
osc::parse_frame_t dframe;
UTEST_ASSERT(osc::parse_begin(&dframe, &parser, packet.data, packet.size) == STATUS_OK);
{
const char *address = NULL, *string = NULL, *type = NULL;
int32_t i32 = 0, ni32 = 0x1770feeb;
float f32 = 0.0f, nf32 = 12345.0f;
int64_t i64 = 0;
uint64_t tag = 0;
double d64 = 0.0;
char ch = '\0';
uint32_t rgba = 0;
bool tf = true, ntf = true;
// "ifshtdScrFNNI"
status_t res = osc::parse_message(&dframe, "ifshtdScrFTif", &address,
&i32, &f32, &string, &i64, &tag, &d64, &type, &ch, &rgba, &tf,
&ntf, &ni32, &nf32
);
UTEST_ASSERT(res == STATUS_OK);
UTEST_ASSERT(strcmp(address, "/test/msg") == 0);
UTEST_ASSERT(i32 == int32_t(0xdeadbeef));
UTEST_ASSERT(f32 == 440.0f);
UTEST_ASSERT(strcmp(string, "some_string") == 0);
UTEST_ASSERT(i64 == int64_t(0x1122334455667788ULL));
UTEST_ASSERT(tag == uint64_t(0xcafebabecafefaceULL));
UTEST_ASSERT(d64 == double(M_PI));
UTEST_ASSERT(strcmp(type, "some_type") == 0);
UTEST_ASSERT(ch == '\n');
UTEST_ASSERT(rgba == uint32_t(0xccffee44));
UTEST_ASSERT(tf == false);
UTEST_ASSERT(ntf == true);
UTEST_ASSERT(ni32 == 0x1770feeb);
UTEST_ASSERT(isinf(nf32));
}
UTEST_ASSERT(osc::parse_end(&dframe) == STATUS_OK);
UTEST_ASSERT(osc::parse_destroy(&parser) == STATUS_OK);
// Free packet data
osc::forge_free(packet.data);
}
void test_parse_legacy_message()
{
osc::parser_t parser;
osc::parse_frame_t frame, message;
osc::parse_token_t token;
uint64_t time_tag;
const char *address;
UTEST_ASSERT(osc::parse_begin(&frame, &parser, legacy_message, sizeof(legacy_message) - 1) != STATUS_OK);
UTEST_ASSERT(osc::parse_begin(&frame, &parser, NULL, sizeof(legacy_message) - 1) != STATUS_OK);
UTEST_ASSERT(osc::parse_begin(&frame, &parser, legacy_message, sizeof(legacy_message)) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_token(&frame, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_MESSAGE);
UTEST_ASSERT(osc::parse_begin_bundle(&message, &frame, &time_tag) != STATUS_OK);
UTEST_ASSERT(osc::parse_begin_array(&message, &frame) != STATUS_OK);
UTEST_ASSERT(osc::parse_begin_message(&message, &frame, &address) == STATUS_OK);
{
UTEST_ASSERT(strcmp(address, "/test") == 0);
UTEST_ASSERT(osc::parse_token(&frame, &token) != STATUS_OK);
UTEST_ASSERT(osc::parse_token(&message, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_EOR);
}
UTEST_ASSERT(osc::parse_end(&frame) != STATUS_OK);
UTEST_ASSERT(osc::parse_end(&message) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&message) != STATUS_OK);
UTEST_ASSERT(osc::parse_token(&frame, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_EOR);
}
UTEST_ASSERT(osc::parse_end(&frame) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&frame) != STATUS_OK);
UTEST_ASSERT(osc::parse_destroy(&parser) == STATUS_OK);
}
void test_parse_simple_message()
{
osc::parser_t parser;
osc::parse_frame_t frame, message, subframe;
osc::parse_token_t token;
const char *address;
const void *bytes;
const uint8_t *midi;
union
{
uint32_t u32;
float f32;
double d64;
int32_t i32;
uint64_t u64;
int64_t i64;
size_t sz;
char ch;
midi::event_t midi;
bool tf;
} xptr;
UTEST_ASSERT(osc::parse_begin(&frame, &parser, simple_message, sizeof(simple_message)) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_raw_message(&frame, &bytes, &xptr.sz, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "/oscillator/4/frequency") == 0);
UTEST_ASSERT(bytes == simple_message);
UTEST_ASSERT(xptr.sz == sizeof(simple_message));
UTEST_ASSERT(osc::parse_begin_message(&message, &frame, &address) == STATUS_OK);
{
UTEST_ASSERT(strcmp(address, "/oscillator/4/frequency") == 0);
UTEST_ASSERT(osc::parse_token(&message, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_FLOAT32);
UTEST_ASSERT(osc::parse_begin_bundle(&subframe, &message, &xptr.u64) != STATUS_OK);
UTEST_ASSERT(osc::parse_begin_message(&subframe, &message, &address) != STATUS_OK);
UTEST_ASSERT(osc::parse_begin_array(&subframe, &message) != STATUS_OK);
UTEST_ASSERT(osc::parse_int32(&message, &xptr.i32) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_string(&message, &address) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_blob(&message, &bytes, &xptr.sz) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_int64(&message, &xptr.i64) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_double64(&message, &xptr.d64) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_time_tag(&message, &xptr.u64) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_type(&message, &address) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_ascii(&message, &xptr.ch) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_rgba(&message, &xptr.u32) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_midi(&message, &xptr.midi) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_midi_raw(&message, &midi, &xptr.sz) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_bool(&message, &xptr.tf) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_null(&message) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_inf(&message) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_float32(&message, &xptr.f32) == STATUS_OK);
UTEST_ASSERT(xptr.f32 == 440.0f);
UTEST_ASSERT(osc::parse_token(&message, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_EOR);
UTEST_ASSERT(osc::parse_int32(&message, &xptr.i32) == STATUS_EOF);
UTEST_ASSERT(osc::parse_string(&message, &address) == STATUS_EOF);
UTEST_ASSERT(osc::parse_blob(&message, &bytes, &xptr.sz) == STATUS_EOF);
UTEST_ASSERT(osc::parse_int64(&message, &xptr.i64) == STATUS_EOF);
UTEST_ASSERT(osc::parse_double64(&message, &xptr.d64) == STATUS_EOF);
UTEST_ASSERT(osc::parse_time_tag(&message, &xptr.u64) == STATUS_EOF);
UTEST_ASSERT(osc::parse_type(&message, &address) == STATUS_EOF);
UTEST_ASSERT(osc::parse_ascii(&message, &xptr.ch) == STATUS_EOF);
UTEST_ASSERT(osc::parse_rgba(&message, &xptr.u32) == STATUS_EOF);
UTEST_ASSERT(osc::parse_midi(&message, &xptr.midi) == STATUS_EOF);
UTEST_ASSERT(osc::parse_midi_raw(&message, &midi, &xptr.sz) == STATUS_EOF);
UTEST_ASSERT(osc::parse_bool(&message, &xptr.tf) == STATUS_EOF);
UTEST_ASSERT(osc::parse_null(&message) == STATUS_EOF);
UTEST_ASSERT(osc::parse_inf(&message) == STATUS_EOF);
UTEST_ASSERT(osc::parse_float32(&message, &xptr.f32) == STATUS_EOF);
}
UTEST_ASSERT(osc::parse_end(&frame) != STATUS_OK);
UTEST_ASSERT(osc::parse_end(&message) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&message) != STATUS_OK);
UTEST_ASSERT(osc::parse_token(&frame, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_EOR);
}
UTEST_ASSERT(osc::parse_end(&frame) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&frame) != STATUS_OK);
UTEST_ASSERT(osc::parse_destroy(&parser) == STATUS_OK);
}
void test_parse_specials_message()
{
special_message_t m;
bzero(&m, sizeof(m));
strcpy(m.address, "/message001");
strcpy(m.types, ",NNNNNNNNNNNNNNNIIII");
// Parse the message
osc::parser_t parser;
osc::parse_frame_t frame, message;
osc::parse_token_t token;
const char *address;
float f32 = 0.0f;
double f64 = 0.0;
UTEST_ASSERT(osc::parse_begin(&frame, &parser, &m, sizeof(m)) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_begin_message(&message, &frame, &address) == STATUS_OK);
{
UTEST_ASSERT(strcmp(address, "/message001") == 0);
UTEST_ASSERT(osc::parse_token(&message, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_NULL);
UTEST_ASSERT(osc::parse_int32(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_float32(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_string(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_blob(&message, NULL, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_int64(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_double64(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_time_tag(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_type(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_ascii(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_rgba(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_midi(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_midi_raw(&message, NULL, 0) == STATUS_NULL);
UTEST_ASSERT(osc::parse_bool(&message, NULL) == STATUS_NULL);
UTEST_ASSERT(osc::parse_null(&message) == STATUS_OK);
UTEST_ASSERT(osc::parse_inf(&message) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_null(&message) == STATUS_OK);
UTEST_ASSERT(osc::parse_int32(&message, NULL) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_inf(&message) == STATUS_OK);
UTEST_ASSERT(osc::parse_null(&message) == STATUS_BAD_TYPE);
UTEST_ASSERT(osc::parse_inf(&message) == STATUS_OK);
UTEST_ASSERT(osc::parse_float32(&message, &f32) == STATUS_OK);
UTEST_ASSERT(isinf(f32));
UTEST_ASSERT(osc::parse_double64(&message, &f64) == STATUS_OK);
UTEST_ASSERT(isinf(f64));
UTEST_ASSERT(osc::parse_null(&message) == STATUS_EOF);
UTEST_ASSERT(osc::parse_token(&message, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_EOR);
}
UTEST_ASSERT(osc::parse_end(&message) == STATUS_OK);
UTEST_ASSERT(osc::parse_token(&frame, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_EOR);
}
UTEST_ASSERT(osc::parse_end(&frame) == STATUS_OK);
UTEST_ASSERT(osc::parse_destroy(&parser) == STATUS_OK);
}
void test_parse_parameters()
{
// Forge the message using OSC serializer
osc::packet_t packet;
osc::forge_t forge;
osc::forge_frame_t sframe, smessage, sarray1, sarray2;
midi::event_t src_midi;
src_midi.timestamp = 0;
src_midi.type = midi::MIDI_MSG_NOTE_ON;
src_midi.channel = 4;
src_midi.note.pitch = 51;
src_midi.note.velocity = 0x7f;
uint8_t src_raw_midi[4];
src_raw_midi[0] = midi::MIDI_MSG_NOTE_OFF | 4;
src_raw_midi[1] = 51;
src_raw_midi[2] = 0x5f;
UTEST_ASSERT(osc::forge_begin_dynamic(&sframe, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_message(&smessage, &sframe, "/address/01") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_int32(&smessage, 0xdeadbeef) == STATUS_OK);
UTEST_ASSERT(osc::forge_float32(&smessage, 440.0f) == STATUS_OK);
UTEST_ASSERT(osc::forge_string(&smessage, "string1") == STATUS_OK);
UTEST_ASSERT(osc::forge_blob(&smessage, "BLOB1", 5) == STATUS_OK);
UTEST_ASSERT(osc::forge_int64(&smessage, uint64_t(0x1234567855aacc33ULL)) == STATUS_OK);
UTEST_ASSERT(osc::forge_double64(&smessage, 48000.0) == STATUS_OK);
UTEST_ASSERT(osc::forge_time_tag(&smessage, uint64_t(0xff00cc01aa028803ULL)) == STATUS_OK);
UTEST_ASSERT(osc::forge_type(&smessage, "type01") == STATUS_OK);
UTEST_ASSERT(osc::forge_ascii(&smessage, '\n') == STATUS_OK);
UTEST_ASSERT(osc::forge_rgba(&smessage, 0x8080ff40) == STATUS_OK);
UTEST_ASSERT(osc::forge_midi(&smessage, &src_midi) == STATUS_OK);
UTEST_ASSERT(osc::forge_midi_raw(&smessage, src_raw_midi, 3) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_array(&sarray1, &smessage) == STATUS_OK);
{
UTEST_ASSERT(osc::forge_int32(&sarray1, int32_t(0xfffefcfd)) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&sarray1, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_array(&sarray2, &sarray1) == STATUS_OK);
{
UTEST_ASSERT(osc::forge_string(&sarray2, "string2") == STATUS_OK);
UTEST_ASSERT(osc::forge_blob(&sarray2, "BLOB02", 6) == STATUS_OK);
UTEST_ASSERT(osc::forge_int32(&sarray2, int32_t(0xcafeface)) == STATUS_OK);
UTEST_ASSERT(osc::forge_inf(&sarray2) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&sarray2) == STATUS_OK);
UTEST_ASSERT(osc::forge_float32(&sarray1, 44100.0f) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&sarray1) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&smessage, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&smessage, false) == STATUS_OK);
UTEST_ASSERT(osc::forge_null(&smessage) == STATUS_OK);
UTEST_ASSERT(osc::forge_inf(&smessage) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&smessage) == STATUS_OK);
UTEST_ASSERT(osc::forge_end(&sframe) == STATUS_OK);
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_destroy(&forge) == STATUS_OK);
// Now deserialize and check the packet data
osc::parser_t parser;
osc::parse_frame_t dframe, dmessage, darray1, darray2;
const char *address;
midi::event_t dst_midi;
const uint8_t *dst_raw_midi;
const void *blob;
union
{
uint32_t u32;
float f32;
double d64;
int32_t i32;
uint64_t u64;
int64_t i64;
size_t sz;
char ch;
midi::event_t midi;
bool tf;
} xptr;
UTEST_ASSERT(osc::parse_begin(&dframe, &parser, packet.data, packet.size) == STATUS_OK);
UTEST_ASSERT(osc::parse_begin_message(&dmessage, &dframe, &address) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_int32(&dmessage, &xptr.i32) == STATUS_OK);
UTEST_ASSERT(xptr.i32 == int32_t(0xdeadbeef));
UTEST_ASSERT(osc::parse_float32(&dmessage, &xptr.f32) == STATUS_OK);
UTEST_ASSERT(xptr.f32 == 440.0f);
UTEST_ASSERT(osc::parse_string(&dmessage, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "string1") == 0);
UTEST_ASSERT(osc::parse_blob(&dmessage, &blob, &xptr.sz) == STATUS_OK);
UTEST_ASSERT(xptr.sz == 5);
UTEST_ASSERT(memcmp(blob, "BLOB1", xptr.sz) == 0);
UTEST_ASSERT(osc::parse_int64(&dmessage, &xptr.i64) == STATUS_OK);
UTEST_ASSERT(xptr.i64 == int64_t(0x1234567855aacc33ULL));
UTEST_ASSERT(osc::parse_double64(&dmessage, &xptr.d64) == STATUS_OK);
UTEST_ASSERT(xptr.d64 == 48000.0);
UTEST_ASSERT(osc::parse_time_tag(&dmessage, &xptr.u64) == STATUS_OK);
UTEST_ASSERT(xptr.u64 == uint64_t(0xff00cc01aa028803ULL));
UTEST_ASSERT(osc::parse_type(&dmessage, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "type01") == 0);
UTEST_ASSERT(osc::parse_ascii(&dmessage, &xptr.ch) == STATUS_OK);
UTEST_ASSERT(xptr.ch == '\n');
UTEST_ASSERT(osc::parse_rgba(&dmessage, &xptr.u32) == STATUS_OK);
UTEST_ASSERT(xptr.u32 == 0x8080ff40);
UTEST_ASSERT(osc::parse_midi(&dmessage, &dst_midi) == STATUS_OK);
UTEST_ASSERT((src_midi.type == dst_midi.type) &&
(src_midi.channel == dst_midi.channel) &&
(src_midi.note.pitch == dst_midi.note.pitch) &&
(src_midi.note.velocity == dst_midi.note.velocity));
UTEST_ASSERT(osc::parse_midi_raw(&dmessage, &dst_raw_midi, &xptr.sz) == STATUS_OK);
UTEST_ASSERT(xptr.sz == 3);
UTEST_ASSERT(memcmp(src_raw_midi, dst_raw_midi, xptr.sz) == 0);
UTEST_ASSERT(osc::parse_begin_array(&darray1, &dmessage) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_int32(&darray1, &xptr.i32) == STATUS_OK);
UTEST_ASSERT(xptr.i32 == int32_t(0xfffefcfd));
UTEST_ASSERT(osc::parse_bool(&darray1, &xptr.tf) == STATUS_OK);
UTEST_ASSERT(xptr.tf == true);
UTEST_ASSERT(osc::parse_begin_array(&darray2, &darray1) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_string(&darray2, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "string2") == 0);
UTEST_ASSERT(osc::parse_blob(&darray2, &blob, &xptr.sz) == STATUS_OK);
UTEST_ASSERT(xptr.sz == 6);
UTEST_ASSERT(memcmp(blob, "BLOB02", xptr.sz) == 0);
UTEST_ASSERT(osc::parse_int32(&darray2, &xptr.i32) == STATUS_OK);
UTEST_ASSERT(xptr.i32 == int32_t(0xcafeface));
UTEST_ASSERT(osc::parse_inf(&darray2) == STATUS_OK);
}
UTEST_ASSERT(osc::parse_end(&darray2) == STATUS_OK);
UTEST_ASSERT(osc::parse_float32(&darray1, &xptr.f32) == STATUS_OK);
UTEST_ASSERT(xptr.f32 == 44100.0f);
}
UTEST_ASSERT(osc::parse_end(&darray1) == STATUS_OK);
UTEST_ASSERT(osc::parse_bool(&dmessage, &xptr.tf) == STATUS_OK);
UTEST_ASSERT(xptr.tf == true);
UTEST_ASSERT(osc::parse_bool(&dmessage, &xptr.tf) == STATUS_OK);
UTEST_ASSERT(xptr.tf == false);
UTEST_ASSERT(osc::parse_null(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_inf(&dmessage) == STATUS_OK);
}
UTEST_ASSERT(osc::parse_end(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&dframe) == STATUS_OK);
UTEST_ASSERT(osc::parse_destroy(&parser) == STATUS_OK);
// Deserialize again, test skips
UTEST_ASSERT(osc::parse_begin(&dframe, &parser, packet.data, packet.size) == STATUS_OK);
UTEST_ASSERT(osc::parse_begin_message(&dmessage, &dframe, &address) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_begin_array(&darray1, &dmessage) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_skip(&darray1) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&darray1) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&darray1) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&darray1) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&darray1) == STATUS_EOF);
}
UTEST_ASSERT(osc::parse_end(&darray1) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_EOF);
}
UTEST_ASSERT(osc::parse_end(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&dframe) == STATUS_OK);
UTEST_ASSERT(osc::parse_destroy(&parser) == STATUS_OK);
// Free the packet data
osc::forge_free(packet.data);
}
void test_parse_bundles()
{
// Serialize message
osc::packet_t packet;
osc::forge_t forge;
osc::forge_frame_t sframe, sbundle1, sbundle2, smessage;
UTEST_ASSERT(osc::forge_begin_dynamic(&sframe, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_bundle(&sbundle1, &sframe, uint64_t(0x1122334455667788ULL)) == STATUS_OK);
{
// Sub-bundle 1
UTEST_ASSERT(osc::forge_begin_bundle(&sbundle2, &sbundle1, uint64_t(0x2233445566778899ULL)) == STATUS_OK);
{
UTEST_ASSERT(osc::forge_begin_message(&smessage, &sbundle2, "/a0") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_int32(&smessage, int32_t(0xdeadbeef)) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&smessage) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_message(&smessage, &sbundle2, "/addr0") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_bool(&smessage, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&smessage, false) == STATUS_OK);
UTEST_ASSERT(osc::forge_int32(&smessage, int32_t(0xcafeface)) == STATUS_OK);
UTEST_ASSERT(osc::forge_float32(&smessage, 440.0f) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&smessage) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&sbundle2) == STATUS_OK);
// Sub-bundle 2
UTEST_ASSERT(osc::forge_begin_bundle(&sbundle2, &sbundle1, uint64_t(0x5566778899aabbccULL)) == STATUS_OK);
{
UTEST_ASSERT(osc::forge_begin_message(&smessage, &sbundle2, "/b0") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_inf(&smessage) == STATUS_OK);
UTEST_ASSERT(osc::forge_int32(&smessage, int32_t(0xf00dfeed)) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&smessage) == STATUS_OK);
UTEST_ASSERT(osc::forge_begin_message(&smessage, &sbundle2, "/c0") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_bool(&smessage, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&smessage, false) == STATUS_OK);
UTEST_ASSERT(osc::forge_null(&smessage) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&smessage) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&sbundle2) == STATUS_OK);
// Sub-message
UTEST_ASSERT(osc::forge_begin_message(&smessage, &sbundle1, "/addr1") == STATUS_OK);
{
UTEST_ASSERT(osc::forge_bool(&smessage, true) == STATUS_OK);
UTEST_ASSERT(osc::forge_bool(&smessage, false) == STATUS_OK);
UTEST_ASSERT(osc::forge_int32(&smessage, int32_t(0x55aacc33)) == STATUS_OK);
UTEST_ASSERT(osc::forge_null(&smessage) == STATUS_OK);
UTEST_ASSERT(osc::forge_inf(&smessage) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&smessage) == STATUS_OK);
}
UTEST_ASSERT(osc::forge_end(&sbundle1) == STATUS_OK);
UTEST_ASSERT(osc::forge_end(&sframe) == STATUS_OK);
UTEST_ASSERT(osc::forge_close(&packet, &forge) == STATUS_OK);
UTEST_ASSERT(osc::forge_destroy(&forge) == STATUS_OK);
// Test reading
union
{
uint32_t u32;
float f32;
double d64;
int32_t i32;
uint64_t u64;
int64_t i64;
size_t sz;
char ch;
midi::event_t midi;
bool tf;
} xptr;
osc::parser_t parser;
osc::parse_frame_t dframe, dbundle1, dbundle2, dmessage;
const char *address;
const void *bytes;
osc::parse_token_t token;
UTEST_ASSERT(osc::parse_begin(&dframe, &parser, packet.data, packet.size) == STATUS_OK);
UTEST_ASSERT(osc::parse_token(&dframe, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_BUNDLE);
UTEST_ASSERT(osc::parse_begin_bundle(&dbundle1, &dframe, &xptr.u64) == STATUS_OK);
UTEST_ASSERT(xptr.u64 == uint64_t(0x1122334455667788ULL));
{
// Sub-bundle 1
UTEST_ASSERT(osc::parse_token(&dbundle1, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_BUNDLE);
UTEST_ASSERT(osc::parse_begin_bundle(&dbundle2, &dbundle1, &xptr.u64) == STATUS_OK);
UTEST_ASSERT(xptr.u64 == uint64_t(0x2233445566778899ULL));
{
UTEST_ASSERT(osc::parse_token(&dbundle2, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_MESSAGE);
UTEST_ASSERT(osc::parse_begin_message(&dmessage, &dbundle2, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "/a0") == 0);
{
UTEST_ASSERT(osc::parse_int32(&dmessage, &xptr.i32) == STATUS_OK);
UTEST_ASSERT(xptr.i32 == int32_t(0xdeadbeef));
}
UTEST_ASSERT(osc::parse_end(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_token(&dbundle2, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_MESSAGE);
UTEST_ASSERT(osc::parse_begin_message(&dmessage, &dbundle2, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "/addr0") == 0);
{
UTEST_ASSERT(osc::parse_bool(&dmessage, &xptr.tf) == STATUS_OK);
UTEST_ASSERT(xptr.tf == true);
UTEST_ASSERT(osc::parse_bool(&dmessage, &xptr.tf) == STATUS_OK);
UTEST_ASSERT(xptr.tf == false);
UTEST_ASSERT(osc::parse_int32(&dmessage, &xptr.i32) == STATUS_OK);
UTEST_ASSERT(xptr.i32 == int32_t(0xcafeface));
UTEST_ASSERT(osc::parse_float32(&dmessage, &xptr.f32) == STATUS_OK);
UTEST_ASSERT(xptr.f32 == 440.0f);
}
UTEST_ASSERT(osc::parse_end(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&dmessage) != STATUS_OK);
}
UTEST_ASSERT(osc::parse_end(&dbundle2) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&dbundle2) != STATUS_OK);
// Sub-bundle 2
UTEST_ASSERT(osc::parse_token(&dbundle1, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_BUNDLE);
UTEST_ASSERT(osc::parse_begin_bundle(&dbundle2, &dbundle1, &xptr.u64) == STATUS_OK);
UTEST_ASSERT(xptr.u64 == uint64_t(0x5566778899aabbccULL));
{
UTEST_ASSERT(osc::parse_token(&dbundle2, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_MESSAGE);
UTEST_ASSERT(osc::parse_raw_message(&dbundle2, &bytes, &xptr.sz, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "/b0") == 0);
UTEST_ASSERT(bytes == address);
UTEST_ASSERT(xptr.sz == 12); // 4 bytes per address, 4 bytes per args, 4 bytes per int32 argument
UTEST_ASSERT(osc::parse_begin_message(&dmessage, &dbundle2, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "/b0") == 0);
{
UTEST_ASSERT(osc::parse_inf(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_int32(&dmessage, &xptr.i32) == STATUS_OK);
UTEST_ASSERT(xptr.i32 == int32_t(0xf00dfeed));
}
UTEST_ASSERT(osc::parse_end(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&dmessage) != STATUS_OK);
UTEST_ASSERT(osc::parse_token(&dbundle2, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_MESSAGE);
UTEST_ASSERT(osc::parse_begin_message(&dmessage, &dbundle2, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "/c0") == 0);
{
UTEST_ASSERT(osc::parse_bool(&dmessage, &xptr.tf) == STATUS_OK);
UTEST_ASSERT(xptr.tf == true);
UTEST_ASSERT(osc::parse_bool(&dmessage, &xptr.tf) == STATUS_OK);
UTEST_ASSERT(xptr.tf == false);
UTEST_ASSERT(osc::parse_null(&dmessage) == STATUS_OK);
}
UTEST_ASSERT(osc::parse_end(&dmessage) == STATUS_OK);
}
UTEST_ASSERT(osc::parse_end(&dbundle2) == STATUS_OK);
// Sub-message
UTEST_ASSERT(osc::parse_token(&dbundle1, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_MESSAGE);
UTEST_ASSERT(osc::parse_begin_message(&dmessage, &dbundle1, &address) == STATUS_OK);
UTEST_ASSERT(strcmp(address, "/addr1") == 0);
{
UTEST_ASSERT(osc::parse_bool(&dmessage, &xptr.tf) == STATUS_OK);
UTEST_ASSERT(xptr.tf == true);
UTEST_ASSERT(osc::parse_bool(&dmessage, &xptr.tf) == STATUS_OK);
UTEST_ASSERT(xptr.tf == false);
UTEST_ASSERT(osc::parse_int32(&dmessage, &xptr.i32) == STATUS_OK);
UTEST_ASSERT(xptr.i32 == int32_t(0x55aacc33));
UTEST_ASSERT(osc::parse_null(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_inf(&dmessage) == STATUS_OK);
}
UTEST_ASSERT(osc::parse_end(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&dmessage) != STATUS_OK);
}
UTEST_ASSERT(osc::parse_end(&dbundle1) == STATUS_OK);
UTEST_ASSERT(osc::parse_end(&dbundle1) != STATUS_OK);
UTEST_ASSERT(osc::parse_end(&dframe) == STATUS_OK);
UTEST_ASSERT(osc::parse_destroy(&parser) == STATUS_OK);
// Test skipping
UTEST_ASSERT(osc::parse_begin(&dframe, &parser, packet.data, packet.size) == STATUS_OK);
UTEST_ASSERT(osc::parse_begin_bundle(&dbundle1, &dframe, NULL) == STATUS_OK);
{
// Sub-bundle 1
UTEST_ASSERT(osc::parse_begin_bundle(&dbundle2, &dbundle1, NULL) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_skip(&dbundle2) == STATUS_OK);
UTEST_ASSERT(osc::parse_begin_message(&dmessage, &dbundle2, NULL) == STATUS_OK);
{
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dmessage) == STATUS_EOF);
}
UTEST_ASSERT(osc::parse_end(&dmessage) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dbundle2) == STATUS_EOF);
}
UTEST_ASSERT(osc::parse_end(&dbundle2) == STATUS_OK);
// Sub-bundle 2
UTEST_ASSERT(osc::parse_skip(&dbundle1) == STATUS_OK);
// Sub-message
UTEST_ASSERT(osc::parse_token(&dbundle1, &token) == STATUS_OK);
UTEST_ASSERT(token == osc::PT_MESSAGE);
UTEST_ASSERT(osc::parse_skip(&dbundle1) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dbundle1) == STATUS_EOF);
}
UTEST_ASSERT(osc::parse_end(&dbundle1) == STATUS_OK);
UTEST_ASSERT(osc::parse_skip(&dframe) == STATUS_EOF);
UTEST_ASSERT(osc::parse_end(&dframe) == STATUS_OK);
UTEST_ASSERT(osc::parse_destroy(&parser) == STATUS_OK);
// Free the packet data
osc::forge_free(packet.data);
}
void test_pattern()
{
osc::pattern_t pattern;
for (const char **p = valid_patterns; *p != NULL; ++p)
{
printf(" testing address pattern: %s\n", *p);
UTEST_ASSERT(osc::pattern_create(&pattern, *p) == STATUS_OK);
UTEST_ASSERT(osc::pattern_destroy(&pattern) == STATUS_OK);
}
for (const char **p = invalid_patterns; *p != NULL; ++p)
{
printf(" testing address pattern: %s\n", *p);
UTEST_ASSERT(osc::pattern_create(&pattern, *p) == STATUS_BAD_FORMAT);
}
for (size_t i=0, n=sizeof(match_pattern)/sizeof(pattern_match_t); i < n; ++i)
{
const pattern_match_t *m = &match_pattern[i];
printf(" matching string \"%s\" to pattern \"%s\"\n", m->address, m->pattern);
UTEST_ASSERT(osc::pattern_create(&pattern, m->pattern) == STATUS_OK);
UTEST_ASSERT(osc::pattern_match(&pattern, m->address) == m->match);
UTEST_ASSERT(osc::pattern_destroy(&pattern) == STATUS_OK);
}
}
UTEST_MAIN
{
#define CALL(v) printf("Executing " #v "...\n"); v();
CALL(test_forge_simple_message);
CALL(test_forge_parameters);
CALL(test_forge_message_bundle);
CALL(test_forge_overflow);
CALL(test_parse_legacy_message);
CALL(test_parse_simple_message);
CALL(test_parse_specials_message);
CALL(test_parse_parameters);
CALL(test_parse_bundles);
CALL(test_format);
CALL(test_pattern);
}
UTEST_END;