WIP.

6 files changed, 32 insertions, 34 deletions

diff --git a/tests/conformance_upb.c b/tests/conformance_upb.c
index e0a7d8c..cefac4c 100644
--- a/tests/conformance_upb.c
+++ b/tests/conformance_upb.c
@@ -130,7 +130,7 @@ void DoTest(
 }
 
 bool DoTestIo() {
-  upb_arena arena;
+  upb_arena *arena;
   upb_alloc *alloc;
   upb_status status;
   char *serialized_input;
@@ -145,8 +145,8 @@ bool DoTestIo() {
     return false;
   }
 
-  upb_arena_init(&arena);
-  alloc = upb_arena_alloc(&arena);
+  arena = upb_arena_new();
+  alloc = upb_arena_alloc(arena);
   serialized_input = upb_malloc(alloc, input_size);
 
   if (!CheckedRead(STDIN_FILENO, serialized_input, input_size)) {
@@ -155,24 +155,26 @@ bool DoTestIo() {
   }
 
   request = conformance_ConformanceRequest_parsenew(
-      upb_stringview_make(serialized_input, input_size), &arena);
-  response = conformance_ConformanceResponse_new(&arena);
+      upb_stringview_make(serialized_input, input_size), arena);
+  response = conformance_ConformanceResponse_new(arena);
 
   if (request) {
-    DoTest(request, response, &arena);
+    DoTest(request, response, arena);
   } else {
     fprintf(stderr, "conformance_upb: parse of ConformanceRequest failed: %s\n",
             upb_status_errmsg(&status));
   }
 
   serialized_output = conformance_ConformanceResponse_serialize(
-      response, &arena, &output_size);
+      response, arena, &output_size);
 
   CheckedWrite(STDOUT_FILENO, &output_size, sizeof(uint32_t));
   CheckedWrite(STDOUT_FILENO, serialized_output, output_size);
 
   test_count++;
 
+  upb_arena_free(arena);
+
   return true;
 }
 
diff --git a/tests/json/test_json.cc b/tests/json/test_json.cc
index b0fd3e3..1f7d364 100644
--- a/tests/json/test_json.cc
+++ b/tests/json/test_json.cc
@@ -174,9 +174,9 @@ void test_json_roundtrip_message(const char* json_src,
   VerboseParserEnvironment env(verbose);
   StringSink data_sink;
   upb::json::PrinterPtr printer = upb::json::PrinterPtr::Create(
-      env.env(), serialize_handlers, data_sink.Sink());
+      env.arena(), serialize_handlers, data_sink.Sink());
   upb::json::ParserPtr parser = upb::json::ParserPtr::Create(
-      env.env(), parser_method, NULL, printer.input(), false);
+      env.arena(), parser_method, NULL, printer.input(), false);
   env.ResetBytesSink(parser.input());
   env.Reset(json_src, strlen(json_src), false, false);
 
