From ef7c50223a9bd1ab451e82a31a93cab3272b497f Mon Sep 17 00:00:00 2001 From: Joshua Haberman Date: Sat, 12 Jan 2019 20:02:52 -0800 Subject: All tests pass again! --- tests/test_cpp.cc | 382 ++++++++++++++++++++++++++---------------------------- 1 file changed, 184 insertions(+), 198 deletions(-) (limited to 'tests') diff --git a/tests/test_cpp.cc b/tests/test_cpp.cc index b6d8212..a5bfbc7 100644 --- a/tests/test_cpp.cc +++ b/tests/test_cpp.cc @@ -52,16 +52,16 @@ class StringBufTesterBase { StringBufTesterBase() : seen_(false), handler_data_val_(0) {} - void CallAndVerify(upb::Sink* sink, const upb::FieldDef* f) { - upb::Handlers::Selector start; - ASSERT(upb::Handlers::GetSelector(f, UPB_HANDLER_STARTSTR, &start)); - upb::Handlers::Selector str; - ASSERT(upb::Handlers::GetSelector(f, UPB_HANDLER_STRING, &str)); + void CallAndVerify(upb::Sink sink, upb::FieldDefPtr f) { + upb_selector_t start; + ASSERT(upb_handlers_getselector(f.ptr(), UPB_HANDLER_STARTSTR, &start)); + upb_selector_t str; + ASSERT(upb_handlers_getselector(f.ptr(), UPB_HANDLER_STRING, &str)); ASSERT(!seen_); upb::Sink sub; - sink->StartMessage(); - sink->StartString(start, 0, &sub); + sink.StartMessage(); + sink.StartString(start, 0, &sub); size_t ret = sub.PutStringBuffer(str, &buf_, 5, &handle_); ASSERT(seen_); ASSERT(len_ == 5); @@ -74,7 +74,7 @@ class StringBufTesterBase { int handler_data_val_; size_t len_; char buf_; - upb::BufferHandle handle_; + upb_bufhandle handle_; }; // Test 8 combinations of: @@ -91,9 +91,9 @@ class StringBufTesterVoidMethodNoHandlerDataNoHandle : public StringBufTesterBase { public: typedef StringBufTesterVoidMethodNoHandlerDataNoHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler))); + ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -109,14 +109,14 @@ class StringBufTesterVoidMethodNoHandlerDataWithHandle : public StringBufTesterBase { public: typedef StringBufTesterVoidMethodNoHandlerDataWithHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler))); + ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } private: - void Handler(const char *buf, size_t len, const upb::BufferHandle* handle) { + void Handler(const char *buf, size_t len, const upb_bufhandle* handle) { ASSERT(buf == &buf_); ASSERT(handle == &handle_); seen_ = true; @@ -128,9 +128,9 @@ class StringBufTesterVoidMethodWithHandlerDataNoHandle : public StringBufTesterBase { public: typedef StringBufTesterVoidMethodWithHandlerDataNoHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler( + ASSERT(h.SetStringHandler( f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); } @@ -147,15 +147,15 @@ class StringBufTesterVoidMethodWithHandlerDataWithHandle : public StringBufTesterBase { public: typedef StringBufTesterVoidMethodWithHandlerDataWithHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler( + ASSERT(h.SetStringHandler( f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); } private: void Handler(const int* hd, const char* buf, size_t len, - const upb::BufferHandle* handle) { + const upb_bufhandle* handle) { ASSERT(buf == &buf_); ASSERT(handle == &handle_); handler_data_val_ = *hd; @@ -168,9 +168,9 @@ class StringBufTesterVoidFunctionNoHandlerDataNoHandle : public StringBufTesterBase { public: typedef StringBufTesterVoidFunctionNoHandlerDataNoHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler))); + ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -186,15 +186,15 @@ class StringBufTesterVoidFunctionNoHandlerDataWithHandle : public StringBufTesterBase { public: typedef StringBufTesterVoidFunctionNoHandlerDataWithHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler))); + ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } private: static void Handler(ME* t, const char* buf, size_t len, - const upb::BufferHandle* handle) { + const upb_bufhandle* handle) { ASSERT(buf == &t->buf_); ASSERT(handle == &t->handle_); t->seen_ = true; @@ -206,9 +206,9 @@ class StringBufTesterVoidFunctionWithHandlerDataNoHandle : public StringBufTesterBase { public: typedef StringBufTesterVoidFunctionWithHandlerDataNoHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler( + ASSERT(h.SetStringHandler( f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); } @@ -225,15 +225,15 @@ class StringBufTesterVoidFunctionWithHandlerDataWithHandle : public StringBufTesterBase { public: typedef StringBufTesterVoidFunctionWithHandlerDataWithHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler( + ASSERT(h.SetStringHandler( f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); } private: static void Handler(ME* t, const int* hd, const char* buf, size_t len, - const upb::BufferHandle* handle) { + const upb_bufhandle* handle) { ASSERT(buf == &t->buf_); ASSERT(handle == &t->handle_); t->handler_data_val_ = *hd; @@ -246,9 +246,9 @@ class StringBufTesterSizeTMethodNoHandlerDataNoHandle : public StringBufTesterBase { public: typedef StringBufTesterSizeTMethodNoHandlerDataNoHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler))); + ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -265,9 +265,9 @@ class StringBufTesterBoolMethodNoHandlerDataNoHandle : public StringBufTesterBase { public: typedef StringBufTesterBoolMethodNoHandlerDataNoHandle ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler))); + ASSERT(h.SetStringHandler(f, UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -288,10 +288,10 @@ class StartMsgTesterBase { StartMsgTesterBase() : seen_(false), handler_data_val_(0) {} - void CallAndVerify(upb::Sink* sink, const upb::FieldDef* f) { + void CallAndVerify(upb::Sink sink, upb::FieldDefPtr f) { UPB_UNUSED(f); ASSERT(!seen_); - sink->StartMessage(); + sink.StartMessage(); ASSERT(seen_); ASSERT(handler_data_val_ == kExpectedHandlerData); } @@ -307,9 +307,9 @@ class StartMsgTesterBase { class StartMsgTesterVoidFunctionNoHandlerData : public StartMsgTesterBase { public: typedef StartMsgTesterVoidFunctionNoHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&Handler))); + ASSERT(h.SetStartMessageHandler(UpbMakeHandler(&Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -323,9 +323,9 @@ class StartMsgTesterVoidFunctionNoHandlerData : public StartMsgTesterBase { class StartMsgTesterBoolFunctionNoHandlerData : public StartMsgTesterBase { public: typedef StartMsgTesterBoolFunctionNoHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&Handler))); + ASSERT(h.SetStartMessageHandler(UpbMakeHandler(&Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -339,9 +339,9 @@ class StartMsgTesterBoolFunctionNoHandlerData : public StartMsgTesterBase { class StartMsgTesterVoidMethodNoHandlerData : public StartMsgTesterBase { public: typedef StartMsgTesterVoidMethodNoHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&ME::Handler))); + ASSERT(h.SetStartMessageHandler(UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -354,9 +354,9 @@ class StartMsgTesterVoidMethodNoHandlerData : public StartMsgTesterBase { class StartMsgTesterBoolMethodNoHandlerData : public StartMsgTesterBase { public: typedef StartMsgTesterBoolMethodNoHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&ME::Handler))); + ASSERT(h.SetStartMessageHandler(UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -370,9 +370,9 @@ class StartMsgTesterBoolMethodNoHandlerData : public StartMsgTesterBase { class StartMsgTesterVoidFunctionWithHandlerData : public StartMsgTesterBase { public: typedef StartMsgTesterVoidFunctionWithHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStartMessageHandler( + ASSERT(h.SetStartMessageHandler( UpbBind(&Handler, new int(kExpectedHandlerData)))); } @@ -386,9 +386,9 @@ class StartMsgTesterVoidFunctionWithHandlerData : public StartMsgTesterBase { class StartMsgTesterBoolFunctionWithHandlerData : public StartMsgTesterBase { public: typedef StartMsgTesterBoolFunctionWithHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStartMessageHandler( + ASSERT(h.SetStartMessageHandler( UpbBind(&Handler, new int(kExpectedHandlerData)))); } @@ -403,9 +403,9 @@ class StartMsgTesterBoolFunctionWithHandlerData : public StartMsgTesterBase { class StartMsgTesterVoidMethodWithHandlerData : public StartMsgTesterBase { public: typedef StartMsgTesterVoidMethodWithHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStartMessageHandler( + ASSERT(h.SetStartMessageHandler( UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); } @@ -419,9 +419,9 @@ class StartMsgTesterVoidMethodWithHandlerData : public StartMsgTesterBase { class StartMsgTesterBoolMethodWithHandlerData : public StartMsgTesterBase { public: typedef StartMsgTesterBoolMethodWithHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { UPB_UNUSED(f); - ASSERT(h->SetStartMessageHandler( + ASSERT(h.SetStartMessageHandler( UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); } @@ -439,12 +439,12 @@ class Int32ValueTesterBase { Int32ValueTesterBase() : seen_(false), val_(0), handler_data_val_(0) {} - void CallAndVerify(upb::Sink* sink, const upb::FieldDef* f) { - upb::Handlers::Selector s; - ASSERT(upb::Handlers::GetSelector(f, UPB_HANDLER_INT32, &s)); + void CallAndVerify(upb::Sink sink, upb::FieldDefPtr f) { + upb_selector_t s; + ASSERT(upb_handlers_getselector(f.ptr(), UPB_HANDLER_INT32, &s)); ASSERT(!seen_); - sink->PutInt32(s, 5); + sink.PutInt32(s, 5); ASSERT(seen_); ASSERT(handler_data_val_ == kExpectedHandlerData); ASSERT(val_ == 5); @@ -463,8 +463,8 @@ class ValueTesterInt32VoidFunctionNoHandlerData : public Int32ValueTesterBase { public: typedef ValueTesterInt32VoidFunctionNoHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { - ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&Handler))); + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { + ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -479,8 +479,8 @@ class ValueTesterInt32BoolFunctionNoHandlerData : public Int32ValueTesterBase { public: typedef ValueTesterInt32BoolFunctionNoHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { - ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&Handler))); + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { + ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -495,8 +495,8 @@ class ValueTesterInt32BoolFunctionNoHandlerData class ValueTesterInt32VoidMethodNoHandlerData : public Int32ValueTesterBase { public: typedef ValueTesterInt32VoidMethodNoHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { - ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&ME::Handler))); + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { + ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -510,8 +510,8 @@ class ValueTesterInt32VoidMethodNoHandlerData : public Int32ValueTesterBase { class ValueTesterInt32BoolMethodNoHandlerData : public Int32ValueTesterBase { public: typedef ValueTesterInt32BoolMethodNoHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { - ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&ME::Handler))); + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { + ASSERT(h.SetInt32Handler(f, UpbMakeHandler(&ME::Handler))); handler_data_val_ = kExpectedHandlerData; } @@ -527,8 +527,8 @@ class ValueTesterInt32VoidFunctionWithHandlerData : public Int32ValueTesterBase { public: typedef ValueTesterInt32VoidFunctionWithHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { - ASSERT(h->SetInt32Handler( + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { + ASSERT(h.SetInt32Handler( f, UpbBind(&Handler, new int(kExpectedHandlerData)))); } @@ -544,8 +544,8 @@ class ValueTesterInt32BoolFunctionWithHandlerData : public Int32ValueTesterBase { public: typedef ValueTesterInt32BoolFunctionWithHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { - ASSERT(h->SetInt32Handler( + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { + ASSERT(h.SetInt32Handler( f, UpbBind(&Handler, new int(kExpectedHandlerData)))); } @@ -561,8 +561,8 @@ class ValueTesterInt32BoolFunctionWithHandlerData class ValueTesterInt32VoidMethodWithHandlerData : public Int32ValueTesterBase { public: typedef ValueTesterInt32VoidMethodWithHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { - ASSERT(h->SetInt32Handler( + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { + ASSERT(h.SetInt32Handler( f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); } @@ -577,8 +577,8 @@ class ValueTesterInt32VoidMethodWithHandlerData : public Int32ValueTesterBase { class ValueTesterInt32BoolMethodWithHandlerData : public Int32ValueTesterBase { public: typedef ValueTesterInt32BoolMethodWithHandlerData ME; - void Register(upb::Handlers* h, const upb::FieldDef* f) { - ASSERT(h->SetInt32Handler( + void Register(upb::HandlersPtr h, upb::FieldDefPtr f) { + ASSERT(h.SetInt32Handler( f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); } @@ -591,22 +591,29 @@ class ValueTesterInt32BoolMethodWithHandlerData : public Int32ValueTesterBase { } }; +template +void RegisterHandlers(const void* closure, upb::Handlers* h_ptr) { + T* tester = const_cast(static_cast(closure)); + upb::HandlersPtr h(h_ptr); + upb::FieldDefPtr f = h.message_def().FindFieldByNumber(T::kFieldNumber); + ASSERT(f); + tester->Register(h, f); +} + template void TestHandler() { - upb::SymbolTable* symtab = upb::SymbolTable::New(); - const upb::MessageDef* md = upb_test_TestMessage_getmsgdef(symtab); + T tester; + upb::SymbolTable symtab; + upb::HandlerCache cache(&RegisterHandlers, &tester); + upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr())); ASSERT(md); - const upb::FieldDef* f = md->FindFieldByNumber(T::kFieldNumber); + upb::FieldDefPtr f = md.FindFieldByNumber(T::kFieldNumber); ASSERT(f); - upb::reffed_ptr h(upb::Handlers::New(md)); - T tester; - tester.Register(h.get(), f); - ASSERT(h->Freeze(NULL)); + const upb::Handlers* h = cache.Get(md); - upb::Sink sink(h.get(), &tester); - tester.CallAndVerify(&sink, f); - upb::SymbolTable::Free(symtab); + upb::Sink sink(h, &tester); + tester.CallAndVerify(sink, f); } class T1 {}; @@ -670,17 +677,17 @@ void DoNothingEndMessageHandler(C* closure, upb::Status *status) { UPB_UNUSED(status); } -void TestMismatchedTypes() { - // First create a schema for our test. - upb::SymbolTable* symtab = upb::SymbolTable::New(); - const upb::MessageDef* md = upb_test_TestMessage_getmsgdef(symtab); +void RegisterMismatchedTypes(const void* closure, upb::Handlers* h_ptr) { + upb::HandlersPtr h(h_ptr); + + upb::MessageDefPtr md(h.message_def()); ASSERT(md); - const upb::FieldDef* i32 = md->FindFieldByName("i32"); - const upb::FieldDef* r_i32 = md->FindFieldByName("r_i32"); - const upb::FieldDef* str = md->FindFieldByName("str"); - const upb::FieldDef* r_str = md->FindFieldByName("r_str"); - const upb::FieldDef* msg = md->FindFieldByName("msg"); - const upb::FieldDef* r_msg = md->FindFieldByName("r_msg"); + upb::FieldDefPtr i32 = md.FindFieldByName("i32"); + upb::FieldDefPtr r_i32 = md.FindFieldByName("r_i32"); + upb::FieldDefPtr str = md.FindFieldByName("str"); + upb::FieldDefPtr r_str = md.FindFieldByName("r_str"); + upb::FieldDefPtr msg = md.FindFieldByName("msg"); + upb::FieldDefPtr r_msg = md.FindFieldByName("r_msg"); ASSERT(i32); ASSERT(r_i32); ASSERT(str); @@ -688,189 +695,163 @@ void TestMismatchedTypes() { ASSERT(msg); ASSERT(r_msg); - // Now test the type-checking in handler registration. - upb::reffed_ptr h(upb::Handlers::New(md)); - // Establish T1 as the top-level closure type. - ASSERT(h->SetInt32Handler(i32, UpbMakeHandler(DoNothingInt32Handler))); + ASSERT(h.SetInt32Handler(i32, UpbMakeHandler(DoNothingInt32Handler))); // Now any other attempt to set another handler with T2 as the top-level // closure should fail. But setting these same handlers with T1 as the // top-level closure will succeed. - ASSERT(!h->SetStartMessageHandler(UpbMakeHandler(DoNothingHandler))); - ASSERT(h->SetStartMessageHandler(UpbMakeHandler(DoNothingHandler))); + ASSERT(!h.SetStartMessageHandler(UpbMakeHandler(DoNothingHandler))); + ASSERT(h.SetStartMessageHandler(UpbMakeHandler(DoNothingHandler))); ASSERT( - !h->SetEndMessageHandler(UpbMakeHandler(DoNothingEndMessageHandler))); + !h.SetEndMessageHandler(UpbMakeHandler(DoNothingEndMessageHandler))); ASSERT( - h->SetEndMessageHandler(UpbMakeHandler(DoNothingEndMessageHandler))); + h.SetEndMessageHandler(UpbMakeHandler(DoNothingEndMessageHandler))); - ASSERT(!h->SetStartStringHandler( + ASSERT(!h.SetStartStringHandler( str, UpbMakeHandler(DoNothingStartHandler::String))); - ASSERT(h->SetStartStringHandler( + ASSERT(h.SetStartStringHandler( str, UpbMakeHandler(DoNothingStartHandler::String))); - ASSERT(!h->SetEndStringHandler(str, UpbMakeHandler(DoNothingHandler))); - ASSERT(h->SetEndStringHandler(str, UpbMakeHandler(DoNothingHandler))); + ASSERT(!h.SetEndStringHandler(str, UpbMakeHandler(DoNothingHandler))); + ASSERT(h.SetEndStringHandler(str, UpbMakeHandler(DoNothingHandler))); - ASSERT(!h->SetStartSubMessageHandler( + ASSERT(!h.SetStartSubMessageHandler( msg, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(h->SetStartSubMessageHandler( + ASSERT(h.SetStartSubMessageHandler( msg, UpbMakeHandler(DoNothingStartHandler::Handler))); ASSERT( - !h->SetEndSubMessageHandler(msg, UpbMakeHandler(DoNothingHandler))); + !h.SetEndSubMessageHandler(msg, UpbMakeHandler(DoNothingHandler))); ASSERT( - h->SetEndSubMessageHandler(msg, UpbMakeHandler(DoNothingHandler))); + h.SetEndSubMessageHandler(msg, UpbMakeHandler(DoNothingHandler))); - ASSERT(!h->SetStartSequenceHandler( + ASSERT(!h.SetStartSequenceHandler( r_i32, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(h->SetStartSequenceHandler( + ASSERT(h.SetStartSequenceHandler( r_i32, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(!h->SetEndSequenceHandler( + ASSERT(!h.SetEndSequenceHandler( r_i32, UpbMakeHandler(DoNothingHandler))); - ASSERT(h->SetEndSequenceHandler( + ASSERT(h.SetEndSequenceHandler( r_i32, UpbMakeHandler(DoNothingHandler))); - ASSERT(!h->SetStartSequenceHandler( + ASSERT(!h.SetStartSequenceHandler( r_msg, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(h->SetStartSequenceHandler( + ASSERT(h.SetStartSequenceHandler( r_msg, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(!h->SetEndSequenceHandler( + ASSERT(!h.SetEndSequenceHandler( r_msg, UpbMakeHandler(DoNothingHandler))); - ASSERT(h->SetEndSequenceHandler( + ASSERT(h.SetEndSequenceHandler( r_msg, UpbMakeHandler(DoNothingHandler))); - ASSERT(!h->SetStartSequenceHandler( + ASSERT(!h.SetStartSequenceHandler( r_str, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(h->SetStartSequenceHandler( + ASSERT(h.SetStartSequenceHandler( r_str, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(!h->SetEndSequenceHandler( + ASSERT(!h.SetEndSequenceHandler( r_str, UpbMakeHandler(DoNothingHandler))); - ASSERT(h->SetEndSequenceHandler( + ASSERT(h.SetEndSequenceHandler( r_str, UpbMakeHandler(DoNothingHandler))); // By setting T1 as the return type for the Start* handlers we have // established T1 as the type of the sequence and string frames. // Setting callbacks that use T2 should fail, but T1 should succeed. ASSERT( - !h->SetStringHandler(str, UpbMakeHandler(DoNothingStringBufHandler))); + !h.SetStringHandler(str, UpbMakeHandler(DoNothingStringBufHandler))); ASSERT( - h->SetStringHandler(str, UpbMakeHandler(DoNothingStringBufHandler))); + h.SetStringHandler(str, UpbMakeHandler(DoNothingStringBufHandler))); - ASSERT(!h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler))); - ASSERT(h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler))); + ASSERT(!h.SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler))); + ASSERT(h.SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler))); - ASSERT(!h->SetStartSubMessageHandler( + ASSERT(!h.SetStartSubMessageHandler( r_msg, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(h->SetStartSubMessageHandler( + ASSERT(h.SetStartSubMessageHandler( r_msg, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(!h->SetEndSubMessageHandler(r_msg, + ASSERT(!h.SetEndSubMessageHandler(r_msg, UpbMakeHandler(DoNothingHandler))); - ASSERT(h->SetEndSubMessageHandler(r_msg, + ASSERT(h.SetEndSubMessageHandler(r_msg, UpbMakeHandler(DoNothingHandler))); - ASSERT(!h->SetStartStringHandler( + ASSERT(!h.SetStartStringHandler( r_str, UpbMakeHandler(DoNothingStartHandler::String))); - ASSERT(h->SetStartStringHandler( + ASSERT(h.SetStartStringHandler( r_str, UpbMakeHandler(DoNothingStartHandler::String))); ASSERT( - !h->SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler))); - ASSERT(h->SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler))); + !h.SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler))); + ASSERT(h.SetEndStringHandler(r_str, UpbMakeHandler(DoNothingHandler))); - ASSERT(!h->SetStringHandler(r_str, + ASSERT(!h.SetStringHandler(r_str, UpbMakeHandler(DoNothingStringBufHandler))); - ASSERT(h->SetStringHandler(r_str, + ASSERT(h.SetStringHandler(r_str, UpbMakeHandler(DoNothingStringBufHandler))); +} - h->ClearError(); - ASSERT(h->Freeze(NULL)); +void RegisterMismatchedTypes2(const void* closure, upb::Handlers* h_ptr) { + upb::HandlersPtr h(h_ptr); + + upb::MessageDefPtr md(h.message_def()); + ASSERT(md); + upb::FieldDefPtr i32 = md.FindFieldByName("i32"); + upb::FieldDefPtr r_i32 = md.FindFieldByName("r_i32"); + upb::FieldDefPtr str = md.FindFieldByName("str"); + upb::FieldDefPtr r_str = md.FindFieldByName("r_str"); + upb::FieldDefPtr msg = md.FindFieldByName("msg"); + upb::FieldDefPtr r_msg = md.FindFieldByName("r_msg"); + ASSERT(i32); + ASSERT(r_i32); + ASSERT(str); + ASSERT(r_str); + ASSERT(msg); + ASSERT(r_msg); // For our second test we do the same in reverse. We directly set the type of // the frame and then observe failures at registering a Start* handler that // returns a different type. - h = upb::Handlers::New(md); // First establish the type of a sequence frame directly. - ASSERT(h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler))); + ASSERT(h.SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler))); // Now setting a StartSequence callback that returns a different type should // fail. - ASSERT(!h->SetStartSequenceHandler( + ASSERT(!h.SetStartSequenceHandler( r_i32, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(h->SetStartSequenceHandler( + ASSERT(h.SetStartSequenceHandler( r_i32, UpbMakeHandler(DoNothingStartHandler::Handler))); // Establish a string frame directly. - ASSERT(h->SetStringHandler(r_str, + ASSERT(h.SetStringHandler(r_str, UpbMakeHandler(DoNothingStringBufHandler))); // Fail setting a StartString callback that returns a different type. - ASSERT(!h->SetStartStringHandler( + ASSERT(!h.SetStartStringHandler( r_str, UpbMakeHandler(DoNothingStartHandler::String))); - ASSERT(h->SetStartStringHandler( + ASSERT(h.SetStartStringHandler( r_str, UpbMakeHandler(DoNothingStartHandler::String))); // The previous established T1 as the frame for the r_str sequence. - ASSERT(!h->SetStartSequenceHandler( + ASSERT(!h.SetStartSequenceHandler( r_str, UpbMakeHandler(DoNothingStartHandler::Handler))); - ASSERT(h->SetStartSequenceHandler( + ASSERT(h.SetStartSequenceHandler( r_str, UpbMakeHandler(DoNothingStartHandler::Handler))); +} - // Now test for this error that is not caught until freeze time: - // Change-of-closure-type implies that a StartSequence or StartString handler - // should exist to return the closure type of the inner frame but no - // StartSequence/StartString handler is registered. - - h = upb::Handlers::New(md); - - // Establish T1 as top-level closure type. - ASSERT(h->SetInt32Handler(i32, UpbMakeHandler(DoNothingInt32Handler))); +void TestMismatchedTypes() { + // First create a schema for our test. + upb::SymbolTable symtab; + upb::HandlerCache handler_cache(&RegisterMismatchedTypes, nullptr); + upb::HandlerCache handler_cache2(&RegisterMismatchedTypes2, nullptr); + const upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr())); - // Establish T2 as closure type of sequence frame. - ASSERT( - h->SetInt32Handler(r_i32, UpbMakeHandler(DoNothingInt32Handler))); - - // Now attempt to freeze; this should fail because a StartSequence handler - // needs to be registered that takes a T1 and returns a T2. - ASSERT(!h->Freeze(NULL)); - - // Now if we register the necessary StartSequence handler, the freezing should - // work. - ASSERT(h->SetStartSequenceHandler( - r_i32, UpbMakeHandler(DoNothingStartHandler::Handler))); - h->ClearError(); - ASSERT(h->Freeze(NULL)); - - // Test for a broken chain that is two deep. - h = upb::Handlers::New(md); - - // Establish T1 as top-level closure type. - ASSERT(h->SetInt32Handler(i32, UpbMakeHandler(DoNothingInt32Handler))); - - // Establish T2 as the closure type of the string frame inside a sequence - // frame. - ASSERT(h->SetStringHandler(r_str, - UpbMakeHandler(DoNothingStringBufHandler))); - - // Now attempt to freeze; this should fail because a StartSequence or - // StartString handler needs to be registered that takes a T1 and returns a - // T2. - ASSERT(!h->Freeze(NULL)); - - // Now if we register a StartSequence handler it succeeds. - ASSERT(h->SetStartSequenceHandler( - r_str, UpbMakeHandler(DoNothingStartHandler::Handler))); - h->ClearError(); - ASSERT(h->Freeze(NULL)); - - // TODO(haberman): test that closure returned by StartSubMessage does not - // match top-level closure of sub-handlers. + // Now test the type-checking in handler registration. + handler_cache.Get(md); + handler_cache2.Get(md); } class IntIncrementer { @@ -889,17 +870,22 @@ class IntIncrementer { int* x_; }; +void RegisterIncrementor(const void* closure, upb::Handlers* h_ptr) { + const int* x = static_cast(closure); + upb::HandlersPtr h(h_ptr); + upb::FieldDefPtr f = h.message_def().FindFieldByName("i32"); + h.SetInt32Handler(f, UpbBind(&IntIncrementer::Handler, + new IntIncrementer(const_cast(x)))); +} void TestHandlerDataDestruction() { - upb::SymbolTable* symtab = upb::SymbolTable::New(); - const upb::MessageDef* md = upb_test_TestMessage_getmsgdef(symtab); - const upb::FieldDef* f = md->FindFieldByName("i32"); - int x = 0; + { - upb::reffed_ptr h(upb::Handlers::New(md)); - h->SetInt32Handler( - f, UpbBind(&IntIncrementer::Handler, new IntIncrementer(&x))); + upb::SymbolTable symtab; + upb::HandlerCache cache(&RegisterIncrementor, &x); + upb::MessageDefPtr md(upb_test_TestMessage_getmsgdef(symtab.ptr())); + cache.Get(md); ASSERT(x == 1); } -- cgit v1.2.3