Major work on Lua extension and default values.

Default values are now supported, and the Lua extension
can now create and modify individual protobuf objects.

2 files changed, 10 insertions, 216 deletions

diff --git a/tests/test_vs_proto2.cc b/tests/test_vs_proto2.cc
index 1839123..f3c54b4 100644
--- a/tests/test_vs_proto2.cc
+++ b/tests/test_vs_proto2.cc
@@ -1,20 +1,20 @@
+/*
+ * upb - a minimalist implementation of protocol buffers.
+ *
+ * A test that verifies that our results are identical to proto2 for a
+ * given proto type and input protobuf.
+ *
+ * Copyright (c) 2011 Joshua Haberman.  See LICENSE for details.
+ */
 
-#undef NDEBUG  /* ensure tests always assert. */
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <google/protobuf/descriptor.h>
-#include "upb_decoder.h"
+#include "upb_test.h"
 #include "upb_def.h"
 #include "upb_glue.h"
 #include "upb_msg.h"
-#include "upb_strstream.h"
-
-int num_assertions = 0;
-#define ASSERT(expr) do { \
-  ++num_assertions; \
-  assert(expr); \
-  } while(0)
 
 #include MESSAGE_HFILE
 
diff --git a/tests/tests.c b/tests/tests.c
index c691b18..a04b1da 100644
--- a/tests/tests.c
+++ b/tests/tests.c
@@ -1,212 +1,13 @@
 
-#undef NDEBUG  /* ensure tests always assert. */
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "upb_decoder.c"
 #include "upb_def.h"
 #include "upb_glue.h"