diff --git a/tests/pb/test_decoder.cc b/tests/pb/test_decoder.cc
index ec7a788..b2dd812 100644
--- a/tests/pb/test_decoder.cc
+++ b/tests/pb/test_decoder.cc
@@ -452,10 +452,10 @@ void callback(const void *closure, upb::Handlers* h_ptr) {
 const upb::Handlers *global_handlers;
 upb::pb::DecoderMethodPtr global_method;
 
-upb::pb::DecoderPtr CreateDecoder(upb::Environment* env,
+upb::pb::DecoderPtr CreateDecoder(upb::Arena* arena,
                                   upb::pb::DecoderMethodPtr method,
                                   upb::Sink sink) {
-  upb::pb::DecoderPtr ret = upb::pb::DecoderPtr::Create(env, method, sink);
+  upb::pb::DecoderPtr ret = upb::pb::DecoderPtr::Create(arena, method, sink);
   ret.set_max_nesting(MAX_NESTING);
   return ret;
 }
@@ -556,7 +556,7 @@ void do_run_decoder(VerboseParserEnvironment* env, upb::pb::DecoderPtr decoder,
 void run_decoder(const string& proto, const string* expected_output) {
   VerboseParserEnvironment env(filter_hash != 0);
   upb::Sink sink(global_handlers, &closures[0]);
-  upb::pb::DecoderPtr decoder = CreateDecoder(env.env(), global_method, sink);
+  upb::pb::DecoderPtr decoder = CreateDecoder(env.arena(), global_method, sink);
   env.ResetBytesSink(decoder.input());
   for (size_t i = 0; i < proto.size(); i++) {
     for (size_t j = i; j < UPB_MIN(proto.size(), i + 5); j++) {
@@ -872,10 +872,9 @@ void test_valid() {
   if (!filter_hash || filter_hash == testhash) {
     testhash = emptyhash;
     upb::Status status;
-    upb::Environment env;
-    env.ReportErrorsTo(&status);
+    upb::Arena arena;
     upb::Sink sink(global_handlers, &closures[0]);
-    upb::pb::DecoderPtr decoder = CreateDecoder(&env, global_method, sink);
+    upb::pb::DecoderPtr decoder = CreateDecoder(&arena, global_method, sink);
     output.clear();
     bool ok = upb::PutBuffer(std::string(), decoder.input());
     ASSERT(ok);
@@ -1161,7 +1160,8 @@ void test_emptyhandlers(upb::SymbolTable* symtab, bool allowjit) {
   for (int i = 0; testdata[i].data; i++) {
     VerboseParserEnvironment env(filter_hash != 0);
     upb::Sink sink(global_method.dest_handlers(), &closures[0]);
-    upb::pb::DecoderPtr decoder = CreateDecoder(env.env(), global_method, sink);
+    upb::pb::DecoderPtr decoder =
+        CreateDecoder(env.arena(), global_method, sink);
     env.ResetBytesSink(decoder.input());
     env.Reset(testdata[i].data, testdata[i].length, true, false);
     ASSERT(env.Start());
diff --git a/tests/pb/test_encoder.cc b/tests/pb/test_encoder.cc
index 35c0e1e..7145097 100644
--- a/tests/pb/test_encoder.cc
+++ b/tests/pb/test_encoder.cc
@@ -24,7 +24,7 @@ void test_pb_roundtrip() {
   upb::Arena arena;
   google_protobuf_FileDescriptorSet *set =
       google_protobuf_FileDescriptorSet_parsenew(
-          upb_stringview_make(input.c_str(), input.size()), &arena);
+          upb_stringview_make(input.c_str(), input.size()), arena.ptr());
   ASSERT(set);
   size_t n;
   const google_protobuf_FileDescriptorProto *const *files =
@@ -33,7 +33,7 @@ void test_pb_roundtrip() {
   upb::Status status;
   bool ok = symtab.AddFile(files[0], &status);
   if (!ok) {
-    fprintf(stderr, "Error building def: %s\n", upb_status_errmsg(&status));
+    fprintf(stderr, "Error building def: %s\n", status.error_message());
     ASSERT(false);
   }
   upb::MessageDefPtr md =
@@ -43,13 +43,12 @@ void test_pb_roundtrip() {
   ASSERT(encoder_handlers);
   const upb::pb::DecoderMethodPtr method = decoder_cache.Get(md);
 
-  upb::InlinedEnvironment<512> env;
   std::string output;
   upb::StringSink string_sink(&output);
   upb::pb::EncoderPtr encoder =
-      upb::pb::EncoderPtr::Create(&env, encoder_handlers, string_sink.input());
+      upb::pb::EncoderPtr::Create(&arena, encoder_handlers, string_sink.input());
   upb::pb::DecoderPtr decoder =
-      upb::pb::DecoderPtr::Create(&env, method, encoder.input());
+      upb::pb::DecoderPtr::Create(&arena, method, encoder.input());
   ok = upb::PutBuffer(input, decoder.input());
   ASSERT(ok);
   ASSERT(input == output);
diff --git a/tests/test_cpp.cc b/tests/test_cpp.cc
index a5bfbc7..5e9a8dd 100644
--- a/tests/test_cpp.cc
+++ b/tests/test_cpp.cc
@@ -672,7 +672,7 @@ void DoNothingStringBufHandler(C* closure, const char *buf, size_t len) {
 }
 
 template <class C>
-void DoNothingEndMessageHandler(C* closure, upb::Status *status) {
+void DoNothingEndMessageHandler(C* closure, upb_status *status) {
   UPB_UNUSED(closure);
   UPB_UNUSED(status);
 }
diff --git a/tests/test_util.h b/tests/test_util.h
index 0b5ddd4..04ca3fb 100644
--- a/tests/test_util.h
+++ b/tests/test_util.h
@@ -30,15 +30,11 @@ upb_bufhandle global_handle;
 class VerboseParserEnvironment {
  public:
   /* Pass verbose=true to print detailed diagnostics to stderr. */
-  VerboseParserEnvironment(bool verbose) : verbose_(verbose) {
-    env_.SetErrorFunction(&VerboseParserEnvironment::OnError, this);
-  }
+  VerboseParserEnvironment(bool verbose) : verbose_(verbose) {}
 
   static bool OnError(void *ud, const upb::Status* status) {
     VerboseParserEnvironment* env = static_cast<VerboseParserEnvironment*>(ud);
 
-    env->saw_error_ = true;
-
     if (env->expect_error_ && env->verbose_) {
       fprintf(stderr, "Encountered error, as expected: ");
     } else if (!env->expect_error_) {
@@ -56,7 +52,6 @@ class VerboseParserEnvironment {
     len_ = len;
     ofs_ = 0;
     expect_error_ = expect_error;
-    saw_error_ = false;
     end_ok_set_ = false;
     skip_until_ = may_skip ? 0 : -1;
     skipped_with_null_ = false;
@@ -94,12 +89,12 @@ class VerboseParserEnvironment {
   bool CheckConsistency() {
     /* If we called end (which we should only do when previous bytes are fully
      * accepted), then end() should return true iff there were no errors. */
-    if (end_ok_set_ && end_ok_ != !saw_error_) {
+    if (end_ok_set_ && end_ok_ != status_.ok()) {
       fprintf(stderr, "End() status and saw_error didn't match.\n");
       return false;
     }
 
-    if (expect_error_ && !saw_error_) {
+    if (expect_error_ && status_.ok()) {
       fprintf(stderr, "Expected error but saw none.\n");
       return false;
     }
@@ -158,8 +153,9 @@ class VerboseParserEnvironment {
       }
     }
 
-    if (saw_error_)
+    if (!status_.ok()) {
       return false;
+    }
 
     if (parsed > bytes && skip_until_ >= 0) {
       skip_until_ = ofs_ + parsed;
@@ -175,12 +171,14 @@ class VerboseParserEnvironment {
   }
 
   size_t ofs() { return ofs_; }
-  upb::Environment* env() { return &env_; }
 
   bool SkippedWithNull() { return skipped_with_null_; }
 
+  upb::Arena* arena() { return &arena_; }
+
  private:
-  upb::Environment env_;
+  upb::Arena arena_;
+  upb::Status status_;
   upb::BytesSink sink_;
   const char* buf_;
   size_t len_;
@@ -188,7 +186,6 @@ class VerboseParserEnvironment {
   size_t ofs_;
   void *subc_;
   bool expect_error_;
-  bool saw_error_;
   bool end_ok_;
   bool end_ok_set_;