From 00ba0d1ac17be08879675e5c1c61ea73e331f9ea Mon Sep 17 00:00:00 2001 From: Joshua Haberman Date: Sun, 30 Aug 2009 20:07:00 -0700 Subject: Unit test comparing parsed results with proto2. --- tests/test_vs_proto2.cc | 220 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 220 insertions(+) create mode 100644 tests/test_vs_proto2.cc (limited to 'tests') diff --git a/tests/test_vs_proto2.cc b/tests/test_vs_proto2.cc new file mode 100644 index 0000000..e284100 --- /dev/null +++ b/tests/test_vs_proto2.cc @@ -0,0 +1,220 @@ + +#undef NDEBUG /* ensure tests always assert. */ +#include +#include +#include +#include +#include "upb_parse.h" +#include "upb_context.h" +#include "upb_context.h" +#include "upb_msg.h" +#include "upb_mm.h" + +int num_assertions = 0; +#define ASSERT(expr) do { \ + ++num_assertions; \ + assert(expr); \ + } while(0) + +#include MESSAGE_HFILE + +void compare(const google::protobuf::Message& proto2_msg, + struct upb_msg *upb_msg); + +void compare_arrays(const google::protobuf::Reflection *r, + const google::protobuf::Message& proto2_msg, + const google::protobuf::FieldDescriptor *proto2_f, + struct upb_msg *upb_msg, struct upb_msg_fielddef *upb_f) +{ + struct upb_array *arr = *upb_msg_getptr(upb_msg, upb_f).arr; + ASSERT(arr->len == (upb_arraylen_t)r->FieldSize(proto2_msg, proto2_f)); + for(upb_arraylen_t i = 0; i < arr->len; i++) { + union upb_value_ptr p = upb_array_getelementptr(arr, i); + switch(upb_f->type) { + default: + ASSERT(false); + case UPB_TYPENUM(DOUBLE): + ASSERT(r->GetRepeatedDouble(proto2_msg, proto2_f, i) == *p._double); + break; + case UPB_TYPENUM(FLOAT): + ASSERT(r->GetRepeatedFloat(proto2_msg, proto2_f, i) == *p._float); + break; + case UPB_TYPENUM(INT64): + case UPB_TYPENUM(SINT64): + case UPB_TYPENUM(SFIXED64): + ASSERT(r->GetRepeatedInt64(proto2_msg, proto2_f, i) == *p.int64); + break; + case UPB_TYPENUM(UINT64): + case UPB_TYPENUM(FIXED64): + ASSERT(r->GetRepeatedUInt64(proto2_msg, proto2_f, i) == *p.uint64); + break; + case UPB_TYPENUM(SFIXED32): + case UPB_TYPENUM(SINT32): + case UPB_TYPENUM(INT32): + case UPB_TYPENUM(ENUM): + ASSERT(r->GetRepeatedInt32(proto2_msg, proto2_f, i) == *p.int32); + break; + case UPB_TYPENUM(FIXED32): + case UPB_TYPENUM(UINT32): + ASSERT(r->GetRepeatedUInt32(proto2_msg, proto2_f, i) == *p.uint32); + break; + case UPB_TYPENUM(BOOL): + ASSERT(r->GetRepeatedBool(proto2_msg, proto2_f, i) == *p._bool); + break; + case UPB_TYPENUM(STRING): + case UPB_TYPENUM(BYTES): { + std::string str = r->GetRepeatedString(proto2_msg, proto2_f, i); + std::string str2((*p.str)->ptr, (*p.str)->byte_len); + ASSERT(str == str2); + break; + } + case UPB_TYPENUM(GROUP): + case UPB_TYPENUM(MESSAGE): + compare(r->GetRepeatedMessage(proto2_msg, proto2_f, i), *p.msg); + } + } +} + +void compare_values(const google::protobuf::Reflection *r, + const google::protobuf::Message& proto2_msg, + const google::protobuf::FieldDescriptor *proto2_f, + struct upb_msg *upb_msg, struct upb_msg_fielddef *upb_f) +{ + union upb_value_ptr p = upb_msg_getptr(upb_msg, upb_f); + switch(upb_f->type) { + default: + ASSERT(false); + case UPB_TYPENUM(DOUBLE): + ASSERT(r->GetDouble(proto2_msg, proto2_f) == *p._double); + break; + case UPB_TYPENUM(FLOAT): + ASSERT(r->GetFloat(proto2_msg, proto2_f) == *p._float); + break; + case UPB_TYPENUM(INT64): + case UPB_TYPENUM(SINT64): + case UPB_TYPENUM(SFIXED64): + ASSERT(r->GetInt64(proto2_msg, proto2_f) == *p.int64); + break; + case UPB_TYPENUM(UINT64): + case UPB_TYPENUM(FIXED64): + ASSERT(r->GetUInt64(proto2_msg, proto2_f) == *p.uint64); + break; + case UPB_TYPENUM(SFIXED32): + case UPB_TYPENUM(SINT32): + case UPB_TYPENUM(INT32): + case UPB_TYPENUM(ENUM): + ASSERT(r->GetInt32(proto2_msg, proto2_f) == *p.int32); + break; + case UPB_TYPENUM(FIXED32): + case UPB_TYPENUM(UINT32): + ASSERT(r->GetUInt32(proto2_msg, proto2_f) == *p.uint32); + break; + case UPB_TYPENUM(BOOL): + ASSERT(r->GetBool(proto2_msg, proto2_f) == *p._bool); + break; + case UPB_TYPENUM(STRING): + case UPB_TYPENUM(BYTES): { + std::string str = r->GetString(proto2_msg, proto2_f); + std::string str2((*p.str)->ptr, (*p.str)->byte_len); + ASSERT(str == str2); + break; + } + case UPB_TYPENUM(GROUP): + case UPB_TYPENUM(MESSAGE): + compare(r->GetMessage(proto2_msg, proto2_f), *p.msg); + } +} + +void compare(const google::protobuf::Message& proto2_msg, + struct upb_msg *upb_msg) +{ + const google::protobuf::Reflection *r = proto2_msg.GetReflection(); + const google::protobuf::Descriptor *d = proto2_msg.GetDescriptor(); + struct upb_msgdef *def = upb_msg->def; + + ASSERT((uint32_t)d->field_count() == def->num_fields); + for(uint32_t i = 0; i < def->num_fields; i++) { + struct upb_msg_fielddef *upb_f = &def->fields[i]; + struct google_protobuf_FieldDescriptorProto *upb_fd = + upb_msg_field_descriptor(upb_f, def); + const google::protobuf::FieldDescriptor *proto2_f = + d->FindFieldByNumber(upb_fd->number); + // Make sure the definitions are equal. + ASSERT(upb_f); + ASSERT(upb_fd); + ASSERT(proto2_f); + ASSERT(upb_fd->number == proto2_f->number()); + ASSERT(std::string(upb_fd->name->ptr, upb_fd->name->byte_len) == + proto2_f->name()); + ASSERT(upb_fd->type == proto2_f->type()); + ASSERT(upb_isarray(upb_f) == proto2_f->is_repeated()); + + if(!upb_msg_isset(upb_msg, upb_f)) { + if(upb_isarray(upb_f)) + ASSERT(r->FieldSize(proto2_msg, proto2_f) == 0); + else + ASSERT(r->HasField(proto2_msg, proto2_f) == false); + } else { + if(upb_isarray(upb_f)) + compare_arrays(r, proto2_msg, proto2_f, upb_msg, upb_f); + else + compare_values(r, proto2_msg, proto2_f, upb_msg, upb_f); + } + } +} + +void parse_and_compare(MESSAGE_CIDENT *proto2_msg, struct upb_msg *upb_msg, + struct upb_string *str) +{ + // Parse to both proto2 and upb. + ASSERT(proto2_msg->ParseFromArray(str->ptr, str->byte_len)); + ASSERT(upb_msg_parsestr(upb_msg, str->ptr, str->byte_len) == UPB_STATUS_OK); + compare(*proto2_msg, upb_msg); +} + +int main() +{ + // Initialize upb state, parse descriptor. + struct upb_context *c = upb_context_new(); + struct upb_string *fds = upb_strreadfile(MESSAGE_DESCRIPTOR_FILE); + if(!fds) { + fprintf(stderr, "Couldn't read " MESSAGE_DESCRIPTOR_FILE ".\n"); + return 1; + } + if(!upb_context_parsefds(c, fds)) { + fprintf(stderr, "Error importing " MESSAGE_DESCRIPTOR_FILE ".\n"); + return 1; + } + upb_string_unref(fds); + + struct upb_string *proto_name = upb_strdupc(MESSAGE_NAME); + struct upb_symtab_entry e; + bool success = upb_context_lookup(c, proto_name, &e); + if(!success || e.type != UPB_SYM_MESSAGE) { + fprintf(stderr, "Error finding symbol '" UPB_STRFMT "'.\n", + UPB_STRARG(proto_name)); + return 1; + } + upb_string_unref(proto_name); + struct upb_msgdef *def = e.ref.msg; + + // Read the message data itself. + struct upb_string *str = upb_strreadfile(MESSAGE_FILE); + if(!str) { + fprintf(stderr, "Error reading " MESSAGE_FILE "\n"); + return 1; + } + + // Run twice to test proper object reuse. + MESSAGE_CIDENT proto2_msg; + struct upb_msg *upb_msg = upb_msg_new(def); + parse_and_compare(&proto2_msg, upb_msg, str); + parse_and_compare(&proto2_msg, upb_msg, str); + printf("All tests passed, %d assertions.\n", num_assertions); + + upb_msg_unref(upb_msg); + upb_string_unref(str); + upb_context_unref(c); + + return 0; +} -- cgit v1.2.3