Sync from internal Google development.

Many improvements, too many to mention.  One significant
perf regression warrants investigation:

omitfp.parsetoproto2_googlemessage1.upb_jit: 343 -> 252 (-26.53)
plain.parsetoproto2_googlemessage1.upb_jit: 334 -> 251 (-24.85)

25% regression for this benchmark is bad, but since I don't think
there's any fundamental design issue that caused it I'm going to
go ahead with the commit anyway.  Can investigate and fix later.

Other benchmarks were neutral or showed slight improvement.

1 files changed, 163 insertions, 8 deletions

diff --git a/tests/test_def.c b/tests/test_def.c
index 3ca3064..698532e 100644
--- a/tests/test_def.c
+++ b/tests/test_def.c
@@ -1,19 +1,174 @@
+/*
+ * upb - a minimalist implementation of protocol buffers.
+ *
+ * Copyright (c) 2011 Google Inc.  See LICENSE for details.
+ *
+ * Test of defs and symtab.  There should be far more tests of edge conditions
+ * (like attempts to link defs that don't have required properties set).
+ */
 
-#undef NDEBUG  /* ensure tests always assert. */
 #include "upb/def.h"
+#include "upb/pb/glue.h"
+#include "upb_test.h"
 #include <stdlib.h>
+#include <string.h>
 
-int main() {
-  upb_symtab *s = upb_symtab_new();
+const char *descriptor_file;
 
-  // Will be empty atm since we haven't added anything to the symtab.
+static void test_empty_symtab() {
+  upb_symtab *s = upb_symtab_new();
   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]);
-  }
+  const upb_def **defs = upb_symtab_getdefs(s, &count, UPB_DEF_ANY, NULL);
+  ASSERT(count == 0);
   free(defs);
+  upb_symtab_unref(s);
+}
 
