static void test_mapentry_check() {
upb_status s = UPB_STATUS_INIT;
upb_msgdef *m = upb_msgdef_new(&m);
upb_fielddef *f = upb_fielddef_new(&f);
upb_symtab *symtab = upb_symtab_new(&symtab);
upb_msgdef *subm = upb_msgdef_new(&subm);
upb_def *defs[2];
upb_msgdef_setfullname(m, "TestMessage", &s);
upb_fielddef_setname(f, "field1", &s);
upb_fielddef_setnumber(f, 1, &s);
upb_fielddef_setlabel(f, UPB_LABEL_OPTIONAL);
upb_fielddef_settype(f, UPB_TYPE_MESSAGE);
upb_fielddef_setsubdefname(f, ".MapEntry", &s);
upb_msgdef_addfield(m, f, &f, &s);
ASSERT(upb_ok(&s));
upb_msgdef_setfullname(subm, "MapEntry", &s);
upb_msgdef_setmapentry(subm, true);
defs[0] = upb_msgdef_upcast_mutable(m);
defs[1] = upb_msgdef_upcast_mutable(subm);
upb_symtab_add(symtab, defs, 2, NULL, &s);
/* Should not have succeeded: non-repeated field pointing to a MapEntry. */
ASSERT(!upb_ok(&s));
upb_fielddef_setlabel(f, UPB_LABEL_REPEATED);
upb_symtab_add(symtab, defs, 2, NULL, &s);
ASSERT(upb_ok(&s));
upb_symtab_unref(symtab, &symtab);
upb_msgdef_unref(subm, &subm);
upb_msgdef_unref(m, &m);
}
static void test_empty_symtab() {
upb_symtab *s = upb_symtab_new(&s);
upb_symtab_iter i;
for (upb_symtab_begin(&i, s, UPB_DEF_ANY); !upb_symtab_done(&i);
upb_symtab_next(&i)) {
ASSERT(false); /* Should not get here. */
}
upb_symtab_unref(s, &s);
}
static void test_symbol_resolution() {
upb_status s = UPB_STATUS_INIT;
upb_def *defs[2];
upb_msgdef *m1;
upb_msgdef *m2;
upb_msgdef *m3;
upb_fielddef *m3_field1;
upb_fielddef *m3_field2;
upb_symtab *symtab = upb_symtab_new(&symtab);
ASSERT(symtab);
/* m1 has name "A.B.C" and no fields. We'll add it to the symtab now. */
m1 = upb_msgdef_new(&m1);
ASSERT(m1);
ASSERT_STATUS(upb_msgdef_setfullname(m1, "A.B.C", &s), &s);
ASSERT_STATUS(upb_symtab_add(symtab, (upb_def**)&m1, 1,
NULL, &s), &s);
/* m2 has name "D.E" and no fields. We'll add it in the same batch as m3
* below. */
m2 = upb_msgdef_new(&m2);
ASSERT(m2);
ASSERT_STATUS(upb_msgdef_setfullname(m2, "D.E", &s), &s);
/* m3 has name "F.G" and two fields, of type A.B.C and D.E respectively. We'll
* add it in the same batch as m2 above. */
m3 = upb_msgdef_new(&m3);
ASSERT(m3);
ASSERT_STATUS(upb_msgdef_setfullname(m3, "F.G", &s), &s);
m3_field1 = upb_fielddef_new(&m3_field1);
ASSERT_STATUS(upb_fielddef_setname(m3_field1, "field1", &s), &s);
ASSERT_STATUS(upb_fielddef_setnumber(m3_field1, 1, &s), &s);
upb_fielddef_setlabel(m3_field1, UPB_LABEL_OPTIONAL);
upb_fielddef_settype(m3_field1, UPB_TYPE_MESSAGE);
ASSERT_STATUS(upb_fielddef_setsubdefname(m3_field1, ".A.B.C", &s), &s);
ASSERT_STATUS(upb_msgdef_addfield(m3, m3_field1, NULL, &s), &s);
m3_field2 = upb_fielddef_new(&m3_field2);
ASSERT_STATUS(upb_fielddef_setname(m3_field2, "field2", &s), &s);
ASSERT_STATUS(upb_fielddef_setnumber(m3_field2, 2, &s), &s);
upb_fielddef_setlabel(m3_field2, UPB_LABEL_OPTIONAL);
upb_fielddef_settype(m3_field2, UPB_TYPE_MESSAGE);
ASSERT_STATUS(upb_fielddef_setsubdefname(m3_field2, ".D.E", &s), &s);
ASSERT_STATUS(upb_msgdef_addfield(m3, m3_field2, NULL, &s), &s);
defs[0] = upb_msgdef_upcast_mutable(m2);
defs[1] = upb_msgdef_upcast_mutable(m3);
ASSERT_STATUS(upb_symtab_add(symtab, defs, 2, NULL, &s), &s);
upb_fielddef_unref(m3_field2, &m3_field2);
upb_fielddef_unref(m3_field1, &m3_field1);
upb_msgdef_unref(m3, &m3);
upb_msgdef_unref(m2, &m2);
upb_msgdef_unref(m1, &m1);
upb_symtab_unref(symtab, &symtab);
}
static void test_oneofs() {
upb_status s = UPB_STATUS_INIT;
bool ok = true;
upb_def *subm_defs[1];
upb_symtab *symtab = upb_symtab_new(&symtab);
upb_msgdef *subm = upb_msgdef_newnamed("SubMessage", &symtab);
upb_msgdef *m = upb_msgdef_newnamed("TestMessage", &symtab);
upb_oneofdef *o = upb_oneofdef_new(&o);
const upb_oneofdef *lookup_o;
const upb_fielddef *lookup_field;
upb_def *defs[1];
ASSERT(symtab != NULL);
/* Create a test message for fields to refer to. */
upb_msgdef_addfield(subm, newfield("field1", 1, UPB_TYPE_INT32,
UPB_LABEL_OPTIONAL, NULL, &symtab),
&symtab, NULL);
subm_defs[0] = upb_msgdef_upcast_mutable(subm);
ASSERT_STATUS(upb_symtab_add(symtab, subm_defs, 1, &symtab, &s), &s);
ASSERT(upb_msgdef_numoneofs(m) == 0);
ASSERT(upb_oneofdef_numfields(o) == 0);
ASSERT(upb_oneofdef_name(o) == NULL);
ok = upb_oneofdef_setname(o, "test_oneof", &s);
ASSERT_STATUS(ok, &s);
ok = upb_oneofdef_addfield(o, newfield("field1", 1, UPB_TYPE_INT32,
UPB_LABEL_OPTIONAL, NULL, &symtab),
&symtab, NULL);
ASSERT_STATUS(ok, &s);
ok = upb_oneofdef_addfield(o, newfield("field2", 2, UPB_TYPE_MESSAGE,
UPB_LABEL_OPTIONAL, ".SubMessage",
&symtab),
&symtab, NULL);
ASSERT_STATUS(ok, &s);
ok = upb_msgdef_addoneof(m, o, NULL, &s);
ASSERT_STATUS(ok, &s);
defs[0] = upb_msgdef_upcast_mutable(m);
ASSERT_STATUS(upb_symtab_add(symtab, defs, 1, &symtab, &s), &s);
ASSERT(upb_msgdef_numoneofs(m) == 1);
lookup_o = upb_msgdef_ntooz(m, "test_oneof");
ASSERT(lookup_o == o);
lookup_field = upb_oneofdef_ntofz(o, "field1");
ASSERT(lookup_field != NULL && upb_fielddef_number(lookup_field) == 1);
upb_symtab_unref(symtab, &symtab);
upb_oneofdef_unref(o, &o);
}
void upb_def_unref(const upb_def *_def) {
upb_def *def = (upb_def*)_def; // Need to modify refcount.
if (!def) return;
if (upb_atomic_unref(&def->refcount)) {
if (def->symtab) {
upb_symtab_unref(def->symtab);
// Def might be deleted now.
} else {
upb_def_free(def);
}
}
}
static void test_cycles_in_replacement() {
upb_symtab *s = upb_symtab_new(&s);
upb_msgdef *m = upb_msgdef_newnamed("M", &s);
upb_status status = UPB_STATUS_INIT;
upb_msgdef_addfield(m, newfield("m", 1, UPB_TYPE_MESSAGE,
UPB_LABEL_OPTIONAL, ".M", &s),
&s, NULL);
ASSERT_STATUS(upb_symtab_add(s, (upb_def**)&m, 1, &s, &status), &status);
ASSERT_STATUS(upb_symtab_add(s, NULL, 0, &s, &status), &status);
upb_symtab_unref(s, &s);
}
static bool initialize()
{
// Initialize upb state, decode descriptor.
upb_status status = UPB_STATUS_INIT;
upb_symtab *s = upb_symtab_new();
upb_string *fds_str = upb_strreadfile(MESSAGE_DESCRIPTOR_FILE);
if(fds_str == NULL) {
fprintf(stderr, "Couldn't read " MESSAGE_DESCRIPTOR_FILE ":"),
upb_printerr(&status);
return false;
}
upb_parsedesc(s, fds_str, &status);
upb_string_unref(fds_str);
if(!upb_ok(&status)) {
fprintf(stderr, "Error importing " MESSAGE_DESCRIPTOR_FILE ":");
upb_printerr(&status);
return false;
}
def = upb_dyncast_msgdef(upb_symtab_lookup(s, UPB_STRLIT(MESSAGE_NAME)));
if(!def) {
fprintf(stderr, "Error finding symbol '" UPB_STRFMT "'.\n",
UPB_STRARG(UPB_STRLIT(MESSAGE_NAME)));
return false;
}
upb_symtab_unref(s);
// Read the message data itself.
input_str = upb_strreadfile(MESSAGE_FILE);
if(input_str == NULL) {
fprintf(stderr, "Error reading " MESSAGE_FILE "\n");
return false;
}
upb_status_uninit(&status);
msg = upb_msg_new(def);
upb_stringsrc_init(&strsrc);
upb_handlers_init(&h, def);
upb_msg_regdhandlers(&h);
upb_decoder_init(&d, &h);
if (!BYREF) {
// Pretend the input string is stack-allocated, which will force its data
// to be copied instead of referenced. There is no good reason to do this,
// except to benchmark against proto2 more fairly, which in its open-source
// release does not support referencing the input string.
input_str->refcount.v = _UPB_STRING_REFCOUNT_STACK;
}
return true;
}
int main() {
upb_symtab *s = upb_symtab_new();
// Will be empty atm since we haven't added anything to the symtab.
int count;
const upb_def **defs = upb_symtab_getdefs(s, &count, UPB_DEF_ANY);
for (int i = 0; i < count; i++) {
upb_def_unref(defs[i]);
}
free(defs);
upb_symtab_unref(s);
return 0;
}
static void test_fielddef_unref() {
bool ok;
upb_symtab *s = load_test_proto(&s);
const upb_msgdef *md = upb_symtab_lookupmsg(s, "A");
const upb_fielddef *f = upb_msgdef_itof(md, 1);
upb_fielddef_ref(f, &f);
/* Unref symtab; now fielddef is the only thing keeping the msgdef alive. */
upb_symtab_unref(s, &s);
/* Check that md is still alive. */
ok = strcmp(upb_msgdef_fullname(md), "A") == 0;
ASSERT(ok);
/* Check that unref of fielddef frees the whole remaining graph. */
upb_fielddef_unref(f, &f);
}
static void test_replacement() {
upb_symtab *s = upb_symtab_new(&s);
upb_enumdef *e2;
upb_msgdef *m2;
upb_enumdef *e;
upb_status status = UPB_STATUS_INIT;
upb_def *newdefs[3];
upb_def *newdefs2[1];
const upb_msgdef *m3;
upb_msgdef *m = upb_msgdef_newnamed("MyMessage", &s);
upb_msgdef_addfield(m, newfield("field1", 1, UPB_TYPE_ENUM,
UPB_LABEL_OPTIONAL, ".MyEnum", &s),
&s, NULL);
m2 = upb_msgdef_newnamed("MyMessage2", &s);
e = upb_enumdef_newnamed("MyEnum", &s);
ASSERT_STATUS(upb_enumdef_addval(e, "VAL1", 1, &status), &status);
newdefs[0] = upb_msgdef_upcast_mutable(m);
newdefs[1] = upb_msgdef_upcast_mutable(m2);
newdefs[2] = upb_enumdef_upcast_mutable(e);
ASSERT_STATUS(upb_symtab_add(s, newdefs, 3, &s, &status), &status);
/* Try adding a new definition of MyEnum, MyMessage should get replaced with
* a new version. */
e2 = upb_enumdef_newnamed("MyEnum", &s);
ASSERT_STATUS(upb_enumdef_addval(e2, "VAL1", 1, &status), &status);
newdefs2[0] = upb_enumdef_upcast_mutable(e2);
ASSERT_STATUS(upb_symtab_add(s, newdefs2, 1, &s, &status), &status);
m3 = upb_symtab_lookupmsg(s, "MyMessage");
ASSERT(m3);
/* Must be different because it points to MyEnum which was replaced. */
ASSERT(m3 != m);
m3 = upb_symtab_lookupmsg(s, "MyMessage2");
/* Should be the same because it was not replaced, nor were any defs that
* are reachable from it. */
ASSERT(m3 == m2);
upb_symtab_unref(s, &s);
}
static bool initialize()
{
// Initialize upb state, decode descriptor.
upb_status status = UPB_STATUS_INIT;
upb_symtab *s = upb_symtab_new();
upb_load_descriptor_file_into_symtab(s, MESSAGE_DESCRIPTOR_FILE, &status);
if(!upb_ok(&status)) {
fprintf(stderr, "Error reading descriptor: %s\n",
upb_status_getstr(&status));
return false;
}
def = upb_dyncast_msgdef_const(upb_symtab_lookup(s, MESSAGE_NAME));
if(!def) {
fprintf(stderr, "Error finding symbol '%s'.\n", MESSAGE_NAME);
return false;
}
upb_symtab_unref(s);
// Read the message data itself.
char *str = upb_readfile(MESSAGE_FILE, &len);
if(str == NULL) {
fprintf(stderr, "Error reading " MESSAGE_FILE "\n");
return false;
}
upb_status_uninit(&status);
for (int i = 0; i < NUM_MESSAGES; i++)
msg[i] = upb_stdmsg_new(def);
upb_stringsrc_init(&strsrc);
upb_stringsrc_reset(&strsrc, str, len);
upb_handlers *h = upb_handlers_new();
upb_accessors_reghandlers(h, def);
if (!JIT) h->should_jit = false;
upb_decoder_init(&d, h);
upb_handlers_unref(h);
if (!BYREF) {
// TODO: use byref/byval accessors.
}
return true;
}
int main() {
upb_symtab *symtab = upb_symtab_new();
upb_symtab_add_descriptorproto(symtab);
upb_def *fds = upb_symtab_lookup(
symtab, UPB_STRLIT("google.protobuf.FileDescriptorSet"));
upb_stdio *in = upb_stdio_new();
upb_stdio_reset(in, stdin);
upb_stdio *out = upb_stdio_new();
upb_stdio_reset(out, stdout);
upb_decoder d;
upb_decoder_init(&d, upb_downcast_msgdef(fds));
upb_decoder_reset(&d, upb_stdio_bytesrc(in));
upb_textprinter *p = upb_textprinter_new();
upb_handlers handlers;
upb_handlers_init(&handlers);
upb_textprinter_reset(p, &handlers, upb_stdio_bytesink(out), false);
upb_src *src = upb_decoder_src(&d);
upb_src_sethandlers(src, &handlers);
upb_status status = UPB_STATUS_INIT;
upb_src_run(src, &status);
assert(upb_ok(&status));
upb_status_uninit(&status);
upb_stdio_free(in);
upb_stdio_free(out);
upb_decoder_uninit(&d);
upb_textprinter_free(p);
upb_def_unref(fds);
upb_symtab_unref(symtab);
// Prevent C library from holding buffers open, so Valgrind doesn't see
// memory leaks.
fclose(stdin);
fclose(stdout);
}
static bool initialize()
{
// Initialize upb state, decode descriptor.
upb_status status = UPB_STATUS_INIT;
upb_symtab *s = upb_symtab_new(&s);
upb_load_descriptor_file_into_symtab(s, MESSAGE_DESCRIPTOR_FILE, &status);
if(!upb_ok(&status)) {
fprintf(stderr, "Error reading descriptor: %s\n",
upb_status_getstr(&status));
return false;
}
def = upb_dyncast_msgdef_const(upb_symtab_lookup(s, MESSAGE_NAME, &def));
if(!def) {
fprintf(stderr, "Error finding symbol '%s'.\n", MESSAGE_NAME);
return false;
}
upb_symtab_unref(s, &s);
// Read the message data itself.
input_str = upb_readfile(MESSAGE_FILE, &input_len);
if(input_str == NULL) {
fprintf(stderr, "Error reading " MESSAGE_FILE "\n");
return false;
}
upb_handlers *handlers = upb_handlers_new();
// Cause all messages to be read, but do nothing when they are.
upb_handlerset hset = {NULL, NULL, value, startsubmsg, NULL, NULL, NULL};
upb_handlers_reghandlerset(handlers, def, &hset);
upb_decoder_init(&decoder);
plan = upb_decoderplan_new(handlers, JIT);
upb_decoder_resetplan(&decoder, plan, 0);
upb_handlers_unref(handlers);
upb_stringsrc_init(&stringsrc);
return true;
}
static void test_cycles() {
bool ok;
upb_symtab *s = load_test_proto(&s);
const upb_msgdef *m;
const upb_fielddef *f;
const upb_def *def;
const upb_def *def2;
/* Test cycle detection by making a cyclic def's main refcount go to zero
* and then be incremented to one again. */
def = upb_symtab_lookup(s, "A");
upb_def_ref(def, &def);
ASSERT(def);
ASSERT(upb_def_isfrozen(def));
upb_symtab_unref(s, &s);
/* Message A has only one subfield: "optional B b = 1". */
m = upb_downcast_msgdef(def);
f = upb_msgdef_itof(m, 1);
ASSERT(f);
ASSERT(upb_fielddef_hassubdef(f));
ASSERT(upb_msgdef_ntofz(m, "b") == f);
ASSERT(upb_msgdef_ntof(m, "b", 1) == f);
def2 = upb_fielddef_subdef(f);
ASSERT(upb_downcast_msgdef(def2));
ok = strcmp(upb_def_fullname(def2), "B") == 0;
ASSERT(ok);
upb_def_ref(def2, &def2);
upb_def_unref(def, &def);
/* We know "def" is still alive because it's reachable from def2. */
ok = strcmp(upb_def_fullname(def), "A") == 0;
ASSERT(ok);
upb_def_unref(def2, &def2);
}
static void PyUpb_SymbolTable_dealloc(PyObject *obj) {
PyUpb_ObjWrapper *wrapper = (void*)obj;
upb_symtab_unref((upb_symtab*)wrapper->obj);
obj->ob_type->tp_free(obj);
}
void DescriptorPool_free(void* _self) {
DescriptorPool* self = _self;
upb_symtab_unref(self->symtab, &self->symtab);
xfree(self);
}
int main(int argc, char *argv[]) {
if (argc < 3) {
fprintf(stderr, "Usage: stream_transcode <descfile> <msgname>\n");
return 1;
}
upb_symtab *symtab = upb_symtab_new();
size_t desc_len;
const char *desc = upb_readfile(argv[1], &desc_len);
if (!desc) {
fprintf(stderr, "Couldn't open descriptor file: %s\n", argv[1]);
return 1;
}
upb_status status = UPB_STATUS_INIT;
upb_load_descriptor_into_symtab(symtab, desc, desc_len, &status);
if (!upb_ok(&status)) {
fprintf(stderr, "Error parsing descriptor: %s", upb_status_getstr(&status));
return 1;
}
free((void*)desc);
const upb_def *md = upb_symtab_lookup(symtab, argv[2]);
if (!md) {
fprintf(stderr, "Descriptor did not contain message: %s\n", argv[2]);
return 1;
}
const upb_msgdef *m = upb_dyncast_msgdef_const(md);
if (!m) {
fprintf(stderr, "Def was not a msgdef.\n");
return 1;
}
upb_stdio in, out;
upb_stdio_init(&in);
upb_stdio_init(&out);
upb_stdio_reset(&in, stdin);
upb_stdio_reset(&out, stdout);
upb_handlers *handlers = upb_handlers_new();
upb_textprinter *p = upb_textprinter_new();
upb_textprinter_reset(p, upb_stdio_bytesink(&out), false);
upb_textprinter_reghandlers(handlers, m);
upb_decoder d;
upb_decoder_init(&d, handlers);
upb_decoder_reset(&d, upb_stdio_bytesrc(&in), 0, UPB_NONDELIMITED, p);
upb_status_clear(&status);
upb_decoder_decode(&d, &status);
if (!upb_ok(&status)) {
fprintf(stderr, "Error parsing input: %s", upb_status_getstr(&status));
}
upb_status_uninit(&status);
upb_stdio_uninit(&in);
upb_stdio_uninit(&out);
upb_decoder_uninit(&d);
upb_textprinter_free(p);
upb_def_unref(UPB_UPCAST(m));
upb_symtab_unref(symtab);
// Prevent C library from holding buffers open, so Valgrind doesn't see
// memory leaks.
fclose(stdin);
fclose(stdout);
}
