diff options
Diffstat (limited to 'tests/test_cpp.cc')
-rw-r--r-- | tests/test_cpp.cc | 737 |
1 files changed, 714 insertions, 23 deletions
diff --git a/tests/test_cpp.cc b/tests/test_cpp.cc index 2b122a3..8d06135 100644 --- a/tests/test_cpp.cc +++ b/tests/test_cpp.cc @@ -9,8 +9,11 @@ #include <stdio.h> #include <string.h> + #include <iostream> #include <set> +#include <type_traits> + #include "upb/def.h" #include "upb/descriptor/reader.h" #include "upb/handlers.h" @@ -25,39 +28,133 @@ void AssertInsert(T* const container, const typename T::value_type& val) { ASSERT(inserted); } -static void TestCasts1() { - const upb::MessageDef* md = upb::MessageDef::New(&md); - const upb::Def* def = md->Upcast(); +static void TestCastsUpDown() { + upb::reffed_ptr<const upb::MessageDef> reffed_md(upb::MessageDef::New()); + const upb::MessageDef* md = reffed_md.get(); + + // Upcast to reffed_ptr implicitly. + upb::reffed_ptr<const upb::Def> reffed_def = reffed_md; + ASSERT(reffed_def.get() == upb::upcast(reffed_md.get())); + + // Upcast to raw pointer must be explicit. + const upb::Def* def = upb::upcast(md); + ASSERT(def == reffed_def.get()); + const upb::Def* def2 = upb::upcast(reffed_md.get()); + ASSERT(def2 == reffed_def.get()); + + // Downcast/dyncast of raw pointer uses upb::down_cast/upb::dyn_cast. const upb::MessageDef* md2 = upb::down_cast<const upb::MessageDef*>(def); const upb::MessageDef* md3 = upb::dyn_cast<const upb::MessageDef*>(def); - ASSERT(md == md2); ASSERT(md == md3); - const upb::EnumDef* ed = upb::dyn_cast<const upb::EnumDef*>(def); - ASSERT(!ed); + // Downcast/dyncast of reffed_ptr uses down_cast/dyn_cast members. + upb::reffed_ptr<const upb::MessageDef> md4( + reffed_def.down_cast<const upb::MessageDef>()); + upb::reffed_ptr<const upb::MessageDef> md5( + reffed_def.dyn_cast<const upb::MessageDef>()); + ASSERT(md == md4.get()); + ASSERT(md == md5.get()); - md->Unref(&md); + // Failed dyncast returns NULL. + ASSERT(upb::dyn_cast<const upb::EnumDef*>(def) == NULL); + ASSERT(reffed_def.dyn_cast<const upb::EnumDef>().get() == NULL); } -static void TestCasts2() { - // Test non-const -> const cast. - upb::MessageDef* md = upb::MessageDef::New(&md); - upb::Def* def = md->Upcast(); - const upb::MessageDef* const_md = upb::down_cast<const upb::MessageDef*>(def); - ASSERT(const_md == md); - md->Unref(&md); +static void TestCastsConst0() { + // Should clean up properly even if it is not assigned to anything. + upb::MessageDef::New(); +} + +static void TestCastsConst1() { + // Test reffed mutable -> reffed mutable construction/assignment. + upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New()); + upb::MessageDef *md2 = md.get(); + md = upb::MessageDef::New(); + ASSERT(md.get()); + ASSERT(md.get() != md2); +} + +static void TestCastsConst2() { + // Test reffed mutable -> reffed mutable upcast construction/assignment. + upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New()); + upb::reffed_ptr<upb::Def> def = md; + ASSERT(upb::upcast(md.get()) == def.get()); + def = md; + ASSERT(upb::upcast(md.get()) == def.get()); +} + +static void TestCastsConst3() { + // Test reffed mutable -> reffed mutable downcast. + upb::reffed_ptr<upb::Def> def(upb::MessageDef::New()); + upb::reffed_ptr<upb::MessageDef> md = def.down_cast<upb::MessageDef>(); + ASSERT(upb::upcast(md.get()) == def.get()); +} + +static void TestCastsConst4() { + // Test reffed mutable -> reffed mutable dyncast. + upb::reffed_ptr<upb::Def> def(upb::MessageDef::New()); + upb::reffed_ptr<upb::MessageDef> md = def.dyn_cast<upb::MessageDef>(); + ASSERT(upb::upcast(md.get()) == def.get()); +} + +static void TestCastsConst5() { + // Test reffed mutable -> reffed const construction/assignment. + upb::reffed_ptr<const upb::MessageDef> md(upb::MessageDef::New()); + const upb::MessageDef *md2 = md.get(); + md = upb::MessageDef::New(); + ASSERT(md.get()); + ASSERT(md.get() != md2); +} + +static void TestCastsConst6() { + // Test reffed mutable -> reffed const upcast construction/assignment. + upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New()); + upb::reffed_ptr<const upb::Def> def = md; + ASSERT(upb::upcast(md.get()) == def.get()); + def = md; + ASSERT(upb::upcast(md.get()) == def.get()); +} + +static void TestCastsConst7() { + // Test reffed mutable -> reffed const downcast. + upb::reffed_ptr<upb::Def> def(upb::MessageDef::New()); + upb::reffed_ptr<const upb::MessageDef> md = + def.down_cast<const upb::MessageDef>(); + ASSERT(upb::upcast(md.get()) == def.get()); +} + +static void TestCastsConst8() { + // Test reffed mutable -> reffed const dyncast. + upb::reffed_ptr<upb::Def> def(upb::MessageDef::New()); + upb::reffed_ptr<const upb::MessageDef> md = + def.dyn_cast<const upb::MessageDef>(); + ASSERT(upb::upcast(md.get()) == def.get()); +} + +static void TestCastsConst9() { + // Test plain mutable -> plain mutable upcast + upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New()); + upb::Def* def = upb::upcast(md.get()); + ASSERT(upb::down_cast<upb::MessageDef*>(def) == md.get()); +} + +static void TestCastsConst10() { + // Test plain const -> plain const upcast + upb::reffed_ptr<const upb::MessageDef> md(upb::MessageDef::New()); + const upb::Def* def = upb::upcast(md.get()); + ASSERT(upb::down_cast<const upb::MessageDef*>(def) == md.get()); } static void TestSymbolTable(const char *descriptor_file) { - upb::SymbolTable *s = upb::SymbolTable::New(&s); + upb::reffed_ptr<upb::SymbolTable> s(upb::SymbolTable::New()); upb::Status status; - if (!upb::LoadDescriptorFileIntoSymtab(s, descriptor_file, &status)) { - std::cerr << "Couldn't load descriptor: " << status.GetString(); + if (!upb::LoadDescriptorFileIntoSymtab(s.get(), descriptor_file, &status)) { + std::cerr << "Couldn't load descriptor: " << status.error_message(); exit(1); } - const upb::MessageDef* md = s->LookupMessage("C", &md); - ASSERT(md); + upb::reffed_ptr<const upb::MessageDef> md(s->LookupMessage("C")); + ASSERT(md.get()); // We want a def that satisfies this to test iteration. ASSERT(md->field_count() > 1); @@ -65,15 +162,554 @@ static void TestSymbolTable(const char *descriptor_file) { #ifdef UPB_CXX11 // Test range-based for. std::set<const upb::FieldDef*> fielddefs; - for (const upb::FieldDef* f : *md) { + for (const upb::FieldDef* f : *md.get()) { AssertInsert(&fielddefs, f); - ASSERT(f->containing_type() == md); + ASSERT(f->containing_type() == md.get()); } ASSERT(fielddefs.size() == md->field_count()); #endif - s->Unref(&s); - md->Unref(&md); + ASSERT(md.get()); +} + +static void TestCasts1() { + upb::reffed_ptr<const upb::MessageDef> md(upb::MessageDef::New()); + const upb::Def* def = upb::upcast(md.get()); + const upb::MessageDef* md2 = upb::down_cast<const upb::MessageDef*>(def); + const upb::MessageDef* md3 = upb::dyn_cast<const upb::MessageDef*>(def); + + ASSERT(md.get() == md2); + ASSERT(md.get() == md3); + + const upb::EnumDef* ed = upb::dyn_cast<const upb::EnumDef*>(def); + ASSERT(!ed); +} + +static void TestCasts2() { + // Test mutable -> const cast. + upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New()); + upb::Def* def = upb::upcast(md.get()); + const upb::MessageDef* const_md = upb::down_cast<const upb::MessageDef*>(def); + ASSERT(const_md == md.get()); +} + +// +// Tests for registering and calling handlers in all their variants. +// This test code is very repetitive because we have to declare each +// handler function variant separately, and they all have different +// signatures so it does not lend itself well to templates. +// +// We test three handler types: +// StartMessage (no data params) +// Int32 (1 data param (int32_t)) +// String Buf (2 data params (const char*, size_t)) +// +// For each handler type we test all 8 handler variants: +// (handler data?) x (function/method) x (returns {void, success}) +// +// The one notable thing we don't test at the moment is +// StartSequence/StartString handlers: these are different from StartMessage() +// in that they return void* for the sub-closure. But this is exercised in +// other tests. +// + +static const int kExpectedHandlerData = 1232323; + +class StringBufTesterBase { + public: + static const upb::FieldDef::Type kFieldType = UPB_TYPE_STRING; + + 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)); + + ASSERT(!seen_); + upb::Sink sub; + sink->StartMessage(); + sink->StartString(start, 0, &sub); + sub.PutStringBuffer(str, NULL, 5); + ASSERT(seen_); + ASSERT(len_ == 5); + ASSERT(handler_data_val_ == kExpectedHandlerData); + } + + protected: + bool seen_; + int handler_data_val_; + size_t len_; +}; + +// Test all 8 combinations of: +// (handler data?) x (function/method) x (returns {void, size_t}) + +class StringBufTesterVoidFunctionNoHandlerData : public StringBufTesterBase { + public: + typedef StringBufTesterVoidFunctionNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStringHandler(f, UpbMakeHandler(&Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + static void Handler(ME* t, const char *buf, size_t len) { + t->seen_ = true; + t->len_ = len; + } +}; + +class StringBufTesterSizeTFunctionNoHandlerData : public StringBufTesterBase { + public: + typedef StringBufTesterSizeTFunctionNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStringHandler(f, UpbMakeHandler(&Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + static size_t Handler(ME* t, const char *buf, size_t len) { + t->seen_ = true; + t->len_ = len; + return len; + } +}; + +class StringBufTesterVoidMethodNoHandlerData : public StringBufTesterBase { + public: + typedef StringBufTesterVoidMethodNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + void Handler(const char *buf, size_t len) { + seen_ = true; + len_ = len; + } +}; + +class StringBufTesterSizeTMethodNoHandlerData : public StringBufTesterBase { + public: + typedef StringBufTesterSizeTMethodNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStringHandler(f, UpbMakeHandler(&ME::Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + size_t Handler(const char *buf, size_t len) { + seen_ = true; + len_ = len; + return len; + } +}; + +class StringBufTesterVoidFunctionWithHandlerData : public StringBufTesterBase { + public: + typedef StringBufTesterVoidFunctionWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStringHandler( + f, UpbBind(&Handler, new int(kExpectedHandlerData)))); + } + + private: + static void Handler(ME* t, const int* hd, const char *buf, size_t len) { + t->handler_data_val_ = *hd; + t->seen_ = true; + t->len_ = len; + } +}; + +class StringBufTesterSizeTFunctionWithHandlerData : public StringBufTesterBase { + public: + typedef StringBufTesterSizeTFunctionWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStringHandler( + f, UpbBind(&Handler, new int(kExpectedHandlerData)))); + } + + private: + static size_t Handler(ME* t, const int* hd, const char *buf, size_t len) { + t->handler_data_val_ = *hd; + t->seen_ = true; + t->len_ = len; + return len; + } +}; + +class StringBufTesterVoidMethodWithHandlerData : public StringBufTesterBase { + public: + typedef StringBufTesterVoidMethodWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStringHandler( + f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); + } + + private: + void Handler(const int* hd, const char *buf, size_t len) { + handler_data_val_ = *hd; + seen_ = true; + len_ = len; + } +}; + +class StringBufTesterSizeTMethodWithHandlerData : public StringBufTesterBase { + public: + typedef StringBufTesterSizeTMethodWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStringHandler( + f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); + } + + private: + size_t Handler(const int* hd, const char *buf, size_t len) { + handler_data_val_ = *hd; + seen_ = true; + len_ = len; + return len; + } +}; + +class StartMsgTesterBase { + public: + // We don't need the FieldDef it will create, but the test harness still + // requires that we provide one. + static const upb::FieldDef::Type kFieldType = UPB_TYPE_STRING; + + StartMsgTesterBase() : seen_(false), handler_data_val_(0) {} + + void CallAndVerify(upb::Sink* sink, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(!seen_); + sink->StartMessage(); + ASSERT(seen_); + ASSERT(handler_data_val_ == kExpectedHandlerData); + } + + protected: + bool seen_; + int handler_data_val_; +}; + +// Test all 8 combinations of: +// (handler data?) x (function/method) x (returns {void, bool}) + +class StartMsgTesterVoidFunctionNoHandlerData : public StartMsgTesterBase { + public: + typedef StartMsgTesterVoidFunctionNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + //static void Handler(ME* t) { + static void Handler(ME* t) { + t->seen_ = true; + } +}; + +class StartMsgTesterBoolFunctionNoHandlerData : public StartMsgTesterBase { + public: + typedef StartMsgTesterBoolFunctionNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + static bool Handler(ME* t) { + t->seen_ = true; + return true; + } +}; + +class StartMsgTesterVoidMethodNoHandlerData : public StartMsgTesterBase { + public: + typedef StartMsgTesterVoidMethodNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&ME::Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + void Handler() { + seen_ = true; + } +}; + +class StartMsgTesterBoolMethodNoHandlerData : public StartMsgTesterBase { + public: + typedef StartMsgTesterBoolMethodNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStartMessageHandler(UpbMakeHandler(&ME::Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + bool Handler() { + seen_ = true; + return true; + } +}; + +class StartMsgTesterVoidFunctionWithHandlerData : public StartMsgTesterBase { + public: + typedef StartMsgTesterVoidFunctionWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStartMessageHandler( + UpbBind(&Handler, new int(kExpectedHandlerData)))); + } + + private: + static void Handler(ME* t, const int* hd) { + t->handler_data_val_ = *hd; + t->seen_ = true; + } +}; + +class StartMsgTesterBoolFunctionWithHandlerData : public StartMsgTesterBase { + public: + typedef StartMsgTesterBoolFunctionWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStartMessageHandler( + UpbBind(&Handler, new int(kExpectedHandlerData)))); + } + + private: + static bool Handler(ME* t, const int* hd) { + t->handler_data_val_ = *hd; + t->seen_ = true; + return true; + } +}; + +class StartMsgTesterVoidMethodWithHandlerData : public StartMsgTesterBase { + public: + typedef StartMsgTesterVoidMethodWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStartMessageHandler( + UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); + } + + private: + void Handler(const int* hd) { + handler_data_val_ = *hd; + seen_ = true; + } +}; + +class StartMsgTesterBoolMethodWithHandlerData : public StartMsgTesterBase { + public: + typedef StartMsgTesterBoolMethodWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + UPB_UNUSED(f); + ASSERT(h->SetStartMessageHandler( + UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); + } + + private: + bool Handler(const int* hd) { + handler_data_val_ = *hd; + seen_ = true; + return true; + } +}; + +class Int32ValueTesterBase { + public: + static const upb::FieldDef::Type kFieldType = UPB_TYPE_INT32; + + 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)); + + ASSERT(!seen_); + sink->PutInt32(s, 5); + ASSERT(seen_); + ASSERT(handler_data_val_ == kExpectedHandlerData); + ASSERT(val_ == 5); + } + + protected: + bool seen_; + int32_t val_; + int handler_data_val_; +}; + +// Test all 8 combinations of: +// (handler data?) x (function/method) x (returns {void, bool}) + +class ValueTesterInt32VoidFunctionNoHandlerData + : public Int32ValueTesterBase { + public: + typedef ValueTesterInt32VoidFunctionNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + static void Handler(ME* t, int32_t val) { + t->val_ = val; + t->seen_ = true; + } +}; + +class ValueTesterInt32BoolFunctionNoHandlerData + : public Int32ValueTesterBase { + public: + typedef ValueTesterInt32BoolFunctionNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + static bool Handler(ME* t, int32_t val) { + t->val_ = val; + t->seen_ = true; + return true; + } +}; + +class ValueTesterInt32VoidMethodNoHandlerData : public Int32ValueTesterBase { + public: + typedef ValueTesterInt32VoidMethodNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&ME::Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + void Handler(int32_t val) { + val_ = val; + seen_ = true; + } +}; + +class ValueTesterInt32BoolMethodNoHandlerData : public Int32ValueTesterBase { + public: + typedef ValueTesterInt32BoolMethodNoHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + ASSERT(h->SetInt32Handler(f, UpbMakeHandler(&ME::Handler))); + handler_data_val_ = kExpectedHandlerData; + } + + private: + bool Handler(int32_t val) { + val_ = val; + seen_ = true; + return true; + } +}; + +class ValueTesterInt32VoidFunctionWithHandlerData + : public Int32ValueTesterBase { + public: + typedef ValueTesterInt32VoidFunctionWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + ASSERT(h->SetInt32Handler( + f, UpbBind(&Handler, new int(kExpectedHandlerData)))); + } + + private: + static void Handler(ME* t, const int* hd, int32_t val) { + t->val_ = val; + t->handler_data_val_ = *hd; + t->seen_ = true; + } +}; + +class ValueTesterInt32BoolFunctionWithHandlerData + : public Int32ValueTesterBase { + public: + typedef ValueTesterInt32BoolFunctionWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + ASSERT(h->SetInt32Handler( + f, UpbBind(&Handler, new int(kExpectedHandlerData)))); + } + + private: + static bool Handler(ME* t, const int* hd, int32_t val) { + t->val_ = val; + t->handler_data_val_ = *hd; + t->seen_ = true; + return true; + } +}; + +class ValueTesterInt32VoidMethodWithHandlerData : public Int32ValueTesterBase { + public: + typedef ValueTesterInt32VoidMethodWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + ASSERT(h->SetInt32Handler( + f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); + } + + private: + void Handler(const int* hd, int32_t val) { + val_ = val; + handler_data_val_ = *hd; + seen_ = true; + } +}; + +class ValueTesterInt32BoolMethodWithHandlerData : public Int32ValueTesterBase { + public: + typedef ValueTesterInt32BoolMethodWithHandlerData ME; + void Register(upb::Handlers* h, const upb::FieldDef* f) { + ASSERT(h->SetInt32Handler( + f, UpbBind(&ME::Handler, new int(kExpectedHandlerData)))); + } + + private: + bool Handler(const int* hd, int32_t val) { + val_ = val; + handler_data_val_ = *hd; + seen_ = true; + return true; + } +}; + +template <class T> +void TestHandler() { + upb::reffed_ptr<upb::MessageDef> md(upb::MessageDef::New()); + upb::reffed_ptr<upb::FieldDef> f(upb::FieldDef::New()); + f->set_type(T::kFieldType); + ASSERT(f->set_name("test", NULL)); + ASSERT(f->set_number(1, NULL)); + ASSERT(md->AddField(f, NULL)); + ASSERT(md->Freeze(NULL)); + + upb::reffed_ptr<upb::Handlers> h(upb::Handlers::New(md.get())); + T tester; + tester.Register(h.get(), f.get()); + ASSERT(h->Freeze(NULL)); + + upb::Sink sink(h.get(), &tester); + tester.CallAndVerify(&sink, f.get()); } extern "C" { @@ -84,8 +720,63 @@ int run_tests(int argc, char *argv[]) { return 1; } TestSymbolTable(argv[1]); + TestCastsUpDown(); TestCasts1(); TestCasts2(); + TestCastsConst0(); + TestCastsConst1(); + TestCastsConst2(); + TestCastsConst3(); + TestCastsConst4(); + TestCastsConst5(); + TestCastsConst6(); + TestCastsConst7(); + TestCastsConst8(); + TestCastsConst9(); + TestCastsConst10(); + + TestHandler<ValueTesterInt32VoidFunctionNoHandlerData>(); + TestHandler<ValueTesterInt32BoolFunctionNoHandlerData>(); + TestHandler<ValueTesterInt32VoidMethodNoHandlerData>(); + TestHandler<ValueTesterInt32BoolMethodNoHandlerData>(); + TestHandler<ValueTesterInt32VoidFunctionWithHandlerData>(); + TestHandler<ValueTesterInt32BoolFunctionWithHandlerData>(); + TestHandler<ValueTesterInt32VoidMethodWithHandlerData>(); + TestHandler<ValueTesterInt32BoolMethodWithHandlerData>(); + + TestHandler<StartMsgTesterVoidFunctionNoHandlerData>(); + TestHandler<StartMsgTesterBoolFunctionNoHandlerData>(); + TestHandler<StartMsgTesterVoidMethodNoHandlerData>(); + TestHandler<StartMsgTesterBoolMethodNoHandlerData>(); + TestHandler<StartMsgTesterVoidFunctionWithHandlerData>(); + TestHandler<StartMsgTesterBoolFunctionWithHandlerData>(); + TestHandler<StartMsgTesterVoidMethodWithHandlerData>(); + TestHandler<StartMsgTesterBoolMethodWithHandlerData>(); + + TestHandler<StringBufTesterVoidFunctionNoHandlerData>(); + TestHandler<StringBufTesterSizeTFunctionNoHandlerData>(); + TestHandler<StringBufTesterVoidMethodNoHandlerData>(); + TestHandler<StringBufTesterSizeTMethodNoHandlerData>(); + TestHandler<StringBufTesterVoidFunctionWithHandlerData>(); + TestHandler<StringBufTesterSizeTFunctionWithHandlerData>(); + TestHandler<StringBufTesterVoidMethodWithHandlerData>(); + TestHandler<StringBufTesterSizeTMethodWithHandlerData>(); + +#ifdef UPB_CXX11 +#define ASSERT_STD_LAYOUT(type) \ + static_assert(std::is_standard_layout<type>::value, \ + #type " must be standard layout"); + ASSERT_STD_LAYOUT(upb::RefCounted); + ASSERT_STD_LAYOUT(upb::Def); + ASSERT_STD_LAYOUT(upb::MessageDef); + ASSERT_STD_LAYOUT(upb::FieldDef); + ASSERT_STD_LAYOUT(upb::EnumDef); + ASSERT_STD_LAYOUT(upb::Handlers); + ASSERT_STD_LAYOUT(upb::SymbolTable); + ASSERT_STD_LAYOUT(upb::pb::Decoder); + ASSERT_STD_LAYOUT(upb::descriptor::Reader); +#endif + return 0; } |