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_freeze_free() {
bool ok;
/* Test that freeze frees defs that were only being kept alive by virtue of
* sharing a group with other defs that are being frozen. */
upb_msgdef *m1 = upb_msgdef_newnamed("M1", &m1);
upb_msgdef *m2 = upb_msgdef_newnamed("M2", &m2);
upb_msgdef *m3 = upb_msgdef_newnamed("M3", &m3);
upb_msgdef *m4 = upb_msgdef_newnamed("M4", &m4);
upb_fielddef *f = upb_fielddef_new(&f);
/* Freeze M4 and make M1 point to it. */
upb_def_freeze((upb_def*const*)&m4, 1, NULL);
upb_fielddef_settype(f, UPB_TYPE_MESSAGE);
ASSERT(upb_fielddef_setnumber(f, 1, NULL));
ASSERT(upb_fielddef_setname(f, "foo", NULL));
ASSERT(upb_fielddef_setmsgsubdef(f, m4, NULL));
ASSERT(upb_msgdef_addfield(m1, f, &f, NULL));
/* After this unref, M1 is the only thing keeping M4 alive. */
upb_msgdef_unref(m4, &m4);
/* Force M1/M2/M3 into a single mutable refcounting group. */
f = upb_fielddef_new(&f);
upb_fielddef_settype(f, UPB_TYPE_MESSAGE);
ASSERT(upb_fielddef_setnumber(f, 1, NULL));
ASSERT(upb_fielddef_setname(f, "foo", NULL));
ASSERT(upb_fielddef_setmsgsubdef(f, m1, NULL));
ASSERT(upb_fielddef_setmsgsubdef(f, m2, NULL));
ASSERT(upb_fielddef_setmsgsubdef(f, m3, NULL));
/* Make M3 cyclic with itself. */
ASSERT(upb_msgdef_addfield(m3, f, &f, NULL));
/* These will be kept alive since they are in the same refcounting group as
* M3, which still has a ref. Note: this behavior is not guaranteed by the
* API, but true in practice with its current implementation. */
upb_msgdef_unref(m1, &m1);
upb_msgdef_unref(m2, &m2);
/* Test that they are still alive (NOT allowed by the API). */
ok = strcmp("M1", upb_msgdef_fullname(m1)) == 0;
ASSERT(ok);
ok = strcmp("M2", upb_msgdef_fullname(m2)) == 0;
ASSERT(ok);
/* Freeze M3. If the test leaked no memory, then freeing m1 and m2 was
* successful. */
ASSERT(upb_def_freeze((upb_def*const*)&m3, 1, NULL));
upb_msgdef_unref(m3, &m3);
}
static int PyUpb_FieldDef_setattro(PyObject *o, PyObject *key, PyObject *val) {
upb_fielddef *f = Check_FieldDef(o, -1);
const char *field = PyString_AsString(key);
if (!upb_fielddef_ismutable(f))
return PyUpb_ErrorInt("fielddef is not mutable.");
if (streql(field, "name")) {
const char *name = PyString_AsString(val);
if (!name || !upb_fielddef_setname(f, name))
return PyUpb_ErrorInt("Invalid name");
} else if (streql(field, "number")) {
// TODO: should check truncation. Non-security issue.
// Non-int will return -1, which is already invalid as a field number.
if (!upb_fielddef_setnumber(f, PyInt_AsLong(val)))
return PyUpb_ErrorInt("Invalid number");
} else if (streql(field, "type")) {
// TODO: should check truncation. Non-security issue.
if (!upb_fielddef_settype(f, PyInt_AsLong(val)))
return PyUpb_ErrorInt("Invalid type");
} else if (streql(field, "label")) {
// TODO: should check truncation. Non-security issue.
if (!upb_fielddef_setlabel(f, PyInt_AsLong(val)))
return PyUpb_ErrorInt("Invalid label");
} else if (streql(field, "type_name")) {
const char *name = PyString_AsString(val);
if (!name || !upb_fielddef_settypename(f, name))
return PyUpb_ErrorInt("Invalid type_name");
} else if (streql(field, "default_value")) {
// NYI
return -1;
} else {
return PyUpb_ErrorInt("Invalid fielddef member.");
}
return 0;
}
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 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;
}
static void test_partial_freeze() {
/* Test that freeze of only part of the graph correctly adjusts objects that
* point to the newly-frozen objects. */
upb_msgdef *m1 = upb_msgdef_newnamed("M1", &m1);
upb_msgdef *m2 = upb_msgdef_newnamed("M2", &m2);
upb_msgdef *m3 = upb_msgdef_newnamed("M3", &m3);
upb_fielddef *f1 = upb_fielddef_new(&f1);
upb_fielddef *f2 = upb_fielddef_new(&f2);
upb_def *defs[2];
defs[0] = upb_msgdef_upcast_mutable(m1);
defs[1] = upb_msgdef_upcast_mutable(m2);
upb_fielddef_settype(f1, UPB_TYPE_MESSAGE);
ASSERT(upb_fielddef_setnumber(f1, 1, NULL));
ASSERT(upb_fielddef_setname(f1, "f1", NULL));
ASSERT(upb_fielddef_setmsgsubdef(f1, m1, NULL));
upb_fielddef_settype(f2, UPB_TYPE_MESSAGE);
ASSERT(upb_fielddef_setnumber(f2, 2, NULL));
ASSERT(upb_fielddef_setname(f2, "f2", NULL));
ASSERT(upb_fielddef_setmsgsubdef(f2, m2, NULL));
ASSERT(upb_msgdef_addfield(m3, f1, &f1, NULL));
ASSERT(upb_msgdef_addfield(m3, f2, &f2, NULL));
/* Freeze M1 and M2, which should cause the group to be split
* and m3 (left mutable) to take references on m1 and m2. */
ASSERT(upb_def_freeze(defs, 2, NULL));
ASSERT(upb_msgdef_isfrozen(m1));
ASSERT(upb_msgdef_isfrozen(m2));
ASSERT(!upb_msgdef_isfrozen(m3));
upb_msgdef_unref(m1, &m1);
upb_msgdef_unref(m2, &m2);
upb_msgdef_unref(m3, &m3);
}
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;
}
void upb_fielddef_setdescriptortype(upb_fielddef *f, int type) {
assert(!upb_fielddef_isfrozen(f));
switch (type) {
case UPB_DESCRIPTOR_TYPE_DOUBLE:
upb_fielddef_settype(f, UPB_TYPE_DOUBLE);
break;
case UPB_DESCRIPTOR_TYPE_FLOAT:
upb_fielddef_settype(f, UPB_TYPE_FLOAT);
break;
case UPB_DESCRIPTOR_TYPE_INT64:
case UPB_DESCRIPTOR_TYPE_SFIXED64:
case UPB_DESCRIPTOR_TYPE_SINT64:
upb_fielddef_settype(f, UPB_TYPE_INT64);
break;
case UPB_DESCRIPTOR_TYPE_UINT64:
case UPB_DESCRIPTOR_TYPE_FIXED64:
upb_fielddef_settype(f, UPB_TYPE_UINT64);
break;
case UPB_DESCRIPTOR_TYPE_INT32:
case UPB_DESCRIPTOR_TYPE_SFIXED32:
case UPB_DESCRIPTOR_TYPE_SINT32:
upb_fielddef_settype(f, UPB_TYPE_INT32);
break;
case UPB_DESCRIPTOR_TYPE_UINT32:
case UPB_DESCRIPTOR_TYPE_FIXED32:
upb_fielddef_settype(f, UPB_TYPE_UINT32);
break;
case UPB_DESCRIPTOR_TYPE_BOOL:
upb_fielddef_settype(f, UPB_TYPE_BOOL);
break;
case UPB_DESCRIPTOR_TYPE_STRING:
upb_fielddef_settype(f, UPB_TYPE_STRING);
break;
case UPB_DESCRIPTOR_TYPE_BYTES:
upb_fielddef_settype(f, UPB_TYPE_BYTES);
break;
case UPB_DESCRIPTOR_TYPE_GROUP:
case UPB_DESCRIPTOR_TYPE_MESSAGE:
upb_fielddef_settype(f, UPB_TYPE_MESSAGE);
break;
case UPB_DESCRIPTOR_TYPE_ENUM:
upb_fielddef_settype(f, UPB_TYPE_ENUM);
break;
default: assert(false);
}
if (type == UPB_DESCRIPTOR_TYPE_FIXED64 ||
type == UPB_DESCRIPTOR_TYPE_FIXED32 ||
type == UPB_DESCRIPTOR_TYPE_SFIXED64 ||
type == UPB_DESCRIPTOR_TYPE_SFIXED32) {
upb_fielddef_setintfmt(f, UPB_INTFMT_FIXED);
} else if (type == UPB_DESCRIPTOR_TYPE_SINT64 ||
type == UPB_DESCRIPTOR_TYPE_SINT32) {
upb_fielddef_setintfmt(f, UPB_INTFMT_ZIGZAG);
} else {
upb_fielddef_setintfmt(f, UPB_INTFMT_VARIABLE);
}
upb_fielddef_settagdelim(f, type == UPB_DESCRIPTOR_TYPE_GROUP);
}
/*
* call-seq:
* FieldDescriptor.type = type
*
* Sets this field's type. Cannot be called if field is part of a message type
* already in a pool.
*/
VALUE FieldDescriptor_type_set(VALUE _self, VALUE type) {
DEFINE_SELF(FieldDescriptor, self, _self);
upb_fielddef* mut_def = check_field_notfrozen(self->fielddef);
upb_fielddef_settype(mut_def, ruby_to_fieldtype(type));
return Qnil;
}
static bool field_ontype(void *_r, void *fval, int32_t val) {
UPB_UNUSED(fval);
upb_descreader *r = _r;
upb_fielddef_settype(r->f, val);
return true;
}