-
-int num_assertions = 0;
-#define ASSERT(expr) do { \
-  ++num_assertions; \
-  assert(expr); \
-  } while(0)
-
-static void test_get_v_uint64_t()
-{
-#define TEST(name, bytes, val) {\
-    upb_status status = UPB_STATUS_INIT; \
-    const char name[] = bytes "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff" ; \
-    const char *name ## _buf = name; \
-    uint64_t name ## _val = 0; \
-    upb_decode_varint_fast(&name ## _buf, &name ## _val, &status); \
-    ASSERT(upb_ok(&status)); \
-    ASSERT(name ## _val == val); \
-    ASSERT(name ## _buf == name + sizeof(name) - 16);  /* - 1 for NULL */ \
-  }
-
-  TEST(zero,   "\x00",                                                      0ULL);
-  TEST(one,    "\x01",                                                      1ULL);
-  TEST(twob,   "\x81\x14",                                              0xa01ULL);
-  TEST(twob,   "\x81\x03",                                              0x181ULL);
-  TEST(threeb, "\x81\x83\x07",                                        0x1c181ULL);
-  TEST(fourb,  "\x81\x83\x87\x0f",                                  0x1e1c181ULL);
-  TEST(fiveb,  "\x81\x83\x87\x8f\x1f",                            0x1f1e1c181ULL);
-  TEST(sixb,   "\x81\x83\x87\x8f\x9f\x3f",                      0x1f9f1e1c181ULL);
-  TEST(sevenb, "\x81\x83\x87\x8f\x9f\xbf\x7f",                0x1fdf9f1e1c181ULL);
-  TEST(eightb, "\x81\x83\x87\x8f\x9f\xbf\xff\x01",            0x3fdf9f1e1c181ULL);
-  TEST(nineb,  "\x81\x83\x87\x8f\x9f\xbf\xff\x81\x03",      0x303fdf9f1e1c181ULL);
-  TEST(tenb,   "\x81\x83\x87\x8f\x9f\xbf\xff\x81\x83\x07", 0x8303fdf9f1e1c181ULL);
-#undef TEST
-
-  char twelvebyte[16] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01, 0x01};
-  const char *twelvebyte_buf = twelvebyte;
-  uint64_t twelvebyte_val = 0;
-  upb_status status = UPB_STATUS_INIT;
-  /* A varint that terminates before hitting the end of the provided buffer,
-   * but in too many bytes (11 instead of 10). */
-  upb_decode_varint_fast(&twelvebyte_buf, &twelvebyte_val, &status);
-  ASSERT(status.code == UPB_ERROR);
-  upb_status_uninit(&status);
-}
-
-#if 0
-static void test_get_v_uint32_t()
-{
-#define TEST(name, bytes, val) {\
-    upb_status status = UPB_STATUS_INIT; \
-    const uint8_t name[] = bytes; \
-    const uint8_t *name ## _buf = name; \
-    uint32_t name ## _val = 0; \
-    name ## _buf = upb_get_v_uint32_t(name, name + sizeof(name), &name ## _val, &status); \
-    ASSERT(upb_ok(&status)); \
-    ASSERT(name ## _val == val); \
-    ASSERT(name ## _buf == name + sizeof(name) - 1);  /* - 1 for NULL */ \
-    /* Test NEED_MORE_DATA. */ \
-    if(sizeof(name) > 2) { \
-      name ## _buf = upb_get_v_uint32_t(name, name + sizeof(name) - 2, &name ## _val, &status); \
-      ASSERT(status.code == UPB_STATUS_NEED_MORE_DATA); \
-    } \
-  }
-
-  TEST(zero,   "\x00",                                              0UL);
-  TEST(one,    "\x01",                                              1UL);
-  TEST(twob,   "\x81\x03",                                      0x181UL);
-  TEST(threeb, "\x81\x83\x07",                                0x1c181UL);
-  TEST(fourb,  "\x81\x83\x87\x0f",                          0x1e1c181UL);
-  /* get_v_uint32_t truncates, so all the rest return the same thing. */
-  TEST(fiveb,  "\x81\x83\x87\x8f\x1f",                     0xf1e1c181UL);
-  TEST(sixb,   "\x81\x83\x87\x8f\x9f\x3f",                 0xf1e1c181UL);
-  TEST(sevenb, "\x81\x83\x87\x8f\x9f\xbf\x7f",             0xf1e1c181UL);
-  TEST(eightb, "\x81\x83\x87\x8f\x9f\xbf\xff\x01",         0xf1e1c181UL);
-  TEST(nineb,  "\x81\x83\x87\x8f\x9f\xbf\xff\x81\x03",     0xf1e1c181UL);
-  TEST(tenb,   "\x81\x83\x87\x8f\x9f\xbf\xff\x81\x83\x07", 0xf1e1c181UL);
-#undef TEST
-
-  uint8_t twelvebyte[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01, 0x01};
-  uint32_t twelvebyte_val = 0;
-  upb_status status = UPB_STATUS_INIT;
-  /* A varint that terminates before hitting the end of the provided buffer,
-   * but in too many bytes (11 instead of 10). */
-  upb_get_v_uint32_t(twelvebyte, twelvebyte + 12, &twelvebyte_val, &status);
-  ASSERT(status.code == UPB_ERROR_UNTERMINATED_VARINT);
-
-  /* A varint that terminates simultaneously with the end of the provided
-   * buffer, but in too many bytes (11 instead of 10). */
-  upb_reset(&status);
-  upb_get_v_uint32_t(twelvebyte, twelvebyte + 11, &twelvebyte_val, &status);
-  ASSERT(status.code == UPB_ERROR_UNTERMINATED_VARINT);
-
-  /* A varint whose buffer ends on exactly the byte where the varint must
-   * terminate, but the final byte does not terminate.  The absolutely most
-   * correct return code here is UPB_ERROR_UNTERMINATED_VARINT, because we know
-   * by this point that the varint does not properly terminate.  But we also
-   * allow a return value of UPB_STATUS_NEED_MORE_DATA here, because it does not
-   * compromise overall correctness -- clients who supply more data later will
-   * then receive a UPB_ERROR_UNTERMINATED_VARINT error; clients who have no
-   * more data to supply will (rightly) conclude that their protobuf is corrupt.
-   */
-  upb_reset(&status);
-  upb_get_v_uint32_t(twelvebyte, twelvebyte + 10, &twelvebyte_val, &status);
-  ASSERT(status.code == UPB_ERROR_UNTERMINATED_VARINT ||
-         status.code == UPB_STATUS_NEED_MORE_DATA);
-
-  upb_reset(&status);
-  upb_get_v_uint32_t(twelvebyte, twelvebyte + 9, &twelvebyte_val, &status);
-  ASSERT(status.code == UPB_STATUS_NEED_MORE_DATA);
-}
-
-static void test_skip_v_uint64_t()
-{
-#define TEST(name, bytes) {\
-    upb_status status = UPB_STATUS_INIT; \
-    const uint8_t name[] = bytes; \
-    const uint8_t *name ## _buf = name; \
-    name ## _buf = upb_skip_v_uint64_t(name ## _buf, name + sizeof(name), &status); \
-    ASSERT(upb_ok(&status)); \
-    ASSERT(name ## _buf == name + sizeof(name) - 1);  /* - 1 for NULL */ \
-    /* Test NEED_MORE_DATA. */ \
-    if(sizeof(name) > 2) { \
-      name ## _buf = upb_skip_v_uint64_t(name, name + sizeof(name) - 2, &status); \
-      ASSERT(status.code == UPB_STATUS_NEED_MORE_DATA); \
-    } \
-  }
-
-  TEST(zero,   "\x00");
-  TEST(one,    "\x01");
-  TEST(twob,   "\x81\x03");
-  TEST(threeb, "\x81\x83\x07");
-  TEST(fourb,  "\x81\x83\x87\x0f");
-  TEST(fiveb,  "\x81\x83\x87\x8f\x1f");
-  TEST(sixb,   "\x81\x83\x87\x8f\x9f\x3f");
-  TEST(sevenb, "\x81\x83\x87\x8f\x9f\xbf\x7f");
-  TEST(eightb, "\x81\x83\x87\x8f\x9f\xbf\xff\x01");
-  TEST(nineb,  "\x81\x83\x87\x8f\x9f\xbf\xff\x81\x03");
-  TEST(tenb,   "\x81\x83\x87\x8f\x9f\xbf\xff\x81\x83\x07");
-#undef TEST
-
-  uint8_t twelvebyte[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x01, 0x01};
-  upb_status status = UPB_STATUS_INIT;
-  /* A varint that terminates before hitting the end of the provided buffer,
-   * but in too many bytes (11 instead of 10). */
-  upb_skip_v_uint64_t(twelvebyte, twelvebyte + 12, &status);
-  ASSERT(status.code == UPB_ERROR_UNTERMINATED_VARINT);
-
-  /* A varint that terminates simultaneously with the end of the provided
-   * buffer, but in too many bytes (11 instead of 10). */
-  upb_reset(&status);
-  upb_skip_v_uint64_t(twelvebyte, twelvebyte + 11, &status);
-  ASSERT(status.code == UPB_ERROR_UNTERMINATED_VARINT);
-
-  /* A varint whose buffer ends on exactly the byte where the varint must
-   * terminate, but the final byte does not terminate.  The absolutely most
-   * correct return code here is UPB_ERROR_UNTERMINATED_VARINT, because we know
-   * by this point that the varint does not properly terminate.  But we also
-   * allow a return value of UPB_STATUS_NEED_MORE_DATA here, because it does not
-   * compromise overall correctness -- clients who supply more data later will
-   * then receive a UPB_ERROR_UNTERMINATED_VARINT error; clients who have no
-   * more data to supply will (rightly) conclude that their protobuf is corrupt.
-   */
-  upb_reset(&status);
-  upb_skip_v_uint64_t(twelvebyte, twelvebyte + 10, &status);
-  ASSERT(status.code == UPB_ERROR_UNTERMINATED_VARINT ||
-         status.code == UPB_STATUS_NEED_MORE_DATA);
-
-  upb_reset(&status);
-  upb_skip_v_uint64_t(twelvebyte, twelvebyte + 9, &status);
-  ASSERT(status.code == UPB_STATUS_NEED_MORE_DATA);
-}
-
-static void test_get_f_uint32_t()
-{
-#define TEST(name, bytes, val) {\
-    upb_status status = UPB_STATUS_INIT; \
-    const uint8_t name[] = bytes; \
-    const uint8_t *name ## _buf = name; \
-    uint32_t name ## _val = 0; \
-    name ## _buf = upb_get_f_uint32_t(name ## _buf, name + sizeof(name), &name ## _val, &status); \
-    ASSERT(upb_ok(&status)); \
-    ASSERT(name ## _val == val); \
-    ASSERT(name ## _buf == name + sizeof(name) - 1);  /* - 1 for NULL */ \
-  }
-
-  TEST(zero,  "\x00\x00\x00\x00",                                0x0UL);
-  TEST(one,   "\x01\x00\x00\x00",                                0x1UL);
-
-  uint8_t threeb[] = {0x00, 0x00, 0x00};
-  uint32_t threeb_val;
-  upb_status status = UPB_STATUS_INIT;
-  upb_get_f_uint32_t(threeb, threeb + sizeof(threeb), &threeb_val, &status);
-  ASSERT(status.code == UPB_STATUS_NEED_MORE_DATA);
-
-#undef TEST
-}
-#endif
+#include "upb_test.h"
 
 static void test_upb_symtab() {
   upb_symtab *s = upb_symtab_new();
-  upb_symtab_add_descriptorproto(s);
   ASSERT(s);
   upb_string *descriptor = upb_strreadfile("tests/test.proto.pb");
   if(!descriptor) {
@@ -240,11 +41,8 @@ static void test_upb_symtab() {
   upb_def_ref(def2);
   upb_def_unref(def);
   upb_def_unref(def2);
-
-
 }
 
-
 int main()
 {
 #define TEST(func) do { \
@@ -254,10 +52,6 @@ int main()
   printf("ok (%d assertions).\n", num_assertions - assertions_before); \
   } while (0)
 
-  TEST(test_get_v_uint64_t);
-  //TEST(test_get_v_uint32_t);
-  //TEST(test_skip_v_uint64_t);
-  //TEST(test_get_f_uint32_t);
   TEST(test_upb_symtab);
   printf("All tests passed (%d assertions).\n", num_assertions);
   return 0;