+static upb_symtab *load_test_proto() {
+  upb_symtab *s = upb_symtab_new();
+  ASSERT(s);
+  upb_status status = UPB_STATUS_INIT;
+  if (!upb_load_descriptor_file_into_symtab(s, descriptor_file, &status)) {
+    fprintf(stderr, "Error loading descriptor file: %s\n",
+            upb_status_getstr(&status));
+    exit(1);
+  }
+  upb_status_uninit(&status);
+  return s;
+}
+
+static void test_cycles() {
+  upb_symtab *s = load_test_proto();
+
+  // Test cycle detection by making a cyclic def's main refcount go to zero
+  // and then be incremented to one again.
+  const upb_def *def = upb_symtab_lookup(s, "A", &def);
+  ASSERT(def);
+  ASSERT(upb_def_isfinalized(def));
   upb_symtab_unref(s);
+
+  // Message A has only one subfield: "optional B b = 1".
+  const upb_msgdef *m = upb_downcast_msgdef_const(def);
+  upb_fielddef *f = upb_msgdef_itof(m, 1);
+  ASSERT(f);
+  ASSERT(upb_hassubdef(f));
+  const upb_def *def2 = upb_fielddef_subdef(f);
+  ASSERT(upb_downcast_msgdef_const(def2));
+  ASSERT(strcmp(upb_def_fullname(def2), "B") == 0);
+
+  upb_def_ref(def2, &def2);
+  upb_def_unref(def, &def);
+  upb_def_unref(def2, &def2);
+}
+
+static void test_fielddef_unref() {
+  upb_symtab *s = load_test_proto();
+  const upb_msgdef *md = upb_symtab_lookupmsg(s, "A", &md);
+  upb_fielddef *f = upb_msgdef_itof(md, 1);
+  upb_fielddef_ref(f, &f);
+
+  // Unref symtab and msgdef; now fielddef is the only thing keeping the msgdef
+  // alive.
+  upb_symtab_unref(s);
+  upb_msgdef_unref(md, &md);
+  // Check that md is still alive.
+  ASSERT(strcmp(upb_def_fullname(UPB_UPCAST(md)), "A") == 0);
+
+  // Check that unref of fielddef frees the whole remaining graph.
+  upb_fielddef_unref(f, &f);
+}
+
+static void test_fielddef_accessors() {
+  upb_fielddef *f1 = upb_fielddef_new(&f1);
+  upb_fielddef *f2 = upb_fielddef_new(&f2);
+
+  ASSERT(upb_fielddef_ismutable(f1));
+  upb_fielddef_setname(f1, "f1");
+  upb_fielddef_setnumber(f1, 1937);
+  upb_fielddef_settype(f1, UPB_TYPE(FIXED64));
+  upb_fielddef_setlabel(f1, UPB_LABEL(REPEATED));
+  ASSERT(upb_fielddef_number(f1) == 1937);
+
+  ASSERT(upb_fielddef_ismutable(f2));
+  upb_fielddef_setname(f2, "f2");
+  upb_fielddef_setnumber(f2, 1572);
+  upb_fielddef_settype(f2, UPB_TYPE(BYTES));
+  upb_fielddef_setlabel(f2, UPB_LABEL(REPEATED));
+  ASSERT(upb_fielddef_number(f2) == 1572);
+
+  upb_fielddef_unref(f1, &f1);
+  upb_fielddef_unref(f2, &f2);
+}
+
+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);
+  upb_fielddef_setname(f, name);
+  upb_fielddef_setnumber(f, num);
+  upb_fielddef_settype(f, type);
+  upb_fielddef_setlabel(f, label);
+  upb_fielddef_setsubtypename(f, type_name);
+  return f;
+}
+
+static upb_msgdef *upb_msgdef_newnamed(const char *name, void *owner) {
+  upb_msgdef *m = upb_msgdef_new(owner);
+  upb_def_setfullname(UPB_UPCAST(m), name);
+  return m;
+}
+
+INLINE upb_enumdef *upb_enumdef_newnamed(const char *name, void *owner) {
+  upb_enumdef *e = upb_enumdef_new(owner);
+  upb_def_setfullname(UPB_UPCAST(e), name);
+  return e;
+}
+
+void test_replacement() {
+  upb_symtab *s = upb_symtab_new();
+
+  upb_msgdef *m = upb_msgdef_newnamed("MyMessage", &s);
+  upb_msgdef_addfield(m, newfield(
+      "field1", 1, UPB_TYPE(ENUM), UPB_LABEL(OPTIONAL), ".MyEnum", &s), &s);
+  upb_msgdef *m2 = upb_msgdef_newnamed("MyMessage2", &s);
+  upb_enumdef *e = upb_enumdef_newnamed("MyEnum", &s);
+
+  upb_def *newdefs[] = {UPB_UPCAST(m), UPB_UPCAST(m2), UPB_UPCAST(e)};
+  upb_status status = UPB_STATUS_INIT;
+  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.
+  upb_enumdef *e2 = upb_enumdef_new(&s);
+  upb_def_setfullname(UPB_UPCAST(e2), "MyEnum");
+  upb_def *newdefs2[] = {UPB_UPCAST(e2)};
+  ASSERT_STATUS(upb_symtab_add(s, newdefs2, 1, &s, &status), &status);
+
+  const upb_msgdef *m3 = upb_symtab_lookupmsg(s, "MyMessage", &m3);
+  ASSERT(m3);
+  // Must be different because it points to MyEnum which was replaced.
+  ASSERT(m3 != m);
+  upb_msgdef_unref(m3, &m3);
+
+  m3 = upb_symtab_lookupmsg(s, "MyMessage2", &m3);
+  // Should be the same because it was not replaced, nor were any defs that
+  // are reachable from it.
+  ASSERT(m3 == m2);
+  upb_msgdef_unref(m3, &m3);
+
+  upb_symtab_unref(s);
+}
+
+int main(int argc, char *argv[]) {
+  if (argc < 2) {
+    fprintf(stderr, "Usage: test_def <test.proto.pb>\n");
+    return 1;
+  }
+  descriptor_file = argv[1];
+  test_empty_symtab();
+  test_cycles();
+  test_fielddef_accessors();
+  test_fielddef_unref();
+  test_replacement();
   return 0;
 }