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_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_fielddef() {
/* Test that we don't leak an unresolved subdef name. */
upb_fielddef *f1 = upb_fielddef_new(&f1);
upb_fielddef_settype(f1, UPB_TYPE_MESSAGE);
ASSERT(upb_fielddef_setsubdefname(f1, "YO", NULL));
upb_fielddef_unref(f1, &f1);
}
upb_fielddef *upb_fielddef_dup(const upb_fielddef *f, const void *owner) {
upb_fielddef *newf = upb_fielddef_new(owner);
if (!newf) return NULL;
upb_fielddef_settype(newf, upb_fielddef_type(f));
upb_fielddef_setlabel(newf, upb_fielddef_label(f));
upb_fielddef_setnumber(newf, upb_fielddef_number(f), NULL);
upb_fielddef_setname(newf, upb_fielddef_name(f), NULL);
if (f->default_is_string) {
str_t *s = upb_value_getptr(upb_fielddef_default(f));
upb_fielddef_setdefaultstr(newf, s->str, s->len, NULL);
} else {
upb_fielddef_setdefault(newf, upb_fielddef_default(f));
}
const char *srcname;
if (f->subdef_is_symbolic) {
srcname = f->sub.name; // Might be NULL.
} else {
srcname = f->sub.def ? upb_def_fullname(f->sub.def) : NULL;
}
if (srcname) {
char *newname = malloc(strlen(f->sub.def->fullname) + 2);
if (!newname) {
upb_fielddef_unref(newf, owner);
return NULL;
}
strcpy(newname, ".");
strcat(newname, f->sub.def->fullname);
upb_fielddef_setsubdefname(newf, newname, NULL);
free(newname);
}
return newf;
}
static size_t field_ontypename(void *_r, void *fval, const char *buf,
size_t n) {
UPB_UNUSED(fval);
upb_descreader *r = _r;
// XXX: see comment at the top of the file.
char *name = upb_strndup(buf, n);
upb_fielddef_setsubdefname(r->f, name);
free(name);
return n;
}
static size_t field_ontypename(void *closure, const void *hd, const char *buf,
size_t n, const upb_bufhandle *handle) {
UPB_UNUSED(hd);
UPB_UNUSED(handle);
upb_descreader *r = closure;
// XXX: see comment at the top of the file.
char *name = upb_strndup(buf, n);
upb_fielddef_setsubdefname(r->f, name, NULL);
free(name);
return n;
}
/*
* call-seq:
* FieldDescriptor.submsg_name = submsg_name
*
* Sets the name of the message or enum type corresponding to this field, if it
* is a message or enum field (respectively). This type name will be resolved
* within the context of the pool to which the containing message type is added.
* Cannot be called on field that are not of message or enum type, or on fields
* that are part of a message type already added to a pool.
*/
VALUE FieldDescriptor_submsg_name_set(VALUE _self, VALUE value) {
DEFINE_SELF(FieldDescriptor, self, _self);
upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
if (!upb_fielddef_hassubdef(self->fielddef)) {
rb_raise(rb_eTypeError, "FieldDescriptor does not have subdef.");
}
const char* str = get_str(value);
CHECK_UPB(upb_fielddef_setsubdefname(mut_def, str, &status),
"Error setting submessage name");
return Qnil;
}
static upb_fielddef *newfield(
const char *name, int32_t num, uint8_t type, uint8_t label,
const char *type_name, void *owner) {
upb_fielddef *f = upb_fielddef_new(owner);
ASSERT(upb_fielddef_setname(f, name, NULL));
ASSERT(upb_fielddef_setnumber(f, num, NULL));
upb_fielddef_settype(f, type);
upb_fielddef_setlabel(f, label);
if (type_name) {
ASSERT(upb_fielddef_setsubdefname(f, type_name, NULL));
}
return f;
}
upb_fielddef *upb_fielddef_dup(const upb_fielddef *f, const void *owner) {
upb_fielddef *newf = upb_fielddef_new(owner);
if (!newf) return NULL;
upb_fielddef_settype(newf, upb_fielddef_type(f));
upb_fielddef_setlabel(newf, upb_fielddef_label(f));
upb_fielddef_setnumber(newf, upb_fielddef_number(f));
upb_fielddef_setname(newf, upb_fielddef_name(f));
if (f->default_is_string) {
upb_byteregion *r = upb_value_getbyteregion(upb_fielddef_default(f));
size_t len;
const char *ptr = upb_byteregion_getptr(r, 0, &len);
assert(len == upb_byteregion_len(r));
upb_fielddef_setdefaultstr(newf, ptr, len);
} else {
upb_fielddef_setdefault(newf, upb_fielddef_default(f));
}
const char *srcname;
if (f->subdef_is_symbolic) {
srcname = f->sub.name; // Might be NULL.
} else {
srcname = f->sub.def ? upb_def_fullname(f->sub.def) : NULL;
}
if (srcname) {
char *newname = malloc(strlen(f->sub.def->fullname) + 2);
if (!newname) {
upb_fielddef_unref(newf, owner);
return NULL;
}
strcpy(newname, ".");
strcat(newname, f->sub.def->fullname);
upb_fielddef_setsubdefname(newf, newname);
free(newname);
}
return newf;
}