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); }
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 bool field_onnumber(void *closure, const void *hd, int32_t val) { UPB_UNUSED(hd); upb_descreader *r = closure; bool ok = upb_fielddef_setnumber(r->f, val, NULL); UPB_ASSERT_VAR(ok, ok); return true; }
/* * call-seq: * FieldDescriptor.number = number * * Sets the tag number for this field. Cannot be called if field is part of a * message type already in a pool. */ VALUE FieldDescriptor_number_set(VALUE _self, VALUE number) { DEFINE_SELF(FieldDescriptor, self, _self); upb_fielddef* mut_def = check_field_notfrozen(self->fielddef); CHECK_UPB(upb_fielddef_setnumber(mut_def, NUM2INT(number), &status), "Error setting field number"); 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; }
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; }
static bool field_onnumber(void *_r, void *fval, int32_t val) { UPB_UNUSED(fval); upb_descreader *r = _r; upb_fielddef_setnumber(r->f, val); return true; }