Merge pull request #2701 from anandolee/master
Add csharp compatibility tests against v3.0.0pull/2814/head
Jie Luo
8 years ago
committed by
GitHub
commit
3f6f73b796
37 changed files with 7893 additions and 1 deletions
@ -0,0 +1,126 @@ |
|||||||
|
syntax = "proto3"; |
||||||
|
|
||||||
|
// These proto descriptors have at one time been reported as an issue or defect. |
||||||
|
// They are kept here to replicate the issue, and continue to verify the fix. |
||||||
|
|
||||||
|
// Issue: Non-"Google.Protobuffers" namespace will ensure that protobuffer library types are qualified |
||||||
|
option csharp_namespace = "UnitTest.Issues.TestProtos"; |
||||||
|
|
||||||
|
package unittest_issues; |
||||||
|
option optimize_for = SPEED; |
||||||
|
|
||||||
|
// Issue 307: when generating doubly-nested types, any references |
||||||
|
// should be of the form A.Types.B.Types.C. |
||||||
|
message Issue307 { |
||||||
|
message NestedOnce { |
||||||
|
message NestedTwice { |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Old issue 13: http://code.google.com/p/protobuf-csharp-port/issues/detail?id=13 |
||||||
|
// New issue 309: https://github.com/google/protobuf/issues/309 |
||||||
|
|
||||||
|
// message A { |
||||||
|
// optional int32 _A = 1; |
||||||
|
// } |
||||||
|
|
||||||
|
// message B { |
||||||
|
// optional int32 B_ = 1; |
||||||
|
// } |
||||||
|
|
||||||
|
//message AB { |
||||||
|
// optional int32 a_b = 1; |
||||||
|
//} |
||||||
|
|
||||||
|
// Similar issue with numeric names |
||||||
|
// Java code failed too, so probably best for this to be a restriction. |
||||||
|
// See https://github.com/google/protobuf/issues/308 |
||||||
|
// message NumberField { |
||||||
|
// optional int32 _01 = 1; |
||||||
|
// } |
||||||
|
|
||||||
|
// issue 19 - negative enum values |
||||||
|
|
||||||
|
enum NegativeEnum { |
||||||
|
NEGATIVE_ENUM_ZERO = 0; |
||||||
|
FiveBelow = -5; |
||||||
|
MinusOne = -1; |
||||||
|
} |
||||||
|
|
||||||
|
message NegativeEnumMessage { |
||||||
|
NegativeEnum value = 1; |
||||||
|
repeated NegativeEnum values = 2 [packed = false]; |
||||||
|
repeated NegativeEnum packed_values = 3 [packed=true]; |
||||||
|
} |
||||||
|
|
||||||
|
// Issue 21: http://code.google.com/p/protobuf-csharp-port/issues/detail?id=21 |
||||||
|
// Decorate fields with [deprecated=true] as [System.Obsolete] |
||||||
|
|
||||||
|
message DeprecatedChild { |
||||||
|
} |
||||||
|
|
||||||
|
enum DeprecatedEnum { |
||||||
|
DEPRECATED_ZERO = 0; |
||||||
|
one = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message DeprecatedFieldsMessage { |
||||||
|
int32 PrimitiveValue = 1 [deprecated = true]; |
||||||
|
repeated int32 PrimitiveArray = 2 [deprecated = true]; |
||||||
|
|
||||||
|
DeprecatedChild MessageValue = 3 [deprecated = true]; |
||||||
|
repeated DeprecatedChild MessageArray = 4 [deprecated = true]; |
||||||
|
|
||||||
|
DeprecatedEnum EnumValue = 5 [deprecated = true]; |
||||||
|
repeated DeprecatedEnum EnumArray = 6 [deprecated = true]; |
||||||
|
} |
||||||
|
|
||||||
|
// Issue 45: http://code.google.com/p/protobuf-csharp-port/issues/detail?id=45 |
||||||
|
message ItemField { |
||||||
|
int32 item = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message ReservedNames { |
||||||
|
// Force a nested type called Types |
||||||
|
message SomeNestedType { |
||||||
|
} |
||||||
|
|
||||||
|
int32 types = 1; |
||||||
|
int32 descriptor = 2; |
||||||
|
} |
||||||
|
|
||||||
|
message TestJsonFieldOrdering { |
||||||
|
// These fields are deliberately not declared in numeric |
||||||
|
// order, and the oneof fields aren't contiguous either. |
||||||
|
// This allows for reasonably robust tests of JSON output |
||||||
|
// ordering. |
||||||
|
// TestFieldOrderings in unittest_proto3.proto is similar, |
||||||
|
// but doesn't include oneofs. |
||||||
|
// TODO: Consider adding oneofs to TestFieldOrderings, although |
||||||
|
// that will require fixing other tests in multiple platforms. |
||||||
|
// Alternatively, consider just adding this to |
||||||
|
// unittest_proto3.proto if multiple platforms want it. |
||||||
|
|
||||||
|
int32 plain_int32 = 4; |
||||||
|
|
||||||
|
oneof o1 { |
||||||
|
string o1_string = 2; |
||||||
|
int32 o1_int32 = 5; |
||||||
|
} |
||||||
|
|
||||||
|
string plain_string = 1; |
||||||
|
|
||||||
|
oneof o2 { |
||||||
|
int32 o2_int32 = 6; |
||||||
|
string o2_string = 3; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
message TestJsonName { |
||||||
|
// Message for testing the effects for of the json_name option |
||||||
|
string name = 1; |
||||||
|
string description = 2 [json_name = "desc"]; |
||||||
|
string guid = 3 [json_name = "exid"]; |
||||||
|
} |
||||||
@ -0,0 +1,120 @@ |
|||||||
|
// Protocol Buffers - Google's data interchange format |
||||||
|
// Copyright 2008 Google Inc. All rights reserved. |
||||||
|
// https://developers.google.com/protocol-buffers/ |
||||||
|
// |
||||||
|
// Redistribution and use in source and binary forms, with or without |
||||||
|
// modification, are permitted provided that the following conditions are |
||||||
|
// met: |
||||||
|
// |
||||||
|
// * Redistributions of source code must retain the above copyright |
||||||
|
// notice, this list of conditions and the following disclaimer. |
||||||
|
// * Redistributions in binary form must reproduce the above |
||||||
|
// copyright notice, this list of conditions and the following disclaimer |
||||||
|
// in the documentation and/or other materials provided with the |
||||||
|
// distribution. |
||||||
|
// * Neither the name of Google Inc. nor the names of its |
||||||
|
// contributors may be used to endorse or promote products derived from |
||||||
|
// this software without specific prior written permission. |
||||||
|
// |
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
|
||||||
|
// This file is mostly equivalent to map_unittest.proto, but imports |
||||||
|
// unittest_proto3.proto instead of unittest.proto, so that it only |
||||||
|
// uses proto3 messages. This makes it suitable for testing |
||||||
|
// implementations which only support proto3. |
||||||
|
// The TestRequiredMessageMap message has been removed as there are no |
||||||
|
// required fields in proto3. |
||||||
|
syntax = "proto3"; |
||||||
|
|
||||||
|
option cc_enable_arenas = true; |
||||||
|
option csharp_namespace = "Google.Protobuf.TestProtos"; |
||||||
|
|
||||||
|
import "google/protobuf/unittest_proto3.proto"; |
||||||
|
|
||||||
|
// We don't put this in a package within proto2 because we need to make sure |
||||||
|
// that the generated code doesn't depend on being in the proto2 namespace. |
||||||
|
// In map_test_util.h we do "using namespace unittest = protobuf_unittest". |
||||||
|
package protobuf_unittest; |
||||||
|
|
||||||
|
// Tests maps. |
||||||
|
message TestMap { |
||||||
|
map<int32 , int32 > map_int32_int32 = 1; |
||||||
|
map<int64 , int64 > map_int64_int64 = 2; |
||||||
|
map<uint32 , uint32 > map_uint32_uint32 = 3; |
||||||
|
map<uint64 , uint64 > map_uint64_uint64 = 4; |
||||||
|
map<sint32 , sint32 > map_sint32_sint32 = 5; |
||||||
|
map<sint64 , sint64 > map_sint64_sint64 = 6; |
||||||
|
map<fixed32 , fixed32 > map_fixed32_fixed32 = 7; |
||||||
|
map<fixed64 , fixed64 > map_fixed64_fixed64 = 8; |
||||||
|
map<sfixed32, sfixed32> map_sfixed32_sfixed32 = 9; |
||||||
|
map<sfixed64, sfixed64> map_sfixed64_sfixed64 = 10; |
||||||
|
map<int32 , float > map_int32_float = 11; |
||||||
|
map<int32 , double > map_int32_double = 12; |
||||||
|
map<bool , bool > map_bool_bool = 13; |
||||||
|
map<string , string > map_string_string = 14; |
||||||
|
map<int32 , bytes > map_int32_bytes = 15; |
||||||
|
map<int32 , MapEnum > map_int32_enum = 16; |
||||||
|
map<int32 , ForeignMessage> map_int32_foreign_message = 17; |
||||||
|
} |
||||||
|
|
||||||
|
message TestMapSubmessage { |
||||||
|
TestMap test_map = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message TestMessageMap { |
||||||
|
map<int32, TestAllTypes> map_int32_message = 1; |
||||||
|
} |
||||||
|
|
||||||
|
// Two map fields share the same entry default instance. |
||||||
|
message TestSameTypeMap { |
||||||
|
map<int32, int32> map1 = 1; |
||||||
|
map<int32, int32> map2 = 2; |
||||||
|
} |
||||||
|
|
||||||
|
enum MapEnum { |
||||||
|
MAP_ENUM_FOO = 0; |
||||||
|
MAP_ENUM_BAR = 1; |
||||||
|
MAP_ENUM_BAZ = 2; |
||||||
|
} |
||||||
|
|
||||||
|
message TestArenaMap { |
||||||
|
map<int32 , int32 > map_int32_int32 = 1; |
||||||
|
map<int64 , int64 > map_int64_int64 = 2; |
||||||
|
map<uint32 , uint32 > map_uint32_uint32 = 3; |
||||||
|
map<uint64 , uint64 > map_uint64_uint64 = 4; |
||||||
|
map<sint32 , sint32 > map_sint32_sint32 = 5; |
||||||
|
map<sint64 , sint64 > map_sint64_sint64 = 6; |
||||||
|
map<fixed32 , fixed32 > map_fixed32_fixed32 = 7; |
||||||
|
map<fixed64 , fixed64 > map_fixed64_fixed64 = 8; |
||||||
|
map<sfixed32, sfixed32> map_sfixed32_sfixed32 = 9; |
||||||
|
map<sfixed64, sfixed64> map_sfixed64_sfixed64 = 10; |
||||||
|
map<int32 , float > map_int32_float = 11; |
||||||
|
map<int32 , double > map_int32_double = 12; |
||||||
|
map<bool , bool > map_bool_bool = 13; |
||||||
|
map<int32 , MapEnum > map_int32_enum = 14; |
||||||
|
map<int32 , ForeignMessage> map_int32_foreign_message = 15; |
||||||
|
} |
||||||
|
|
||||||
|
// Previously, message containing enum called Type cannot be used as value of |
||||||
|
// map field. |
||||||
|
message MessageContainingEnumCalledType { |
||||||
|
enum Type { |
||||||
|
TYPE_FOO = 0; |
||||||
|
} |
||||||
|
map<int32, MessageContainingEnumCalledType> type = 1; |
||||||
|
} |
||||||
|
|
||||||
|
// Previously, message cannot contain map field called "entry". |
||||||
|
message MessageContainingMapCalledEntry { |
||||||
|
map<int32, int32> entry = 1; |
||||||
|
} |
||||||
@ -0,0 +1,68 @@ |
|||||||
|
// Protocol Buffers - Google's data interchange format |
||||||
|
// Copyright 2008 Google Inc. All rights reserved. |
||||||
|
// https://developers.google.com/protocol-buffers/ |
||||||
|
// |
||||||
|
// Redistribution and use in source and binary forms, with or without |
||||||
|
// modification, are permitted provided that the following conditions are |
||||||
|
// met: |
||||||
|
// |
||||||
|
// * Redistributions of source code must retain the above copyright |
||||||
|
// notice, this list of conditions and the following disclaimer. |
||||||
|
// * Redistributions in binary form must reproduce the above |
||||||
|
// copyright notice, this list of conditions and the following disclaimer |
||||||
|
// in the documentation and/or other materials provided with the |
||||||
|
// distribution. |
||||||
|
// * Neither the name of Google Inc. nor the names of its |
||||||
|
// contributors may be used to endorse or promote products derived from |
||||||
|
// this software without specific prior written permission. |
||||||
|
// |
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
|
||||||
|
// Author: kenton@google.com (Kenton Varda) |
||||||
|
// Based on original Protocol Buffers design by |
||||||
|
// Sanjay Ghemawat, Jeff Dean, and others. |
||||||
|
// |
||||||
|
// A proto file which is imported by unittest_proto3.proto to test importing. |
||||||
|
|
||||||
|
syntax = "proto3"; |
||||||
|
|
||||||
|
// We don't put this in a package within proto2 because we need to make sure |
||||||
|
// that the generated code doesn't depend on being in the proto2 namespace. |
||||||
|
// In test_util.h we do |
||||||
|
// "using namespace unittest_import = protobuf_unittest_import". |
||||||
|
package protobuf_unittest_import; |
||||||
|
|
||||||
|
option optimize_for = SPEED; |
||||||
|
option cc_enable_arenas = true; |
||||||
|
|
||||||
|
// Exercise the java_package option. |
||||||
|
option java_package = "com.google.protobuf.test"; |
||||||
|
option csharp_namespace = "Google.Protobuf.TestProtos"; |
||||||
|
|
||||||
|
// Do not set a java_outer_classname here to verify that Proto2 works without |
||||||
|
// one. |
||||||
|
|
||||||
|
// Test public import |
||||||
|
import public "google/protobuf/unittest_import_public_proto3.proto"; |
||||||
|
|
||||||
|
message ImportMessage { |
||||||
|
int32 d = 1; |
||||||
|
} |
||||||
|
|
||||||
|
enum ImportEnum { |
||||||
|
IMPORT_ENUM_UNSPECIFIED = 0; |
||||||
|
IMPORT_FOO = 7; |
||||||
|
IMPORT_BAR = 8; |
||||||
|
IMPORT_BAZ = 9; |
||||||
|
} |
||||||
|
|
||||||
@ -0,0 +1,42 @@ |
|||||||
|
// Protocol Buffers - Google's data interchange format |
||||||
|
// Copyright 2008 Google Inc. All rights reserved. |
||||||
|
// https://developers.google.com/protocol-buffers/ |
||||||
|
// |
||||||
|
// Redistribution and use in source and binary forms, with or without |
||||||
|
// modification, are permitted provided that the following conditions are |
||||||
|
// met: |
||||||
|
// |
||||||
|
// * Redistributions of source code must retain the above copyright |
||||||
|
// notice, this list of conditions and the following disclaimer. |
||||||
|
// * Redistributions in binary form must reproduce the above |
||||||
|
// copyright notice, this list of conditions and the following disclaimer |
||||||
|
// in the documentation and/or other materials provided with the |
||||||
|
// distribution. |
||||||
|
// * Neither the name of Google Inc. nor the names of its |
||||||
|
// contributors may be used to endorse or promote products derived from |
||||||
|
// this software without specific prior written permission. |
||||||
|
// |
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
|
||||||
|
// Author: liujisi@google.com (Pherl Liu) |
||||||
|
|
||||||
|
syntax = "proto3"; |
||||||
|
|
||||||
|
package protobuf_unittest_import; |
||||||
|
|
||||||
|
option java_package = "com.google.protobuf.test"; |
||||||
|
option csharp_namespace = "Google.Protobuf.TestProtos"; |
||||||
|
|
||||||
|
message PublicImportMessage { |
||||||
|
int32 e = 1; |
||||||
|
} |
||||||
@ -0,0 +1,388 @@ |
|||||||
|
// Protocol Buffers - Google's data interchange format |
||||||
|
// Copyright 2008 Google Inc. All rights reserved. |
||||||
|
// https://developers.google.com/protocol-buffers/ |
||||||
|
// |
||||||
|
// Redistribution and use in source and binary forms, with or without |
||||||
|
// modification, are permitted provided that the following conditions are |
||||||
|
// met: |
||||||
|
// |
||||||
|
// * Redistributions of source code must retain the above copyright |
||||||
|
// notice, this list of conditions and the following disclaimer. |
||||||
|
// * Redistributions in binary form must reproduce the above |
||||||
|
// copyright notice, this list of conditions and the following disclaimer |
||||||
|
// in the documentation and/or other materials provided with the |
||||||
|
// distribution. |
||||||
|
// * Neither the name of Google Inc. nor the names of its |
||||||
|
// contributors may be used to endorse or promote products derived from |
||||||
|
// this software without specific prior written permission. |
||||||
|
// |
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
|
||||||
|
// Author: kenton@google.com (Kenton Varda) |
||||||
|
// Based on original Protocol Buffers design by |
||||||
|
// Sanjay Ghemawat, Jeff Dean, and others. |
||||||
|
// |
||||||
|
// A proto file we will use for unit testing. |
||||||
|
|
||||||
|
syntax = "proto3"; |
||||||
|
|
||||||
|
// Some generic_services option(s) added automatically. |
||||||
|
// See: http://go/proto2-generic-services-default |
||||||
|
option cc_generic_services = true; // auto-added |
||||||
|
option java_generic_services = true; // auto-added |
||||||
|
option py_generic_services = true; // auto-added |
||||||
|
option cc_enable_arenas = true; |
||||||
|
option csharp_namespace = "Google.Protobuf.TestProtos"; |
||||||
|
|
||||||
|
import "google/protobuf/unittest_import_proto3.proto"; |
||||||
|
|
||||||
|
// We don't put this in a package within proto2 because we need to make sure |
||||||
|
// that the generated code doesn't depend on being in the proto2 namespace. |
||||||
|
// In test_util.h we do "using namespace unittest = protobuf_unittest". |
||||||
|
package protobuf_unittest; |
||||||
|
|
||||||
|
// Protos optimized for SPEED use a strict superset of the generated code |
||||||
|
// of equivalent ones optimized for CODE_SIZE, so we should optimize all our |
||||||
|
// tests for speed unless explicitly testing code size optimization. |
||||||
|
option optimize_for = SPEED; |
||||||
|
|
||||||
|
option java_outer_classname = "UnittestProto"; |
||||||
|
|
||||||
|
// This proto includes every type of field in both singular and repeated |
||||||
|
// forms. |
||||||
|
message TestAllTypes { |
||||||
|
message NestedMessage { |
||||||
|
// The field name "b" fails to compile in proto1 because it conflicts with |
||||||
|
// a local variable named "b" in one of the generated methods. Doh. |
||||||
|
// This file needs to compile in proto1 to test backwards-compatibility. |
||||||
|
int32 bb = 1; |
||||||
|
} |
||||||
|
|
||||||
|
enum NestedEnum { |
||||||
|
NESTED_ENUM_UNSPECIFIED = 0; |
||||||
|
FOO = 1; |
||||||
|
BAR = 2; |
||||||
|
BAZ = 3; |
||||||
|
NEG = -1; // Intentionally negative. |
||||||
|
} |
||||||
|
|
||||||
|
// Singular |
||||||
|
int32 single_int32 = 1; |
||||||
|
int64 single_int64 = 2; |
||||||
|
uint32 single_uint32 = 3; |
||||||
|
uint64 single_uint64 = 4; |
||||||
|
sint32 single_sint32 = 5; |
||||||
|
sint64 single_sint64 = 6; |
||||||
|
fixed32 single_fixed32 = 7; |
||||||
|
fixed64 single_fixed64 = 8; |
||||||
|
sfixed32 single_sfixed32 = 9; |
||||||
|
sfixed64 single_sfixed64 = 10; |
||||||
|
float single_float = 11; |
||||||
|
double single_double = 12; |
||||||
|
bool single_bool = 13; |
||||||
|
string single_string = 14; |
||||||
|
bytes single_bytes = 15; |
||||||
|
|
||||||
|
NestedMessage single_nested_message = 18; |
||||||
|
ForeignMessage single_foreign_message = 19; |
||||||
|
protobuf_unittest_import.ImportMessage single_import_message = 20; |
||||||
|
|
||||||
|
NestedEnum single_nested_enum = 21; |
||||||
|
ForeignEnum single_foreign_enum = 22; |
||||||
|
protobuf_unittest_import.ImportEnum single_import_enum = 23; |
||||||
|
|
||||||
|
// Defined in unittest_import_public.proto |
||||||
|
protobuf_unittest_import.PublicImportMessage |
||||||
|
single_public_import_message = 26; |
||||||
|
|
||||||
|
// Repeated |
||||||
|
repeated int32 repeated_int32 = 31; |
||||||
|
repeated int64 repeated_int64 = 32; |
||||||
|
repeated uint32 repeated_uint32 = 33; |
||||||
|
repeated uint64 repeated_uint64 = 34; |
||||||
|
repeated sint32 repeated_sint32 = 35; |
||||||
|
repeated sint64 repeated_sint64 = 36; |
||||||
|
repeated fixed32 repeated_fixed32 = 37; |
||||||
|
repeated fixed64 repeated_fixed64 = 38; |
||||||
|
repeated sfixed32 repeated_sfixed32 = 39; |
||||||
|
repeated sfixed64 repeated_sfixed64 = 40; |
||||||
|
repeated float repeated_float = 41; |
||||||
|
repeated double repeated_double = 42; |
||||||
|
repeated bool repeated_bool = 43; |
||||||
|
repeated string repeated_string = 44; |
||||||
|
repeated bytes repeated_bytes = 45; |
||||||
|
|
||||||
|
repeated NestedMessage repeated_nested_message = 48; |
||||||
|
repeated ForeignMessage repeated_foreign_message = 49; |
||||||
|
repeated protobuf_unittest_import.ImportMessage repeated_import_message = 50; |
||||||
|
|
||||||
|
repeated NestedEnum repeated_nested_enum = 51; |
||||||
|
repeated ForeignEnum repeated_foreign_enum = 52; |
||||||
|
repeated protobuf_unittest_import.ImportEnum repeated_import_enum = 53; |
||||||
|
// Defined in unittest_import_public.proto |
||||||
|
repeated protobuf_unittest_import.PublicImportMessage |
||||||
|
repeated_public_import_message = 54; |
||||||
|
|
||||||
|
// For oneof test |
||||||
|
oneof oneof_field { |
||||||
|
uint32 oneof_uint32 = 111; |
||||||
|
NestedMessage oneof_nested_message = 112; |
||||||
|
string oneof_string = 113; |
||||||
|
bytes oneof_bytes = 114; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// This proto includes a recusively nested message. |
||||||
|
message NestedTestAllTypes { |
||||||
|
NestedTestAllTypes child = 1; |
||||||
|
TestAllTypes payload = 2; |
||||||
|
repeated NestedTestAllTypes repeated_child = 3; |
||||||
|
} |
||||||
|
|
||||||
|
message TestDeprecatedFields { |
||||||
|
int32 deprecated_int32 = 1 [deprecated=true]; |
||||||
|
} |
||||||
|
|
||||||
|
// Define these after TestAllTypes to make sure the compiler can handle |
||||||
|
// that. |
||||||
|
message ForeignMessage { |
||||||
|
int32 c = 1; |
||||||
|
} |
||||||
|
|
||||||
|
enum ForeignEnum { |
||||||
|
FOREIGN_UNSPECIFIED = 0; |
||||||
|
FOREIGN_FOO = 4; |
||||||
|
FOREIGN_BAR = 5; |
||||||
|
FOREIGN_BAZ = 6; |
||||||
|
} |
||||||
|
|
||||||
|
message TestReservedFields { |
||||||
|
reserved 2, 15, 9 to 11; |
||||||
|
reserved "bar", "baz"; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
// Test that we can use NestedMessage from outside TestAllTypes. |
||||||
|
message TestForeignNested { |
||||||
|
TestAllTypes.NestedMessage foreign_nested = 1; |
||||||
|
} |
||||||
|
|
||||||
|
// Test that really large tag numbers don't break anything. |
||||||
|
message TestReallyLargeTagNumber { |
||||||
|
// The largest possible tag number is 2^28 - 1, since the wire format uses |
||||||
|
// three bits to communicate wire type. |
||||||
|
int32 a = 1; |
||||||
|
int32 bb = 268435455; |
||||||
|
} |
||||||
|
|
||||||
|
message TestRecursiveMessage { |
||||||
|
TestRecursiveMessage a = 1; |
||||||
|
int32 i = 2; |
||||||
|
} |
||||||
|
|
||||||
|
// Test that mutual recursion works. |
||||||
|
message TestMutualRecursionA { |
||||||
|
TestMutualRecursionB bb = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message TestMutualRecursionB { |
||||||
|
TestMutualRecursionA a = 1; |
||||||
|
int32 optional_int32 = 2; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
// Test an enum that has multiple values with the same number. |
||||||
|
enum TestEnumWithDupValue { |
||||||
|
TEST_ENUM_WITH_DUP_VALUE_UNSPECIFIED = 0; |
||||||
|
option allow_alias = true; |
||||||
|
|
||||||
|
FOO1 = 1; |
||||||
|
BAR1 = 2; |
||||||
|
BAZ = 3; |
||||||
|
FOO2 = 1; |
||||||
|
BAR2 = 2; |
||||||
|
} |
||||||
|
|
||||||
|
// Test an enum with large, unordered values. |
||||||
|
enum TestSparseEnum { |
||||||
|
TEST_SPARSE_ENUM_UNSPECIFIED = 0; |
||||||
|
SPARSE_A = 123; |
||||||
|
SPARSE_B = 62374; |
||||||
|
SPARSE_C = 12589234; |
||||||
|
SPARSE_D = -15; |
||||||
|
SPARSE_E = -53452; |
||||||
|
// In proto3, value 0 must be the first one specified |
||||||
|
// SPARSE_F = 0; |
||||||
|
SPARSE_G = 2; |
||||||
|
} |
||||||
|
|
||||||
|
// Test message with CamelCase field names. This violates Protocol Buffer |
||||||
|
// standard style. |
||||||
|
message TestCamelCaseFieldNames { |
||||||
|
int32 PrimitiveField = 1; |
||||||
|
string StringField = 2; |
||||||
|
ForeignEnum EnumField = 3; |
||||||
|
ForeignMessage MessageField = 4; |
||||||
|
|
||||||
|
repeated int32 RepeatedPrimitiveField = 7; |
||||||
|
repeated string RepeatedStringField = 8; |
||||||
|
repeated ForeignEnum RepeatedEnumField = 9; |
||||||
|
repeated ForeignMessage RepeatedMessageField = 10; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
// We list fields out of order, to ensure that we're using field number and not |
||||||
|
// field index to determine serialization order. |
||||||
|
message TestFieldOrderings { |
||||||
|
string my_string = 11; |
||||||
|
int64 my_int = 1; |
||||||
|
float my_float = 101; |
||||||
|
message NestedMessage { |
||||||
|
int64 oo = 2; |
||||||
|
// The field name "b" fails to compile in proto1 because it conflicts with |
||||||
|
// a local variable named "b" in one of the generated methods. Doh. |
||||||
|
// This file needs to compile in proto1 to test backwards-compatibility. |
||||||
|
int32 bb = 1; |
||||||
|
} |
||||||
|
|
||||||
|
NestedMessage single_nested_message = 200; |
||||||
|
} |
||||||
|
|
||||||
|
message SparseEnumMessage { |
||||||
|
TestSparseEnum sparse_enum = 1; |
||||||
|
} |
||||||
|
|
||||||
|
// Test String and Bytes: string is for valid UTF-8 strings |
||||||
|
message OneString { |
||||||
|
string data = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message MoreString { |
||||||
|
repeated string data = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message OneBytes { |
||||||
|
bytes data = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message MoreBytes { |
||||||
|
bytes data = 1; |
||||||
|
} |
||||||
|
|
||||||
|
// Test int32, uint32, int64, uint64, and bool are all compatible |
||||||
|
message Int32Message { |
||||||
|
int32 data = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message Uint32Message { |
||||||
|
uint32 data = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message Int64Message { |
||||||
|
int64 data = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message Uint64Message { |
||||||
|
uint64 data = 1; |
||||||
|
} |
||||||
|
|
||||||
|
message BoolMessage { |
||||||
|
bool data = 1; |
||||||
|
} |
||||||
|
|
||||||
|
// Test oneofs. |
||||||
|
message TestOneof { |
||||||
|
oneof foo { |
||||||
|
int32 foo_int = 1; |
||||||
|
string foo_string = 2; |
||||||
|
TestAllTypes foo_message = 3; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Test messages for packed fields |
||||||
|
|
||||||
|
message TestPackedTypes { |
||||||
|
repeated int32 packed_int32 = 90 [packed = true]; |
||||||
|
repeated int64 packed_int64 = 91 [packed = true]; |
||||||
|
repeated uint32 packed_uint32 = 92 [packed = true]; |
||||||
|
repeated uint64 packed_uint64 = 93 [packed = true]; |
||||||
|
repeated sint32 packed_sint32 = 94 [packed = true]; |
||||||
|
repeated sint64 packed_sint64 = 95 [packed = true]; |
||||||
|
repeated fixed32 packed_fixed32 = 96 [packed = true]; |
||||||
|
repeated fixed64 packed_fixed64 = 97 [packed = true]; |
||||||
|
repeated sfixed32 packed_sfixed32 = 98 [packed = true]; |
||||||
|
repeated sfixed64 packed_sfixed64 = 99 [packed = true]; |
||||||
|
repeated float packed_float = 100 [packed = true]; |
||||||
|
repeated double packed_double = 101 [packed = true]; |
||||||
|
repeated bool packed_bool = 102 [packed = true]; |
||||||
|
repeated ForeignEnum packed_enum = 103 [packed = true]; |
||||||
|
} |
||||||
|
|
||||||
|
// A message with the same fields as TestPackedTypes, but without packing. Used |
||||||
|
// to test packed <-> unpacked wire compatibility. |
||||||
|
message TestUnpackedTypes { |
||||||
|
repeated int32 unpacked_int32 = 90 [packed = false]; |
||||||
|
repeated int64 unpacked_int64 = 91 [packed = false]; |
||||||
|
repeated uint32 unpacked_uint32 = 92 [packed = false]; |
||||||
|
repeated uint64 unpacked_uint64 = 93 [packed = false]; |
||||||
|
repeated sint32 unpacked_sint32 = 94 [packed = false]; |
||||||
|
repeated sint64 unpacked_sint64 = 95 [packed = false]; |
||||||
|
repeated fixed32 unpacked_fixed32 = 96 [packed = false]; |
||||||
|
repeated fixed64 unpacked_fixed64 = 97 [packed = false]; |
||||||
|
repeated sfixed32 unpacked_sfixed32 = 98 [packed = false]; |
||||||
|
repeated sfixed64 unpacked_sfixed64 = 99 [packed = false]; |
||||||
|
repeated float unpacked_float = 100 [packed = false]; |
||||||
|
repeated double unpacked_double = 101 [packed = false]; |
||||||
|
repeated bool unpacked_bool = 102 [packed = false]; |
||||||
|
repeated ForeignEnum unpacked_enum = 103 [packed = false]; |
||||||
|
} |
||||||
|
|
||||||
|
message TestRepeatedScalarDifferentTagSizes { |
||||||
|
// Parsing repeated fixed size values used to fail. This message needs to be |
||||||
|
// used in order to get a tag of the right size; all of the repeated fields |
||||||
|
// in TestAllTypes didn't trigger the check. |
||||||
|
repeated fixed32 repeated_fixed32 = 12; |
||||||
|
// Check for a varint type, just for good measure. |
||||||
|
repeated int32 repeated_int32 = 13; |
||||||
|
|
||||||
|
// These have two-byte tags. |
||||||
|
repeated fixed64 repeated_fixed64 = 2046; |
||||||
|
repeated int64 repeated_int64 = 2047; |
||||||
|
|
||||||
|
// Three byte tags. |
||||||
|
repeated float repeated_float = 262142; |
||||||
|
repeated uint64 repeated_uint64 = 262143; |
||||||
|
} |
||||||
|
|
||||||
|
message TestCommentInjectionMessage { |
||||||
|
// */ <- This should not close the generated doc comment |
||||||
|
string a = 1; |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
// Test that RPC services work. |
||||||
|
message FooRequest {} |
||||||
|
message FooResponse {} |
||||||
|
|
||||||
|
message FooClientMessage {} |
||||||
|
message FooServerMessage{} |
||||||
|
|
||||||
|
service TestService { |
||||||
|
rpc Foo(FooRequest) returns (FooResponse); |
||||||
|
rpc Bar(BarRequest) returns (BarResponse); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
message BarRequest {} |
||||||
|
message BarResponse {} |
||||||
|
|
||||||
@ -0,0 +1,114 @@ |
|||||||
|
syntax = "proto3"; |
||||||
|
|
||||||
|
package protobuf_unittest; |
||||||
|
|
||||||
|
option csharp_namespace = "Google.Protobuf.TestProtos"; |
||||||
|
option java_multiple_files = true; |
||||||
|
option java_package = "com.google.protobuf.test"; |
||||||
|
|
||||||
|
import "google/protobuf/any.proto"; |
||||||
|
import "google/protobuf/api.proto"; |
||||||
|
import "google/protobuf/duration.proto"; |
||||||
|
import "google/protobuf/empty.proto"; |
||||||
|
import "google/protobuf/field_mask.proto"; |
||||||
|
import "google/protobuf/source_context.proto"; |
||||||
|
import "google/protobuf/struct.proto"; |
||||||
|
import "google/protobuf/timestamp.proto"; |
||||||
|
import "google/protobuf/type.proto"; |
||||||
|
import "google/protobuf/wrappers.proto"; |
||||||
|
|
||||||
|
// Test that we can include all well-known types. |
||||||
|
// Each wrapper type is included separately, as languages |
||||||
|
// map handle different wrappers in different ways. |
||||||
|
message TestWellKnownTypes { |
||||||
|
google.protobuf.Any any_field = 1; |
||||||
|
google.protobuf.Api api_field = 2; |
||||||
|
google.protobuf.Duration duration_field = 3; |
||||||
|
google.protobuf.Empty empty_field = 4; |
||||||
|
google.protobuf.FieldMask field_mask_field = 5; |
||||||
|
google.protobuf.SourceContext source_context_field = 6; |
||||||
|
google.protobuf.Struct struct_field = 7; |
||||||
|
google.protobuf.Timestamp timestamp_field = 8; |
||||||
|
google.protobuf.Type type_field = 9; |
||||||
|
google.protobuf.DoubleValue double_field = 10; |
||||||
|
google.protobuf.FloatValue float_field = 11; |
||||||
|
google.protobuf.Int64Value int64_field = 12; |
||||||
|
google.protobuf.UInt64Value uint64_field = 13; |
||||||
|
google.protobuf.Int32Value int32_field = 14; |
||||||
|
google.protobuf.UInt32Value uint32_field = 15; |
||||||
|
google.protobuf.BoolValue bool_field = 16; |
||||||
|
google.protobuf.StringValue string_field = 17; |
||||||
|
google.protobuf.BytesValue bytes_field = 18; |
||||||
|
// Part of struct, but useful to be able to test separately |
||||||
|
google.protobuf.Value value_field = 19; |
||||||
|
} |
||||||
|
|
||||||
|
// A repeated field for each well-known type. |
||||||
|
message RepeatedWellKnownTypes { |
||||||
|
repeated google.protobuf.Any any_field = 1; |
||||||
|
repeated google.protobuf.Api api_field = 2; |
||||||
|
repeated google.protobuf.Duration duration_field = 3; |
||||||
|
repeated google.protobuf.Empty empty_field = 4; |
||||||
|
repeated google.protobuf.FieldMask field_mask_field = 5; |
||||||
|
repeated google.protobuf.SourceContext source_context_field = 6; |
||||||
|
repeated google.protobuf.Struct struct_field = 7; |
||||||
|
repeated google.protobuf.Timestamp timestamp_field = 8; |
||||||
|
repeated google.protobuf.Type type_field = 9; |
||||||
|
// These don't actually make a lot of sense, but they're not prohibited... |
||||||
|
repeated google.protobuf.DoubleValue double_field = 10; |
||||||
|
repeated google.protobuf.FloatValue float_field = 11; |
||||||
|
repeated google.protobuf.Int64Value int64_field = 12; |
||||||
|
repeated google.protobuf.UInt64Value uint64_field = 13; |
||||||
|
repeated google.protobuf.Int32Value int32_field = 14; |
||||||
|
repeated google.protobuf.UInt32Value uint32_field = 15; |
||||||
|
repeated google.protobuf.BoolValue bool_field = 16; |
||||||
|
repeated google.protobuf.StringValue string_field = 17; |
||||||
|
repeated google.protobuf.BytesValue bytes_field = 18; |
||||||
|
} |
||||||
|
|
||||||
|
message OneofWellKnownTypes { |
||||||
|
oneof oneof_field { |
||||||
|
google.protobuf.Any any_field = 1; |
||||||
|
google.protobuf.Api api_field = 2; |
||||||
|
google.protobuf.Duration duration_field = 3; |
||||||
|
google.protobuf.Empty empty_field = 4; |
||||||
|
google.protobuf.FieldMask field_mask_field = 5; |
||||||
|
google.protobuf.SourceContext source_context_field = 6; |
||||||
|
google.protobuf.Struct struct_field = 7; |
||||||
|
google.protobuf.Timestamp timestamp_field = 8; |
||||||
|
google.protobuf.Type type_field = 9; |
||||||
|
google.protobuf.DoubleValue double_field = 10; |
||||||
|
google.protobuf.FloatValue float_field = 11; |
||||||
|
google.protobuf.Int64Value int64_field = 12; |
||||||
|
google.protobuf.UInt64Value uint64_field = 13; |
||||||
|
google.protobuf.Int32Value int32_field = 14; |
||||||
|
google.protobuf.UInt32Value uint32_field = 15; |
||||||
|
google.protobuf.BoolValue bool_field = 16; |
||||||
|
google.protobuf.StringValue string_field = 17; |
||||||
|
google.protobuf.BytesValue bytes_field = 18; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// A map field for each well-known type. We only |
||||||
|
// need to worry about the value part of the map being the |
||||||
|
// well-known types, as messages can't be map keys. |
||||||
|
message MapWellKnownTypes { |
||||||
|
map<int32,google.protobuf.Any> any_field = 1; |
||||||
|
map<int32,google.protobuf.Api> api_field = 2; |
||||||
|
map<int32,google.protobuf.Duration> duration_field = 3; |
||||||
|
map<int32,google.protobuf.Empty> empty_field = 4; |
||||||
|
map<int32,google.protobuf.FieldMask> field_mask_field = 5; |
||||||
|
map<int32,google.protobuf.SourceContext> source_context_field = 6; |
||||||
|
map<int32,google.protobuf.Struct> struct_field = 7; |
||||||
|
map<int32,google.protobuf.Timestamp> timestamp_field = 8; |
||||||
|
map<int32,google.protobuf.Type> type_field = 9; |
||||||
|
map<int32,google.protobuf.DoubleValue> double_field = 10; |
||||||
|
map<int32,google.protobuf.FloatValue> float_field = 11; |
||||||
|
map<int32,google.protobuf.Int64Value> int64_field = 12; |
||||||
|
map<int32,google.protobuf.UInt64Value> uint64_field = 13; |
||||||
|
map<int32,google.protobuf.Int32Value> int32_field = 14; |
||||||
|
map<int32,google.protobuf.UInt32Value> uint32_field = 15; |
||||||
|
map<int32,google.protobuf.BoolValue> bool_field = 16; |
||||||
|
map<int32,google.protobuf.StringValue> string_field = 17; |
||||||
|
map<int32,google.protobuf.BytesValue> bytes_field = 18; |
||||||
|
} |
||||||
@ -0,0 +1,171 @@ |
|||||||
|
#region Copyright notice and license |
||||||
|
// Protocol Buffers - Google's data interchange format |
||||||
|
// Copyright 2008 Google Inc. All rights reserved. |
||||||
|
// https://developers.google.com/protocol-buffers/ |
||||||
|
// |
||||||
|
// Redistribution and use in source and binary forms, with or without |
||||||
|
// modification, are permitted provided that the following conditions are |
||||||
|
// met: |
||||||
|
// |
||||||
|
// * Redistributions of source code must retain the above copyright |
||||||
|
// notice, this list of conditions and the following disclaimer. |
||||||
|
// * Redistributions in binary form must reproduce the above |
||||||
|
// copyright notice, this list of conditions and the following disclaimer |
||||||
|
// in the documentation and/or other materials provided with the |
||||||
|
// distribution. |
||||||
|
// * Neither the name of Google Inc. nor the names of its |
||||||
|
// contributors may be used to endorse or promote products derived from |
||||||
|
// this software without specific prior written permission. |
||||||
|
// |
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
#endregion |
||||||
|
|
||||||
|
using System; |
||||||
|
using System.Text; |
||||||
|
using NUnit.Framework; |
||||||
|
|
||||||
|
namespace Google.Protobuf |
||||||
|
{ |
||||||
|
public class ByteStringTest |
||||||
|
{ |
||||||
|
[Test] |
||||||
|
public void Equality() |
||||||
|
{ |
||||||
|
ByteString b1 = ByteString.CopyFrom(1, 2, 3); |
||||||
|
ByteString b2 = ByteString.CopyFrom(1, 2, 3); |
||||||
|
ByteString b3 = ByteString.CopyFrom(1, 2, 4); |
||||||
|
ByteString b4 = ByteString.CopyFrom(1, 2, 3, 4); |
||||||
|
EqualityTester.AssertEquality(b1, b1); |
||||||
|
EqualityTester.AssertEquality(b1, b2); |
||||||
|
EqualityTester.AssertInequality(b1, b3); |
||||||
|
EqualityTester.AssertInequality(b1, b4); |
||||||
|
EqualityTester.AssertInequality(b1, null); |
||||||
|
#pragma warning disable 1718 // Deliberately calling ==(b1, b1) and !=(b1, b1) |
||||||
|
Assert.IsTrue(b1 == b1); |
||||||
|
Assert.IsTrue(b1 == b2); |
||||||
|
Assert.IsFalse(b1 == b3); |
||||||
|
Assert.IsFalse(b1 == b4); |
||||||
|
Assert.IsFalse(b1 == null); |
||||||
|
Assert.IsTrue((ByteString) null == null); |
||||||
|
Assert.IsFalse(b1 != b1); |
||||||
|
Assert.IsFalse(b1 != b2); |
||||||
|
#pragma warning disable 1718 |
||||||
|
Assert.IsTrue(b1 != b3); |
||||||
|
Assert.IsTrue(b1 != b4); |
||||||
|
Assert.IsTrue(b1 != null); |
||||||
|
Assert.IsFalse((ByteString) null != null); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void EmptyByteStringHasZeroSize() |
||||||
|
{ |
||||||
|
Assert.AreEqual(0, ByteString.Empty.Length); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void CopyFromStringWithExplicitEncoding() |
||||||
|
{ |
||||||
|
ByteString bs = ByteString.CopyFrom("AB", Encoding.Unicode); |
||||||
|
Assert.AreEqual(4, bs.Length); |
||||||
|
Assert.AreEqual(65, bs[0]); |
||||||
|
Assert.AreEqual(0, bs[1]); |
||||||
|
Assert.AreEqual(66, bs[2]); |
||||||
|
Assert.AreEqual(0, bs[3]); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void IsEmptyWhenEmpty() |
||||||
|
{ |
||||||
|
Assert.IsTrue(ByteString.CopyFromUtf8("").IsEmpty); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void IsEmptyWhenNotEmpty() |
||||||
|
{ |
||||||
|
Assert.IsFalse(ByteString.CopyFromUtf8("X").IsEmpty); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void CopyFromByteArrayCopiesContents() |
||||||
|
{ |
||||||
|
byte[] data = new byte[1]; |
||||||
|
data[0] = 10; |
||||||
|
ByteString bs = ByteString.CopyFrom(data); |
||||||
|
Assert.AreEqual(10, bs[0]); |
||||||
|
data[0] = 5; |
||||||
|
Assert.AreEqual(10, bs[0]); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void ToByteArrayCopiesContents() |
||||||
|
{ |
||||||
|
ByteString bs = ByteString.CopyFromUtf8("Hello"); |
||||||
|
byte[] data = bs.ToByteArray(); |
||||||
|
Assert.AreEqual((byte)'H', data[0]); |
||||||
|
Assert.AreEqual((byte)'H', bs[0]); |
||||||
|
data[0] = 0; |
||||||
|
Assert.AreEqual(0, data[0]); |
||||||
|
Assert.AreEqual((byte)'H', bs[0]); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void CopyFromUtf8UsesUtf8() |
||||||
|
{ |
||||||
|
ByteString bs = ByteString.CopyFromUtf8("\u20ac"); |
||||||
|
Assert.AreEqual(3, bs.Length); |
||||||
|
Assert.AreEqual(0xe2, bs[0]); |
||||||
|
Assert.AreEqual(0x82, bs[1]); |
||||||
|
Assert.AreEqual(0xac, bs[2]); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void CopyFromPortion() |
||||||
|
{ |
||||||
|
byte[] data = new byte[] {0, 1, 2, 3, 4, 5, 6}; |
||||||
|
ByteString bs = ByteString.CopyFrom(data, 2, 3); |
||||||
|
Assert.AreEqual(3, bs.Length); |
||||||
|
Assert.AreEqual(2, bs[0]); |
||||||
|
Assert.AreEqual(3, bs[1]); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void ToStringUtf8() |
||||||
|
{ |
||||||
|
ByteString bs = ByteString.CopyFromUtf8("\u20ac"); |
||||||
|
Assert.AreEqual("\u20ac", bs.ToStringUtf8()); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void ToStringWithExplicitEncoding() |
||||||
|
{ |
||||||
|
ByteString bs = ByteString.CopyFrom("\u20ac", Encoding.Unicode); |
||||||
|
Assert.AreEqual("\u20ac", bs.ToString(Encoding.Unicode)); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void FromBase64_WithText() |
||||||
|
{ |
||||||
|
byte[] data = new byte[] {0, 1, 2, 3, 4, 5, 6}; |
||||||
|
string base64 = Convert.ToBase64String(data); |
||||||
|
ByteString bs = ByteString.FromBase64(base64); |
||||||
|
Assert.AreEqual(data, bs.ToByteArray()); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void FromBase64_Empty() |
||||||
|
{ |
||||||
|
// Optimization which also fixes issue 61. |
||||||
|
Assert.AreSame(ByteString.Empty, ByteString.FromBase64("")); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,598 @@ |
|||||||
|
#region Copyright notice and license |
||||||
|
// Protocol Buffers - Google's data interchange format |
||||||
|
// Copyright 2008 Google Inc. All rights reserved. |
||||||
|
// https://developers.google.com/protocol-buffers/ |
||||||
|
// |
||||||
|
// Redistribution and use in source and binary forms, with or without |
||||||
|
// modification, are permitted provided that the following conditions are |
||||||
|
// met: |
||||||
|
// |
||||||
|
// * Redistributions of source code must retain the above copyright |
||||||
|
// notice, this list of conditions and the following disclaimer. |
||||||
|
// * Redistributions in binary form must reproduce the above |
||||||
|
// copyright notice, this list of conditions and the following disclaimer |
||||||
|
// in the documentation and/or other materials provided with the |
||||||
|
// distribution. |
||||||
|
// * Neither the name of Google Inc. nor the names of its |
||||||
|
// contributors may be used to endorse or promote products derived from |
||||||
|
// this software without specific prior written permission. |
||||||
|
// |
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
#endregion |
||||||
|
|
||||||
|
using System; |
||||||
|
using System.IO; |
||||||
|
using Google.Protobuf.TestProtos; |
||||||
|
using NUnit.Framework; |
||||||
|
|
||||||
|
namespace Google.Protobuf |
||||||
|
{ |
||||||
|
public class CodedInputStreamTest |
||||||
|
{ |
||||||
|
/// <summary> |
||||||
|
/// Helper to construct a byte array from a bunch of bytes. The inputs are |
||||||
|
/// actually ints so that I can use hex notation and not get stupid errors |
||||||
|
/// about precision. |
||||||
|
/// </summary> |
||||||
|
private static byte[] Bytes(params int[] bytesAsInts) |
||||||
|
{ |
||||||
|
byte[] bytes = new byte[bytesAsInts.Length]; |
||||||
|
for (int i = 0; i < bytesAsInts.Length; i++) |
||||||
|
{ |
||||||
|
bytes[i] = (byte) bytesAsInts[i]; |
||||||
|
} |
||||||
|
return bytes; |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() |
||||||
|
/// </summary> |
||||||
|
private static void AssertReadVarint(byte[] data, ulong value) |
||||||
|
{ |
||||||
|
CodedInputStream input = new CodedInputStream(data); |
||||||
|
Assert.AreEqual((uint) value, input.ReadRawVarint32()); |
||||||
|
|
||||||
|
input = new CodedInputStream(data); |
||||||
|
Assert.AreEqual(value, input.ReadRawVarint64()); |
||||||
|
Assert.IsTrue(input.IsAtEnd); |
||||||
|
|
||||||
|
// Try different block sizes. |
||||||
|
for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) |
||||||
|
{ |
||||||
|
input = new CodedInputStream(new SmallBlockInputStream(data, bufferSize)); |
||||||
|
Assert.AreEqual((uint) value, input.ReadRawVarint32()); |
||||||
|
|
||||||
|
input = new CodedInputStream(new SmallBlockInputStream(data, bufferSize)); |
||||||
|
Assert.AreEqual(value, input.ReadRawVarint64()); |
||||||
|
Assert.IsTrue(input.IsAtEnd); |
||||||
|
} |
||||||
|
|
||||||
|
// Try reading directly from a MemoryStream. We want to verify that it |
||||||
|
// doesn't read past the end of the input, so write an extra byte - this |
||||||
|
// lets us test the position at the end. |
||||||
|
MemoryStream memoryStream = new MemoryStream(); |
||||||
|
memoryStream.Write(data, 0, data.Length); |
||||||
|
memoryStream.WriteByte(0); |
||||||
|
memoryStream.Position = 0; |
||||||
|
Assert.AreEqual((uint) value, CodedInputStream.ReadRawVarint32(memoryStream)); |
||||||
|
Assert.AreEqual(data.Length, memoryStream.Position); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// Parses the given bytes using ReadRawVarint32() and ReadRawVarint64() and |
||||||
|
/// expects them to fail with an InvalidProtocolBufferException whose |
||||||
|
/// description matches the given one. |
||||||
|
/// </summary> |
||||||
|
private static void AssertReadVarintFailure(InvalidProtocolBufferException expected, byte[] data) |
||||||
|
{ |
||||||
|
CodedInputStream input = new CodedInputStream(data); |
||||||
|
var exception = Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawVarint32()); |
||||||
|
Assert.AreEqual(expected.Message, exception.Message); |
||||||
|
|
||||||
|
input = new CodedInputStream(data); |
||||||
|
exception = Assert.Throws<InvalidProtocolBufferException>(() => input.ReadRawVarint64()); |
||||||
|
Assert.AreEqual(expected.Message, exception.Message); |
||||||
|
|
||||||
|
// Make sure we get the same error when reading directly from a Stream. |
||||||
|
exception = Assert.Throws<InvalidProtocolBufferException>(() => CodedInputStream.ReadRawVarint32(new MemoryStream(data))); |
||||||
|
Assert.AreEqual(expected.Message, exception.Message); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void ReadVarint() |
||||||
|
{ |
||||||
|
AssertReadVarint(Bytes(0x00), 0); |
||||||
|
AssertReadVarint(Bytes(0x01), 1); |
||||||
|
AssertReadVarint(Bytes(0x7f), 127); |
||||||
|
// 14882 |
||||||
|
AssertReadVarint(Bytes(0xa2, 0x74), (0x22 << 0) | (0x74 << 7)); |
||||||
|
// 2961488830 |
||||||
|
AssertReadVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x0b), |
||||||
|
(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | |
||||||
|
(0x0bL << 28)); |
||||||
|
|
||||||
|
// 64-bit |
||||||
|
// 7256456126 |
||||||
|
AssertReadVarint(Bytes(0xbe, 0xf7, 0x92, 0x84, 0x1b), |
||||||
|
(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | |
||||||
|
(0x1bL << 28)); |
||||||
|
// 41256202580718336 |
||||||
|
AssertReadVarint(Bytes(0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49), |
||||||
|
(0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) | |
||||||
|
(0x43L << 28) | (0x49L << 35) | (0x24L << 42) | (0x49L << 49)); |
||||||
|
// 11964378330978735131 |
||||||
|
AssertReadVarint(Bytes(0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01), |
||||||
|
(0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) | |
||||||
|
(0x3bUL << 28) | (0x56UL << 35) | (0x00UL << 42) | |
||||||
|
(0x05UL << 49) | (0x26UL << 56) | (0x01UL << 63)); |
||||||
|
|
||||||
|
// Failures |
||||||
|
AssertReadVarintFailure( |
||||||
|
InvalidProtocolBufferException.MalformedVarint(), |
||||||
|
Bytes(0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, |
||||||
|
0x00)); |
||||||
|
AssertReadVarintFailure( |
||||||
|
InvalidProtocolBufferException.TruncatedMessage(), |
||||||
|
Bytes(0x80)); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// Parses the given bytes using ReadRawLittleEndian32() and checks |
||||||
|
/// that the result matches the given value. |
||||||
|
/// </summary> |
||||||
|
private static void AssertReadLittleEndian32(byte[] data, uint value) |
||||||
|
{ |
||||||
|
CodedInputStream input = new CodedInputStream(data); |
||||||
|
Assert.AreEqual(value, input.ReadRawLittleEndian32()); |
||||||
|
Assert.IsTrue(input.IsAtEnd); |
||||||
|
|
||||||
|
// Try different block sizes. |
||||||
|
for (int blockSize = 1; blockSize <= 16; blockSize *= 2) |
||||||
|
{ |
||||||
|
input = new CodedInputStream( |
||||||
|
new SmallBlockInputStream(data, blockSize)); |
||||||
|
Assert.AreEqual(value, input.ReadRawLittleEndian32()); |
||||||
|
Assert.IsTrue(input.IsAtEnd); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// Parses the given bytes using ReadRawLittleEndian64() and checks |
||||||
|
/// that the result matches the given value. |
||||||
|
/// </summary> |
||||||
|
private static void AssertReadLittleEndian64(byte[] data, ulong value) |
||||||
|
{ |
||||||
|
CodedInputStream input = new CodedInputStream(data); |
||||||
|
Assert.AreEqual(value, input.ReadRawLittleEndian64()); |
||||||
|
Assert.IsTrue(input.IsAtEnd); |
||||||
|
|
||||||
|
// Try different block sizes. |
||||||
|
for (int blockSize = 1; blockSize <= 16; blockSize *= 2) |
||||||
|
{ |
||||||
|
input = new CodedInputStream( |
||||||
|
new SmallBlockInputStream(data, blockSize)); |
||||||
|
Assert.AreEqual(value, input.ReadRawLittleEndian64()); |
||||||
|
Assert.IsTrue(input.IsAtEnd); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void ReadLittleEndian() |
||||||
|
{ |
||||||
|
AssertReadLittleEndian32(Bytes(0x78, 0x56, 0x34, 0x12), 0x12345678); |
||||||
|
AssertReadLittleEndian32(Bytes(0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef0); |
||||||
|
|
||||||
|
AssertReadLittleEndian64(Bytes(0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12), |
||||||
|
0x123456789abcdef0L); |
||||||
|
AssertReadLittleEndian64( |
||||||
|
Bytes(0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a), 0x9abcdef012345678UL); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void DecodeZigZag32() |
||||||
|
{ |
||||||
|
Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(0)); |
||||||
|
Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(1)); |
||||||
|
Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(2)); |
||||||
|
Assert.AreEqual(-2, CodedInputStream.DecodeZigZag32(3)); |
||||||
|
Assert.AreEqual(0x3FFFFFFF, CodedInputStream.DecodeZigZag32(0x7FFFFFFE)); |
||||||
|
Assert.AreEqual(unchecked((int) 0xC0000000), CodedInputStream.DecodeZigZag32(0x7FFFFFFF)); |
||||||
|
Assert.AreEqual(0x7FFFFFFF, CodedInputStream.DecodeZigZag32(0xFFFFFFFE)); |
||||||
|
Assert.AreEqual(unchecked((int) 0x80000000), CodedInputStream.DecodeZigZag32(0xFFFFFFFF)); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void DecodeZigZag64() |
||||||
|
{ |
||||||
|
Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(0)); |
||||||
|
Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(1)); |
||||||
|
Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(2)); |
||||||
|
Assert.AreEqual(-2, CodedInputStream.DecodeZigZag64(3)); |
||||||
|
Assert.AreEqual(0x000000003FFFFFFFL, CodedInputStream.DecodeZigZag64(0x000000007FFFFFFEL)); |
||||||
|
Assert.AreEqual(unchecked((long) 0xFFFFFFFFC0000000L), CodedInputStream.DecodeZigZag64(0x000000007FFFFFFFL)); |
||||||
|
Assert.AreEqual(0x000000007FFFFFFFL, CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFEL)); |
||||||
|
Assert.AreEqual(unchecked((long) 0xFFFFFFFF80000000L), CodedInputStream.DecodeZigZag64(0x00000000FFFFFFFFL)); |
||||||
|
Assert.AreEqual(0x7FFFFFFFFFFFFFFFL, CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFEL)); |
||||||
|
Assert.AreEqual(unchecked((long) 0x8000000000000000L), CodedInputStream.DecodeZigZag64(0xFFFFFFFFFFFFFFFFL)); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void ReadWholeMessage_VaryingBlockSizes() |
||||||
|
{ |
||||||
|
TestAllTypes message = SampleMessages.CreateFullTestAllTypes(); |
||||||
|
|
||||||
|
byte[] rawBytes = message.ToByteArray(); |
||||||
|
Assert.AreEqual(rawBytes.Length, message.CalculateSize()); |
||||||
|
TestAllTypes message2 = TestAllTypes.Parser.ParseFrom(rawBytes); |
||||||
|
Assert.AreEqual(message, message2); |
||||||
|
|
||||||
|
// Try different block sizes. |
||||||
|
for (int blockSize = 1; blockSize < 256; blockSize *= 2) |
||||||
|
{ |
||||||
|
message2 = TestAllTypes.Parser.ParseFrom(new SmallBlockInputStream(rawBytes, blockSize)); |
||||||
|
Assert.AreEqual(message, message2); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void ReadHugeBlob() |
||||||
|
{ |
||||||
|
// Allocate and initialize a 1MB blob. |
||||||
|
byte[] blob = new byte[1 << 20]; |
||||||
|
for (int i = 0; i < blob.Length; i++) |
||||||
|
{ |
||||||
|
blob[i] = (byte) i; |
||||||
|
} |
||||||
|
|
||||||
|
// Make a message containing it. |
||||||
|
var message = new TestAllTypes { SingleBytes = ByteString.CopyFrom(blob) }; |
||||||
|
|
||||||
|
// Serialize and parse it. Make sure to parse from an InputStream, not |
||||||
|
// directly from a ByteString, so that CodedInputStream uses buffered |
||||||
|
// reading. |
||||||
|
TestAllTypes message2 = TestAllTypes.Parser.ParseFrom(message.ToByteString()); |
||||||
|
|
||||||
|
Assert.AreEqual(message, message2); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void ReadMaliciouslyLargeBlob() |
||||||
|
{ |
||||||
|
MemoryStream ms = new MemoryStream(); |
||||||
|
CodedOutputStream output = new CodedOutputStream(ms); |
||||||
|
|
||||||
|
uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); |
||||||
|
output.WriteRawVarint32(tag); |
||||||
|
output.WriteRawVarint32(0x7FFFFFFF); |
||||||
|
output.WriteRawBytes(new byte[32]); // Pad with a few random bytes. |
||||||
|
output.Flush(); |
||||||
|
ms.Position = 0; |
||||||
|
|
||||||
|
CodedInputStream input = new CodedInputStream(ms); |
||||||
|
Assert.AreEqual(tag, input.ReadTag()); |
||||||
|
|
||||||
|
Assert.Throws<InvalidProtocolBufferException>(() => input.ReadBytes()); |
||||||
|
} |
||||||
|
|
||||||
|
internal static TestRecursiveMessage MakeRecursiveMessage(int depth) |
||||||
|
{ |
||||||
|
if (depth == 0) |
||||||
|
{ |
||||||
|
return new TestRecursiveMessage { I = 5 }; |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
return new TestRecursiveMessage { A = MakeRecursiveMessage(depth - 1) }; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
internal static void AssertMessageDepth(TestRecursiveMessage message, int depth) |
||||||
|
{ |
||||||
|
if (depth == 0) |
||||||
|
{ |
||||||
|
Assert.IsNull(message.A); |
||||||
|
Assert.AreEqual(5, message.I); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
Assert.IsNotNull(message.A); |
||||||
|
AssertMessageDepth(message.A, depth - 1); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void MaliciousRecursion() |
||||||
|
{ |
||||||
|
ByteString data64 = MakeRecursiveMessage(64).ToByteString(); |
||||||
|
ByteString data65 = MakeRecursiveMessage(65).ToByteString(); |
||||||
|
|
||||||
|
AssertMessageDepth(TestRecursiveMessage.Parser.ParseFrom(data64), 64); |
||||||
|
|
||||||
|
Assert.Throws<InvalidProtocolBufferException>(() => TestRecursiveMessage.Parser.ParseFrom(data65)); |
||||||
|
|
||||||
|
CodedInputStream input = CodedInputStream.CreateWithLimits(new MemoryStream(data64.ToByteArray()), 1000000, 63); |
||||||
|
Assert.Throws<InvalidProtocolBufferException>(() => TestRecursiveMessage.Parser.ParseFrom(input)); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void SizeLimit() |
||||||
|
{ |
||||||
|
// Have to use a Stream rather than ByteString.CreateCodedInput as SizeLimit doesn't |
||||||
|
// apply to the latter case. |
||||||
|
MemoryStream ms = new MemoryStream(SampleMessages.CreateFullTestAllTypes().ToByteArray()); |
||||||
|
CodedInputStream input = CodedInputStream.CreateWithLimits(ms, 16, 100); |
||||||
|
Assert.Throws<InvalidProtocolBufferException>(() => TestAllTypes.Parser.ParseFrom(input)); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// Tests that if we read an string that contains invalid UTF-8, no exception |
||||||
|
/// is thrown. Instead, the invalid bytes are replaced with the Unicode |
||||||
|
/// "replacement character" U+FFFD. |
||||||
|
/// </summary> |
||||||
|
[Test] |
||||||
|
public void ReadInvalidUtf8() |
||||||
|
{ |
||||||
|
MemoryStream ms = new MemoryStream(); |
||||||
|
CodedOutputStream output = new CodedOutputStream(ms); |
||||||
|
|
||||||
|
uint tag = WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited); |
||||||
|
output.WriteRawVarint32(tag); |
||||||
|
output.WriteRawVarint32(1); |
||||||
|
output.WriteRawBytes(new byte[] {0x80}); |
||||||
|
output.Flush(); |
||||||
|
ms.Position = 0; |
||||||
|
|
||||||
|
CodedInputStream input = new CodedInputStream(ms); |
||||||
|
|
||||||
|
Assert.AreEqual(tag, input.ReadTag()); |
||||||
|
string text = input.ReadString(); |
||||||
|
Assert.AreEqual('\ufffd', text[0]); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// A stream which limits the number of bytes it reads at a time. |
||||||
|
/// We use this to make sure that CodedInputStream doesn't screw up when |
||||||
|
/// reading in small blocks. |
||||||
|
/// </summary> |
||||||
|
private sealed class SmallBlockInputStream : MemoryStream |
||||||
|
{ |
||||||
|
private readonly int blockSize; |
||||||
|
|
||||||
|
public SmallBlockInputStream(byte[] data, int blockSize) |
||||||
|
: base(data) |
||||||
|
{ |
||||||
|
this.blockSize = blockSize; |
||||||
|
} |
||||||
|
|
||||||
|
public override int Read(byte[] buffer, int offset, int count) |
||||||
|
{ |
||||||
|
return base.Read(buffer, offset, Math.Min(count, blockSize)); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void TestNegativeEnum() |
||||||
|
{ |
||||||
|
byte[] bytes = { 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01 }; |
||||||
|
CodedInputStream input = new CodedInputStream(bytes); |
||||||
|
Assert.AreEqual((int)SampleEnum.NegativeValue, input.ReadEnum()); |
||||||
|
Assert.IsTrue(input.IsAtEnd); |
||||||
|
} |
||||||
|
|
||||||
|
//Issue 71: CodedInputStream.ReadBytes go to slow path unnecessarily |
||||||
|
[Test] |
||||||
|
public void TestSlowPathAvoidance() |
||||||
|
{ |
||||||
|
using (var ms = new MemoryStream()) |
||||||
|
{ |
||||||
|
CodedOutputStream output = new CodedOutputStream(ms); |
||||||
|
output.WriteTag(1, WireFormat.WireType.LengthDelimited); |
||||||
|
output.WriteBytes(ByteString.CopyFrom(new byte[100])); |
||||||
|
output.WriteTag(2, WireFormat.WireType.LengthDelimited); |
||||||
|
output.WriteBytes(ByteString.CopyFrom(new byte[100])); |
||||||
|
output.Flush(); |
||||||
|
|
||||||
|
ms.Position = 0; |
||||||
|
CodedInputStream input = new CodedInputStream(ms, new byte[ms.Length / 2], 0, 0); |
||||||
|
|
||||||
|
uint tag = input.ReadTag(); |
||||||
|
Assert.AreEqual(1, WireFormat.GetTagFieldNumber(tag)); |
||||||
|
Assert.AreEqual(100, input.ReadBytes().Length); |
||||||
|
|
||||||
|
tag = input.ReadTag(); |
||||||
|
Assert.AreEqual(2, WireFormat.GetTagFieldNumber(tag)); |
||||||
|
Assert.AreEqual(100, input.ReadBytes().Length); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void Tag0Throws() |
||||||
|
{ |
||||||
|
var input = new CodedInputStream(new byte[] { 0 }); |
||||||
|
Assert.Throws<InvalidProtocolBufferException>(() => input.ReadTag()); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void SkipGroup() |
||||||
|
{ |
||||||
|
// Create an output stream with a group in: |
||||||
|
// Field 1: string "field 1" |
||||||
|
// Field 2: group containing: |
||||||
|
// Field 1: fixed int32 value 100 |
||||||
|
// Field 2: string "ignore me" |
||||||
|
// Field 3: nested group containing |
||||||
|
// Field 1: fixed int64 value 1000 |
||||||
|
// Field 3: string "field 3" |
||||||
|
var stream = new MemoryStream(); |
||||||
|
var output = new CodedOutputStream(stream); |
||||||
|
output.WriteTag(1, WireFormat.WireType.LengthDelimited); |
||||||
|
output.WriteString("field 1"); |
||||||
|
|
||||||
|
// The outer group... |
||||||
|
output.WriteTag(2, WireFormat.WireType.StartGroup); |
||||||
|
output.WriteTag(1, WireFormat.WireType.Fixed32); |
||||||
|
output.WriteFixed32(100); |
||||||
|
output.WriteTag(2, WireFormat.WireType.LengthDelimited); |
||||||
|
output.WriteString("ignore me"); |
||||||
|
// The nested group... |
||||||
|
output.WriteTag(3, WireFormat.WireType.StartGroup); |
||||||
|
output.WriteTag(1, WireFormat.WireType.Fixed64); |
||||||
|
output.WriteFixed64(1000); |
||||||
|
// Note: Not sure the field number is relevant for end group... |
||||||
|
output.WriteTag(3, WireFormat.WireType.EndGroup); |
||||||
|
|
||||||
|
// End the outer group |
||||||
|
output.WriteTag(2, WireFormat.WireType.EndGroup); |
||||||
|
|
||||||
|
output.WriteTag(3, WireFormat.WireType.LengthDelimited); |
||||||
|
output.WriteString("field 3"); |
||||||
|
output.Flush(); |
||||||
|
stream.Position = 0; |
||||||
|
|
||||||
|
// Now act like a generated client |
||||||
|
var input = new CodedInputStream(stream); |
||||||
|
Assert.AreEqual(WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited), input.ReadTag()); |
||||||
|
Assert.AreEqual("field 1", input.ReadString()); |
||||||
|
Assert.AreEqual(WireFormat.MakeTag(2, WireFormat.WireType.StartGroup), input.ReadTag()); |
||||||
|
input.SkipLastField(); // Should consume the whole group, including the nested one. |
||||||
|
Assert.AreEqual(WireFormat.MakeTag(3, WireFormat.WireType.LengthDelimited), input.ReadTag()); |
||||||
|
Assert.AreEqual("field 3", input.ReadString()); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void SkipGroup_WrongEndGroupTag() |
||||||
|
{ |
||||||
|
// Create an output stream with: |
||||||
|
// Field 1: string "field 1" |
||||||
|
// Start group 2 |
||||||
|
// Field 3: fixed int32 |
||||||
|
// End group 4 (should give an error) |
||||||
|
var stream = new MemoryStream(); |
||||||
|
var output = new CodedOutputStream(stream); |
||||||
|
output.WriteTag(1, WireFormat.WireType.LengthDelimited); |
||||||
|
output.WriteString("field 1"); |
||||||
|
|
||||||
|
// The outer group... |
||||||
|
output.WriteTag(2, WireFormat.WireType.StartGroup); |
||||||
|
output.WriteTag(3, WireFormat.WireType.Fixed32); |
||||||
|
output.WriteFixed32(100); |
||||||
|
output.WriteTag(4, WireFormat.WireType.EndGroup); |
||||||
|
output.Flush(); |
||||||
|
stream.Position = 0; |
||||||
|
|
||||||
|
// Now act like a generated client |
||||||
|
var input = new CodedInputStream(stream); |
||||||
|
Assert.AreEqual(WireFormat.MakeTag(1, WireFormat.WireType.LengthDelimited), input.ReadTag()); |
||||||
|
Assert.AreEqual("field 1", input.ReadString()); |
||||||
|
Assert.AreEqual(WireFormat.MakeTag(2, WireFormat.WireType.StartGroup), input.ReadTag()); |
||||||
|
Assert.Throws<InvalidProtocolBufferException>(input.SkipLastField); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void RogueEndGroupTag() |
||||||
|
{ |
||||||
|
// If we have an end-group tag without a leading start-group tag, generated |
||||||
|
// code will just call SkipLastField... so that should fail. |
||||||
|
|
||||||
|
var stream = new MemoryStream(); |
||||||
|
var output = new CodedOutputStream(stream); |
||||||
|
output.WriteTag(1, WireFormat.WireType.EndGroup); |
||||||
|
output.Flush(); |
||||||
|
stream.Position = 0; |
||||||
|
|
||||||
|
var input = new CodedInputStream(stream); |
||||||
|
Assert.AreEqual(WireFormat.MakeTag(1, WireFormat.WireType.EndGroup), input.ReadTag()); |
||||||
|
Assert.Throws<InvalidProtocolBufferException>(input.SkipLastField); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void EndOfStreamReachedWhileSkippingGroup() |
||||||
|
{ |
||||||
|
var stream = new MemoryStream(); |
||||||
|
var output = new CodedOutputStream(stream); |
||||||
|
output.WriteTag(1, WireFormat.WireType.StartGroup); |
||||||
|
output.WriteTag(2, WireFormat.WireType.StartGroup); |
||||||
|
output.WriteTag(2, WireFormat.WireType.EndGroup); |
||||||
|
|
||||||
|
output.Flush(); |
||||||
|
stream.Position = 0; |
||||||
|
|
||||||
|
// Now act like a generated client |
||||||
|
var input = new CodedInputStream(stream); |
||||||
|
input.ReadTag(); |
||||||
|
Assert.Throws<InvalidProtocolBufferException>(input.SkipLastField); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void RecursionLimitAppliedWhileSkippingGroup() |
||||||
|
{ |
||||||
|
var stream = new MemoryStream(); |
||||||
|
var output = new CodedOutputStream(stream); |
||||||
|
for (int i = 0; i < CodedInputStream.DefaultRecursionLimit + 1; i++) |
||||||
|
{ |
||||||
|
output.WriteTag(1, WireFormat.WireType.StartGroup); |
||||||
|
} |
||||||
|
for (int i = 0; i < CodedInputStream.DefaultRecursionLimit + 1; i++) |
||||||
|
{ |
||||||
|
output.WriteTag(1, WireFormat.WireType.EndGroup); |
||||||
|
} |
||||||
|
output.Flush(); |
||||||
|
stream.Position = 0; |
||||||
|
|
||||||
|
// Now act like a generated client |
||||||
|
var input = new CodedInputStream(stream); |
||||||
|
Assert.AreEqual(WireFormat.MakeTag(1, WireFormat.WireType.StartGroup), input.ReadTag()); |
||||||
|
Assert.Throws<InvalidProtocolBufferException>(input.SkipLastField); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void Construction_Invalid() |
||||||
|
{ |
||||||
|
Assert.Throws<ArgumentNullException>(() => new CodedInputStream((byte[]) null)); |
||||||
|
Assert.Throws<ArgumentNullException>(() => new CodedInputStream(null, 0, 0)); |
||||||
|
Assert.Throws<ArgumentNullException>(() => new CodedInputStream((Stream) null)); |
||||||
|
Assert.Throws<ArgumentOutOfRangeException>(() => new CodedInputStream(new byte[10], 100, 0)); |
||||||
|
Assert.Throws<ArgumentOutOfRangeException>(() => new CodedInputStream(new byte[10], 5, 10)); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void CreateWithLimits_InvalidLimits() |
||||||
|
{ |
||||||
|
var stream = new MemoryStream(); |
||||||
|
Assert.Throws<ArgumentOutOfRangeException>(() => CodedInputStream.CreateWithLimits(stream, 0, 1)); |
||||||
|
Assert.Throws<ArgumentOutOfRangeException>(() => CodedInputStream.CreateWithLimits(stream, 1, 0)); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void Dispose_DisposesUnderlyingStream() |
||||||
|
{ |
||||||
|
var memoryStream = new MemoryStream(); |
||||||
|
Assert.IsTrue(memoryStream.CanRead); |
||||||
|
using (var cis = new CodedInputStream(memoryStream)) |
||||||
|
{ |
||||||
|
} |
||||||
|
Assert.IsFalse(memoryStream.CanRead); // Disposed |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void Dispose_WithLeaveOpen() |
||||||
|
{ |
||||||
|
var memoryStream = new MemoryStream(); |
||||||
|
Assert.IsTrue(memoryStream.CanRead); |
||||||
|
using (var cis = new CodedInputStream(memoryStream, true)) |
||||||
|
{ |
||||||
|
} |
||||||
|
Assert.IsTrue(memoryStream.CanRead); // We left the stream open |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,419 @@ |
|||||||
|
#region Copyright notice and license |
||||||
|
// Protocol Buffers - Google's data interchange format |
||||||
|
// Copyright 2008 Google Inc. All rights reserved. |
||||||
|
// https://developers.google.com/protocol-buffers/ |
||||||
|
// |
||||||
|
// Redistribution and use in source and binary forms, with or without |
||||||
|
// modification, are permitted provided that the following conditions are |
||||||
|
// met: |
||||||
|
// |
||||||
|
// * Redistributions of source code must retain the above copyright |
||||||
|
// notice, this list of conditions and the following disclaimer. |
||||||
|
// * Redistributions in binary form must reproduce the above |
||||||
|
// copyright notice, this list of conditions and the following disclaimer |
||||||
|
// in the documentation and/or other materials provided with the |
||||||
|
// distribution. |
||||||
|
// * Neither the name of Google Inc. nor the names of its |
||||||
|
// contributors may be used to endorse or promote products derived from |
||||||
|
// this software without specific prior written permission. |
||||||
|
// |
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
#endregion |
||||||
|
|
||||||
|
using System; |
||||||
|
using System.IO; |
||||||
|
using Google.Protobuf.TestProtos; |
||||||
|
using NUnit.Framework; |
||||||
|
|
||||||
|
namespace Google.Protobuf |
||||||
|
{ |
||||||
|
public class CodedOutputStreamTest |
||||||
|
{ |
||||||
|
/// <summary> |
||||||
|
/// Writes the given value using WriteRawVarint32() and WriteRawVarint64() and |
||||||
|
/// checks that the result matches the given bytes |
||||||
|
/// </summary> |
||||||
|
private static void AssertWriteVarint(byte[] data, ulong value) |
||||||
|
{ |
||||||
|
// Only do 32-bit write if the value fits in 32 bits. |
||||||
|
if ((value >> 32) == 0) |
||||||
|
{ |
||||||
|
MemoryStream rawOutput = new MemoryStream(); |
||||||
|
CodedOutputStream output = new CodedOutputStream(rawOutput); |
||||||
|
output.WriteRawVarint32((uint) value); |
||||||
|
output.Flush(); |
||||||
|
Assert.AreEqual(data, rawOutput.ToArray()); |
||||||
|
// Also try computing size. |
||||||
|
Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint32Size((uint) value)); |
||||||
|
} |
||||||
|
|
||||||
|
{ |
||||||
|
MemoryStream rawOutput = new MemoryStream(); |
||||||
|
CodedOutputStream output = new CodedOutputStream(rawOutput); |
||||||
|
output.WriteRawVarint64(value); |
||||||
|
output.Flush(); |
||||||
|
Assert.AreEqual(data, rawOutput.ToArray()); |
||||||
|
|
||||||
|
// Also try computing size. |
||||||
|
Assert.AreEqual(data.Length, CodedOutputStream.ComputeRawVarint64Size(value)); |
||||||
|
} |
||||||
|
|
||||||
|
// Try different buffer sizes. |
||||||
|
for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) |
||||||
|
{ |
||||||
|
// Only do 32-bit write if the value fits in 32 bits. |
||||||
|
if ((value >> 32) == 0) |
||||||
|
{ |
||||||
|
MemoryStream rawOutput = new MemoryStream(); |
||||||
|
CodedOutputStream output = |
||||||
|
new CodedOutputStream(rawOutput, bufferSize); |
||||||
|
output.WriteRawVarint32((uint) value); |
||||||
|
output.Flush(); |
||||||
|
Assert.AreEqual(data, rawOutput.ToArray()); |
||||||
|
} |
||||||
|
|
||||||
|
{ |
||||||
|
MemoryStream rawOutput = new MemoryStream(); |
||||||
|
CodedOutputStream output = new CodedOutputStream(rawOutput, bufferSize); |
||||||
|
output.WriteRawVarint64(value); |
||||||
|
output.Flush(); |
||||||
|
Assert.AreEqual(data, rawOutput.ToArray()); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// Tests WriteRawVarint32() and WriteRawVarint64() |
||||||
|
/// </summary> |
||||||
|
[Test] |
||||||
|
public void WriteVarint() |
||||||
|
{ |
||||||
|
AssertWriteVarint(new byte[] {0x00}, 0); |
||||||
|
AssertWriteVarint(new byte[] {0x01}, 1); |
||||||
|
AssertWriteVarint(new byte[] {0x7f}, 127); |
||||||
|
// 14882 |
||||||
|
AssertWriteVarint(new byte[] {0xa2, 0x74}, (0x22 << 0) | (0x74 << 7)); |
||||||
|
// 2961488830 |
||||||
|
AssertWriteVarint(new byte[] {0xbe, 0xf7, 0x92, 0x84, 0x0b}, |
||||||
|
(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | |
||||||
|
(0x0bL << 28)); |
||||||
|
|
||||||
|
// 64-bit |
||||||
|
// 7256456126 |
||||||
|
AssertWriteVarint(new byte[] {0xbe, 0xf7, 0x92, 0x84, 0x1b}, |
||||||
|
(0x3e << 0) | (0x77 << 7) | (0x12 << 14) | (0x04 << 21) | |
||||||
|
(0x1bL << 28)); |
||||||
|
// 41256202580718336 |
||||||
|
AssertWriteVarint( |
||||||
|
new byte[] {0x80, 0xe6, 0xeb, 0x9c, 0xc3, 0xc9, 0xa4, 0x49}, |
||||||
|
(0x00 << 0) | (0x66 << 7) | (0x6b << 14) | (0x1c << 21) | |
||||||
|
(0x43UL << 28) | (0x49L << 35) | (0x24UL << 42) | (0x49UL << 49)); |
||||||
|
// 11964378330978735131 |
||||||
|
AssertWriteVarint( |
||||||
|
new byte[] {0x9b, 0xa8, 0xf9, 0xc2, 0xbb, 0xd6, 0x80, 0x85, 0xa6, 0x01}, |
||||||
|
unchecked((ulong) |
||||||
|
((0x1b << 0) | (0x28 << 7) | (0x79 << 14) | (0x42 << 21) | |
||||||
|
(0x3bL << 28) | (0x56L << 35) | (0x00L << 42) | |
||||||
|
(0x05L << 49) | (0x26L << 56) | (0x01L << 63)))); |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// Parses the given bytes using WriteRawLittleEndian32() and checks |
||||||
|
/// that the result matches the given value. |
||||||
|
/// </summary> |
||||||
|
private static void AssertWriteLittleEndian32(byte[] data, uint value) |
||||||
|
{ |
||||||
|
MemoryStream rawOutput = new MemoryStream(); |
||||||
|
CodedOutputStream output = new CodedOutputStream(rawOutput); |
||||||
|
output.WriteRawLittleEndian32(value); |
||||||
|
output.Flush(); |
||||||
|
Assert.AreEqual(data, rawOutput.ToArray()); |
||||||
|
|
||||||
|
// Try different buffer sizes. |
||||||
|
for (int bufferSize = 1; bufferSize <= 16; bufferSize *= 2) |
||||||
|
{ |
||||||
|
rawOutput = new MemoryStream(); |
||||||
|
output = new CodedOutputStream(rawOutput, bufferSize); |
||||||
|
output.WriteRawLittleEndian32(value); |
||||||
|
output.Flush(); |
||||||
|
Assert.AreEqual(data, rawOutput.ToArray()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// Parses the given bytes using WriteRawLittleEndian64() and checks |
||||||
|
/// that the result matches the given value. |
||||||
|
/// </summary> |
||||||
|
private static void AssertWriteLittleEndian64(byte[] data, ulong value) |
||||||
|
{ |
||||||
|
MemoryStream rawOutput = new MemoryStream(); |
||||||
|
CodedOutputStream output = new CodedOutputStream(rawOutput); |
||||||
|
output.WriteRawLittleEndian64(value); |
||||||
|
output.Flush(); |
||||||
|
Assert.AreEqual(data, rawOutput.ToArray()); |
||||||
|
|
||||||
|
// Try different block sizes. |
||||||
|
for (int blockSize = 1; blockSize <= 16; blockSize *= 2) |
||||||
|
{ |
||||||
|
rawOutput = new MemoryStream(); |
||||||
|
output = new CodedOutputStream(rawOutput, blockSize); |
||||||
|
output.WriteRawLittleEndian64(value); |
||||||
|
output.Flush(); |
||||||
|
Assert.AreEqual(data, rawOutput.ToArray()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/// <summary> |
||||||
|
/// Tests writeRawLittleEndian32() and writeRawLittleEndian64(). |
||||||
|
/// </summary> |
||||||
|
[Test] |
||||||
|
public void WriteLittleEndian() |
||||||
|
{ |
||||||
|
AssertWriteLittleEndian32(new byte[] {0x78, 0x56, 0x34, 0x12}, 0x12345678); |
||||||
|
AssertWriteLittleEndian32(new byte[] {0xf0, 0xde, 0xbc, 0x9a}, 0x9abcdef0); |
||||||
|
|
||||||
|
AssertWriteLittleEndian64( |
||||||
|
new byte[] {0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12}, |
||||||
|
0x123456789abcdef0L); |
||||||
|
AssertWriteLittleEndian64( |
||||||
|
new byte[] {0x78, 0x56, 0x34, 0x12, 0xf0, 0xde, 0xbc, 0x9a}, |
||||||
|
0x9abcdef012345678UL); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void WriteWholeMessage_VaryingBlockSizes() |
||||||
|
{ |
||||||
|
TestAllTypes message = SampleMessages.CreateFullTestAllTypes(); |
||||||
|
|
||||||
|
byte[] rawBytes = message.ToByteArray(); |
||||||
|
|
||||||
|
// Try different block sizes. |
||||||
|
for (int blockSize = 1; blockSize < 256; blockSize *= 2) |
||||||
|
{ |
||||||
|
MemoryStream rawOutput = new MemoryStream(); |
||||||
|
CodedOutputStream output = new CodedOutputStream(rawOutput, blockSize); |
||||||
|
message.WriteTo(output); |
||||||
|
output.Flush(); |
||||||
|
Assert.AreEqual(rawBytes, rawOutput.ToArray()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void EncodeZigZag32() |
||||||
|
{ |
||||||
|
Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag32(0)); |
||||||
|
Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag32(-1)); |
||||||
|
Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag32(1)); |
||||||
|
Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag32(-2)); |
||||||
|
Assert.AreEqual(0x7FFFFFFEu, CodedOutputStream.EncodeZigZag32(0x3FFFFFFF)); |
||||||
|
Assert.AreEqual(0x7FFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0xC0000000))); |
||||||
|
Assert.AreEqual(0xFFFFFFFEu, CodedOutputStream.EncodeZigZag32(0x7FFFFFFF)); |
||||||
|
Assert.AreEqual(0xFFFFFFFFu, CodedOutputStream.EncodeZigZag32(unchecked((int) 0x80000000))); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void EncodeZigZag64() |
||||||
|
{ |
||||||
|
Assert.AreEqual(0u, CodedOutputStream.EncodeZigZag64(0)); |
||||||
|
Assert.AreEqual(1u, CodedOutputStream.EncodeZigZag64(-1)); |
||||||
|
Assert.AreEqual(2u, CodedOutputStream.EncodeZigZag64(1)); |
||||||
|
Assert.AreEqual(3u, CodedOutputStream.EncodeZigZag64(-2)); |
||||||
|
Assert.AreEqual(0x000000007FFFFFFEuL, |
||||||
|
CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000003FFFFFFFUL))); |
||||||
|
Assert.AreEqual(0x000000007FFFFFFFuL, |
||||||
|
CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFFC0000000UL))); |
||||||
|
Assert.AreEqual(0x00000000FFFFFFFEuL, |
||||||
|
CodedOutputStream.EncodeZigZag64(unchecked((long) 0x000000007FFFFFFFUL))); |
||||||
|
Assert.AreEqual(0x00000000FFFFFFFFuL, |
||||||
|
CodedOutputStream.EncodeZigZag64(unchecked((long) 0xFFFFFFFF80000000UL))); |
||||||
|
Assert.AreEqual(0xFFFFFFFFFFFFFFFEL, |
||||||
|
CodedOutputStream.EncodeZigZag64(unchecked((long) 0x7FFFFFFFFFFFFFFFUL))); |
||||||
|
Assert.AreEqual(0xFFFFFFFFFFFFFFFFL, |
||||||
|
CodedOutputStream.EncodeZigZag64(unchecked((long) 0x8000000000000000UL))); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void RoundTripZigZag32() |
||||||
|
{ |
||||||
|
// Some easier-to-verify round-trip tests. The inputs (other than 0, 1, -1) |
||||||
|
// were chosen semi-randomly via keyboard bashing. |
||||||
|
Assert.AreEqual(0, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(0))); |
||||||
|
Assert.AreEqual(1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(1))); |
||||||
|
Assert.AreEqual(-1, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-1))); |
||||||
|
Assert.AreEqual(14927, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(14927))); |
||||||
|
Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag32(CodedOutputStream.EncodeZigZag32(-3612))); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void RoundTripZigZag64() |
||||||
|
{ |
||||||
|
Assert.AreEqual(0, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(0))); |
||||||
|
Assert.AreEqual(1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(1))); |
||||||
|
Assert.AreEqual(-1, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-1))); |
||||||
|
Assert.AreEqual(14927, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(14927))); |
||||||
|
Assert.AreEqual(-3612, CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-3612))); |
||||||
|
|
||||||
|
Assert.AreEqual(856912304801416L, |
||||||
|
CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(856912304801416L))); |
||||||
|
Assert.AreEqual(-75123905439571256L, |
||||||
|
CodedInputStream.DecodeZigZag64(CodedOutputStream.EncodeZigZag64(-75123905439571256L))); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void TestNegativeEnumNoTag() |
||||||
|
{ |
||||||
|
Assert.AreEqual(10, CodedOutputStream.ComputeInt32Size(-2)); |
||||||
|
Assert.AreEqual(10, CodedOutputStream.ComputeEnumSize((int) SampleEnum.NegativeValue)); |
||||||
|
|
||||||
|
byte[] bytes = new byte[10]; |
||||||
|
CodedOutputStream output = new CodedOutputStream(bytes); |
||||||
|
output.WriteEnum((int) SampleEnum.NegativeValue); |
||||||
|
|
||||||
|
Assert.AreEqual(0, output.SpaceLeft); |
||||||
|
Assert.AreEqual("FE-FF-FF-FF-FF-FF-FF-FF-FF-01", BitConverter.ToString(bytes)); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void TestCodedInputOutputPosition() |
||||||
|
{ |
||||||
|
byte[] content = new byte[110]; |
||||||
|
for (int i = 0; i < content.Length; i++) |
||||||
|
content[i] = (byte)i; |
||||||
|
|
||||||
|
byte[] child = new byte[120]; |
||||||
|
{ |
||||||
|
MemoryStream ms = new MemoryStream(child); |
||||||
|
CodedOutputStream cout = new CodedOutputStream(ms, 20); |
||||||
|
// Field 11: numeric value: 500 |
||||||
|
cout.WriteTag(11, WireFormat.WireType.Varint); |
||||||
|
Assert.AreEqual(1, cout.Position); |
||||||
|
cout.WriteInt32(500); |
||||||
|
Assert.AreEqual(3, cout.Position); |
||||||
|
//Field 12: length delimited 120 bytes |
||||||
|
cout.WriteTag(12, WireFormat.WireType.LengthDelimited); |
||||||
|
Assert.AreEqual(4, cout.Position); |
||||||
|
cout.WriteBytes(ByteString.CopyFrom(content)); |
||||||
|
Assert.AreEqual(115, cout.Position); |
||||||
|
// Field 13: fixed numeric value: 501 |
||||||
|
cout.WriteTag(13, WireFormat.WireType.Fixed32); |
||||||
|
Assert.AreEqual(116, cout.Position); |
||||||
|
cout.WriteSFixed32(501); |
||||||
|
Assert.AreEqual(120, cout.Position); |
||||||
|
cout.Flush(); |
||||||
|
} |
||||||
|
|
||||||
|
byte[] bytes = new byte[130]; |
||||||
|
{ |
||||||
|
CodedOutputStream cout = new CodedOutputStream(bytes); |
||||||
|
// Field 1: numeric value: 500 |
||||||
|
cout.WriteTag(1, WireFormat.WireType.Varint); |
||||||
|
Assert.AreEqual(1, cout.Position); |
||||||
|
cout.WriteInt32(500); |
||||||
|
Assert.AreEqual(3, cout.Position); |
||||||
|
//Field 2: length delimited 120 bytes |
||||||
|
cout.WriteTag(2, WireFormat.WireType.LengthDelimited); |
||||||
|
Assert.AreEqual(4, cout.Position); |
||||||
|
cout.WriteBytes(ByteString.CopyFrom(child)); |
||||||
|
Assert.AreEqual(125, cout.Position); |
||||||
|
// Field 3: fixed numeric value: 500 |
||||||
|
cout.WriteTag(3, WireFormat.WireType.Fixed32); |
||||||
|
Assert.AreEqual(126, cout.Position); |
||||||
|
cout.WriteSFixed32(501); |
||||||
|
Assert.AreEqual(130, cout.Position); |
||||||
|
cout.Flush(); |
||||||
|
} |
||||||
|
// Now test Input stream: |
||||||
|
{ |
||||||
|
CodedInputStream cin = new CodedInputStream(new MemoryStream(bytes), new byte[50], 0, 0); |
||||||
|
Assert.AreEqual(0, cin.Position); |
||||||
|
// Field 1: |
||||||
|
uint tag = cin.ReadTag(); |
||||||
|
Assert.AreEqual(1, tag >> 3); |
||||||
|
Assert.AreEqual(1, cin.Position); |
||||||
|
Assert.AreEqual(500, cin.ReadInt32()); |
||||||
|
Assert.AreEqual(3, cin.Position); |
||||||
|
//Field 2: |
||||||
|
tag = cin.ReadTag(); |
||||||
|
Assert.AreEqual(2, tag >> 3); |
||||||
|
Assert.AreEqual(4, cin.Position); |
||||||
|
int childlen = cin.ReadLength(); |
||||||
|
Assert.AreEqual(120, childlen); |
||||||
|
Assert.AreEqual(5, cin.Position); |
||||||
|
int oldlimit = cin.PushLimit((int)childlen); |
||||||
|
Assert.AreEqual(5, cin.Position); |
||||||
|
// Now we are reading child message |
||||||
|
{ |
||||||
|
// Field 11: numeric value: 500 |
||||||
|
tag = cin.ReadTag(); |
||||||
|
Assert.AreEqual(11, tag >> 3); |
||||||
|
Assert.AreEqual(6, cin.Position); |
||||||
|
Assert.AreEqual(500, cin.ReadInt32()); |
||||||
|
Assert.AreEqual(8, cin.Position); |
||||||
|
//Field 12: length delimited 120 bytes |
||||||
|
tag = cin.ReadTag(); |
||||||
|
Assert.AreEqual(12, tag >> 3); |
||||||
|
Assert.AreEqual(9, cin.Position); |
||||||
|
ByteString bstr = cin.ReadBytes(); |
||||||
|
Assert.AreEqual(110, bstr.Length); |
||||||
|
Assert.AreEqual((byte) 109, bstr[109]); |
||||||
|
Assert.AreEqual(120, cin.Position); |
||||||
|
// Field 13: fixed numeric value: 501 |
||||||
|
tag = cin.ReadTag(); |
||||||
|
Assert.AreEqual(13, tag >> 3); |
||||||
|
// ROK - Previously broken here, this returned 126 failing to account for bufferSizeAfterLimit |
||||||
|
Assert.AreEqual(121, cin.Position); |
||||||
|
Assert.AreEqual(501, cin.ReadSFixed32()); |
||||||
|
Assert.AreEqual(125, cin.Position); |
||||||
|
Assert.IsTrue(cin.IsAtEnd); |
||||||
|
} |
||||||
|
cin.PopLimit(oldlimit); |
||||||
|
Assert.AreEqual(125, cin.Position); |
||||||
|
// Field 3: fixed numeric value: 501 |
||||||
|
tag = cin.ReadTag(); |
||||||
|
Assert.AreEqual(3, tag >> 3); |
||||||
|
Assert.AreEqual(126, cin.Position); |
||||||
|
Assert.AreEqual(501, cin.ReadSFixed32()); |
||||||
|
Assert.AreEqual(130, cin.Position); |
||||||
|
Assert.IsTrue(cin.IsAtEnd); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void Dispose_DisposesUnderlyingStream() |
||||||
|
{ |
||||||
|
var memoryStream = new MemoryStream(); |
||||||
|
Assert.IsTrue(memoryStream.CanWrite); |
||||||
|
using (var cos = new CodedOutputStream(memoryStream)) |
||||||
|
{ |
||||||
|
cos.WriteRawByte(0); |
||||||
|
Assert.AreEqual(0, memoryStream.Position); // Not flushed yet |
||||||
|
} |
||||||
|
Assert.AreEqual(1, memoryStream.ToArray().Length); // Flushed data from CodedOutputStream to MemoryStream |
||||||
|
Assert.IsFalse(memoryStream.CanWrite); // Disposed |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void Dispose_WithLeaveOpen() |
||||||
|
{ |
||||||
|
var memoryStream = new MemoryStream(); |
||||||
|
Assert.IsTrue(memoryStream.CanWrite); |
||||||
|
using (var cos = new CodedOutputStream(memoryStream, true)) |
||||||
|
{ |
||||||
|
cos.WriteRawByte(0); |
||||||
|
Assert.AreEqual(0, memoryStream.Position); // Not flushed yet |
||||||
|
} |
||||||
|
Assert.AreEqual(1, memoryStream.Position); // Flushed data from CodedOutputStream to MemoryStream |
||||||
|
Assert.IsTrue(memoryStream.CanWrite); // We left the stream open |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,259 @@ |
|||||||
|
#region Copyright notice and license |
||||||
|
// Protocol Buffers - Google's data interchange format |
||||||
|
// Copyright 2008 Google Inc. All rights reserved. |
||||||
|
// https://developers.google.com/protocol-buffers/ |
||||||
|
// |
||||||
|
// Redistribution and use in source and binary forms, with or without |
||||||
|
// modification, are permitted provided that the following conditions are |
||||||
|
// met: |
||||||
|
// |
||||||
|
// * Redistributions of source code must retain the above copyright |
||||||
|
// notice, this list of conditions and the following disclaimer. |
||||||
|
// * Redistributions in binary form must reproduce the above |
||||||
|
// copyright notice, this list of conditions and the following disclaimer |
||||||
|
// in the documentation and/or other materials provided with the |
||||||
|
// distribution. |
||||||
|
// * Neither the name of Google Inc. nor the names of its |
||||||
|
// contributors may be used to endorse or promote products derived from |
||||||
|
// this software without specific prior written permission. |
||||||
|
// |
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
#endregion |
||||||
|
|
||||||
|
using System.Linq; |
||||||
|
using Google.Protobuf.TestProtos; |
||||||
|
using NUnit.Framework; |
||||||
|
using UnitTest.Issues.TestProtos; |
||||||
|
|
||||||
|
namespace Google.Protobuf.Reflection |
||||||
|
{ |
||||||
|
/// <summary> |
||||||
|
/// Tests for descriptors. (Not in its own namespace or broken up into individual classes as the |
||||||
|
/// size doesn't warrant it. On the other hand, this makes me feel a bit dirty...) |
||||||
|
/// </summary> |
||||||
|
public class DescriptorsTest |
||||||
|
{ |
||||||
|
[Test] |
||||||
|
public void FileDescriptor() |
||||||
|
{ |
||||||
|
FileDescriptor file = UnittestProto3Reflection.Descriptor; |
||||||
|
|
||||||
|
Assert.AreEqual("google/protobuf/unittest_proto3.proto", file.Name); |
||||||
|
Assert.AreEqual("protobuf_unittest", file.Package); |
||||||
|
|
||||||
|
Assert.AreEqual("UnittestProto", file.Proto.Options.JavaOuterClassname); |
||||||
|
Assert.AreEqual("google/protobuf/unittest_proto3.proto", file.Proto.Name); |
||||||
|
|
||||||
|
// unittest.proto doesn't have any public imports, but unittest_import.proto does. |
||||||
|
Assert.AreEqual(0, file.PublicDependencies.Count); |
||||||
|
Assert.AreEqual(1, UnittestImportProto3Reflection.Descriptor.PublicDependencies.Count); |
||||||
|
Assert.AreEqual(UnittestImportPublicProto3Reflection.Descriptor, UnittestImportProto3Reflection.Descriptor.PublicDependencies[0]); |
||||||
|
|
||||||
|
Assert.AreEqual(1, file.Dependencies.Count); |
||||||
|
Assert.AreEqual(UnittestImportProto3Reflection.Descriptor, file.Dependencies[0]); |
||||||
|
|
||||||
|
MessageDescriptor messageType = TestAllTypes.Descriptor; |
||||||
|
Assert.AreSame(typeof(TestAllTypes), messageType.ClrType); |
||||||
|
Assert.AreSame(TestAllTypes.Parser, messageType.Parser); |
||||||
|
Assert.AreEqual(messageType, file.MessageTypes[0]); |
||||||
|
Assert.AreEqual(messageType, file.FindTypeByName<MessageDescriptor>("TestAllTypes")); |
||||||
|
Assert.Null(file.FindTypeByName<MessageDescriptor>("NoSuchType")); |
||||||
|
Assert.Null(file.FindTypeByName<MessageDescriptor>("protobuf_unittest.TestAllTypes")); |
||||||
|
for (int i = 0; i < file.MessageTypes.Count; i++) |
||||||
|
{ |
||||||
|
Assert.AreEqual(i, file.MessageTypes[i].Index); |
||||||
|
} |
||||||
|
|
||||||
|
Assert.AreEqual(file.EnumTypes[0], file.FindTypeByName<EnumDescriptor>("ForeignEnum")); |
||||||
|
Assert.Null(file.FindTypeByName<EnumDescriptor>("NoSuchType")); |
||||||
|
Assert.Null(file.FindTypeByName<EnumDescriptor>("protobuf_unittest.ForeignEnum")); |
||||||
|
Assert.AreEqual(1, UnittestImportProto3Reflection.Descriptor.EnumTypes.Count); |
||||||
|
Assert.AreEqual("ImportEnum", UnittestImportProto3Reflection.Descriptor.EnumTypes[0].Name); |
||||||
|
for (int i = 0; i < file.EnumTypes.Count; i++) |
||||||
|
{ |
||||||
|
Assert.AreEqual(i, file.EnumTypes[i].Index); |
||||||
|
} |
||||||
|
|
||||||
|
Assert.AreEqual(10, file.SerializedData[0]); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void MessageDescriptor() |
||||||
|
{ |
||||||
|
MessageDescriptor messageType = TestAllTypes.Descriptor; |
||||||
|
MessageDescriptor nestedType = TestAllTypes.Types.NestedMessage.Descriptor; |
||||||
|
|
||||||
|
Assert.AreEqual("TestAllTypes", messageType.Name); |
||||||
|
Assert.AreEqual("protobuf_unittest.TestAllTypes", messageType.FullName); |
||||||
|
Assert.AreEqual(UnittestProto3Reflection.Descriptor, messageType.File); |
||||||
|
Assert.IsNull(messageType.ContainingType); |
||||||
|
Assert.IsNull(messageType.Proto.Options); |
||||||
|
|
||||||
|
Assert.AreEqual("TestAllTypes", messageType.Name); |
||||||
|
|
||||||
|
Assert.AreEqual("NestedMessage", nestedType.Name); |
||||||
|
Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedMessage", nestedType.FullName); |
||||||
|
Assert.AreEqual(UnittestProto3Reflection.Descriptor, nestedType.File); |
||||||
|
Assert.AreEqual(messageType, nestedType.ContainingType); |
||||||
|
|
||||||
|
FieldDescriptor field = messageType.Fields.InDeclarationOrder()[0]; |
||||||
|
Assert.AreEqual("single_int32", field.Name); |
||||||
|
Assert.AreEqual(field, messageType.FindDescriptor<FieldDescriptor>("single_int32")); |
||||||
|
Assert.Null(messageType.FindDescriptor<FieldDescriptor>("no_such_field")); |
||||||
|
Assert.AreEqual(field, messageType.FindFieldByNumber(1)); |
||||||
|
Assert.Null(messageType.FindFieldByNumber(571283)); |
||||||
|
var fieldsInDeclarationOrder = messageType.Fields.InDeclarationOrder(); |
||||||
|
for (int i = 0; i < fieldsInDeclarationOrder.Count; i++) |
||||||
|
{ |
||||||
|
Assert.AreEqual(i, fieldsInDeclarationOrder[i].Index); |
||||||
|
} |
||||||
|
|
||||||
|
Assert.AreEqual(nestedType, messageType.NestedTypes[0]); |
||||||
|
Assert.AreEqual(nestedType, messageType.FindDescriptor<MessageDescriptor>("NestedMessage")); |
||||||
|
Assert.Null(messageType.FindDescriptor<MessageDescriptor>("NoSuchType")); |
||||||
|
for (int i = 0; i < messageType.NestedTypes.Count; i++) |
||||||
|
{ |
||||||
|
Assert.AreEqual(i, messageType.NestedTypes[i].Index); |
||||||
|
} |
||||||
|
|
||||||
|
Assert.AreEqual(messageType.EnumTypes[0], messageType.FindDescriptor<EnumDescriptor>("NestedEnum")); |
||||||
|
Assert.Null(messageType.FindDescriptor<EnumDescriptor>("NoSuchType")); |
||||||
|
for (int i = 0; i < messageType.EnumTypes.Count; i++) |
||||||
|
{ |
||||||
|
Assert.AreEqual(i, messageType.EnumTypes[i].Index); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void FieldDescriptor() |
||||||
|
{ |
||||||
|
MessageDescriptor messageType = TestAllTypes.Descriptor; |
||||||
|
FieldDescriptor primitiveField = messageType.FindDescriptor<FieldDescriptor>("single_int32"); |
||||||
|
FieldDescriptor enumField = messageType.FindDescriptor<FieldDescriptor>("single_nested_enum"); |
||||||
|
FieldDescriptor messageField = messageType.FindDescriptor<FieldDescriptor>("single_foreign_message"); |
||||||
|
|
||||||
|
Assert.AreEqual("single_int32", primitiveField.Name); |
||||||
|
Assert.AreEqual("protobuf_unittest.TestAllTypes.single_int32", |
||||||
|
primitiveField.FullName); |
||||||
|
Assert.AreEqual(1, primitiveField.FieldNumber); |
||||||
|
Assert.AreEqual(messageType, primitiveField.ContainingType); |
||||||
|
Assert.AreEqual(UnittestProto3Reflection.Descriptor, primitiveField.File); |
||||||
|
Assert.AreEqual(FieldType.Int32, primitiveField.FieldType); |
||||||
|
Assert.IsNull(primitiveField.Proto.Options); |
||||||
|
|
||||||
|
Assert.AreEqual("single_nested_enum", enumField.Name); |
||||||
|
Assert.AreEqual(FieldType.Enum, enumField.FieldType); |
||||||
|
// Assert.AreEqual(TestAllTypes.Types.NestedEnum.DescriptorProtoFile, enumField.EnumType); |
||||||
|
|
||||||
|
Assert.AreEqual("single_foreign_message", messageField.Name); |
||||||
|
Assert.AreEqual(FieldType.Message, messageField.FieldType); |
||||||
|
Assert.AreEqual(ForeignMessage.Descriptor, messageField.MessageType); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void FieldDescriptorLabel() |
||||||
|
{ |
||||||
|
FieldDescriptor singleField = |
||||||
|
TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("single_int32"); |
||||||
|
FieldDescriptor repeatedField = |
||||||
|
TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("repeated_int32"); |
||||||
|
|
||||||
|
Assert.IsFalse(singleField.IsRepeated); |
||||||
|
Assert.IsTrue(repeatedField.IsRepeated); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void EnumDescriptor() |
||||||
|
{ |
||||||
|
// Note: this test is a bit different to the Java version because there's no static way of getting to the descriptor |
||||||
|
EnumDescriptor enumType = UnittestProto3Reflection.Descriptor.FindTypeByName<EnumDescriptor>("ForeignEnum"); |
||||||
|
EnumDescriptor nestedType = TestAllTypes.Descriptor.FindDescriptor<EnumDescriptor>("NestedEnum"); |
||||||
|
|
||||||
|
Assert.AreEqual("ForeignEnum", enumType.Name); |
||||||
|
Assert.AreEqual("protobuf_unittest.ForeignEnum", enumType.FullName); |
||||||
|
Assert.AreEqual(UnittestProto3Reflection.Descriptor, enumType.File); |
||||||
|
Assert.Null(enumType.ContainingType); |
||||||
|
Assert.Null(enumType.Proto.Options); |
||||||
|
|
||||||
|
Assert.AreEqual("NestedEnum", nestedType.Name); |
||||||
|
Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedEnum", |
||||||
|
nestedType.FullName); |
||||||
|
Assert.AreEqual(UnittestProto3Reflection.Descriptor, nestedType.File); |
||||||
|
Assert.AreEqual(TestAllTypes.Descriptor, nestedType.ContainingType); |
||||||
|
|
||||||
|
EnumValueDescriptor value = enumType.FindValueByName("FOREIGN_FOO"); |
||||||
|
Assert.AreEqual(value, enumType.Values[1]); |
||||||
|
Assert.AreEqual("FOREIGN_FOO", value.Name); |
||||||
|
Assert.AreEqual(4, value.Number); |
||||||
|
Assert.AreEqual((int) ForeignEnum.ForeignFoo, value.Number); |
||||||
|
Assert.AreEqual(value, enumType.FindValueByNumber(4)); |
||||||
|
Assert.Null(enumType.FindValueByName("NO_SUCH_VALUE")); |
||||||
|
for (int i = 0; i < enumType.Values.Count; i++) |
||||||
|
{ |
||||||
|
Assert.AreEqual(i, enumType.Values[i].Index); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void OneofDescriptor() |
||||||
|
{ |
||||||
|
OneofDescriptor descriptor = TestAllTypes.Descriptor.FindDescriptor<OneofDescriptor>("oneof_field"); |
||||||
|
Assert.AreEqual("oneof_field", descriptor.Name); |
||||||
|
Assert.AreEqual("protobuf_unittest.TestAllTypes.oneof_field", descriptor.FullName); |
||||||
|
|
||||||
|
var expectedFields = new[] { |
||||||
|
TestAllTypes.OneofBytesFieldNumber, |
||||||
|
TestAllTypes.OneofNestedMessageFieldNumber, |
||||||
|
TestAllTypes.OneofStringFieldNumber, |
||||||
|
TestAllTypes.OneofUint32FieldNumber } |
||||||
|
.Select(fieldNumber => TestAllTypes.Descriptor.FindFieldByNumber(fieldNumber)) |
||||||
|
.ToList(); |
||||||
|
foreach (var field in expectedFields) |
||||||
|
{ |
||||||
|
Assert.AreSame(descriptor, field.ContainingOneof); |
||||||
|
} |
||||||
|
|
||||||
|
CollectionAssert.AreEquivalent(expectedFields, descriptor.Fields); |
||||||
|
} |
||||||
|
|
||||||
|
[Test] |
||||||
|
public void MapEntryMessageDescriptor() |
||||||
|
{ |
||||||
|
var descriptor = MapWellKnownTypes.Descriptor.NestedTypes[0]; |
||||||
|
Assert.IsNull(descriptor.Parser); |
||||||
|
Assert.IsNull(descriptor.ClrType); |
||||||
|
Assert.IsNull(descriptor.Fields[1].Accessor); |
||||||
|
} |
||||||
|
|
||||||
|
// From TestFieldOrdering: |
||||||
|
// string my_string = 11; |
||||||
|
// int64 my_int = 1; |
||||||
|
// float my_float = 101; |
||||||
|
// NestedMessage single_nested_message = 200; |
||||||
|
[Test] |
||||||
|
public void FieldListOrderings() |
||||||
|
{ |
||||||
|
var fields = TestFieldOrderings.Descriptor.Fields; |
||||||
|
Assert.AreEqual(new[] { 11, 1, 101, 200 }, fields.InDeclarationOrder().Select(x => x.FieldNumber)); |
||||||
|
Assert.AreEqual(new[] { 1, 11, 101, 200 }, fields.InFieldNumberOrder().Select(x => x.FieldNumber)); |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
[Test] |
||||||
|
public void DescriptorProtoFileDescriptor() |
||||||
|
{ |
||||||
|
var descriptor = Google.Protobuf.Reflection.FileDescriptor.DescriptorProtoFileDescriptor; |
||||||
|
Assert.AreEqual("google/protobuf/descriptor.proto", descriptor.Name); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,42 @@ |
|||||||
|
#region Copyright notice and license |
||||||
|
// Protocol Buffers - Google's data interchange format |
||||||
|
// Copyright 2015 Google Inc. All rights reserved. |
||||||
|
// https://developers.google.com/protocol-buffers/ |
||||||
|
// |
||||||
|
// Redistribution and use in source and binary forms, with or without |
||||||
|
// modification, are permitted provided that the following conditions are |
||||||
|
// met: |
||||||
|
// |
||||||
|
// * Redistributions of source code must retain the above copyright |
||||||
|
// notice, this list of conditions and the following disclaimer. |
||||||
|
// * Redistributions in binary form must reproduce the above |
||||||
|
// copyright notice, this list of conditions and the following disclaimer |
||||||
|
// in the documentation and/or other materials provided with the |
||||||
|
// distribution. |
||||||
|
// * Neither the name of Google Inc. nor the names of its |
||||||
|
// contributors may be used to endorse or promote products derived from |
||||||
|
// this software without specific prior written permission. |
||||||
|
// |
||||||
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||||||
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||||||
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||||||
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||||||
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||||||
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||||||
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||||
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||||||
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||||
|
#endregion |
||||||
|
|
||||||
|
namespace Google.Protobuf |
||||||
|
{ |
||||||
|
// Just a sample enum with positive and negative values to be used in tests. |
||||||
|
internal enum SampleEnum |
||||||
|
{ |
||||||
|
NegativeValue = -2, |
||||||
|
None = 0, |
||||||
|
PositiveValue = 3 |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,44 @@ |
|||||||
|
{ |
||||||
|
"buildOptions": { |
||||||
|
"debugType": "portable", |
||||||
|
"keyFile": "../../keys/Google.Protobuf.snk" |
||||||
|
}, |
||||||
|
|
||||||
|
"configurations": { |
||||||
|
"Debug": { |
||||||
|
"buildOptions": { |
||||||
|
"define": [ "DEBUG", "TRACE" ] |
||||||
|
} |
||||||
|
}, |
||||||
|
"Release": { |
||||||
|
"buildOptions": { |
||||||
|
"define": [ "RELEASE", "TRACE" ], |
||||||
|
"optimize": true |
||||||
|
} |
||||||
|
} |
||||||
|
}, |
||||||
|
|
||||||
|
"dependencies": { |
||||||
|
"Google.Protobuf": { "target": "project" }, |
||||||
|
"NUnit": "3.4.0", |
||||||
|
"dotnet-test-nunit": "3.4.0-alpha-2", |
||||||
|
}, |
||||||
|
|
||||||
|
"testRunner": "nunit", |
||||||
|
|
||||||
|
"frameworks": { |
||||||
|
"netcoreapp1.0": { |
||||||
|
"imports" : [ "dnxcore50", "netcoreapp1.0", "portable-net45+win8" ], |
||||||
|
"buildOptions": { |
||||||
|
"define": [ "PCL" ] |
||||||
|
}, |
||||||
|
"dependencies": { |
||||||
|
"Microsoft.NETCore.App": { |
||||||
|
"version": "1.0.0", |
||||||
|
"type": "platform" |
||||||
|
}, |
||||||
|
"System.Console": "4.0.0" |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,102 @@ |
|||||||
|
#!/bin/bash |
||||||
|
|
||||||
|
function run_test() { |
||||||
|
# Generate test proto files. |
||||||
|
./protoc_1 -Iprotos/src -I../../../src/ --csharp_out=src/Google.Protobuf.Test \ |
||||||
|
--csharp_opt=base_namespace=Google.Protobuf \ |
||||||
|
protos/src/google/protobuf/unittest_import_proto3.proto \ |
||||||
|
protos/src/google/protobuf/unittest_import_public_proto3.proto \ |
||||||
|
protos/src/google/protobuf/unittest_well_known_types.proto |
||||||
|
|
||||||
|
./protoc_1 -Iprotos/csharp --csharp_out=src/Google.Protobuf.Test \ |
||||||
|
--csharp_opt=base_namespace=UnitTest.Issues \ |
||||||
|
protos/csharp/protos/unittest_issues.proto |
||||||
|
|
||||||
|
./protoc_2 -Iprotos/src --csharp_out=src/Google.Protobuf.Test \ |
||||||
|
--csharp_opt=base_namespace=Google.Protobuf \ |
||||||
|
protos/src/google/protobuf/unittest_proto3.proto \ |
||||||
|
protos/src/google/protobuf/map_unittest_proto3.proto |
||||||
|
|
||||||
|
# Build and test. |
||||||
|
dotnet build -c release src/Google.Protobuf src/Google.Protobuf.Test |
||||||
|
dotnet test -c release -f netcoreapp1.0 src/Google.Protobuf.Test |
||||||
|
} |
||||||
|
|
||||||
|
set -ex |
||||||
|
|
||||||
|
# Change to the script's directory. |
||||||
|
cd $(dirname $0) |
||||||
|
|
||||||
|
# Version of the tests (i.e., the version of protobuf from where we extracted |
||||||
|
# these tests). |
||||||
|
TEST_VERSION=3.0.0 |
||||||
|
|
||||||
|
# The old version of protobuf that we are testing compatibility against. This |
||||||
|
# is usually the same as TEST_VERSION (i.e., we use the tests extracted from |
||||||
|
# that version to test compatibility of the newest runtime against it), but it |
||||||
|
# is also possible to use this same test set to test the compatibiilty of the |
||||||
|
# latest version against other versions. |
||||||
|
case "$1" in |
||||||
|
""|3.0.0) |
||||||
|
OLD_VERSION=3.0.0 |
||||||
|
OLD_VERSION_PROTOC=http://repo1.maven.org/maven2/com/google/protobuf/protoc/3.0.0/protoc-3.0.0-linux-x86_64.exe |
||||||
|
;; |
||||||
|
3.0.2) |
||||||
|
OLD_VERSION=3.0.2 |
||||||
|
OLD_VERSION_PROTOC=http://repo1.maven.org/maven2/com/google/protobuf/protoc/3.0.2/protoc-3.0.2-linux-x86_64.exe |
||||||
|
;; |
||||||
|
3.1.0) |
||||||
|
OLD_VERSION=3.1.0 |
||||||
|
OLD_VERSION_PROTOC=http://repo1.maven.org/maven2/com/google/protobuf/protoc/3.1.0/protoc-3.1.0-linux-x86_64.exe |
||||||
|
;; |
||||||
|
*) |
||||||
|
echo "[ERROR]: Unknown version number: $1" |
||||||
|
exit 1 |
||||||
|
;; |
||||||
|
esac |
||||||
|
|
||||||
|
echo "Running compatibility tests with $OLD_VERSION" |
||||||
|
|
||||||
|
# Check protoc |
||||||
|
[ -f ../../../src/protoc ] || { |
||||||
|
echo "[ERROR]: Please build protoc first." |
||||||
|
exit 1 |
||||||
|
} |
||||||
|
|
||||||
|
# Download old version protoc compiler (for linux). |
||||||
|
wget $OLD_VERSION_PROTOC -O old_protoc |
||||||
|
chmod +x old_protoc |
||||||
|
|
||||||
|
# Test source compatibility. In these tests we recompile everything against |
||||||
|
# the new runtime (including old version generated code). |
||||||
|
# Copy the new runtime and keys. |
||||||
|
cp ../../src/Google.Protobuf src/Google.Protobuf -r |
||||||
|
cp ../../keys . -r |
||||||
|
dotnet restore |
||||||
|
|
||||||
|
# Test A.1: |
||||||
|
# proto set 1: use old version |
||||||
|
# proto set 2 which may import protos in set 1: use old version |
||||||
|
cp old_protoc protoc_1 |
||||||
|
cp old_protoc protoc_2 |
||||||
|
run_test |
||||||
|
|
||||||
|
# Test A.2: |
||||||
|
# proto set 1: use new version |
||||||
|
# proto set 2 which may import protos in set 1: use old version |
||||||
|
cp ../../../src/protoc protoc_1 |
||||||
|
cp old_protoc protoc_2 |
||||||
|
run_test |
||||||
|
|
||||||
|
# Test A.3: |
||||||
|
# proto set 1: use old version |
||||||
|
# proto set 2 which may import protos in set 1: use new version |
||||||
|
cp old_protoc protoc_1 |
||||||
|
cp ../../../src/protoc protoc_2 |
||||||
|
run_test |
||||||
|
|
||||||
|
rm protoc_1 |
||||||
|
rm protoc_2 |
||||||
|
rm old_protoc |
||||||
|
rm keys -r |
||||||
|
rm src/Google.Protobuf -r |
||||||
Loading…
Reference in new issue