Skip to content
Projects
Groups
Snippets
Help
Loading...
Sign in / Register
Toggle navigation
P
protobuf
Project
Project
Details
Activity
Cycle Analytics
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Charts
Issues
0
Issues
0
List
Board
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Charts
Packages
Packages
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Charts
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
submodule
protobuf
Commits
5af0b547
Commit
5af0b547
authored
Jan 27, 2017
by
Jie Luo
Committed by
GitHub
Jan 27, 2017
Browse files
Options
Browse Files
Download
Plain Diff
Merge pull request #2619 from anandolee/master
Add python compatibility tests against v2.5.0
parents
1f097862
ea511491
Hide whitespace changes
Inline
Side-by-side
Showing
32 changed files
with
5851 additions
and
1 deletion
+5851
-1
.travis.yml
.travis.yml
+4
-0
factory_test1.proto
...rotos/python/google/protobuf/internal/factory_test1.proto
+55
-0
factory_test2.proto
...rotos/python/google/protobuf/internal/factory_test2.proto
+77
-0
more_extensions.proto
...tos/python/google/protobuf/internal/more_extensions.proto
+58
-0
more_extensions_dynamic.proto
...on/google/protobuf/internal/more_extensions_dynamic.proto
+49
-0
more_messages.proto
...rotos/python/google/protobuf/internal/more_messages.proto
+51
-0
test_bad_identifiers.proto
...ython/google/protobuf/internal/test_bad_identifiers.proto
+52
-0
descriptor.proto
.../v2.5.0/protos/src/proto/google/protobuf/descriptor.proto
+620
-0
unittest.proto
...ts/v2.5.0/protos/src/proto/google/protobuf/unittest.proto
+719
-0
unittest_custom_options.proto
...s/src/proto/google/protobuf/unittest_custom_options.proto
+387
-0
unittest_import.proto
....0/protos/src/proto/google/protobuf/unittest_import.proto
+64
-0
unittest_import_public.proto
...os/src/proto/google/protobuf/unittest_import_public.proto
+40
-0
unittest_mset.proto
....5.0/protos/src/proto/google/protobuf/unittest_mset.proto
+72
-0
unittest_no_generic_services.proto
.../proto/google/protobuf/unittest_no_generic_services.proto
+52
-0
setup.py
python/compatibility_tests/v2.5.0/setup.py
+87
-0
test.sh
python/compatibility_tests/v2.5.0/test.sh
+110
-0
__init__.py
python/compatibility_tests/v2.5.0/tests/__init__.py
+4
-0
__init__.py
python/compatibility_tests/v2.5.0/tests/google/__init__.py
+4
-0
__init__.py
...patibility_tests/v2.5.0/tests/google/protobuf/__init__.py
+4
-0
__init__.py
...y_tests/v2.5.0/tests/google/protobuf/internal/__init__.py
+37
-0
descriptor_test.py
.../v2.5.0/tests/google/protobuf/internal/descriptor_test.py
+613
-0
generator_test.py
...s/v2.5.0/tests/google/protobuf/internal/generator_test.py
+269
-0
golden_message
...ests/v2.5.0/tests/google/protobuf/internal/golden_message
+0
-0
golden_packed_fields_message
...sts/google/protobuf/internal/golden_packed_fields_message
+0
-0
message_test.py
...sts/v2.5.0/tests/google/protobuf/internal/message_test.py
+494
-0
service_reflection_test.py
...tests/google/protobuf/internal/service_reflection_test.py
+136
-0
test_util.py
..._tests/v2.5.0/tests/google/protobuf/internal/test_util.py
+651
-0
text_format_test.py
...v2.5.0/tests/google/protobuf/internal/text_format_test.py
+620
-0
text_format_unittest_data.txt
...ts/google/protobuf/internal/text_format_unittest_data.txt
+128
-0
text_format_unittest_extensions_data.txt
...rotobuf/internal/text_format_unittest_extensions_data.txt
+128
-0
wire_format_test.py
...v2.5.0/tests/google/protobuf/internal/wire_format_test.py
+253
-0
tests.sh
tests.sh
+13
-1
No files found.
.travis.yml
View file @
5af0b547
...
...
@@ -63,6 +63,10 @@ matrix:
# fetch pre-built Linux protoc binaries in the test.
-
os
:
linux
env
:
CONFIG=java_compatibility
# The Python compatibility test currently only runs on Linux because it will
# fetch pre-built Linux protoc binaries in the test.
-
os
:
linux
env
:
CONFIG=python_compatibility
allow_failures
:
# These currently do not work on OS X but are being worked on by @haberman.
-
os
:
osx
...
...
python/compatibility_tests/v2.5.0/protos/python/google/protobuf/internal/factory_test1.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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: matthewtoia@google.com (Matt Toia)
package
google
.
protobuf.python.internal
;
enum
Factory1Enum
{
FACTORY_1_VALUE_0
=
0
;
FACTORY_1_VALUE_1
=
1
;
}
message
Factory1Message
{
optional
Factory1Enum
factory_1_enum
=
1
;
enum
NestedFactory1Enum
{
NESTED_FACTORY_1_VALUE_0
=
0
;
NESTED_FACTORY_1_VALUE_1
=
1
;
}
optional
NestedFactory1Enum
nested_factory_1_enum
=
2
;
message
NestedFactory1Message
{
optional
string
value
=
1
;
}
optional
NestedFactory1Message
nested_factory_1_message
=
3
;
optional
int32
scalar_value
=
4
;
repeated
string
list_value
=
5
;
}
python/compatibility_tests/v2.5.0/protos/python/google/protobuf/internal/factory_test2.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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: matthewtoia@google.com (Matt Toia)
package
google
.
protobuf.python.internal
;
import
"google/protobuf/internal/factory_test1.proto"
;
enum
Factory2Enum
{
FACTORY_2_VALUE_0
=
0
;
FACTORY_2_VALUE_1
=
1
;
}
message
Factory2Message
{
required
int32
mandatory
=
1
;
optional
Factory2Enum
factory_2_enum
=
2
;
enum
NestedFactory2Enum
{
NESTED_FACTORY_2_VALUE_0
=
0
;
NESTED_FACTORY_2_VALUE_1
=
1
;
}
optional
NestedFactory2Enum
nested_factory_2_enum
=
3
;
message
NestedFactory2Message
{
optional
string
value
=
1
;
}
optional
NestedFactory2Message
nested_factory_2_message
=
4
;
optional
Factory1Message
factory_1_message
=
5
;
optional
Factory1Enum
factory_1_enum
=
6
;
optional
Factory1Message.NestedFactory1Enum
nested_factory_1_enum
=
7
;
optional
Factory1Message.NestedFactory1Message
nested_factory_1_message
=
8
;
optional
Factory2Message
circular_message
=
9
;
optional
string
scalar_value
=
10
;
repeated
string
list_value
=
11
;
repeated
group
Grouped
=
12
{
optional
string
part_1
=
13
;
optional
string
part_2
=
14
;
}
optional
LoopMessage
loop
=
15
;
optional
int32
int_with_default
=
16
[
default
=
1776
];
optional
double
double_with_default
=
17
[
default
=
9.99
];
optional
string
string_with_default
=
18
[
default
=
"hello world"
];
optional
bool
bool_with_default
=
19
[
default
=
false
];
optional
Factory2Enum
enum_with_default
=
20
[
default
=
FACTORY_2_VALUE_1
];
}
message
LoopMessage
{
optional
Factory2Message
loop
=
1
;
}
python/compatibility_tests/v2.5.0/protos/python/google/protobuf/internal/more_extensions.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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: robinson@google.com (Will Robinson)
package
google
.
protobuf.internal
;
message
TopLevelMessage
{
optional
ExtendedMessage
submessage
=
1
;
}
message
ExtendedMessage
{
extensions
1
to
max
;
}
message
ForeignMessage
{
optional
int32
foreign_message_int
=
1
;
}
extend
ExtendedMessage
{
optional
int32
optional_int_extension
=
1
;
optional
ForeignMessage
optional_message_extension
=
2
;
repeated
int32
repeated_int_extension
=
3
;
repeated
ForeignMessage
repeated_message_extension
=
4
;
}
python/compatibility_tests/v2.5.0/protos/python/google/protobuf/internal/more_extensions_dynamic.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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: jasonh@google.com (Jason Hsueh)
//
// This file is used to test a corner case in the CPP implementation where the
// generated C++ type is available for the extendee, but the extension is
// defined in a file whose C++ type is not in the binary.
import
"google/protobuf/internal/more_extensions.proto"
;
package
google
.
protobuf.internal
;
message
DynamicMessageType
{
optional
int32
a
=
1
;
}
extend
ExtendedMessage
{
optional
int32
dynamic_int32_extension
=
100
;
optional
DynamicMessageType
dynamic_message_extension
=
101
;
}
python/compatibility_tests/v2.5.0/protos/python/google/protobuf/internal/more_messages.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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: robinson@google.com (Will Robinson)
package
google
.
protobuf.internal
;
// A message where tag numbers are listed out of order, to allow us to test our
// canonicalization of serialized output, which should always be in tag order.
// We also mix in some extensions for extra fun.
message
OutOfOrderFields
{
optional
sint32
optional_sint32
=
5
;
extensions
4
to
4
;
optional
uint32
optional_uint32
=
3
;
extensions
2
to
2
;
optional
int32
optional_int32
=
1
;
};
extend
OutOfOrderFields
{
optional
uint64
optional_uint64
=
4
;
optional
int64
optional_int64
=
2
;
}
python/compatibility_tests/v2.5.0/protos/python/google/protobuf/internal/test_bad_identifiers.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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)
package
protobuf_unittest
;
option
py_generic_services
=
true
;
message
TestBadIdentifiers
{
extensions
100
to
max
;
}
// Make sure these reasonable extension names don't conflict with internal
// variables.
extend
TestBadIdentifiers
{
optional
string
message
=
100
[
default
=
"foo"
];
optional
string
descriptor
=
101
[
default
=
"bar"
];
optional
string
reflection
=
102
[
default
=
"baz"
];
optional
string
service
=
103
[
default
=
"qux"
];
}
message
AnotherMessage
{}
service
AnotherService
{}
python/compatibility_tests/v2.5.0/protos/src/proto/google/protobuf/descriptor.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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.
//
// The messages in this file describe the definitions found in .proto files.
// A valid .proto file can be translated directly to a FileDescriptorProto
// without any other information (e.g. without reading its imports).
package
google
.
protobuf
;
option
java_package
=
"com.google.protobuf"
;
option
java_outer_classname
=
"DescriptorProtos"
;
// descriptor.proto must be optimized for speed because reflection-based
// algorithms don't work during bootstrapping.
option
optimize_for
=
SPEED
;
// The protocol compiler can output a FileDescriptorSet containing the .proto
// files it parses.
message
FileDescriptorSet
{
repeated
FileDescriptorProto
file
=
1
;
}
// Describes a complete .proto file.
message
FileDescriptorProto
{
optional
string
name
=
1
;
// file name, relative to root of source tree
optional
string
package
=
2
;
// e.g. "foo", "foo.bar", etc.
// Names of files imported by this file.
repeated
string
dependency
=
3
;
// Indexes of the public imported files in the dependency list above.
repeated
int32
public_dependency
=
10
;
// Indexes of the weak imported files in the dependency list.
// For Google-internal migration only. Do not use.
repeated
int32
weak_dependency
=
11
;
// All top-level definitions in this file.
repeated
DescriptorProto
message_type
=
4
;
repeated
EnumDescriptorProto
enum_type
=
5
;
repeated
ServiceDescriptorProto
service
=
6
;
repeated
FieldDescriptorProto
extension
=
7
;
optional
FileOptions
options
=
8
;
// This field contains optional information about the original source code.
// You may safely remove this entire field whithout harming runtime
// functionality of the descriptors -- the information is needed only by
// development tools.
optional
SourceCodeInfo
source_code_info
=
9
;
}
// Describes a message type.
message
DescriptorProto
{
optional
string
name
=
1
;
repeated
FieldDescriptorProto
field
=
2
;
repeated
FieldDescriptorProto
extension
=
6
;
repeated
DescriptorProto
nested_type
=
3
;
repeated
EnumDescriptorProto
enum_type
=
4
;
message
ExtensionRange
{
optional
int32
start
=
1
;
optional
int32
end
=
2
;
}
repeated
ExtensionRange
extension_range
=
5
;
optional
MessageOptions
options
=
7
;
}
// Describes a field within a message.
message
FieldDescriptorProto
{
enum
Type
{
// 0 is reserved for errors.
// Order is weird for historical reasons.
TYPE_DOUBLE
=
1
;
TYPE_FLOAT
=
2
;
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
// negative values are likely.
TYPE_INT64
=
3
;
TYPE_UINT64
=
4
;
// Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
// negative values are likely.
TYPE_INT32
=
5
;
TYPE_FIXED64
=
6
;
TYPE_FIXED32
=
7
;
TYPE_BOOL
=
8
;
TYPE_STRING
=
9
;
TYPE_GROUP
=
10
;
// Tag-delimited aggregate.
TYPE_MESSAGE
=
11
;
// Length-delimited aggregate.
// New in version 2.
TYPE_BYTES
=
12
;
TYPE_UINT32
=
13
;
TYPE_ENUM
=
14
;
TYPE_SFIXED32
=
15
;
TYPE_SFIXED64
=
16
;
TYPE_SINT32
=
17
;
// Uses ZigZag encoding.
TYPE_SINT64
=
18
;
// Uses ZigZag encoding.
};
enum
Label
{
// 0 is reserved for errors
LABEL_OPTIONAL
=
1
;
LABEL_REQUIRED
=
2
;
LABEL_REPEATED
=
3
;
// TODO(sanjay): Should we add LABEL_MAP?
};
optional
string
name
=
1
;
optional
int32
number
=
3
;
optional
Label
label
=
4
;
// If type_name is set, this need not be set. If both this and type_name
// are set, this must be either TYPE_ENUM or TYPE_MESSAGE.
optional
Type
type
=
5
;
// For message and enum types, this is the name of the type. If the name
// starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
// rules are used to find the type (i.e. first the nested types within this
// message are searched, then within the parent, on up to the root
// namespace).
optional
string
type_name
=
6
;
// For extensions, this is the name of the type being extended. It is
// resolved in the same manner as type_name.
optional
string
extendee
=
2
;
// For numeric types, contains the original text representation of the value.
// For booleans, "true" or "false".
// For strings, contains the default text contents (not escaped in any way).
// For bytes, contains the C escaped value. All bytes >= 128 are escaped.
// TODO(kenton): Base-64 encode?
optional
string
default_value
=
7
;
optional
FieldOptions
options
=
8
;
}
// Describes an enum type.
message
EnumDescriptorProto
{
optional
string
name
=
1
;
repeated
EnumValueDescriptorProto
value
=
2
;
optional
EnumOptions
options
=
3
;
}
// Describes a value within an enum.
message
EnumValueDescriptorProto
{
optional
string
name
=
1
;
optional
int32
number
=
2
;
optional
EnumValueOptions
options
=
3
;
}
// Describes a service.
message
ServiceDescriptorProto
{
optional
string
name
=
1
;
repeated
MethodDescriptorProto
method
=
2
;
optional
ServiceOptions
options
=
3
;
}
// Describes a method of a service.
message
MethodDescriptorProto
{
optional
string
name
=
1
;
// Input and output type names. These are resolved in the same way as
// FieldDescriptorProto.type_name, but must refer to a message type.
optional
string
input_type
=
2
;
optional
string
output_type
=
3
;
optional
MethodOptions
options
=
4
;
}
// ===================================================================
// Options
// Each of the definitions above may have "options" attached. These are
// just annotations which may cause code to be generated slightly differently
// or may contain hints for code that manipulates protocol messages.
//
// Clients may define custom options as extensions of the *Options messages.
// These extensions may not yet be known at parsing time, so the parser cannot
// store the values in them. Instead it stores them in a field in the *Options
// message called uninterpreted_option. This field must have the same name
// across all *Options messages. We then use this field to populate the
// extensions when we build a descriptor, at which point all protos have been
// parsed and so all extensions are known.
//
// Extension numbers for custom options may be chosen as follows:
// * For options which will only be used within a single application or
// organization, or for experimental options, use field numbers 50000
// through 99999. It is up to you to ensure that you do not use the
// same number for multiple options.
// * For options which will be published and used publicly by multiple
// independent entities, e-mail protobuf-global-extension-registry@google.com
// to reserve extension numbers. Simply provide your project name (e.g.
// Object-C plugin) and your porject website (if available) -- there's no need
// to explain how you intend to use them. Usually you only need one extension
// number. You can declare multiple options with only one extension number by
// putting them in a sub-message. See the Custom Options section of the docs
// for examples:
// http://code.google.com/apis/protocolbuffers/docs/proto.html#options
// If this turns out to be popular, a web service will be set up
// to automatically assign option numbers.
message
FileOptions
{
// Sets the Java package where classes generated from this .proto will be
// placed. By default, the proto package is used, but this is often
// inappropriate because proto packages do not normally start with backwards
// domain names.
optional
string
java_package
=
1
;
// If set, all the classes from the .proto file are wrapped in a single
// outer class with the given name. This applies to both Proto1
// (equivalent to the old "--one_java_file" option) and Proto2 (where
// a .proto always translates to a single class, but you may want to
// explicitly choose the class name).
optional
string
java_outer_classname
=
8
;
// If set true, then the Java code generator will generate a separate .java
// file for each top-level message, enum, and service defined in the .proto
// file. Thus, these types will *not* be nested inside the outer class
// named by java_outer_classname. However, the outer class will still be
// generated to contain the file's getDescriptor() method as well as any
// top-level extensions defined in the file.
optional
bool
java_multiple_files
=
10
[
default
=
false
];
// If set true, then the Java code generator will generate equals() and
// hashCode() methods for all messages defined in the .proto file. This is
// purely a speed optimization, as the AbstractMessage base class includes
// reflection-based implementations of these methods.
optional
bool
java_generate_equals_and_hash
=
20
[
default
=
false
];
// Generated classes can be optimized for speed or code size.
enum
OptimizeMode
{
SPEED
=
1
;
// Generate complete code for parsing, serialization,
// etc.
CODE_SIZE
=
2
;
// Use ReflectionOps to implement these methods.
LITE_RUNTIME
=
3
;
// Generate code using MessageLite and the lite runtime.
}
optional
OptimizeMode
optimize_for
=
9
[
default
=
SPEED
];
// Sets the Go package where structs generated from this .proto will be
// placed. There is no default.
optional
string
go_package
=
11
;
// Should generic services be generated in each language? "Generic" services
// are not specific to any particular RPC system. They are generated by the
// main code generators in each language (without additional plugins).
// Generic services were the only kind of service generation supported by
// early versions of proto2.
//
// Generic services are now considered deprecated in favor of using plugins
// that generate code specific to your particular RPC system. Therefore,
// these default to false. Old code which depends on generic services should
// explicitly set them to true.
optional
bool
cc_generic_services
=
16
[
default
=
false
];
optional
bool
java_generic_services
=
17
[
default
=
false
];
optional
bool
py_generic_services
=
18
[
default
=
false
];
// The parser stores options it doesn't recognize here. See above.
repeated
UninterpretedOption
uninterpreted_option
=
999
;
// Clients can define custom options in extensions of this message. See above.
extensions
1000
to
max
;
}
message
MessageOptions
{
// Set true to use the old proto1 MessageSet wire format for extensions.
// This is provided for backwards-compatibility with the MessageSet wire
// format. You should not use this for any other reason: It's less
// efficient, has fewer features, and is more complicated.
//
// The message must be defined exactly as follows:
// message Foo {
// option message_set_wire_format = true;
// extensions 4 to max;
// }
// Note that the message cannot have any defined fields; MessageSets only
// have extensions.
//
// All extensions of your type must be singular messages; e.g. they cannot
// be int32s, enums, or repeated messages.
//
// Because this is an option, the above two restrictions are not enforced by
// the protocol compiler.
optional
bool
message_set_wire_format
=
1
[
default
=
false
];
// Disables the generation of the standard "descriptor()" accessor, which can
// conflict with a field of the same name. This is meant to make migration
// from proto1 easier; new code should avoid fields named "descriptor".
optional
bool
no_standard_descriptor_accessor
=
2
[
default
=
false
];
// The parser stores options it doesn't recognize here. See above.
repeated
UninterpretedOption
uninterpreted_option
=
999
;
// Clients can define custom options in extensions of this message. See above.
extensions
1000
to
max
;
}
message
FieldOptions
{
// The ctype option instructs the C++ code generator to use a different
// representation of the field than it normally would. See the specific
// options below. This option is not yet implemented in the open source
// release -- sorry, we'll try to include it in a future version!
optional
CType
ctype
=
1
[
default
=
STRING
];
enum
CType
{
// Default mode.
STRING
=
0
;
CORD
=
1
;
STRING_PIECE
=
2
;
}
// The packed option can be enabled for repeated primitive fields to enable
// a more efficient representation on the wire. Rather than repeatedly
// writing the tag and type for each element, the entire array is encoded as
// a single length-delimited blob.
optional
bool
packed
=
2
;
// Should this field be parsed lazily? Lazy applies only to message-type
// fields. It means that when the outer message is initially parsed, the
// inner message's contents will not be parsed but instead stored in encoded
// form. The inner message will actually be parsed when it is first accessed.
//
// This is only a hint. Implementations are free to choose whether to use
// eager or lazy parsing regardless of the value of this option. However,
// setting this option true suggests that the protocol author believes that
// using lazy parsing on this field is worth the additional bookkeeping
// overhead typically needed to implement it.
//
// This option does not affect the public interface of any generated code;
// all method signatures remain the same. Furthermore, thread-safety of the
// interface is not affected by this option; const methods remain safe to
// call from multiple threads concurrently, while non-const methods continue
// to require exclusive access.
//
//
// Note that implementations may choose not to check required fields within
// a lazy sub-message. That is, calling IsInitialized() on the outher message
// may return true even if the inner message has missing required fields.
// This is necessary because otherwise the inner message would have to be
// parsed in order to perform the check, defeating the purpose of lazy
// parsing. An implementation which chooses not to check required fields
// must be consistent about it. That is, for any particular sub-message, the
// implementation must either *always* check its required fields, or *never*
// check its required fields, regardless of whether or not the message has
// been parsed.
optional
bool
lazy
=
5
[
default
=
false
];
// Is this field deprecated?
// Depending on the target platform, this can emit Deprecated annotations
// for accessors, or it will be completely ignored; in the very least, this
// is a formalization for deprecating fields.
optional
bool
deprecated
=
3
[
default
=
false
];
// EXPERIMENTAL. DO NOT USE.
// For "map" fields, the name of the field in the enclosed type that
// is the key for this map. For example, suppose we have:
// message Item {
// required string name = 1;
// required string value = 2;
// }
// message Config {
// repeated Item items = 1 [experimental_map_key="name"];
// }
// In this situation, the map key for Item will be set to "name".
// TODO: Fully-implement this, then remove the "experimental_" prefix.
optional
string
experimental_map_key
=
9
;
// For Google-internal migration only. Do not use.
optional
bool
weak
=
10
[
default
=
false
];
// The parser stores options it doesn't recognize here. See above.
repeated
UninterpretedOption
uninterpreted_option
=
999
;
// Clients can define custom options in extensions of this message. See above.
extensions
1000
to
max
;
}
message
EnumOptions
{
// Set this option to false to disallow mapping different tag names to a same
// value.
optional
bool
allow_alias
=
2
[
default
=
true
];
// The parser stores options it doesn't recognize here. See above.
repeated
UninterpretedOption
uninterpreted_option
=
999
;
// Clients can define custom options in extensions of this message. See above.
extensions
1000
to
max
;
}
message
EnumValueOptions
{
// The parser stores options it doesn't recognize here. See above.
repeated
UninterpretedOption
uninterpreted_option
=
999
;
// Clients can define custom options in extensions of this message. See above.
extensions
1000
to
max
;
}
message
ServiceOptions
{
// Note: Field numbers 1 through 32 are reserved for Google's internal RPC
// framework. We apologize for hoarding these numbers to ourselves, but
// we were already using them long before we decided to release Protocol
// Buffers.
// The parser stores options it doesn't recognize here. See above.
repeated
UninterpretedOption
uninterpreted_option
=
999
;
// Clients can define custom options in extensions of this message. See above.
extensions
1000
to
max
;
}
message
MethodOptions
{
// Note: Field numbers 1 through 32 are reserved for Google's internal RPC
// framework. We apologize for hoarding these numbers to ourselves, but
// we were already using them long before we decided to release Protocol
// Buffers.
// The parser stores options it doesn't recognize here. See above.
repeated
UninterpretedOption
uninterpreted_option
=
999
;
// Clients can define custom options in extensions of this message. See above.
extensions
1000
to
max
;
}
// A message representing a option the parser does not recognize. This only
// appears in options protos created by the compiler::Parser class.
// DescriptorPool resolves these when building Descriptor objects. Therefore,
// options protos in descriptor objects (e.g. returned by Descriptor::options(),
// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
// in them.
message
UninterpretedOption
{
// The name of the uninterpreted option. Each string represents a segment in
// a dot-separated name. is_extension is true iff a segment represents an
// extension (denoted with parentheses in options specs in .proto files).
// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
// "foo.(bar.baz).qux".
message
NamePart
{
required
string
name_part
=
1
;
required
bool
is_extension
=
2
;
}
repeated
NamePart
name
=
2
;
// The value of the uninterpreted option, in whatever type the tokenizer
// identified it as during parsing. Exactly one of these should be set.
optional
string
identifier_value
=
3
;
optional
uint64
positive_int_value
=
4
;
optional
int64
negative_int_value
=
5
;
optional
double
double_value
=
6
;
optional
bytes
string_value
=
7
;
optional
string
aggregate_value
=
8
;
}
// ===================================================================
// Optional source code info
// Encapsulates information about the original source file from which a
// FileDescriptorProto was generated.
message
SourceCodeInfo
{
// A Location identifies a piece of source code in a .proto file which
// corresponds to a particular definition. This information is intended
// to be useful to IDEs, code indexers, documentation generators, and similar
// tools.
//
// For example, say we have a file like:
// message Foo {
// optional string foo = 1;
// }
// Let's look at just the field definition:
// optional string foo = 1;
// ^ ^^ ^^ ^ ^^^
// a bc de f ghi
// We have the following locations:
// span path represents
// [a,i) [ 4, 0, 2, 0 ] The whole field definition.
// [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
// [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
// [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
// [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
//
// Notes:
// - A location may refer to a repeated field itself (i.e. not to any
// particular index within it). This is used whenever a set of elements are
// logically enclosed in a single code segment. For example, an entire
// extend block (possibly containing multiple extension definitions) will
// have an outer location whose path refers to the "extensions" repeated
// field without an index.
// - Multiple locations may have the same path. This happens when a single
// logical declaration is spread out across multiple places. The most
// obvious example is the "extend" block again -- there may be multiple
// extend blocks in the same scope, each of which will have the same path.
// - A location's span is not always a subset of its parent's span. For
// example, the "extendee" of an extension declaration appears at the
// beginning of the "extend" block and is shared by all extensions within
// the block.
// - Just because a location's span is a subset of some other location's span
// does not mean that it is a descendent. For example, a "group" defines
// both a type and a field in a single declaration. Thus, the locations
// corresponding to the type and field and their components will overlap.
// - Code which tries to interpret locations should probably be designed to
// ignore those that it doesn't understand, as more types of locations could
// be recorded in the future.
repeated
Location
location
=
1
;
message
Location
{
// Identifies which part of the FileDescriptorProto was defined at this
// location.
//
// Each element is a field number or an index. They form a path from
// the root FileDescriptorProto to the place where the definition. For
// example, this path:
// [ 4, 3, 2, 7, 1 ]
// refers to:
// file.message_type(3) // 4, 3
// .field(7) // 2, 7
// .name() // 1
// This is because FileDescriptorProto.message_type has field number 4:
// repeated DescriptorProto message_type = 4;
// and DescriptorProto.field has field number 2:
// repeated FieldDescriptorProto field = 2;
// and FieldDescriptorProto.name has field number 1:
// optional string name = 1;
//
// Thus, the above path gives the location of a field name. If we removed
// the last element:
// [ 4, 3, 2, 7 ]
// this path refers to the whole field declaration (from the beginning
// of the label to the terminating semicolon).
repeated
int32
path
=
1
[
packed
=
true
];
// Always has exactly three or four elements: start line, start column,
// end line (optional, otherwise assumed same as start line), end column.
// These are packed into a single field for efficiency. Note that line
// and column numbers are zero-based -- typically you will want to add
// 1 to each before displaying to a user.
repeated
int32
span
=
2
[
packed
=
true
];
// If this SourceCodeInfo represents a complete declaration, these are any
// comments appearing before and after the declaration which appear to be
// attached to the declaration.
//
// A series of line comments appearing on consecutive lines, with no other
// tokens appearing on those lines, will be treated as a single comment.
//
// Only the comment content is provided; comment markers (e.g. //) are
// stripped out. For block comments, leading whitespace and an asterisk
// will be stripped from the beginning of each line other than the first.
// Newlines are included in the output.
//
// Examples:
//
// optional int32 foo = 1; // Comment attached to foo.
// // Comment attached to bar.
// optional int32 bar = 2;
//
// optional string baz = 3;
// // Comment attached to baz.
// // Another line attached to baz.
//
// // Comment attached to qux.
// //
// // Another line attached to qux.
// optional double qux = 4;
//
// optional string corge = 5;
// /* Block comment attached
// * to corge. Leading asterisks
// * will be removed. */
// /* Block comment attached to
// * grault. */
// optional int32 grault = 6;
optional
string
leading_comments
=
3
;
optional
string
trailing_comments
=
4
;
}
}
python/compatibility_tests/v2.5.0/protos/src/proto/google/protobuf/unittest.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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.
// 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
import
"google/protobuf/unittest_import.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.
optional
int32
bb
=
1
;
}
enum
NestedEnum
{
FOO
=
1
;
BAR
=
2
;
BAZ
=
3
;
}
// Singular
optional
int32
optional_int32
=
1
;
optional
int64
optional_int64
=
2
;
optional
uint32
optional_uint32
=
3
;
optional
uint64
optional_uint64
=
4
;
optional
sint32
optional_sint32
=
5
;
optional
sint64
optional_sint64
=
6
;
optional
fixed32
optional_fixed32
=
7
;
optional
fixed64
optional_fixed64
=
8
;
optional
sfixed32
optional_sfixed32
=
9
;
optional
sfixed64
optional_sfixed64
=
10
;
optional
float
optional_float
=
11
;
optional
double
optional_double
=
12
;
optional
bool
optional_bool
=
13
;
optional
string
optional_string
=
14
;
optional
bytes
optional_bytes
=
15
;
optional
group
OptionalGroup
=
16
{
optional
int32
a
=
17
;
}
optional
NestedMessage
optional_nested_message
=
18
;
optional
ForeignMessage
optional_foreign_message
=
19
;
optional
protobuf_unittest_import.ImportMessage
optional_import_message
=
20
;
optional
NestedEnum
optional_nested_enum
=
21
;
optional
ForeignEnum
optional_foreign_enum
=
22
;
optional
protobuf_unittest_import.ImportEnum
optional_import_enum
=
23
;
optional
string
optional_string_piece
=
24
[
ctype
=
STRING_PIECE
];
optional
string
optional_cord
=
25
[
ctype
=
CORD
];
// Defined in unittest_import_public.proto
optional
protobuf_unittest_import.PublicImportMessage
optional_public_import_message
=
26
;
optional
NestedMessage
optional_lazy_message
=
27
[
lazy
=
true
];
// 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
group
RepeatedGroup
=
46
{
optional
int32
a
=
47
;
}
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
;
repeated
string
repeated_string_piece
=
54
[
ctype
=
STRING_PIECE
];
repeated
string
repeated_cord
=
55
[
ctype
=
CORD
];
repeated
NestedMessage
repeated_lazy_message
=
57
[
lazy
=
true
];
// Singular with defaults
optional
int32
default_int32
=
61
[
default
=
41
];
optional
int64
default_int64
=
62
[
default
=
42
];
optional
uint32
default_uint32
=
63
[
default
=
43
];
optional
uint64
default_uint64
=
64
[
default
=
44
];
optional
sint32
default_sint32
=
65
[
default
=
-
45
];
optional
sint64
default_sint64
=
66
[
default
=
46
];
optional
fixed32
default_fixed32
=
67
[
default
=
47
];
optional
fixed64
default_fixed64
=
68
[
default
=
48
];
optional
sfixed32
default_sfixed32
=
69
[
default
=
49
];
optional
sfixed64
default_sfixed64
=
70
[
default
=
-
50
];
optional
float
default_float
=
71
[
default
=
51.5
];
optional
double
default_double
=
72
[
default
=
52e3
];
optional
bool
default_bool
=
73
[
default
=
true
];
optional
string
default_string
=
74
[
default
=
"hello"
];
optional
bytes
default_bytes
=
75
[
default
=
"world"
];
optional
NestedEnum
default_nested_enum
=
81
[
default
=
BAR
];
optional
ForeignEnum
default_foreign_enum
=
82
[
default
=
FOREIGN_BAR
];
optional
protobuf_unittest_import.ImportEnum
default_import_enum
=
83
[
default
=
IMPORT_BAR
];
optional
string
default_string_piece
=
84
[
ctype
=
STRING_PIECE
,
default
=
"abc"
];
optional
string
default_cord
=
85
[
ctype
=
CORD
,
default
=
"123"
];
}
message
TestDeprecatedFields
{
optional
int32
deprecated_int32
=
1
[
deprecated
=
true
];
}
// Define these after TestAllTypes to make sure the compiler can handle
// that.
message
ForeignMessage
{
optional
int32
c
=
1
;
}
enum
ForeignEnum
{
FOREIGN_FOO
=
4
;
FOREIGN_BAR
=
5
;
FOREIGN_BAZ
=
6
;
}
message
TestAllExtensions
{
extensions
1
to
max
;
}
extend
TestAllExtensions
{
// Singular
optional
int32
optional_int32_extension
=
1
;
optional
int64
optional_int64_extension
=
2
;
optional
uint32
optional_uint32_extension
=
3
;
optional
uint64
optional_uint64_extension
=
4
;
optional
sint32
optional_sint32_extension
=
5
;
optional
sint64
optional_sint64_extension
=
6
;
optional
fixed32
optional_fixed32_extension
=
7
;
optional
fixed64
optional_fixed64_extension
=
8
;
optional
sfixed32
optional_sfixed32_extension
=
9
;
optional
sfixed64
optional_sfixed64_extension
=
10
;
optional
float
optional_float_extension
=
11
;
optional
double
optional_double_extension
=
12
;
optional
bool
optional_bool_extension
=
13
;
optional
string
optional_string_extension
=
14
;
optional
bytes
optional_bytes_extension
=
15
;
optional
group
OptionalGroup_extension
=
16
{
optional
int32
a
=
17
;
}
optional
TestAllTypes.NestedMessage
optional_nested_message_extension
=
18
;
optional
ForeignMessage
optional_foreign_message_extension
=
19
;
optional
protobuf_unittest_import.ImportMessage
optional_import_message_extension
=
20
;
optional
TestAllTypes.NestedEnum
optional_nested_enum_extension
=
21
;
optional
ForeignEnum
optional_foreign_enum_extension
=
22
;
optional
protobuf_unittest_import.ImportEnum
optional_import_enum_extension
=
23
;
optional
string
optional_string_piece_extension
=
24
[
ctype
=
STRING_PIECE
];
optional
string
optional_cord_extension
=
25
[
ctype
=
CORD
];
optional
protobuf_unittest_import.PublicImportMessage
optional_public_import_message_extension
=
26
;
optional
TestAllTypes.NestedMessage
optional_lazy_message_extension
=
27
[
lazy
=
true
];
// Repeated
repeated
int32
repeated_int32_extension
=
31
;
repeated
int64
repeated_int64_extension
=
32
;
repeated
uint32
repeated_uint32_extension
=
33
;
repeated
uint64
repeated_uint64_extension
=
34
;
repeated
sint32
repeated_sint32_extension
=
35
;
repeated
sint64
repeated_sint64_extension
=
36
;
repeated
fixed32
repeated_fixed32_extension
=
37
;
repeated
fixed64
repeated_fixed64_extension
=
38
;
repeated
sfixed32
repeated_sfixed32_extension
=
39
;
repeated
sfixed64
repeated_sfixed64_extension
=
40
;
repeated
float
repeated_float_extension
=
41
;
repeated
double
repeated_double_extension
=
42
;
repeated
bool
repeated_bool_extension
=
43
;
repeated
string
repeated_string_extension
=
44
;
repeated
bytes
repeated_bytes_extension
=
45
;
repeated
group
RepeatedGroup_extension
=
46
{
optional
int32
a
=
47
;
}
repeated
TestAllTypes.NestedMessage
repeated_nested_message_extension
=
48
;
repeated
ForeignMessage
repeated_foreign_message_extension
=
49
;
repeated
protobuf_unittest_import.ImportMessage
repeated_import_message_extension
=
50
;
repeated
TestAllTypes.NestedEnum
repeated_nested_enum_extension
=
51
;
repeated
ForeignEnum
repeated_foreign_enum_extension
=
52
;
repeated
protobuf_unittest_import.ImportEnum
repeated_import_enum_extension
=
53
;
repeated
string
repeated_string_piece_extension
=
54
[
ctype
=
STRING_PIECE
];
repeated
string
repeated_cord_extension
=
55
[
ctype
=
CORD
];
repeated
TestAllTypes.NestedMessage
repeated_lazy_message_extension
=
57
[
lazy
=
true
];
// Singular with defaults
optional
int32
default_int32_extension
=
61
[
default
=
41
];
optional
int64
default_int64_extension
=
62
[
default
=
42
];
optional
uint32
default_uint32_extension
=
63
[
default
=
43
];
optional
uint64
default_uint64_extension
=
64
[
default
=
44
];
optional
sint32
default_sint32_extension
=
65
[
default
=
-
45
];
optional
sint64
default_sint64_extension
=
66
[
default
=
46
];
optional
fixed32
default_fixed32_extension
=
67
[
default
=
47
];
optional
fixed64
default_fixed64_extension
=
68
[
default
=
48
];
optional
sfixed32
default_sfixed32_extension
=
69
[
default
=
49
];
optional
sfixed64
default_sfixed64_extension
=
70
[
default
=
-
50
];
optional
float
default_float_extension
=
71
[
default
=
51.5
];
optional
double
default_double_extension
=
72
[
default
=
52e3
];
optional
bool
default_bool_extension
=
73
[
default
=
true
];
optional
string
default_string_extension
=
74
[
default
=
"hello"
];
optional
bytes
default_bytes_extension
=
75
[
default
=
"world"
];
optional
TestAllTypes.NestedEnum
default_nested_enum_extension
=
81
[
default
=
BAR
];
optional
ForeignEnum
default_foreign_enum_extension
=
82
[
default
=
FOREIGN_BAR
];
optional
protobuf_unittest_import.ImportEnum
default_import_enum_extension
=
83
[
default
=
IMPORT_BAR
];
optional
string
default_string_piece_extension
=
84
[
ctype
=
STRING_PIECE
,
default
=
"abc"
];
optional
string
default_cord_extension
=
85
[
ctype
=
CORD
,
default
=
"123"
];
}
message
TestNestedExtension
{
extend
TestAllExtensions
{
// Check for bug where string extensions declared in tested scope did not
// compile.
optional
string
test
=
1002
[
default
=
"test"
];
}
}
// We have separate messages for testing required fields because it's
// annoying to have to fill in required fields in TestProto in order to
// do anything with it. Note that we don't need to test every type of
// required filed because the code output is basically identical to
// optional fields for all types.
message
TestRequired
{
required
int32
a
=
1
;
optional
int32
dummy2
=
2
;
required
int32
b
=
3
;
extend
TestAllExtensions
{
optional
TestRequired
single
=
1000
;
repeated
TestRequired
multi
=
1001
;
}
// Pad the field count to 32 so that we can test that IsInitialized()
// properly checks multiple elements of has_bits_.
optional
int32
dummy4
=
4
;
optional
int32
dummy5
=
5
;
optional
int32
dummy6
=
6
;
optional
int32
dummy7
=
7
;
optional
int32
dummy8
=
8
;
optional
int32
dummy9
=
9
;
optional
int32
dummy10
=
10
;
optional
int32
dummy11
=
11
;
optional
int32
dummy12
=
12
;
optional
int32
dummy13
=
13
;
optional
int32
dummy14
=
14
;
optional
int32
dummy15
=
15
;
optional
int32
dummy16
=
16
;
optional
int32
dummy17
=
17
;
optional
int32
dummy18
=
18
;
optional
int32
dummy19
=
19
;
optional
int32
dummy20
=
20
;
optional
int32
dummy21
=
21
;
optional
int32
dummy22
=
22
;
optional
int32
dummy23
=
23
;
optional
int32
dummy24
=
24
;
optional
int32
dummy25
=
25
;
optional
int32
dummy26
=
26
;
optional
int32
dummy27
=
27
;
optional
int32
dummy28
=
28
;
optional
int32
dummy29
=
29
;
optional
int32
dummy30
=
30
;
optional
int32
dummy31
=
31
;
optional
int32
dummy32
=
32
;
required
int32
c
=
33
;
}
message
TestRequiredForeign
{
optional
TestRequired
optional_message
=
1
;
repeated
TestRequired
repeated_message
=
2
;
optional
int32
dummy
=
3
;
}
// Test that we can use NestedMessage from outside TestAllTypes.
message
TestForeignNested
{
optional
TestAllTypes.NestedMessage
foreign_nested
=
1
;
}
// TestEmptyMessage is used to test unknown field support.
message
TestEmptyMessage
{
}
// Like above, but declare all field numbers as potential extensions. No
// actual extensions should ever be defined for this type.
message
TestEmptyMessageWithExtensions
{
extensions
1
to
max
;
}
message
TestMultipleExtensionRanges
{
extensions
42
;
extensions
4143
to
4243
;
extensions
65536
to
max
;
}
// 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.
optional
int32
a
=
1
;
optional
int32
bb
=
268435455
;
}
message
TestRecursiveMessage
{
optional
TestRecursiveMessage
a
=
1
;
optional
int32
i
=
2
;
}
// Test that mutual recursion works.
message
TestMutualRecursionA
{
optional
TestMutualRecursionB
bb
=
1
;
}
message
TestMutualRecursionB
{
optional
TestMutualRecursionA
a
=
1
;
optional
int32
optional_int32
=
2
;
}
// Test that groups have disjoint field numbers from their siblings and
// parents. This is NOT possible in proto1; only proto2. When attempting
// to compile with proto1, this will emit an error; so we only include it
// in protobuf_unittest_proto.
message
TestDupFieldNumber
{
// NO_PROTO1
optional
int32
a
=
1
;
// NO_PROTO1
optional
group
Foo
=
2
{
optional
int32
a
=
1
;
}
// NO_PROTO1
optional
group
Bar
=
3
{
optional
int32
a
=
1
;
}
// NO_PROTO1
}
// NO_PROTO1
// Additional messages for testing lazy fields.
message
TestEagerMessage
{
optional
TestAllTypes
sub_message
=
1
[
lazy
=
false
];
}
message
TestLazyMessage
{
optional
TestAllTypes
sub_message
=
1
[
lazy
=
true
];
}
// Needed for a Python test.
message
TestNestedMessageHasBits
{
message
NestedMessage
{
repeated
int32
nestedmessage_repeated_int32
=
1
;
repeated
ForeignMessage
nestedmessage_repeated_foreignmessage
=
2
;
}
optional
NestedMessage
optional_nested_message
=
1
;
}
// Test an enum that has multiple values with the same number.
enum
TestEnumWithDupValue
{
option
allow_alias
=
true
;
FOO1
=
1
;
BAR1
=
2
;
BAZ
=
3
;
FOO2
=
1
;
BAR2
=
2
;
}
// Test an enum with large, unordered values.
enum
TestSparseEnum
{
SPARSE_A
=
123
;
SPARSE_B
=
62374
;
SPARSE_C
=
12589234
;
SPARSE_D
=
-
15
;
SPARSE_E
=
-
53452
;
SPARSE_F
=
0
;
SPARSE_G
=
2
;
}
// Test message with CamelCase field names. This violates Protocol Buffer
// standard style.
message
TestCamelCaseFieldNames
{
optional
int32
PrimitiveField
=
1
;
optional
string
StringField
=
2
;
optional
ForeignEnum
EnumField
=
3
;
optional
ForeignMessage
MessageField
=
4
;
optional
string
StringPieceField
=
5
[
ctype
=
STRING_PIECE
];
optional
string
CordField
=
6
[
ctype
=
CORD
];
repeated
int32
RepeatedPrimitiveField
=
7
;
repeated
string
RepeatedStringField
=
8
;
repeated
ForeignEnum
RepeatedEnumField
=
9
;
repeated
ForeignMessage
RepeatedMessageField
=
10
;
repeated
string
RepeatedStringPieceField
=
11
[
ctype
=
STRING_PIECE
];
repeated
string
RepeatedCordField
=
12
[
ctype
=
CORD
];
}
// We list fields out of order, to ensure that we're using field number and not
// field index to determine serialization order.
message
TestFieldOrderings
{
optional
string
my_string
=
11
;
extensions
2
to
10
;
optional
int64
my_int
=
1
;
extensions
12
to
100
;
optional
float
my_float
=
101
;
}
extend
TestFieldOrderings
{
optional
string
my_extension_string
=
50
;
optional
int32
my_extension_int
=
5
;
}
message
TestExtremeDefaultValues
{
optional
bytes
escaped_bytes
=
1
[
default
=
"\0\001\a\b\f\n\r\t\v\\\'\"
\
xfe
"
];
optional
uint32
large_uint32
=
2
[
default
=
0xFFFFFFFF
];
optional
uint64
large_uint64
=
3
[
default
=
0xFFFFFFFFFFFFFFFF
];
optional
int32
small_int32
=
4
[
default
=
-
0x7FFFFFFF
];
optional
int64
small_int64
=
5
[
default
=
-
0x7FFFFFFFFFFFFFFF
];
optional
int32
really_small_int32
=
21
[
default
=
-
0x80000000
];
optional
int64
really_small_int64
=
22
[
default
=
-
0x8000000000000000
];
// The default value here is UTF-8 for "\u1234". (We could also just type
// the UTF-8 text directly into this text file rather than escape it, but
// lots of people use editors that would be confused by this.)
optional
string
utf8_string
=
6
[
default
=
"\341\210\264"
];
// Tests for single-precision floating-point values.
optional
float
zero_float
=
7
[
default
=
0
];
optional
float
one_float
=
8
[
default
=
1
];
optional
float
small_float
=
9
[
default
=
1.5
];
optional
float
negative_one_float
=
10
[
default
=
-
1
];
optional
float
negative_float
=
11
[
default
=
-
1.5
];
// Using exponents
optional
float
large_float
=
12
[
default
=
2E8
];
optional
float
small_negative_float
=
13
[
default
=
-
8e-28
];
// Text for nonfinite floating-point values.
optional
double
inf_double
=
14
[
default
=
inf
];
optional
double
neg_inf_double
=
15
[
default
=
-inf
];
optional
double
nan_double
=
16
[
default
=
nan
];
optional
float
inf_float
=
17
[
default
=
inf
];
optional
float
neg_inf_float
=
18
[
default
=
-inf
];
optional
float
nan_float
=
19
[
default
=
nan
];
// Tests for C++ trigraphs.
// Trigraphs should be escaped in C++ generated files, but they should not be
// escaped for other languages.
// Note that in .proto file, "\?" is a valid way to escape ? in string
// literals.
optional
string
cpp_trigraph
=
20
[
default
=
"? \? ?? \?? \??? ??/ ?\?-"
];
// String defaults containing the character '\000'
optional
string
string_with_zero
=
23
[
default
=
"hel\000lo"
];
optional
bytes
bytes_with_zero
=
24
[
default
=
"wor\000ld"
];
optional
string
string_piece_with_zero
=
25
[
ctype
=
STRING_PIECE
,
default
=
"ab\000c"
];
optional
string
cord_with_zero
=
26
[
ctype
=
CORD
,
default
=
"12\0003"
];
}
message
SparseEnumMessage
{
optional
TestSparseEnum
sparse_enum
=
1
;
}
// Test String and Bytes: string is for valid UTF-8 strings
message
OneString
{
optional
string
data
=
1
;
}
message
MoreString
{
repeated
string
data
=
1
;
}
message
OneBytes
{
optional
bytes
data
=
1
;
}
message
MoreBytes
{
repeated
bytes
data
=
1
;
}
// 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
TestPackedExtensions
{
extensions
1
to
max
;
}
extend
TestPackedExtensions
{
repeated
int32
packed_int32_extension
=
90
[
packed
=
true
];
repeated
int64
packed_int64_extension
=
91
[
packed
=
true
];
repeated
uint32
packed_uint32_extension
=
92
[
packed
=
true
];
repeated
uint64
packed_uint64_extension
=
93
[
packed
=
true
];
repeated
sint32
packed_sint32_extension
=
94
[
packed
=
true
];
repeated
sint64
packed_sint64_extension
=
95
[
packed
=
true
];
repeated
fixed32
packed_fixed32_extension
=
96
[
packed
=
true
];
repeated
fixed64
packed_fixed64_extension
=
97
[
packed
=
true
];
repeated
sfixed32
packed_sfixed32_extension
=
98
[
packed
=
true
];
repeated
sfixed64
packed_sfixed64_extension
=
99
[
packed
=
true
];
repeated
float
packed_float_extension
=
100
[
packed
=
true
];
repeated
double
packed_double_extension
=
101
[
packed
=
true
];
repeated
bool
packed_bool_extension
=
102
[
packed
=
true
];
repeated
ForeignEnum
packed_enum_extension
=
103
[
packed
=
true
];
}
// Used by ExtensionSetTest/DynamicExtensions. The test actually builds
// a set of extensions to TestAllExtensions dynamically, based on the fields
// of this message type.
message
TestDynamicExtensions
{
enum
DynamicEnumType
{
DYNAMIC_FOO
=
2200
;
DYNAMIC_BAR
=
2201
;
DYNAMIC_BAZ
=
2202
;
}
message
DynamicMessageType
{
optional
int32
dynamic_field
=
2100
;
}
optional
fixed32
scalar_extension
=
2000
;
optional
ForeignEnum
enum_extension
=
2001
;
optional
DynamicEnumType
dynamic_enum_extension
=
2002
;
optional
ForeignMessage
message_extension
=
2003
;
optional
DynamicMessageType
dynamic_message_extension
=
2004
;
repeated
string
repeated_extension
=
2005
;
repeated
sint32
packed_extension
=
2006
[
packed
=
true
];
}
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
;
}
// Test that if an optional or required message/group field appears multiple
// times in the input, they need to be merged.
message
TestParsingMerge
{
// RepeatedFieldsGenerator defines matching field types as TestParsingMerge,
// except that all fields are repeated. In the tests, we will serialize the
// RepeatedFieldsGenerator to bytes, and parse the bytes to TestParsingMerge.
// Repeated fields in RepeatedFieldsGenerator are expected to be merged into
// the corresponding required/optional fields in TestParsingMerge.
message
RepeatedFieldsGenerator
{
repeated
TestAllTypes
field1
=
1
;
repeated
TestAllTypes
field2
=
2
;
repeated
TestAllTypes
field3
=
3
;
repeated
group
Group1
=
10
{
optional
TestAllTypes
field1
=
11
;
}
repeated
group
Group2
=
20
{
optional
TestAllTypes
field1
=
21
;
}
repeated
TestAllTypes
ext1
=
1000
;
repeated
TestAllTypes
ext2
=
1001
;
}
required
TestAllTypes
required_all_types
=
1
;
optional
TestAllTypes
optional_all_types
=
2
;
repeated
TestAllTypes
repeated_all_types
=
3
;
optional
group
OptionalGroup
=
10
{
optional
TestAllTypes
optional_group_all_types
=
11
;
}
repeated
group
RepeatedGroup
=
20
{
optional
TestAllTypes
repeated_group_all_types
=
21
;
}
extensions
1000
to
max
;
extend
TestParsingMerge
{
optional
TestAllTypes
optional_ext
=
1000
;
repeated
TestAllTypes
repeated_ext
=
1001
;
}
}
message
TestCommentInjectionMessage
{
// */ <- This should not close the generated doc comment
optional
string
a
=
1
[
default
=
"*/ <- Neither should this."
];
}
// 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
{}
python/compatibility_tests/v2.5.0/protos/src/proto/google/protobuf/unittest_custom_options.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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: benjy@google.com (Benjy Weinberger)
// Based on original Protocol Buffers design by
// Sanjay Ghemawat, Jeff Dean, and others.
//
// A proto file used to test the "custom options" feature of proto2.
// 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
;
// A custom file option (defined below).
option
(
file_opt1
)
=
9876543210
;
import
"google/protobuf/descriptor.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.
package
protobuf_unittest
;
// Some simple test custom options of various types.
extend
google
.
protobuf.FileOptions
{
optional
uint64
file_opt1
=
7736974
;
}
extend
google
.
protobuf.MessageOptions
{
optional
int32
message_opt1
=
7739036
;
}
extend
google
.
protobuf.FieldOptions
{
optional
fixed64
field_opt1
=
7740936
;
// This is useful for testing that we correctly register default values for
// extension options.
optional
int32
field_opt2
=
7753913
[
default
=
42
];
}
extend
google
.
protobuf.EnumOptions
{
optional
sfixed32
enum_opt1
=
7753576
;
}
extend
google
.
protobuf.EnumValueOptions
{
optional
int32
enum_value_opt1
=
1560678
;
}
extend
google
.
protobuf.ServiceOptions
{
optional
sint64
service_opt1
=
7887650
;
}
enum
MethodOpt1
{
METHODOPT1_VAL1
=
1
;
METHODOPT1_VAL2
=
2
;
}
extend
google
.
protobuf.MethodOptions
{
optional
MethodOpt1
method_opt1
=
7890860
;
}
// A test message with custom options at all possible locations (and also some
// regular options, to make sure they interact nicely).
message
TestMessageWithCustomOptions
{
option
message_set_wire_format
=
false
;
option
(
message_opt1
)
=
-
56
;
optional
string
field1
=
1
[
ctype
=
CORD
,
(
field_opt1
)
=
8765432109
];
enum
AnEnum
{
option
(
enum_opt1
)
=
-
789
;
ANENUM_VAL1
=
1
;
ANENUM_VAL2
=
2
[(
enum_value_opt1
)
=
123
];
}
}
// A test RPC service with custom options at all possible locations (and also
// some regular options, to make sure they interact nicely).
message
CustomOptionFooRequest
{
}
message
CustomOptionFooResponse
{
}
message
CustomOptionFooClientMessage
{
}
message
CustomOptionFooServerMessage
{
}
service
TestServiceWithCustomOptions
{
option
(
service_opt1
)
=
-
9876543210
;
rpc
Foo
(
CustomOptionFooRequest
)
returns
(
CustomOptionFooResponse
)
{
option
(
method_opt1
)
=
METHODOPT1_VAL2
;
}
}
// Options of every possible field type, so we can test them all exhaustively.
message
DummyMessageContainingEnum
{
enum
TestEnumType
{
TEST_OPTION_ENUM_TYPE1
=
22
;
TEST_OPTION_ENUM_TYPE2
=
-
23
;
}
}
message
DummyMessageInvalidAsOptionType
{
}
extend
google
.
protobuf.MessageOptions
{
optional
bool
bool_opt
=
7706090
;
optional
int32
int32_opt
=
7705709
;
optional
int64
int64_opt
=
7705542
;
optional
uint32
uint32_opt
=
7704880
;
optional
uint64
uint64_opt
=
7702367
;
optional
sint32
sint32_opt
=
7701568
;
optional
sint64
sint64_opt
=
7700863
;
optional
fixed32
fixed32_opt
=
7700307
;
optional
fixed64
fixed64_opt
=
7700194
;
optional
sfixed32
sfixed32_opt
=
7698645
;
optional
sfixed64
sfixed64_opt
=
7685475
;
optional
float
float_opt
=
7675390
;
optional
double
double_opt
=
7673293
;
optional
string
string_opt
=
7673285
;
optional
bytes
bytes_opt
=
7673238
;
optional
DummyMessageContainingEnum.TestEnumType
enum_opt
=
7673233
;
optional
DummyMessageInvalidAsOptionType
message_type_opt
=
7665967
;
}
message
CustomOptionMinIntegerValues
{
option
(
bool_opt
)
=
false
;
option
(
int32_opt
)
=
-
0x80000000
;
option
(
int64_opt
)
=
-
0x8000000000000000
;
option
(
uint32_opt
)
=
0
;
option
(
uint64_opt
)
=
0
;
option
(
sint32_opt
)
=
-
0x80000000
;
option
(
sint64_opt
)
=
-
0x8000000000000000
;
option
(
fixed32_opt
)
=
0
;
option
(
fixed64_opt
)
=
0
;
option
(
sfixed32_opt
)
=
-
0x80000000
;
option
(
sfixed64_opt
)
=
-
0x8000000000000000
;
}
message
CustomOptionMaxIntegerValues
{
option
(
bool_opt
)
=
true
;
option
(
int32_opt
)
=
0x7FFFFFFF
;
option
(
int64_opt
)
=
0x7FFFFFFFFFFFFFFF
;
option
(
uint32_opt
)
=
0xFFFFFFFF
;
option
(
uint64_opt
)
=
0xFFFFFFFFFFFFFFFF
;
option
(
sint32_opt
)
=
0x7FFFFFFF
;
option
(
sint64_opt
)
=
0x7FFFFFFFFFFFFFFF
;
option
(
fixed32_opt
)
=
0xFFFFFFFF
;
option
(
fixed64_opt
)
=
0xFFFFFFFFFFFFFFFF
;
option
(
sfixed32_opt
)
=
0x7FFFFFFF
;
option
(
sfixed64_opt
)
=
0x7FFFFFFFFFFFFFFF
;
}
message
CustomOptionOtherValues
{
option
(
int32_opt
)
=
-
100
;
// To test sign-extension.
option
(
float_opt
)
=
12.3456789
;
option
(
double_opt
)
=
1.234567890123456789
;
option
(
string_opt
)
=
"Hello, \"
World
\
""
;
option
(
bytes_opt
)
=
"Hello\0World"
;
option
(
enum_opt
)
=
TEST_OPTION_ENUM_TYPE2
;
}
message
SettingRealsFromPositiveInts
{
option
(
float_opt
)
=
12
;
option
(
double_opt
)
=
154
;
}
message
SettingRealsFromNegativeInts
{
option
(
float_opt
)
=
-
12
;
option
(
double_opt
)
=
-
154
;
}
// Options of complex message types, themselves combined and extended in
// various ways.
message
ComplexOptionType1
{
optional
int32
foo
=
1
;
optional
int32
foo2
=
2
;
optional
int32
foo3
=
3
;
extensions
100
to
max
;
}
message
ComplexOptionType2
{
optional
ComplexOptionType1
bar
=
1
;
optional
int32
baz
=
2
;
message
ComplexOptionType4
{
optional
int32
waldo
=
1
;
extend
google
.
protobuf.MessageOptions
{
optional
ComplexOptionType4
complex_opt4
=
7633546
;
}
}
optional
ComplexOptionType4
fred
=
3
;
extensions
100
to
max
;
}
message
ComplexOptionType3
{
optional
int32
qux
=
1
;
optional
group
ComplexOptionType5
=
2
{
optional
int32
plugh
=
3
;
}
}
extend
ComplexOptionType1
{
optional
int32
quux
=
7663707
;
optional
ComplexOptionType3
corge
=
7663442
;
}
extend
ComplexOptionType2
{
optional
int32
grault
=
7650927
;
optional
ComplexOptionType1
garply
=
7649992
;
}
extend
google
.
protobuf.MessageOptions
{
optional
protobuf_unittest.ComplexOptionType1
complex_opt1
=
7646756
;
optional
ComplexOptionType2
complex_opt2
=
7636949
;
optional
ComplexOptionType3
complex_opt3
=
7636463
;
optional
group
ComplexOpt6
=
7595468
{
optional
int32
xyzzy
=
7593951
;
}
}
// Note that we try various different ways of naming the same extension.
message
VariousComplexOptions
{
option
(
.
protobuf_unittest.complex_opt1
)
.
foo
=
42
;
option
(
protobuf_unittest.complex_opt1
)
.
(
.
protobuf_unittest.quux
)
=
324
;
option
(
.
protobuf_unittest.complex_opt1
)
.
(
protobuf_unittest.corge
)
.
qux
=
876
;
option
(
complex_opt2
)
.
baz
=
987
;
option
(
complex_opt2
)
.
(
grault
)
=
654
;
option
(
complex_opt2
)
.
bar.foo
=
743
;
option
(
complex_opt2
)
.
bar.
(
quux
)
=
1999
;
option
(
complex_opt2
)
.
bar.
(
protobuf_unittest.corge
)
.
qux
=
2008
;
option
(
complex_opt2
)
.
(
garply
)
.
foo
=
741
;
option
(
complex_opt2
)
.
(
garply
)
.
(
.
protobuf_unittest.quux
)
=
1998
;
option
(
complex_opt2
)
.
(
protobuf_unittest.garply
)
.
(
corge
)
.
qux
=
2121
;
option
(
ComplexOptionType2.ComplexOptionType4.complex_opt4
)
.
waldo
=
1971
;
option
(
complex_opt2
)
.
fred.waldo
=
321
;
option
(
protobuf_unittest.complex_opt3
)
.
qux
=
9
;
option
(
complex_opt3
)
.
complexoptiontype5.plugh
=
22
;
option
(
complexopt6
)
.
xyzzy
=
24
;
}
// ------------------------------------------------------
// Definitions for testing aggregate option parsing.
// See descriptor_unittest.cc.
message
AggregateMessageSet
{
option
message_set_wire_format
=
true
;
extensions
4
to
max
;
}
message
AggregateMessageSetElement
{
extend
AggregateMessageSet
{
optional
AggregateMessageSetElement
message_set_extension
=
15447542
;
}
optional
string
s
=
1
;
}
// A helper type used to test aggregate option parsing
message
Aggregate
{
optional
int32
i
=
1
;
optional
string
s
=
2
;
// A nested object
optional
Aggregate
sub
=
3
;
// To test the parsing of extensions inside aggregate values
optional
google.protobuf.FileOptions
file
=
4
;
extend
google
.
protobuf.FileOptions
{
optional
Aggregate
nested
=
15476903
;
}
// An embedded message set
optional
AggregateMessageSet
mset
=
5
;
}
// Allow Aggregate to be used as an option at all possible locations
// in the .proto grammer.
extend
google
.
protobuf.FileOptions
{
optional
Aggregate
fileopt
=
15478479
;
}
extend
google
.
protobuf.MessageOptions
{
optional
Aggregate
msgopt
=
15480088
;
}
extend
google
.
protobuf.FieldOptions
{
optional
Aggregate
fieldopt
=
15481374
;
}
extend
google
.
protobuf.EnumOptions
{
optional
Aggregate
enumopt
=
15483218
;
}
extend
google
.
protobuf.EnumValueOptions
{
optional
Aggregate
enumvalopt
=
15486921
;
}
extend
google
.
protobuf.ServiceOptions
{
optional
Aggregate
serviceopt
=
15497145
;
}
extend
google
.
protobuf.MethodOptions
{
optional
Aggregate
methodopt
=
15512713
;
}
// Try using AggregateOption at different points in the proto grammar
option
(
fileopt
)
=
{
s
:
'FileAnnotation'
// Also test the handling of comments
/* of both types */
i
:
100
sub
{
s
:
'NestedFileAnnotation'
}
// Include a google.protobuf.FileOptions and recursively extend it with
// another fileopt.
file
{
[
protobuf_unittest.fileopt
]
{
s
:
'FileExtensionAnnotation'
}
}
// A message set inside an option value
mset
{
[
protobuf_unittest.AggregateMessageSetElement.message_set_extension
]
{
s
:
'EmbeddedMessageSetElement'
}
}
};
message
AggregateMessage
{
option
(
msgopt
)
=
{
i
:
101
s
:
'MessageAnnotation'
};
optional
int32
fieldname
=
1
[(
fieldopt
)
=
{
s
:
'FieldAnnotation'
}];
}
service
AggregateService
{
option
(
serviceopt
)
=
{
s
:
'ServiceAnnotation'
};
rpc
Method
(
AggregateMessage
)
returns
(
AggregateMessage
)
{
option
(
methodopt
)
=
{
s
:
'MethodAnnotation'
};
}
}
enum
AggregateEnum
{
option
(
enumopt
)
=
{
s
:
'EnumAnnotation'
};
VALUE
=
1
[(
enumvalopt
)
=
{
s
:
'EnumValueAnnotation'
}];
}
// Test custom options for nested type.
message
NestedOptionType
{
message
NestedMessage
{
option
(
message_opt1
)
=
1001
;
optional
int32
nested_field
=
1
[(
field_opt1
)
=
1002
];
}
enum
NestedEnum
{
option
(
enum_opt1
)
=
1003
;
NESTED_ENUM_VALUE
=
1
[(
enum_value_opt1
)
=
1004
];
}
extend
google
.
protobuf.FileOptions
{
optional
int32
nested_extension
=
7912573
[(
field_opt2
)
=
1005
];
}
}
python/compatibility_tests/v2.5.0/protos/src/proto/google/protobuf/unittest_import.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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.proto to test importing.
// 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
;
// Excercise the java_package option.
option
java_package
=
"com.google.protobuf.test"
;
// 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.proto"
;
message
ImportMessage
{
optional
int32
d
=
1
;
}
enum
ImportEnum
{
IMPORT_FOO
=
7
;
IMPORT_BAR
=
8
;
IMPORT_BAZ
=
9
;
}
python/compatibility_tests/v2.5.0/protos/src/proto/google/protobuf/unittest_import_public.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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)
package
protobuf_unittest_import
;
option
java_package
=
"com.google.protobuf.test"
;
message
PublicImportMessage
{
optional
int32
e
=
1
;
}
python/compatibility_tests/v2.5.0/protos/src/proto/google/protobuf/unittest_mset.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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.
//
// This file contains messages for testing message_set_wire_format.
package
protobuf_unittest
;
option
optimize_for
=
SPEED
;
// A message with message_set_wire_format.
message
TestMessageSet
{
option
message_set_wire_format
=
true
;
extensions
4
to
max
;
}
message
TestMessageSetContainer
{
optional
TestMessageSet
message_set
=
1
;
}
message
TestMessageSetExtension1
{
extend
TestMessageSet
{
optional
TestMessageSetExtension1
message_set_extension
=
1545008
;
}
optional
int32
i
=
15
;
}
message
TestMessageSetExtension2
{
extend
TestMessageSet
{
optional
TestMessageSetExtension2
message_set_extension
=
1547769
;
}
optional
string
str
=
25
;
}
// MessageSet wire format is equivalent to this.
message
RawMessageSet
{
repeated
group
Item
=
1
{
required
int32
type_id
=
2
;
required
bytes
message
=
3
;
}
}
python/compatibility_tests/v2.5.0/protos/src/proto/google/protobuf/unittest_no_generic_services.proto
0 → 100644
View file @
5af0b547
// Protocol Buffers - Google's data interchange format
// Copyright 2008 Google Inc. All rights reserved.
// http://code.google.com/p/protobuf/
//
// 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)
package
google
.
protobuf.no_generic_services_test
;
// *_generic_services are false by default.
message
TestMessage
{
optional
int32
a
=
1
;
extensions
1000
to
max
;
}
enum
TestEnum
{
FOO
=
1
;
}
extend
TestMessage
{
optional
int32
test_extension
=
1000
;
}
service
TestService
{
rpc
Foo
(
TestMessage
)
returns
(
TestMessage
);
}
python/compatibility_tests/v2.5.0/setup.py
0 → 100755
View file @
5af0b547
#! /usr/bin/env python
#
import
glob
import
os
import
subprocess
import
sys
from
setuptools
import
setup
,
Extension
,
find_packages
if
sys
.
version_info
[
0
]
==
3
:
# Python 3
from
distutils.command.build_py
import
build_py_2to3
as
_build_py
else
:
# Python 2
from
distutils.command.build_py
import
build_py
as
_build_py
from
distutils.spawn
import
find_executable
def
generate_proto
(
source
,
code_gen
):
"""Invokes the Protocol Compiler to generate a _pb2.py from the given
.proto file."""
output
=
source
.
replace
(
".proto"
,
"_pb2.py"
)
.
replace
(
"protos/src/proto/"
,
""
)
.
replace
(
"protos/python/"
,
""
)
if
not
os
.
path
.
exists
(
source
):
sys
.
stderr
.
write
(
"Can't find required file:
%
s
\n
"
%
source
)
sys
.
exit
(
-
1
)
protoc_command
=
[
code_gen
,
"-Iprotos/src/proto"
,
"-Iprotos/python"
,
"--python_out=."
,
source
]
if
subprocess
.
call
(
protoc_command
)
!=
0
:
sys
.
exit
(
-
1
)
class
build_py
(
_build_py
):
def
run
(
self
):
# generate .proto file
protoc_1
=
"./protoc_1"
protoc_2
=
"./protoc_2"
generate_proto
(
"protos/src/proto/google/protobuf/unittest.proto"
,
protoc_2
)
generate_proto
(
"protos/src/proto/google/protobuf/unittest_custom_options.proto"
,
protoc_1
)
generate_proto
(
"protos/src/proto/google/protobuf/unittest_import.proto"
,
protoc_1
)
generate_proto
(
"protos/src/proto/google/protobuf/unittest_import_public.proto"
,
protoc_1
)
generate_proto
(
"protos/src/proto/google/protobuf/unittest_mset.proto"
,
protoc_1
)
generate_proto
(
"protos/src/proto/google/protobuf/unittest_no_generic_services.proto"
,
protoc_1
)
generate_proto
(
"protos/python/google/protobuf/internal/factory_test1.proto"
,
protoc_1
)
generate_proto
(
"protos/python/google/protobuf/internal/factory_test2.proto"
,
protoc_1
)
generate_proto
(
"protos/python/google/protobuf/internal/more_extensions.proto"
,
protoc_1
)
generate_proto
(
"protos/python/google/protobuf/internal/more_extensions_dynamic.proto"
,
protoc_1
)
generate_proto
(
"protos/python/google/protobuf/internal/more_messages.proto"
,
protoc_1
)
generate_proto
(
"protos/python/google/protobuf/internal/test_bad_identifiers.proto"
,
protoc_1
)
# _build_py is an old-style class, so super() doesn't work.
_build_py
.
run
(
self
)
if
__name__
==
'__main__'
:
# Keep this list of dependencies in sync with tox.ini.
install_requires
=
[
'six>=1.9'
,
'setuptools'
]
if
sys
.
version_info
<=
(
2
,
7
):
install_requires
.
append
(
'ordereddict'
)
install_requires
.
append
(
'unittest2'
)
setup
(
name
=
'protobuf'
,
description
=
'Protocol Buffers'
,
download_url
=
'https://github.com/google/protobuf/releases'
,
long_description
=
"Protocol Buffers are Google's data interchange format"
,
url
=
'https://developers.google.com/protocol-buffers/'
,
maintainer
=
'protobuf@googlegroups.com'
,
maintainer_email
=
'protobuf@googlegroups.com'
,
license
=
'New BSD License'
,
classifiers
=
[
"Programming Language :: Python"
,
"Programming Language :: Python :: 2"
,
"Programming Language :: Python :: 2.6"
,
"Programming Language :: Python :: 2.7"
,
"Programming Language :: Python :: 3"
,
"Programming Language :: Python :: 3.3"
,
"Programming Language :: Python :: 3.4"
,
],
packages
=
find_packages
(
exclude
=
[
'import_test_package'
,
],
),
test_suite
=
'tests.google.protobuf.internal'
,
cmdclass
=
{
'build_py'
:
build_py
,
},
install_requires
=
install_requires
,
)
python/compatibility_tests/v2.5.0/test.sh
0 → 100755
View file @
5af0b547
#!/bin/bash
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
=
2.5.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
""
|
2.5.0
)
OLD_VERSION
=
2.5.0
OLD_VERSION_PROTOC
=
https://github.com/xfxyjwf/protobuf-compiler-release/raw/master/v2.5.0/linux/protoc
;;
2.6.1
)
OLD_VERSION
=
2.6.1
OLD_VERSION_PROTOC
=
http://repo1.maven.org/maven2/com/google/protobuf/protoc/2.6.1-build2/protoc-2.6.1-build2-linux-x86_64.exe
;;
3.0.0-beta-1
)
OLD_VERSION
=
3.0.0-beta-1
OLD_VERSION_PROTOC
=
http://repo1.maven.org/maven2/com/google/protobuf/protoc/3.0.0-beta-1/protoc-3.0.0-beta-1-linux-x86_64.exe
;;
3.0.0-beta-2
)
OLD_VERSION
=
3.0.0-beta-2
OLD_VERSION_PROTOC
=
http://repo1.maven.org/maven2/com/google/protobuf/protoc/3.0.0-beta-2/protoc-3.0.0-beta-2-linux-x86_64.exe
;;
3.0.0-beta-3
)
OLD_VERSION
=
3.0.0-beta-3
OLD_VERSION_PROTOC
=
http://repo1.maven.org/maven2/com/google/protobuf/protoc/3.0.0-beta-3/protoc-3.0.0-beta-3-linux-x86_64.exe
;;
3.0.0-beta-4
)
OLD_VERSION
=
3.0.0-beta-4
OLD_VERSION_PROTOC
=
http://repo1.maven.org/maven2/com/google/protobuf/protoc/3.0.0-beta-4/protoc-3.0.0-beta-4-linux-x86_64.exe
;;
*
)
echo
"[ERROR]: Unknown version number:
$1
"
exit
1
;;
esac
# Extract the latest protobuf version number.
VERSION_NUMBER
=
`
grep
"^__version__ = '.*'"
../../google/protobuf/__init__.py |
sed
"s|__version__ = '
\(
.*
\)
'|
\1
|"
`
echo
"Running compatibility tests between
$VERSION_NUMBER
and
$OLD_VERSION
"
# Check protoc
[
-f
../../../src/protoc
]
||
{
echo
"[ERROR]: Please build protoc first."
exit
1
}
# Test source compatibility. In these tests we recompile everything against
# the new runtime (including old version generated code).
rm
google
-f
-r
mkdir
-p
google/protobuf/internal
# Build and copy the new runtime
cd
../../
python setup.py build
cp
google/protobuf/
*
.py compatibility_tests/v2.5.0/google/protobuf/
cp
google/protobuf/internal/
*
.py compatibility_tests/v2.5.0/google/protobuf/internal/
cd
compatibility_tests/v2.5.0
cp
tests/google/protobuf/internal/test_util.py google/protobuf/internal/
cp
google/protobuf/__init__.py google/
# Download old version protoc compiler (for linux)
wget
$OLD_VERSION_PROTOC
-O
old_protoc
chmod
+x old_protoc
# 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
python setup.py build
python setup.py
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
python setup.py build
python setup.py
test
# Test A.3:
# proto set 1: use old version
# proto set 2 which may import protos in set 1: use new version
# Compatiblility test fail if the old verison is less than 3.0.0-alpha-1.
# Because module name aliases was added in v3.0.0-alpha-1 instead of
# fully-qualified module names to refer to dependencies: dot was replaced
# with _dot_.
if
[
"
$(
printf
"
$OLD_VERSION
\n
3.0.0"
|
sort
-V
|
head
-n
1
)
"
=
"3.0.0"
]
;
then
cp
old_protoc protoc_1
cp
../../../src/protoc protoc_2
python setup.py build
python setup.py
test
fi
rm
google
-r
-f
rm
build
-r
-f
rm
protoc_1
rm
protoc_2
rm
old_protoc
python/compatibility_tests/v2.5.0/tests/__init__.py
0 → 100644
View file @
5af0b547
try
:
__import__
(
'pkg_resources'
)
.
declare_namespace
(
__name__
)
except
ImportError
:
__path__
=
__import__
(
'pkgutil'
)
.
extend_path
(
__path__
,
__name__
)
python/compatibility_tests/v2.5.0/tests/google/__init__.py
0 → 100644
View file @
5af0b547
try
:
__import__
(
'pkg_resources'
)
.
declare_namespace
(
__name__
)
except
ImportError
:
__path__
=
__import__
(
'pkgutil'
)
.
extend_path
(
__path__
,
__name__
)
python/compatibility_tests/v2.5.0/tests/google/protobuf/__init__.py
0 → 100644
View file @
5af0b547
try
:
__import__
(
'pkg_resources'
)
.
declare_namespace
(
__name__
)
except
ImportError
:
__path__
=
__import__
(
'pkgutil'
)
.
extend_path
(
__path__
,
__name__
)
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/__init__.py
0 → 100644
View file @
5af0b547
# 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.
# Copyright 2007 Google Inc. All Rights Reserved.
if
__name__
!=
'__main__'
:
try
:
__import__
(
'pkg_resources'
)
.
declare_namespace
(
__name__
)
except
ImportError
:
__path__
=
__import__
(
'pkgutil'
)
.
extend_path
(
__path__
,
__name__
)
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/descriptor_test.py
0 → 100755
View file @
5af0b547
#! /usr/bin/python
#
# Protocol Buffers - Google's data interchange format
# Copyright 2008 Google Inc. All rights reserved.
# http://code.google.com/p/protobuf/
#
# 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.
"""Unittest for google.protobuf.internal.descriptor."""
__author__
=
'robinson@google.com (Will Robinson)'
import
unittest
from
google.protobuf
import
unittest_custom_options_pb2
from
google.protobuf
import
unittest_import_pb2
from
google.protobuf
import
unittest_pb2
from
google.protobuf
import
descriptor_pb2
from
google.protobuf
import
descriptor
from
google.protobuf
import
text_format
TEST_EMPTY_MESSAGE_DESCRIPTOR_ASCII
=
"""
name: 'TestEmptyMessage'
"""
class
DescriptorTest
(
unittest
.
TestCase
):
def
setUp
(
self
):
self
.
my_file
=
descriptor
.
FileDescriptor
(
name
=
'some/filename/some.proto'
,
package
=
'protobuf_unittest'
)
self
.
my_enum
=
descriptor
.
EnumDescriptor
(
name
=
'ForeignEnum'
,
full_name
=
'protobuf_unittest.ForeignEnum'
,
filename
=
None
,
file
=
self
.
my_file
,
values
=
[
descriptor
.
EnumValueDescriptor
(
name
=
'FOREIGN_FOO'
,
index
=
0
,
number
=
4
),
descriptor
.
EnumValueDescriptor
(
name
=
'FOREIGN_BAR'
,
index
=
1
,
number
=
5
),
descriptor
.
EnumValueDescriptor
(
name
=
'FOREIGN_BAZ'
,
index
=
2
,
number
=
6
),
])
self
.
my_message
=
descriptor
.
Descriptor
(
name
=
'NestedMessage'
,
full_name
=
'protobuf_unittest.TestAllTypes.NestedMessage'
,
filename
=
None
,
file
=
self
.
my_file
,
containing_type
=
None
,
fields
=
[
descriptor
.
FieldDescriptor
(
name
=
'bb'
,
full_name
=
'protobuf_unittest.TestAllTypes.NestedMessage.bb'
,
index
=
0
,
number
=
1
,
type
=
5
,
cpp_type
=
1
,
label
=
1
,
has_default_value
=
False
,
default_value
=
0
,
message_type
=
None
,
enum_type
=
None
,
containing_type
=
None
,
is_extension
=
False
,
extension_scope
=
None
),
],
nested_types
=
[],
enum_types
=
[
self
.
my_enum
,
],
extensions
=
[])
self
.
my_method
=
descriptor
.
MethodDescriptor
(
name
=
'Bar'
,
full_name
=
'protobuf_unittest.TestService.Bar'
,
index
=
0
,
containing_service
=
None
,
input_type
=
None
,
output_type
=
None
)
self
.
my_service
=
descriptor
.
ServiceDescriptor
(
name
=
'TestServiceWithOptions'
,
full_name
=
'protobuf_unittest.TestServiceWithOptions'
,
file
=
self
.
my_file
,
index
=
0
,
methods
=
[
self
.
my_method
])
def
testEnumValueName
(
self
):
self
.
assertEqual
(
self
.
my_message
.
EnumValueName
(
'ForeignEnum'
,
4
),
'FOREIGN_FOO'
)
self
.
assertEqual
(
self
.
my_message
.
enum_types_by_name
[
'ForeignEnum'
]
.
values_by_number
[
4
]
.
name
,
self
.
my_message
.
EnumValueName
(
'ForeignEnum'
,
4
))
def
testEnumFixups
(
self
):
self
.
assertEqual
(
self
.
my_enum
,
self
.
my_enum
.
values
[
0
]
.
type
)
def
testContainingTypeFixups
(
self
):
self
.
assertEqual
(
self
.
my_message
,
self
.
my_message
.
fields
[
0
]
.
containing_type
)
self
.
assertEqual
(
self
.
my_message
,
self
.
my_enum
.
containing_type
)
def
testContainingServiceFixups
(
self
):
self
.
assertEqual
(
self
.
my_service
,
self
.
my_method
.
containing_service
)
def
testGetOptions
(
self
):
self
.
assertEqual
(
self
.
my_enum
.
GetOptions
(),
descriptor_pb2
.
EnumOptions
())
self
.
assertEqual
(
self
.
my_enum
.
values
[
0
]
.
GetOptions
(),
descriptor_pb2
.
EnumValueOptions
())
self
.
assertEqual
(
self
.
my_message
.
GetOptions
(),
descriptor_pb2
.
MessageOptions
())
self
.
assertEqual
(
self
.
my_message
.
fields
[
0
]
.
GetOptions
(),
descriptor_pb2
.
FieldOptions
())
self
.
assertEqual
(
self
.
my_method
.
GetOptions
(),
descriptor_pb2
.
MethodOptions
())
self
.
assertEqual
(
self
.
my_service
.
GetOptions
(),
descriptor_pb2
.
ServiceOptions
())
def
testSimpleCustomOptions
(
self
):
file_descriptor
=
unittest_custom_options_pb2
.
DESCRIPTOR
message_descriptor
=
\
unittest_custom_options_pb2
.
TestMessageWithCustomOptions
.
DESCRIPTOR
field_descriptor
=
message_descriptor
.
fields_by_name
[
"field1"
]
enum_descriptor
=
message_descriptor
.
enum_types_by_name
[
"AnEnum"
]
enum_value_descriptor
=
\
message_descriptor
.
enum_values_by_name
[
"ANENUM_VAL2"
]
service_descriptor
=
\
unittest_custom_options_pb2
.
TestServiceWithCustomOptions
.
DESCRIPTOR
method_descriptor
=
service_descriptor
.
FindMethodByName
(
"Foo"
)
file_options
=
file_descriptor
.
GetOptions
()
file_opt1
=
unittest_custom_options_pb2
.
file_opt1
self
.
assertEqual
(
9876543210
,
file_options
.
Extensions
[
file_opt1
])
message_options
=
message_descriptor
.
GetOptions
()
message_opt1
=
unittest_custom_options_pb2
.
message_opt1
self
.
assertEqual
(
-
56
,
message_options
.
Extensions
[
message_opt1
])
field_options
=
field_descriptor
.
GetOptions
()
field_opt1
=
unittest_custom_options_pb2
.
field_opt1
self
.
assertEqual
(
8765432109
,
field_options
.
Extensions
[
field_opt1
])
field_opt2
=
unittest_custom_options_pb2
.
field_opt2
self
.
assertEqual
(
42
,
field_options
.
Extensions
[
field_opt2
])
enum_options
=
enum_descriptor
.
GetOptions
()
enum_opt1
=
unittest_custom_options_pb2
.
enum_opt1
self
.
assertEqual
(
-
789
,
enum_options
.
Extensions
[
enum_opt1
])
enum_value_options
=
enum_value_descriptor
.
GetOptions
()
enum_value_opt1
=
unittest_custom_options_pb2
.
enum_value_opt1
self
.
assertEqual
(
123
,
enum_value_options
.
Extensions
[
enum_value_opt1
])
service_options
=
service_descriptor
.
GetOptions
()
service_opt1
=
unittest_custom_options_pb2
.
service_opt1
self
.
assertEqual
(
-
9876543210
,
service_options
.
Extensions
[
service_opt1
])
method_options
=
method_descriptor
.
GetOptions
()
method_opt1
=
unittest_custom_options_pb2
.
method_opt1
self
.
assertEqual
(
unittest_custom_options_pb2
.
METHODOPT1_VAL2
,
method_options
.
Extensions
[
method_opt1
])
def
testDifferentCustomOptionTypes
(
self
):
kint32min
=
-
2
**
31
kint64min
=
-
2
**
63
kint32max
=
2
**
31
-
1
kint64max
=
2
**
63
-
1
kuint32max
=
2
**
32
-
1
kuint64max
=
2
**
64
-
1
message_descriptor
=
\
unittest_custom_options_pb2
.
CustomOptionMinIntegerValues
.
DESCRIPTOR
message_options
=
message_descriptor
.
GetOptions
()
self
.
assertEqual
(
False
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
bool_opt
])
self
.
assertEqual
(
kint32min
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
int32_opt
])
self
.
assertEqual
(
kint64min
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
int64_opt
])
self
.
assertEqual
(
0
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
uint32_opt
])
self
.
assertEqual
(
0
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
uint64_opt
])
self
.
assertEqual
(
kint32min
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
sint32_opt
])
self
.
assertEqual
(
kint64min
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
sint64_opt
])
self
.
assertEqual
(
0
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
fixed32_opt
])
self
.
assertEqual
(
0
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
fixed64_opt
])
self
.
assertEqual
(
kint32min
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
sfixed32_opt
])
self
.
assertEqual
(
kint64min
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
sfixed64_opt
])
message_descriptor
=
\
unittest_custom_options_pb2
.
CustomOptionMaxIntegerValues
.
DESCRIPTOR
message_options
=
message_descriptor
.
GetOptions
()
self
.
assertEqual
(
True
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
bool_opt
])
self
.
assertEqual
(
kint32max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
int32_opt
])
self
.
assertEqual
(
kint64max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
int64_opt
])
self
.
assertEqual
(
kuint32max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
uint32_opt
])
self
.
assertEqual
(
kuint64max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
uint64_opt
])
self
.
assertEqual
(
kint32max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
sint32_opt
])
self
.
assertEqual
(
kint64max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
sint64_opt
])
self
.
assertEqual
(
kuint32max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
fixed32_opt
])
self
.
assertEqual
(
kuint64max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
fixed64_opt
])
self
.
assertEqual
(
kint32max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
sfixed32_opt
])
self
.
assertEqual
(
kint64max
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
sfixed64_opt
])
message_descriptor
=
\
unittest_custom_options_pb2
.
CustomOptionOtherValues
.
DESCRIPTOR
message_options
=
message_descriptor
.
GetOptions
()
self
.
assertEqual
(
-
100
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
int32_opt
])
self
.
assertAlmostEqual
(
12.3456789
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
float_opt
],
6
)
self
.
assertAlmostEqual
(
1.234567890123456789
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
double_opt
])
self
.
assertEqual
(
"Hello,
\"
World
\"
"
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
string_opt
])
self
.
assertEqual
(
"Hello
\0
World"
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
bytes_opt
])
dummy_enum
=
unittest_custom_options_pb2
.
DummyMessageContainingEnum
self
.
assertEqual
(
dummy_enum
.
TEST_OPTION_ENUM_TYPE2
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
enum_opt
])
message_descriptor
=
\
unittest_custom_options_pb2
.
SettingRealsFromPositiveInts
.
DESCRIPTOR
message_options
=
message_descriptor
.
GetOptions
()
self
.
assertAlmostEqual
(
12
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
float_opt
],
6
)
self
.
assertAlmostEqual
(
154
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
double_opt
])
message_descriptor
=
\
unittest_custom_options_pb2
.
SettingRealsFromNegativeInts
.
DESCRIPTOR
message_options
=
message_descriptor
.
GetOptions
()
self
.
assertAlmostEqual
(
-
12
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
float_opt
],
6
)
self
.
assertAlmostEqual
(
-
154
,
message_options
.
Extensions
[
unittest_custom_options_pb2
.
double_opt
])
def
testComplexExtensionOptions
(
self
):
descriptor
=
\
unittest_custom_options_pb2
.
VariousComplexOptions
.
DESCRIPTOR
options
=
descriptor
.
GetOptions
()
self
.
assertEqual
(
42
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt1
]
.
foo
)
self
.
assertEqual
(
324
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt1
]
.
Extensions
[
unittest_custom_options_pb2
.
quux
])
self
.
assertEqual
(
876
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt1
]
.
Extensions
[
unittest_custom_options_pb2
.
corge
]
.
qux
)
self
.
assertEqual
(
987
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt2
]
.
baz
)
self
.
assertEqual
(
654
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt2
]
.
Extensions
[
unittest_custom_options_pb2
.
grault
])
self
.
assertEqual
(
743
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt2
]
.
bar
.
foo
)
self
.
assertEqual
(
1999
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt2
]
.
bar
.
Extensions
[
unittest_custom_options_pb2
.
quux
])
self
.
assertEqual
(
2008
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt2
]
.
bar
.
Extensions
[
unittest_custom_options_pb2
.
corge
]
.
qux
)
self
.
assertEqual
(
741
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt2
]
.
Extensions
[
unittest_custom_options_pb2
.
garply
]
.
foo
)
self
.
assertEqual
(
1998
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt2
]
.
Extensions
[
unittest_custom_options_pb2
.
garply
]
.
Extensions
[
unittest_custom_options_pb2
.
quux
])
self
.
assertEqual
(
2121
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt2
]
.
Extensions
[
unittest_custom_options_pb2
.
garply
]
.
Extensions
[
unittest_custom_options_pb2
.
corge
]
.
qux
)
self
.
assertEqual
(
1971
,
options
.
Extensions
[
unittest_custom_options_pb2
.
ComplexOptionType2
.
ComplexOptionType4
.
complex_opt4
]
.
waldo
)
self
.
assertEqual
(
321
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt2
]
.
fred
.
waldo
)
self
.
assertEqual
(
9
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt3
]
.
qux
)
self
.
assertEqual
(
22
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complex_opt3
]
.
complexoptiontype5
.
plugh
)
self
.
assertEqual
(
24
,
options
.
Extensions
[
unittest_custom_options_pb2
.
complexopt6
]
.
xyzzy
)
# Check that aggregate options were parsed and saved correctly in
# the appropriate descriptors.
def
testAggregateOptions
(
self
):
file_descriptor
=
unittest_custom_options_pb2
.
DESCRIPTOR
message_descriptor
=
\
unittest_custom_options_pb2
.
AggregateMessage
.
DESCRIPTOR
field_descriptor
=
message_descriptor
.
fields_by_name
[
"fieldname"
]
enum_descriptor
=
unittest_custom_options_pb2
.
AggregateEnum
.
DESCRIPTOR
enum_value_descriptor
=
enum_descriptor
.
values_by_name
[
"VALUE"
]
service_descriptor
=
\
unittest_custom_options_pb2
.
AggregateService
.
DESCRIPTOR
method_descriptor
=
service_descriptor
.
FindMethodByName
(
"Method"
)
# Tests for the different types of data embedded in fileopt
file_options
=
file_descriptor
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
fileopt
]
self
.
assertEqual
(
100
,
file_options
.
i
)
self
.
assertEqual
(
"FileAnnotation"
,
file_options
.
s
)
self
.
assertEqual
(
"NestedFileAnnotation"
,
file_options
.
sub
.
s
)
self
.
assertEqual
(
"FileExtensionAnnotation"
,
file_options
.
file
.
Extensions
[
unittest_custom_options_pb2
.
fileopt
]
.
s
)
self
.
assertEqual
(
"EmbeddedMessageSetElement"
,
file_options
.
mset
.
Extensions
[
unittest_custom_options_pb2
.
AggregateMessageSetElement
.
message_set_extension
]
.
s
)
# Simple tests for all the other types of annotations
self
.
assertEqual
(
"MessageAnnotation"
,
message_descriptor
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
msgopt
]
.
s
)
self
.
assertEqual
(
"FieldAnnotation"
,
field_descriptor
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
fieldopt
]
.
s
)
self
.
assertEqual
(
"EnumAnnotation"
,
enum_descriptor
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
enumopt
]
.
s
)
self
.
assertEqual
(
"EnumValueAnnotation"
,
enum_value_descriptor
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
enumvalopt
]
.
s
)
self
.
assertEqual
(
"ServiceAnnotation"
,
service_descriptor
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
serviceopt
]
.
s
)
self
.
assertEqual
(
"MethodAnnotation"
,
method_descriptor
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
methodopt
]
.
s
)
def
testNestedOptions
(
self
):
nested_message
=
\
unittest_custom_options_pb2
.
NestedOptionType
.
NestedMessage
.
DESCRIPTOR
self
.
assertEqual
(
1001
,
nested_message
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
message_opt1
])
nested_field
=
nested_message
.
fields_by_name
[
"nested_field"
]
self
.
assertEqual
(
1002
,
nested_field
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
field_opt1
])
outer_message
=
\
unittest_custom_options_pb2
.
NestedOptionType
.
DESCRIPTOR
nested_enum
=
outer_message
.
enum_types_by_name
[
"NestedEnum"
]
self
.
assertEqual
(
1003
,
nested_enum
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
enum_opt1
])
nested_enum_value
=
outer_message
.
enum_values_by_name
[
"NESTED_ENUM_VALUE"
]
self
.
assertEqual
(
1004
,
nested_enum_value
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
enum_value_opt1
])
nested_extension
=
outer_message
.
extensions_by_name
[
"nested_extension"
]
self
.
assertEqual
(
1005
,
nested_extension
.
GetOptions
()
.
Extensions
[
unittest_custom_options_pb2
.
field_opt2
])
def
testFileDescriptorReferences
(
self
):
self
.
assertEqual
(
self
.
my_enum
.
file
,
self
.
my_file
)
self
.
assertEqual
(
self
.
my_message
.
file
,
self
.
my_file
)
def
testFileDescriptor
(
self
):
self
.
assertEqual
(
self
.
my_file
.
name
,
'some/filename/some.proto'
)
self
.
assertEqual
(
self
.
my_file
.
package
,
'protobuf_unittest'
)
class
DescriptorCopyToProtoTest
(
unittest
.
TestCase
):
"""Tests for CopyTo functions of Descriptor."""
def
_AssertProtoEqual
(
self
,
actual_proto
,
expected_class
,
expected_ascii
):
expected_proto
=
expected_class
()
text_format
.
Merge
(
expected_ascii
,
expected_proto
)
self
.
assertEqual
(
actual_proto
,
expected_proto
,
'Not equal,
\n
Actual:
\n
%
s
\n
Expected:
\n
%
s
\n
'
%
(
str
(
actual_proto
),
str
(
expected_proto
)))
def
_InternalTestCopyToProto
(
self
,
desc
,
expected_proto_class
,
expected_proto_ascii
):
actual
=
expected_proto_class
()
desc
.
CopyToProto
(
actual
)
self
.
_AssertProtoEqual
(
actual
,
expected_proto_class
,
expected_proto_ascii
)
def
testCopyToProto_EmptyMessage
(
self
):
self
.
_InternalTestCopyToProto
(
unittest_pb2
.
TestEmptyMessage
.
DESCRIPTOR
,
descriptor_pb2
.
DescriptorProto
,
TEST_EMPTY_MESSAGE_DESCRIPTOR_ASCII
)
def
testCopyToProto_NestedMessage
(
self
):
TEST_NESTED_MESSAGE_ASCII
=
"""
name: 'NestedMessage'
field: <
name: 'bb'
number: 1
label: 1 # Optional
type: 5 # TYPE_INT32
>
"""
self
.
_InternalTestCopyToProto
(
unittest_pb2
.
TestAllTypes
.
NestedMessage
.
DESCRIPTOR
,
descriptor_pb2
.
DescriptorProto
,
TEST_NESTED_MESSAGE_ASCII
)
def
testCopyToProto_ForeignNestedMessage
(
self
):
TEST_FOREIGN_NESTED_ASCII
=
"""
name: 'TestForeignNested'
field: <
name: 'foreign_nested'
number: 1
label: 1 # Optional
type: 11 # TYPE_MESSAGE
type_name: '.protobuf_unittest.TestAllTypes.NestedMessage'
>
"""
self
.
_InternalTestCopyToProto
(
unittest_pb2
.
TestForeignNested
.
DESCRIPTOR
,
descriptor_pb2
.
DescriptorProto
,
TEST_FOREIGN_NESTED_ASCII
)
def
testCopyToProto_ForeignEnum
(
self
):
TEST_FOREIGN_ENUM_ASCII
=
"""
name: 'ForeignEnum'
value: <
name: 'FOREIGN_FOO'
number: 4
>
value: <
name: 'FOREIGN_BAR'
number: 5
>
value: <
name: 'FOREIGN_BAZ'
number: 6
>
"""
self
.
_InternalTestCopyToProto
(
unittest_pb2
.
_FOREIGNENUM
,
descriptor_pb2
.
EnumDescriptorProto
,
TEST_FOREIGN_ENUM_ASCII
)
def
testCopyToProto_Options
(
self
):
TEST_DEPRECATED_FIELDS_ASCII
=
"""
name: 'TestDeprecatedFields'
field: <
name: 'deprecated_int32'
number: 1
label: 1 # Optional
type: 5 # TYPE_INT32
options: <
deprecated: true
>
>
"""
self
.
_InternalTestCopyToProto
(
unittest_pb2
.
TestDeprecatedFields
.
DESCRIPTOR
,
descriptor_pb2
.
DescriptorProto
,
TEST_DEPRECATED_FIELDS_ASCII
)
def
testCopyToProto_AllExtensions
(
self
):
TEST_EMPTY_MESSAGE_WITH_EXTENSIONS_ASCII
=
"""
name: 'TestEmptyMessageWithExtensions'
extension_range: <
start: 1
end: 536870912
>
"""
self
.
_InternalTestCopyToProto
(
unittest_pb2
.
TestEmptyMessageWithExtensions
.
DESCRIPTOR
,
descriptor_pb2
.
DescriptorProto
,
TEST_EMPTY_MESSAGE_WITH_EXTENSIONS_ASCII
)
def
testCopyToProto_SeveralExtensions
(
self
):
TEST_MESSAGE_WITH_SEVERAL_EXTENSIONS_ASCII
=
"""
name: 'TestMultipleExtensionRanges'
extension_range: <
start: 42
end: 43
>
extension_range: <
start: 4143
end: 4244
>
extension_range: <
start: 65536
end: 536870912
>
"""
self
.
_InternalTestCopyToProto
(
unittest_pb2
.
TestMultipleExtensionRanges
.
DESCRIPTOR
,
descriptor_pb2
.
DescriptorProto
,
TEST_MESSAGE_WITH_SEVERAL_EXTENSIONS_ASCII
)
def
testCopyToProto_FileDescriptor
(
self
):
UNITTEST_IMPORT_FILE_DESCRIPTOR_ASCII
=
(
"""
name: 'google/protobuf/unittest_import.proto'
package: 'protobuf_unittest_import'
dependency: 'google/protobuf/unittest_import_public.proto'
message_type: <
name: 'ImportMessage'
field: <
name: 'd'
number: 1
label: 1 # Optional
type: 5 # TYPE_INT32
>
>
"""
+
"""enum_type: <
name: 'ImportEnum'
value: <
name: 'IMPORT_FOO'
number: 7
>
value: <
name: 'IMPORT_BAR'
number: 8
>
value: <
name: 'IMPORT_BAZ'
number: 9
>
>
options: <
java_package: 'com.google.protobuf.test'
optimize_for: 1 # SPEED
>
public_dependency: 0
"""
)
self
.
_InternalTestCopyToProto
(
unittest_import_pb2
.
DESCRIPTOR
,
descriptor_pb2
.
FileDescriptorProto
,
UNITTEST_IMPORT_FILE_DESCRIPTOR_ASCII
)
def
testCopyToProto_ServiceDescriptor
(
self
):
TEST_SERVICE_ASCII
=
"""
name: 'TestService'
method: <
name: 'Foo'
input_type: '.protobuf_unittest.FooRequest'
output_type: '.protobuf_unittest.FooResponse'
>
method: <
name: 'Bar'
input_type: '.protobuf_unittest.BarRequest'
output_type: '.protobuf_unittest.BarResponse'
>
"""
self
.
_InternalTestCopyToProto
(
unittest_pb2
.
TestService
.
DESCRIPTOR
,
descriptor_pb2
.
ServiceDescriptorProto
,
TEST_SERVICE_ASCII
)
class
MakeDescriptorTest
(
unittest
.
TestCase
):
def
testMakeDescriptorWithUnsignedIntField
(
self
):
file_descriptor_proto
=
descriptor_pb2
.
FileDescriptorProto
()
file_descriptor_proto
.
name
=
'Foo'
message_type
=
file_descriptor_proto
.
message_type
.
add
()
message_type
.
name
=
file_descriptor_proto
.
name
field
=
message_type
.
field
.
add
()
field
.
number
=
1
field
.
name
=
'uint64_field'
field
.
label
=
descriptor
.
FieldDescriptor
.
LABEL_REQUIRED
field
.
type
=
descriptor
.
FieldDescriptor
.
TYPE_UINT64
result
=
descriptor
.
MakeDescriptor
(
message_type
)
self
.
assertEqual
(
result
.
fields
[
0
]
.
cpp_type
,
descriptor
.
FieldDescriptor
.
CPPTYPE_UINT64
)
if
__name__
==
'__main__'
:
unittest
.
main
()
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/generator_test.py
0 → 100755
View file @
5af0b547
#! /usr/bin/python
#
# Protocol Buffers - Google's data interchange format
# Copyright 2008 Google Inc. All rights reserved.
# http://code.google.com/p/protobuf/
#
# 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.
# TODO(robinson): Flesh this out considerably. We focused on reflection_test.py
# first, since it's testing the subtler code, and since it provides decent
# indirect testing of the protocol compiler output.
"""Unittest that directly tests the output of the pure-Python protocol
compiler. See //google/protobuf/reflection_test.py for a test which
further ensures that we can use Python protocol message objects as we expect.
"""
__author__
=
'robinson@google.com (Will Robinson)'
import
unittest
from
google.protobuf.internal
import
test_bad_identifiers_pb2
from
google.protobuf
import
unittest_custom_options_pb2
from
google.protobuf
import
unittest_import_pb2
from
google.protobuf
import
unittest_import_public_pb2
from
google.protobuf
import
unittest_mset_pb2
from
google.protobuf
import
unittest_pb2
from
google.protobuf
import
unittest_no_generic_services_pb2
from
google.protobuf
import
service
MAX_EXTENSION
=
536870912
class
GeneratorTest
(
unittest
.
TestCase
):
def
testNestedMessageDescriptor
(
self
):
field_name
=
'optional_nested_message'
proto_type
=
unittest_pb2
.
TestAllTypes
self
.
assertEqual
(
proto_type
.
NestedMessage
.
DESCRIPTOR
,
proto_type
.
DESCRIPTOR
.
fields_by_name
[
field_name
]
.
message_type
)
def
testEnums
(
self
):
# We test only module-level enums here.
# TODO(robinson): Examine descriptors directly to check
# enum descriptor output.
self
.
assertEqual
(
4
,
unittest_pb2
.
FOREIGN_FOO
)
self
.
assertEqual
(
5
,
unittest_pb2
.
FOREIGN_BAR
)
self
.
assertEqual
(
6
,
unittest_pb2
.
FOREIGN_BAZ
)
proto
=
unittest_pb2
.
TestAllTypes
()
self
.
assertEqual
(
1
,
proto
.
FOO
)
self
.
assertEqual
(
1
,
unittest_pb2
.
TestAllTypes
.
FOO
)
self
.
assertEqual
(
2
,
proto
.
BAR
)
self
.
assertEqual
(
2
,
unittest_pb2
.
TestAllTypes
.
BAR
)
self
.
assertEqual
(
3
,
proto
.
BAZ
)
self
.
assertEqual
(
3
,
unittest_pb2
.
TestAllTypes
.
BAZ
)
def
testExtremeDefaultValues
(
self
):
message
=
unittest_pb2
.
TestExtremeDefaultValues
()
# Python pre-2.6 does not have isinf() or isnan() functions, so we have
# to provide our own.
def
isnan
(
val
):
# NaN is never equal to itself.
return
val
!=
val
def
isinf
(
val
):
# Infinity times zero equals NaN.
return
not
isnan
(
val
)
and
isnan
(
val
*
0
)
self
.
assertTrue
(
isinf
(
message
.
inf_double
))
self
.
assertTrue
(
message
.
inf_double
>
0
)
self
.
assertTrue
(
isinf
(
message
.
neg_inf_double
))
self
.
assertTrue
(
message
.
neg_inf_double
<
0
)
self
.
assertTrue
(
isnan
(
message
.
nan_double
))
self
.
assertTrue
(
isinf
(
message
.
inf_float
))
self
.
assertTrue
(
message
.
inf_float
>
0
)
self
.
assertTrue
(
isinf
(
message
.
neg_inf_float
))
self
.
assertTrue
(
message
.
neg_inf_float
<
0
)
self
.
assertTrue
(
isnan
(
message
.
nan_float
))
self
.
assertEqual
(
"? ? ?? ?? ??? ??/ ??-"
,
message
.
cpp_trigraph
)
def
testHasDefaultValues
(
self
):
desc
=
unittest_pb2
.
TestAllTypes
.
DESCRIPTOR
expected_has_default_by_name
=
{
'optional_int32'
:
False
,
'repeated_int32'
:
False
,
'optional_nested_message'
:
False
,
'default_int32'
:
True
,
}
has_default_by_name
=
dict
(
[(
f
.
name
,
f
.
has_default_value
)
for
f
in
desc
.
fields
if
f
.
name
in
expected_has_default_by_name
])
self
.
assertEqual
(
expected_has_default_by_name
,
has_default_by_name
)
def
testContainingTypeBehaviorForExtensions
(
self
):
self
.
assertEqual
(
unittest_pb2
.
optional_int32_extension
.
containing_type
,
unittest_pb2
.
TestAllExtensions
.
DESCRIPTOR
)
self
.
assertEqual
(
unittest_pb2
.
TestRequired
.
single
.
containing_type
,
unittest_pb2
.
TestAllExtensions
.
DESCRIPTOR
)
def
testExtensionScope
(
self
):
self
.
assertEqual
(
unittest_pb2
.
optional_int32_extension
.
extension_scope
,
None
)
self
.
assertEqual
(
unittest_pb2
.
TestRequired
.
single
.
extension_scope
,
unittest_pb2
.
TestRequired
.
DESCRIPTOR
)
def
testIsExtension
(
self
):
self
.
assertTrue
(
unittest_pb2
.
optional_int32_extension
.
is_extension
)
self
.
assertTrue
(
unittest_pb2
.
TestRequired
.
single
.
is_extension
)
message_descriptor
=
unittest_pb2
.
TestRequired
.
DESCRIPTOR
non_extension_descriptor
=
message_descriptor
.
fields_by_name
[
'a'
]
self
.
assertTrue
(
not
non_extension_descriptor
.
is_extension
)
def
testOptions
(
self
):
proto
=
unittest_mset_pb2
.
TestMessageSet
()
self
.
assertTrue
(
proto
.
DESCRIPTOR
.
GetOptions
()
.
message_set_wire_format
)
def
testMessageWithCustomOptions
(
self
):
proto
=
unittest_custom_options_pb2
.
TestMessageWithCustomOptions
()
enum_options
=
proto
.
DESCRIPTOR
.
enum_types_by_name
[
'AnEnum'
]
.
GetOptions
()
self
.
assertTrue
(
enum_options
is
not
None
)
# TODO(gps): We really should test for the presense of the enum_opt1
# extension and for its value to be set to -789.
def
testNestedTypes
(
self
):
self
.
assertEquals
(
set
(
unittest_pb2
.
TestAllTypes
.
DESCRIPTOR
.
nested_types
),
set
([
unittest_pb2
.
TestAllTypes
.
NestedMessage
.
DESCRIPTOR
,
unittest_pb2
.
TestAllTypes
.
OptionalGroup
.
DESCRIPTOR
,
unittest_pb2
.
TestAllTypes
.
RepeatedGroup
.
DESCRIPTOR
,
]))
self
.
assertEqual
(
unittest_pb2
.
TestEmptyMessage
.
DESCRIPTOR
.
nested_types
,
[])
self
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
NestedMessage
.
DESCRIPTOR
.
nested_types
,
[])
def
testContainingType
(
self
):
self
.
assertTrue
(
unittest_pb2
.
TestEmptyMessage
.
DESCRIPTOR
.
containing_type
is
None
)
self
.
assertTrue
(
unittest_pb2
.
TestAllTypes
.
DESCRIPTOR
.
containing_type
is
None
)
self
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
NestedMessage
.
DESCRIPTOR
.
containing_type
,
unittest_pb2
.
TestAllTypes
.
DESCRIPTOR
)
self
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
NestedMessage
.
DESCRIPTOR
.
containing_type
,
unittest_pb2
.
TestAllTypes
.
DESCRIPTOR
)
self
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
RepeatedGroup
.
DESCRIPTOR
.
containing_type
,
unittest_pb2
.
TestAllTypes
.
DESCRIPTOR
)
def
testContainingTypeInEnumDescriptor
(
self
):
self
.
assertTrue
(
unittest_pb2
.
_FOREIGNENUM
.
containing_type
is
None
)
self
.
assertEqual
(
unittest_pb2
.
_TESTALLTYPES_NESTEDENUM
.
containing_type
,
unittest_pb2
.
TestAllTypes
.
DESCRIPTOR
)
def
testPackage
(
self
):
self
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
DESCRIPTOR
.
file
.
package
,
'protobuf_unittest'
)
desc
=
unittest_pb2
.
TestAllTypes
.
NestedMessage
.
DESCRIPTOR
self
.
assertEqual
(
desc
.
file
.
package
,
'protobuf_unittest'
)
self
.
assertEqual
(
unittest_import_pb2
.
ImportMessage
.
DESCRIPTOR
.
file
.
package
,
'protobuf_unittest_import'
)
self
.
assertEqual
(
unittest_pb2
.
_FOREIGNENUM
.
file
.
package
,
'protobuf_unittest'
)
self
.
assertEqual
(
unittest_pb2
.
_TESTALLTYPES_NESTEDENUM
.
file
.
package
,
'protobuf_unittest'
)
self
.
assertEqual
(
unittest_import_pb2
.
_IMPORTENUM
.
file
.
package
,
'protobuf_unittest_import'
)
def
testExtensionRange
(
self
):
self
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
DESCRIPTOR
.
extension_ranges
,
[])
self
.
assertEqual
(
unittest_pb2
.
TestAllExtensions
.
DESCRIPTOR
.
extension_ranges
,
[(
1
,
MAX_EXTENSION
)])
self
.
assertEqual
(
unittest_pb2
.
TestMultipleExtensionRanges
.
DESCRIPTOR
.
extension_ranges
,
[(
42
,
43
),
(
4143
,
4244
),
(
65536
,
MAX_EXTENSION
)])
def
testFileDescriptor
(
self
):
self
.
assertEqual
(
unittest_pb2
.
DESCRIPTOR
.
name
,
'google/protobuf/unittest.proto'
)
self
.
assertEqual
(
unittest_pb2
.
DESCRIPTOR
.
package
,
'protobuf_unittest'
)
self
.
assertFalse
(
unittest_pb2
.
DESCRIPTOR
.
serialized_pb
is
None
)
def
testNoGenericServices
(
self
):
self
.
assertTrue
(
hasattr
(
unittest_no_generic_services_pb2
,
"TestMessage"
))
self
.
assertTrue
(
hasattr
(
unittest_no_generic_services_pb2
,
"FOO"
))
self
.
assertTrue
(
hasattr
(
unittest_no_generic_services_pb2
,
"test_extension"
))
# Make sure unittest_no_generic_services_pb2 has no services subclassing
# Proto2 Service class.
if
hasattr
(
unittest_no_generic_services_pb2
,
"TestService"
):
self
.
assertFalse
(
issubclass
(
unittest_no_generic_services_pb2
.
TestService
,
service
.
Service
))
def
testMessageTypesByName
(
self
):
file_type
=
unittest_pb2
.
DESCRIPTOR
self
.
assertEqual
(
unittest_pb2
.
_TESTALLTYPES
,
file_type
.
message_types_by_name
[
unittest_pb2
.
_TESTALLTYPES
.
name
])
# Nested messages shouldn't be included in the message_types_by_name
# dictionary (like in the C++ API).
self
.
assertFalse
(
unittest_pb2
.
_TESTALLTYPES_NESTEDMESSAGE
.
name
in
file_type
.
message_types_by_name
)
def
testPublicImports
(
self
):
# Test public imports as embedded message.
all_type_proto
=
unittest_pb2
.
TestAllTypes
()
self
.
assertEqual
(
0
,
all_type_proto
.
optional_public_import_message
.
e
)
# PublicImportMessage is actually defined in unittest_import_public_pb2
# module, and is public imported by unittest_import_pb2 module.
public_import_proto
=
unittest_import_pb2
.
PublicImportMessage
()
self
.
assertEqual
(
0
,
public_import_proto
.
e
)
self
.
assertTrue
(
unittest_import_public_pb2
.
PublicImportMessage
is
unittest_import_pb2
.
PublicImportMessage
)
def
testBadIdentifiers
(
self
):
# We're just testing that the code was imported without problems.
message
=
test_bad_identifiers_pb2
.
TestBadIdentifiers
()
self
.
assertEqual
(
message
.
Extensions
[
test_bad_identifiers_pb2
.
message
],
"foo"
)
self
.
assertEqual
(
message
.
Extensions
[
test_bad_identifiers_pb2
.
descriptor
],
"bar"
)
self
.
assertEqual
(
message
.
Extensions
[
test_bad_identifiers_pb2
.
reflection
],
"baz"
)
self
.
assertEqual
(
message
.
Extensions
[
test_bad_identifiers_pb2
.
service
],
"qux"
)
if
__name__
==
'__main__'
:
unittest
.
main
()
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/golden_message
0 → 100644
View file @
5af0b547
File added
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/golden_packed_fields_message
0 → 100644
View file @
5af0b547
File added
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/message_test.py
0 → 100755
View file @
5af0b547
#! /usr/bin/python
#
# Protocol Buffers - Google's data interchange format
# Copyright 2008 Google Inc. All rights reserved.
# http://code.google.com/p/protobuf/
#
# 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.
"""Tests python protocol buffers against the golden message.
Note that the golden messages exercise every known field type, thus this
test ends up exercising and verifying nearly all of the parsing and
serialization code in the whole library.
TODO(kenton): Merge with wire_format_test? It doesn't make a whole lot of
sense to call this a test of the "message" module, which only declares an
abstract interface.
"""
__author__
=
'gps@google.com (Gregory P. Smith)'
import
copy
import
math
import
operator
import
pickle
import
unittest
from
google.protobuf
import
unittest_import_pb2
from
google.protobuf
import
unittest_pb2
from
google.protobuf.internal
import
api_implementation
from
google.protobuf.internal
import
test_util
from
google.protobuf
import
message
# Python pre-2.6 does not have isinf() or isnan() functions, so we have
# to provide our own.
def
isnan
(
val
):
# NaN is never equal to itself.
return
val
!=
val
def
isinf
(
val
):
# Infinity times zero equals NaN.
return
not
isnan
(
val
)
and
isnan
(
val
*
0
)
def
IsPosInf
(
val
):
return
isinf
(
val
)
and
(
val
>
0
)
def
IsNegInf
(
val
):
return
isinf
(
val
)
and
(
val
<
0
)
class
MessageTest
(
unittest
.
TestCase
):
def
testGoldenMessage
(
self
):
golden_data
=
test_util
.
GoldenFile
(
'golden_message'
)
.
read
()
golden_message
=
unittest_pb2
.
TestAllTypes
()
golden_message
.
ParseFromString
(
golden_data
)
test_util
.
ExpectAllFieldsSet
(
self
,
golden_message
)
self
.
assertEqual
(
golden_data
,
golden_message
.
SerializeToString
())
golden_copy
=
copy
.
deepcopy
(
golden_message
)
self
.
assertEqual
(
golden_data
,
golden_copy
.
SerializeToString
())
def
testGoldenExtensions
(
self
):
golden_data
=
test_util
.
GoldenFile
(
'golden_message'
)
.
read
()
golden_message
=
unittest_pb2
.
TestAllExtensions
()
golden_message
.
ParseFromString
(
golden_data
)
all_set
=
unittest_pb2
.
TestAllExtensions
()
test_util
.
SetAllExtensions
(
all_set
)
self
.
assertEquals
(
all_set
,
golden_message
)
self
.
assertEqual
(
golden_data
,
golden_message
.
SerializeToString
())
golden_copy
=
copy
.
deepcopy
(
golden_message
)
self
.
assertEqual
(
golden_data
,
golden_copy
.
SerializeToString
())
def
testGoldenPackedMessage
(
self
):
golden_data
=
test_util
.
GoldenFile
(
'golden_packed_fields_message'
)
.
read
()
golden_message
=
unittest_pb2
.
TestPackedTypes
()
golden_message
.
ParseFromString
(
golden_data
)
all_set
=
unittest_pb2
.
TestPackedTypes
()
test_util
.
SetAllPackedFields
(
all_set
)
self
.
assertEquals
(
all_set
,
golden_message
)
self
.
assertEqual
(
golden_data
,
all_set
.
SerializeToString
())
golden_copy
=
copy
.
deepcopy
(
golden_message
)
self
.
assertEqual
(
golden_data
,
golden_copy
.
SerializeToString
())
def
testGoldenPackedExtensions
(
self
):
golden_data
=
test_util
.
GoldenFile
(
'golden_packed_fields_message'
)
.
read
()
golden_message
=
unittest_pb2
.
TestPackedExtensions
()
golden_message
.
ParseFromString
(
golden_data
)
all_set
=
unittest_pb2
.
TestPackedExtensions
()
test_util
.
SetAllPackedExtensions
(
all_set
)
self
.
assertEquals
(
all_set
,
golden_message
)
self
.
assertEqual
(
golden_data
,
all_set
.
SerializeToString
())
golden_copy
=
copy
.
deepcopy
(
golden_message
)
self
.
assertEqual
(
golden_data
,
golden_copy
.
SerializeToString
())
def
testPickleSupport
(
self
):
golden_data
=
test_util
.
GoldenFile
(
'golden_message'
)
.
read
()
golden_message
=
unittest_pb2
.
TestAllTypes
()
golden_message
.
ParseFromString
(
golden_data
)
pickled_message
=
pickle
.
dumps
(
golden_message
)
unpickled_message
=
pickle
.
loads
(
pickled_message
)
self
.
assertEquals
(
unpickled_message
,
golden_message
)
def
testPickleIncompleteProto
(
self
):
golden_message
=
unittest_pb2
.
TestRequired
(
a
=
1
)
pickled_message
=
pickle
.
dumps
(
golden_message
)
unpickled_message
=
pickle
.
loads
(
pickled_message
)
self
.
assertEquals
(
unpickled_message
,
golden_message
)
self
.
assertEquals
(
unpickled_message
.
a
,
1
)
# This is still an incomplete proto - so serializing should fail
self
.
assertRaises
(
message
.
EncodeError
,
unpickled_message
.
SerializeToString
)
def
testPositiveInfinity
(
self
):
golden_data
=
(
'
\x5D\x00\x00\x80\x7F
'
'
\x61\x00\x00\x00\x00\x00\x00\xF0\x7F
'
'
\xCD\x02\x00\x00\x80\x7F
'
'
\xD1\x02\x00\x00\x00\x00\x00\x00\xF0\x7F
'
)
golden_message
=
unittest_pb2
.
TestAllTypes
()
golden_message
.
ParseFromString
(
golden_data
)
self
.
assertTrue
(
IsPosInf
(
golden_message
.
optional_float
))
self
.
assertTrue
(
IsPosInf
(
golden_message
.
optional_double
))
self
.
assertTrue
(
IsPosInf
(
golden_message
.
repeated_float
[
0
]))
self
.
assertTrue
(
IsPosInf
(
golden_message
.
repeated_double
[
0
]))
self
.
assertEqual
(
golden_data
,
golden_message
.
SerializeToString
())
def
testNegativeInfinity
(
self
):
golden_data
=
(
'
\x5D\x00\x00\x80\xFF
'
'
\x61\x00\x00\x00\x00\x00\x00\xF0\xFF
'
'
\xCD\x02\x00\x00\x80\xFF
'
'
\xD1\x02\x00\x00\x00\x00\x00\x00\xF0\xFF
'
)
golden_message
=
unittest_pb2
.
TestAllTypes
()
golden_message
.
ParseFromString
(
golden_data
)
self
.
assertTrue
(
IsNegInf
(
golden_message
.
optional_float
))
self
.
assertTrue
(
IsNegInf
(
golden_message
.
optional_double
))
self
.
assertTrue
(
IsNegInf
(
golden_message
.
repeated_float
[
0
]))
self
.
assertTrue
(
IsNegInf
(
golden_message
.
repeated_double
[
0
]))
self
.
assertEqual
(
golden_data
,
golden_message
.
SerializeToString
())
def
testNotANumber
(
self
):
golden_data
=
(
'
\x5D\x00\x00\xC0\x7F
'
'
\x61\x00\x00\x00\x00\x00\x00\xF8\x7F
'
'
\xCD\x02\x00\x00\xC0\x7F
'
'
\xD1\x02\x00\x00\x00\x00\x00\x00\xF8\x7F
'
)
golden_message
=
unittest_pb2
.
TestAllTypes
()
golden_message
.
ParseFromString
(
golden_data
)
self
.
assertTrue
(
isnan
(
golden_message
.
optional_float
))
self
.
assertTrue
(
isnan
(
golden_message
.
optional_double
))
self
.
assertTrue
(
isnan
(
golden_message
.
repeated_float
[
0
]))
self
.
assertTrue
(
isnan
(
golden_message
.
repeated_double
[
0
]))
# The protocol buffer may serialize to any one of multiple different
# representations of a NaN. Rather than verify a specific representation,
# verify the serialized string can be converted into a correctly
# behaving protocol buffer.
serialized
=
golden_message
.
SerializeToString
()
message
=
unittest_pb2
.
TestAllTypes
()
message
.
ParseFromString
(
serialized
)
self
.
assertTrue
(
isnan
(
message
.
optional_float
))
self
.
assertTrue
(
isnan
(
message
.
optional_double
))
self
.
assertTrue
(
isnan
(
message
.
repeated_float
[
0
]))
self
.
assertTrue
(
isnan
(
message
.
repeated_double
[
0
]))
def
testPositiveInfinityPacked
(
self
):
golden_data
=
(
'
\xA2\x06\x04\x00\x00\x80\x7F
'
'
\xAA\x06\x08\x00\x00\x00\x00\x00\x00\xF0\x7F
'
)
golden_message
=
unittest_pb2
.
TestPackedTypes
()
golden_message
.
ParseFromString
(
golden_data
)
self
.
assertTrue
(
IsPosInf
(
golden_message
.
packed_float
[
0
]))
self
.
assertTrue
(
IsPosInf
(
golden_message
.
packed_double
[
0
]))
self
.
assertEqual
(
golden_data
,
golden_message
.
SerializeToString
())
def
testNegativeInfinityPacked
(
self
):
golden_data
=
(
'
\xA2\x06\x04\x00\x00\x80\xFF
'
'
\xAA\x06\x08\x00\x00\x00\x00\x00\x00\xF0\xFF
'
)
golden_message
=
unittest_pb2
.
TestPackedTypes
()
golden_message
.
ParseFromString
(
golden_data
)
self
.
assertTrue
(
IsNegInf
(
golden_message
.
packed_float
[
0
]))
self
.
assertTrue
(
IsNegInf
(
golden_message
.
packed_double
[
0
]))
self
.
assertEqual
(
golden_data
,
golden_message
.
SerializeToString
())
def
testNotANumberPacked
(
self
):
golden_data
=
(
'
\xA2\x06\x04\x00\x00\xC0\x7F
'
'
\xAA\x06\x08\x00\x00\x00\x00\x00\x00\xF8\x7F
'
)
golden_message
=
unittest_pb2
.
TestPackedTypes
()
golden_message
.
ParseFromString
(
golden_data
)
self
.
assertTrue
(
isnan
(
golden_message
.
packed_float
[
0
]))
self
.
assertTrue
(
isnan
(
golden_message
.
packed_double
[
0
]))
serialized
=
golden_message
.
SerializeToString
()
message
=
unittest_pb2
.
TestPackedTypes
()
message
.
ParseFromString
(
serialized
)
self
.
assertTrue
(
isnan
(
message
.
packed_float
[
0
]))
self
.
assertTrue
(
isnan
(
message
.
packed_double
[
0
]))
def
testExtremeFloatValues
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
# Most positive exponent, no significand bits set.
kMostPosExponentNoSigBits
=
math
.
pow
(
2
,
127
)
message
.
optional_float
=
kMostPosExponentNoSigBits
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_float
==
kMostPosExponentNoSigBits
)
# Most positive exponent, one significand bit set.
kMostPosExponentOneSigBit
=
1.5
*
math
.
pow
(
2
,
127
)
message
.
optional_float
=
kMostPosExponentOneSigBit
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_float
==
kMostPosExponentOneSigBit
)
# Repeat last two cases with values of same magnitude, but negative.
message
.
optional_float
=
-
kMostPosExponentNoSigBits
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_float
==
-
kMostPosExponentNoSigBits
)
message
.
optional_float
=
-
kMostPosExponentOneSigBit
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_float
==
-
kMostPosExponentOneSigBit
)
# Most negative exponent, no significand bits set.
kMostNegExponentNoSigBits
=
math
.
pow
(
2
,
-
127
)
message
.
optional_float
=
kMostNegExponentNoSigBits
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_float
==
kMostNegExponentNoSigBits
)
# Most negative exponent, one significand bit set.
kMostNegExponentOneSigBit
=
1.5
*
math
.
pow
(
2
,
-
127
)
message
.
optional_float
=
kMostNegExponentOneSigBit
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_float
==
kMostNegExponentOneSigBit
)
# Repeat last two cases with values of the same magnitude, but negative.
message
.
optional_float
=
-
kMostNegExponentNoSigBits
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_float
==
-
kMostNegExponentNoSigBits
)
message
.
optional_float
=
-
kMostNegExponentOneSigBit
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_float
==
-
kMostNegExponentOneSigBit
)
def
testExtremeDoubleValues
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
# Most positive exponent, no significand bits set.
kMostPosExponentNoSigBits
=
math
.
pow
(
2
,
1023
)
message
.
optional_double
=
kMostPosExponentNoSigBits
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_double
==
kMostPosExponentNoSigBits
)
# Most positive exponent, one significand bit set.
kMostPosExponentOneSigBit
=
1.5
*
math
.
pow
(
2
,
1023
)
message
.
optional_double
=
kMostPosExponentOneSigBit
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_double
==
kMostPosExponentOneSigBit
)
# Repeat last two cases with values of same magnitude, but negative.
message
.
optional_double
=
-
kMostPosExponentNoSigBits
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_double
==
-
kMostPosExponentNoSigBits
)
message
.
optional_double
=
-
kMostPosExponentOneSigBit
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_double
==
-
kMostPosExponentOneSigBit
)
# Most negative exponent, no significand bits set.
kMostNegExponentNoSigBits
=
math
.
pow
(
2
,
-
1023
)
message
.
optional_double
=
kMostNegExponentNoSigBits
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_double
==
kMostNegExponentNoSigBits
)
# Most negative exponent, one significand bit set.
kMostNegExponentOneSigBit
=
1.5
*
math
.
pow
(
2
,
-
1023
)
message
.
optional_double
=
kMostNegExponentOneSigBit
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_double
==
kMostNegExponentOneSigBit
)
# Repeat last two cases with values of the same magnitude, but negative.
message
.
optional_double
=
-
kMostNegExponentNoSigBits
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_double
==
-
kMostNegExponentNoSigBits
)
message
.
optional_double
=
-
kMostNegExponentOneSigBit
message
.
ParseFromString
(
message
.
SerializeToString
())
self
.
assertTrue
(
message
.
optional_double
==
-
kMostNegExponentOneSigBit
)
def
testSortingRepeatedScalarFieldsDefaultComparator
(
self
):
"""Check some different types with the default comparator."""
message
=
unittest_pb2
.
TestAllTypes
()
# TODO(mattp): would testing more scalar types strengthen test?
message
.
repeated_int32
.
append
(
1
)
message
.
repeated_int32
.
append
(
3
)
message
.
repeated_int32
.
append
(
2
)
message
.
repeated_int32
.
sort
()
self
.
assertEqual
(
message
.
repeated_int32
[
0
],
1
)
self
.
assertEqual
(
message
.
repeated_int32
[
1
],
2
)
self
.
assertEqual
(
message
.
repeated_int32
[
2
],
3
)
message
.
repeated_float
.
append
(
1.1
)
message
.
repeated_float
.
append
(
1.3
)
message
.
repeated_float
.
append
(
1.2
)
message
.
repeated_float
.
sort
()
self
.
assertAlmostEqual
(
message
.
repeated_float
[
0
],
1.1
)
self
.
assertAlmostEqual
(
message
.
repeated_float
[
1
],
1.2
)
self
.
assertAlmostEqual
(
message
.
repeated_float
[
2
],
1.3
)
message
.
repeated_string
.
append
(
'a'
)
message
.
repeated_string
.
append
(
'c'
)
message
.
repeated_string
.
append
(
'b'
)
message
.
repeated_string
.
sort
()
self
.
assertEqual
(
message
.
repeated_string
[
0
],
'a'
)
self
.
assertEqual
(
message
.
repeated_string
[
1
],
'b'
)
self
.
assertEqual
(
message
.
repeated_string
[
2
],
'c'
)
message
.
repeated_bytes
.
append
(
'a'
)
message
.
repeated_bytes
.
append
(
'c'
)
message
.
repeated_bytes
.
append
(
'b'
)
message
.
repeated_bytes
.
sort
()
self
.
assertEqual
(
message
.
repeated_bytes
[
0
],
'a'
)
self
.
assertEqual
(
message
.
repeated_bytes
[
1
],
'b'
)
self
.
assertEqual
(
message
.
repeated_bytes
[
2
],
'c'
)
def
testSortingRepeatedScalarFieldsCustomComparator
(
self
):
"""Check some different types with custom comparator."""
message
=
unittest_pb2
.
TestAllTypes
()
message
.
repeated_int32
.
append
(
-
3
)
message
.
repeated_int32
.
append
(
-
2
)
message
.
repeated_int32
.
append
(
-
1
)
message
.
repeated_int32
.
sort
(
lambda
x
,
y
:
cmp
(
abs
(
x
),
abs
(
y
)))
self
.
assertEqual
(
message
.
repeated_int32
[
0
],
-
1
)
self
.
assertEqual
(
message
.
repeated_int32
[
1
],
-
2
)
self
.
assertEqual
(
message
.
repeated_int32
[
2
],
-
3
)
message
.
repeated_string
.
append
(
'aaa'
)
message
.
repeated_string
.
append
(
'bb'
)
message
.
repeated_string
.
append
(
'c'
)
message
.
repeated_string
.
sort
(
lambda
x
,
y
:
cmp
(
len
(
x
),
len
(
y
)))
self
.
assertEqual
(
message
.
repeated_string
[
0
],
'c'
)
self
.
assertEqual
(
message
.
repeated_string
[
1
],
'bb'
)
self
.
assertEqual
(
message
.
repeated_string
[
2
],
'aaa'
)
def
testSortingRepeatedCompositeFieldsCustomComparator
(
self
):
"""Check passing a custom comparator to sort a repeated composite field."""
message
=
unittest_pb2
.
TestAllTypes
()
message
.
repeated_nested_message
.
add
()
.
bb
=
1
message
.
repeated_nested_message
.
add
()
.
bb
=
3
message
.
repeated_nested_message
.
add
()
.
bb
=
2
message
.
repeated_nested_message
.
add
()
.
bb
=
6
message
.
repeated_nested_message
.
add
()
.
bb
=
5
message
.
repeated_nested_message
.
add
()
.
bb
=
4
message
.
repeated_nested_message
.
sort
(
lambda
x
,
y
:
cmp
(
x
.
bb
,
y
.
bb
))
self
.
assertEqual
(
message
.
repeated_nested_message
[
0
]
.
bb
,
1
)
self
.
assertEqual
(
message
.
repeated_nested_message
[
1
]
.
bb
,
2
)
self
.
assertEqual
(
message
.
repeated_nested_message
[
2
]
.
bb
,
3
)
self
.
assertEqual
(
message
.
repeated_nested_message
[
3
]
.
bb
,
4
)
self
.
assertEqual
(
message
.
repeated_nested_message
[
4
]
.
bb
,
5
)
self
.
assertEqual
(
message
.
repeated_nested_message
[
5
]
.
bb
,
6
)
def
testRepeatedCompositeFieldSortArguments
(
self
):
"""Check sorting a repeated composite field using list.sort() arguments."""
message
=
unittest_pb2
.
TestAllTypes
()
get_bb
=
operator
.
attrgetter
(
'bb'
)
cmp_bb
=
lambda
a
,
b
:
cmp
(
a
.
bb
,
b
.
bb
)
message
.
repeated_nested_message
.
add
()
.
bb
=
1
message
.
repeated_nested_message
.
add
()
.
bb
=
3
message
.
repeated_nested_message
.
add
()
.
bb
=
2
message
.
repeated_nested_message
.
add
()
.
bb
=
6
message
.
repeated_nested_message
.
add
()
.
bb
=
5
message
.
repeated_nested_message
.
add
()
.
bb
=
4
message
.
repeated_nested_message
.
sort
(
key
=
get_bb
)
self
.
assertEqual
([
k
.
bb
for
k
in
message
.
repeated_nested_message
],
[
1
,
2
,
3
,
4
,
5
,
6
])
message
.
repeated_nested_message
.
sort
(
key
=
get_bb
,
reverse
=
True
)
self
.
assertEqual
([
k
.
bb
for
k
in
message
.
repeated_nested_message
],
[
6
,
5
,
4
,
3
,
2
,
1
])
message
.
repeated_nested_message
.
sort
(
sort_function
=
cmp_bb
)
self
.
assertEqual
([
k
.
bb
for
k
in
message
.
repeated_nested_message
],
[
1
,
2
,
3
,
4
,
5
,
6
])
message
.
repeated_nested_message
.
sort
(
cmp
=
cmp_bb
,
reverse
=
True
)
self
.
assertEqual
([
k
.
bb
for
k
in
message
.
repeated_nested_message
],
[
6
,
5
,
4
,
3
,
2
,
1
])
def
testRepeatedScalarFieldSortArguments
(
self
):
"""Check sorting a scalar field using list.sort() arguments."""
message
=
unittest_pb2
.
TestAllTypes
()
abs_cmp
=
lambda
a
,
b
:
cmp
(
abs
(
a
),
abs
(
b
))
message
.
repeated_int32
.
append
(
-
3
)
message
.
repeated_int32
.
append
(
-
2
)
message
.
repeated_int32
.
append
(
-
1
)
message
.
repeated_int32
.
sort
(
key
=
abs
)
self
.
assertEqual
(
list
(
message
.
repeated_int32
),
[
-
1
,
-
2
,
-
3
])
message
.
repeated_int32
.
sort
(
key
=
abs
,
reverse
=
True
)
self
.
assertEqual
(
list
(
message
.
repeated_int32
),
[
-
3
,
-
2
,
-
1
])
message
.
repeated_int32
.
sort
(
sort_function
=
abs_cmp
)
self
.
assertEqual
(
list
(
message
.
repeated_int32
),
[
-
1
,
-
2
,
-
3
])
message
.
repeated_int32
.
sort
(
cmp
=
abs_cmp
,
reverse
=
True
)
self
.
assertEqual
(
list
(
message
.
repeated_int32
),
[
-
3
,
-
2
,
-
1
])
len_cmp
=
lambda
a
,
b
:
cmp
(
len
(
a
),
len
(
b
))
message
.
repeated_string
.
append
(
'aaa'
)
message
.
repeated_string
.
append
(
'bb'
)
message
.
repeated_string
.
append
(
'c'
)
message
.
repeated_string
.
sort
(
key
=
len
)
self
.
assertEqual
(
list
(
message
.
repeated_string
),
[
'c'
,
'bb'
,
'aaa'
])
message
.
repeated_string
.
sort
(
key
=
len
,
reverse
=
True
)
self
.
assertEqual
(
list
(
message
.
repeated_string
),
[
'aaa'
,
'bb'
,
'c'
])
message
.
repeated_string
.
sort
(
sort_function
=
len_cmp
)
self
.
assertEqual
(
list
(
message
.
repeated_string
),
[
'c'
,
'bb'
,
'aaa'
])
message
.
repeated_string
.
sort
(
cmp
=
len_cmp
,
reverse
=
True
)
self
.
assertEqual
(
list
(
message
.
repeated_string
),
[
'aaa'
,
'bb'
,
'c'
])
def
testParsingMerge
(
self
):
"""Check the merge behavior when a required or optional field appears
multiple times in the input."""
messages
=
[
unittest_pb2
.
TestAllTypes
(),
unittest_pb2
.
TestAllTypes
(),
unittest_pb2
.
TestAllTypes
()
]
messages
[
0
]
.
optional_int32
=
1
messages
[
1
]
.
optional_int64
=
2
messages
[
2
]
.
optional_int32
=
3
messages
[
2
]
.
optional_string
=
'hello'
merged_message
=
unittest_pb2
.
TestAllTypes
()
merged_message
.
optional_int32
=
3
merged_message
.
optional_int64
=
2
merged_message
.
optional_string
=
'hello'
generator
=
unittest_pb2
.
TestParsingMerge
.
RepeatedFieldsGenerator
()
generator
.
field1
.
extend
(
messages
)
generator
.
field2
.
extend
(
messages
)
generator
.
field3
.
extend
(
messages
)
generator
.
ext1
.
extend
(
messages
)
generator
.
ext2
.
extend
(
messages
)
generator
.
group1
.
add
()
.
field1
.
MergeFrom
(
messages
[
0
])
generator
.
group1
.
add
()
.
field1
.
MergeFrom
(
messages
[
1
])
generator
.
group1
.
add
()
.
field1
.
MergeFrom
(
messages
[
2
])
generator
.
group2
.
add
()
.
field1
.
MergeFrom
(
messages
[
0
])
generator
.
group2
.
add
()
.
field1
.
MergeFrom
(
messages
[
1
])
generator
.
group2
.
add
()
.
field1
.
MergeFrom
(
messages
[
2
])
data
=
generator
.
SerializeToString
()
parsing_merge
=
unittest_pb2
.
TestParsingMerge
()
parsing_merge
.
ParseFromString
(
data
)
# Required and optional fields should be merged.
self
.
assertEqual
(
parsing_merge
.
required_all_types
,
merged_message
)
self
.
assertEqual
(
parsing_merge
.
optional_all_types
,
merged_message
)
self
.
assertEqual
(
parsing_merge
.
optionalgroup
.
optional_group_all_types
,
merged_message
)
self
.
assertEqual
(
parsing_merge
.
Extensions
[
unittest_pb2
.
TestParsingMerge
.
optional_ext
],
merged_message
)
# Repeated fields should not be merged.
self
.
assertEqual
(
len
(
parsing_merge
.
repeated_all_types
),
3
)
self
.
assertEqual
(
len
(
parsing_merge
.
repeatedgroup
),
3
)
self
.
assertEqual
(
len
(
parsing_merge
.
Extensions
[
unittest_pb2
.
TestParsingMerge
.
repeated_ext
]),
3
)
def
testSortEmptyRepeatedCompositeContainer
(
self
):
"""Exercise a scenario that has led to segfaults in the past.
"""
m
=
unittest_pb2
.
TestAllTypes
()
m
.
repeated_nested_message
.
sort
()
if
__name__
==
'__main__'
:
unittest
.
main
()
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/service_reflection_test.py
0 → 100755
View file @
5af0b547
#! /usr/bin/python
#
# Protocol Buffers - Google's data interchange format
# Copyright 2008 Google Inc. All rights reserved.
# http://code.google.com/p/protobuf/
#
# 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.
"""Tests for google.protobuf.internal.service_reflection."""
__author__
=
'petar@google.com (Petar Petrov)'
import
unittest
from
google.protobuf
import
unittest_pb2
from
google.protobuf
import
service_reflection
from
google.protobuf
import
service
class
FooUnitTest
(
unittest
.
TestCase
):
def
testService
(
self
):
class
MockRpcChannel
(
service
.
RpcChannel
):
def
CallMethod
(
self
,
method
,
controller
,
request
,
response
,
callback
):
self
.
method
=
method
self
.
controller
=
controller
self
.
request
=
request
callback
(
response
)
class
MockRpcController
(
service
.
RpcController
):
def
SetFailed
(
self
,
msg
):
self
.
failure_message
=
msg
self
.
callback_response
=
None
class
MyService
(
unittest_pb2
.
TestService
):
pass
self
.
callback_response
=
None
def
MyCallback
(
response
):
self
.
callback_response
=
response
rpc_controller
=
MockRpcController
()
channel
=
MockRpcChannel
()
srvc
=
MyService
()
srvc
.
Foo
(
rpc_controller
,
unittest_pb2
.
FooRequest
(),
MyCallback
)
self
.
assertEqual
(
'Method Foo not implemented.'
,
rpc_controller
.
failure_message
)
self
.
assertEqual
(
None
,
self
.
callback_response
)
rpc_controller
.
failure_message
=
None
service_descriptor
=
unittest_pb2
.
TestService
.
GetDescriptor
()
srvc
.
CallMethod
(
service_descriptor
.
methods
[
1
],
rpc_controller
,
unittest_pb2
.
BarRequest
(),
MyCallback
)
self
.
assertEqual
(
'Method Bar not implemented.'
,
rpc_controller
.
failure_message
)
self
.
assertEqual
(
None
,
self
.
callback_response
)
class
MyServiceImpl
(
unittest_pb2
.
TestService
):
def
Foo
(
self
,
rpc_controller
,
request
,
done
):
self
.
foo_called
=
True
def
Bar
(
self
,
rpc_controller
,
request
,
done
):
self
.
bar_called
=
True
srvc
=
MyServiceImpl
()
rpc_controller
.
failure_message
=
None
srvc
.
Foo
(
rpc_controller
,
unittest_pb2
.
FooRequest
(),
MyCallback
)
self
.
assertEqual
(
None
,
rpc_controller
.
failure_message
)
self
.
assertEqual
(
True
,
srvc
.
foo_called
)
rpc_controller
.
failure_message
=
None
srvc
.
CallMethod
(
service_descriptor
.
methods
[
1
],
rpc_controller
,
unittest_pb2
.
BarRequest
(),
MyCallback
)
self
.
assertEqual
(
None
,
rpc_controller
.
failure_message
)
self
.
assertEqual
(
True
,
srvc
.
bar_called
)
def
testServiceStub
(
self
):
class
MockRpcChannel
(
service
.
RpcChannel
):
def
CallMethod
(
self
,
method
,
controller
,
request
,
response_class
,
callback
):
self
.
method
=
method
self
.
controller
=
controller
self
.
request
=
request
callback
(
response_class
())
self
.
callback_response
=
None
def
MyCallback
(
response
):
self
.
callback_response
=
response
channel
=
MockRpcChannel
()
stub
=
unittest_pb2
.
TestService_Stub
(
channel
)
rpc_controller
=
'controller'
request
=
'request'
# GetDescriptor now static, still works as instance method for compatability
self
.
assertEqual
(
unittest_pb2
.
TestService_Stub
.
GetDescriptor
(),
stub
.
GetDescriptor
())
# Invoke method.
stub
.
Foo
(
rpc_controller
,
request
,
MyCallback
)
self
.
assertTrue
(
isinstance
(
self
.
callback_response
,
unittest_pb2
.
FooResponse
))
self
.
assertEqual
(
request
,
channel
.
request
)
self
.
assertEqual
(
rpc_controller
,
channel
.
controller
)
self
.
assertEqual
(
stub
.
GetDescriptor
()
.
methods
[
0
],
channel
.
method
)
if
__name__
==
'__main__'
:
unittest
.
main
()
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/test_util.py
0 → 100755
View file @
5af0b547
# Protocol Buffers - Google's data interchange format
# Copyright 2008 Google Inc. All rights reserved.
# http://code.google.com/p/protobuf/
#
# 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.
"""Utilities for Python proto2 tests.
This is intentionally modeled on C++ code in
//google/protobuf/test_util.*.
"""
__author__
=
'robinson@google.com (Will Robinson)'
import
os.path
from
google.protobuf
import
unittest_import_pb2
from
google.protobuf
import
unittest_pb2
def
SetAllNonLazyFields
(
message
):
"""Sets every non-lazy field in the message to a unique value.
Args:
message: A unittest_pb2.TestAllTypes instance.
"""
#
# Optional fields.
#
message
.
optional_int32
=
101
message
.
optional_int64
=
102
message
.
optional_uint32
=
103
message
.
optional_uint64
=
104
message
.
optional_sint32
=
105
message
.
optional_sint64
=
106
message
.
optional_fixed32
=
107
message
.
optional_fixed64
=
108
message
.
optional_sfixed32
=
109
message
.
optional_sfixed64
=
110
message
.
optional_float
=
111
message
.
optional_double
=
112
message
.
optional_bool
=
True
# TODO(robinson): Firmly spec out and test how
# protos interact with unicode. One specific example:
# what happens if we change the literal below to
# u'115'? What *should* happen? Still some discussion
# to finish with Kenton about bytes vs. strings
# and forcing everything to be utf8. :-/
message
.
optional_string
=
'115'
message
.
optional_bytes
=
'116'
message
.
optionalgroup
.
a
=
117
message
.
optional_nested_message
.
bb
=
118
message
.
optional_foreign_message
.
c
=
119
message
.
optional_import_message
.
d
=
120
message
.
optional_public_import_message
.
e
=
126
message
.
optional_nested_enum
=
unittest_pb2
.
TestAllTypes
.
BAZ
message
.
optional_foreign_enum
=
unittest_pb2
.
FOREIGN_BAZ
message
.
optional_import_enum
=
unittest_import_pb2
.
IMPORT_BAZ
message
.
optional_string_piece
=
'124'
message
.
optional_cord
=
'125'
#
# Repeated fields.
#
message
.
repeated_int32
.
append
(
201
)
message
.
repeated_int64
.
append
(
202
)
message
.
repeated_uint32
.
append
(
203
)
message
.
repeated_uint64
.
append
(
204
)
message
.
repeated_sint32
.
append
(
205
)
message
.
repeated_sint64
.
append
(
206
)
message
.
repeated_fixed32
.
append
(
207
)
message
.
repeated_fixed64
.
append
(
208
)
message
.
repeated_sfixed32
.
append
(
209
)
message
.
repeated_sfixed64
.
append
(
210
)
message
.
repeated_float
.
append
(
211
)
message
.
repeated_double
.
append
(
212
)
message
.
repeated_bool
.
append
(
True
)
message
.
repeated_string
.
append
(
'215'
)
message
.
repeated_bytes
.
append
(
'216'
)
message
.
repeatedgroup
.
add
()
.
a
=
217
message
.
repeated_nested_message
.
add
()
.
bb
=
218
message
.
repeated_foreign_message
.
add
()
.
c
=
219
message
.
repeated_import_message
.
add
()
.
d
=
220
message
.
repeated_lazy_message
.
add
()
.
bb
=
227
message
.
repeated_nested_enum
.
append
(
unittest_pb2
.
TestAllTypes
.
BAR
)
message
.
repeated_foreign_enum
.
append
(
unittest_pb2
.
FOREIGN_BAR
)
message
.
repeated_import_enum
.
append
(
unittest_import_pb2
.
IMPORT_BAR
)
message
.
repeated_string_piece
.
append
(
'224'
)
message
.
repeated_cord
.
append
(
'225'
)
# Add a second one of each field.
message
.
repeated_int32
.
append
(
301
)
message
.
repeated_int64
.
append
(
302
)
message
.
repeated_uint32
.
append
(
303
)
message
.
repeated_uint64
.
append
(
304
)
message
.
repeated_sint32
.
append
(
305
)
message
.
repeated_sint64
.
append
(
306
)
message
.
repeated_fixed32
.
append
(
307
)
message
.
repeated_fixed64
.
append
(
308
)
message
.
repeated_sfixed32
.
append
(
309
)
message
.
repeated_sfixed64
.
append
(
310
)
message
.
repeated_float
.
append
(
311
)
message
.
repeated_double
.
append
(
312
)
message
.
repeated_bool
.
append
(
False
)
message
.
repeated_string
.
append
(
'315'
)
message
.
repeated_bytes
.
append
(
'316'
)
message
.
repeatedgroup
.
add
()
.
a
=
317
message
.
repeated_nested_message
.
add
()
.
bb
=
318
message
.
repeated_foreign_message
.
add
()
.
c
=
319
message
.
repeated_import_message
.
add
()
.
d
=
320
message
.
repeated_lazy_message
.
add
()
.
bb
=
327
message
.
repeated_nested_enum
.
append
(
unittest_pb2
.
TestAllTypes
.
BAZ
)
message
.
repeated_foreign_enum
.
append
(
unittest_pb2
.
FOREIGN_BAZ
)
message
.
repeated_import_enum
.
append
(
unittest_import_pb2
.
IMPORT_BAZ
)
message
.
repeated_string_piece
.
append
(
'324'
)
message
.
repeated_cord
.
append
(
'325'
)
#
# Fields that have defaults.
#
message
.
default_int32
=
401
message
.
default_int64
=
402
message
.
default_uint32
=
403
message
.
default_uint64
=
404
message
.
default_sint32
=
405
message
.
default_sint64
=
406
message
.
default_fixed32
=
407
message
.
default_fixed64
=
408
message
.
default_sfixed32
=
409
message
.
default_sfixed64
=
410
message
.
default_float
=
411
message
.
default_double
=
412
message
.
default_bool
=
False
message
.
default_string
=
'415'
message
.
default_bytes
=
'416'
message
.
default_nested_enum
=
unittest_pb2
.
TestAllTypes
.
FOO
message
.
default_foreign_enum
=
unittest_pb2
.
FOREIGN_FOO
message
.
default_import_enum
=
unittest_import_pb2
.
IMPORT_FOO
message
.
default_string_piece
=
'424'
message
.
default_cord
=
'425'
def
SetAllFields
(
message
):
SetAllNonLazyFields
(
message
)
message
.
optional_lazy_message
.
bb
=
127
def
SetAllExtensions
(
message
):
"""Sets every extension in the message to a unique value.
Args:
message: A unittest_pb2.TestAllExtensions instance.
"""
extensions
=
message
.
Extensions
pb2
=
unittest_pb2
import_pb2
=
unittest_import_pb2
#
# Optional fields.
#
extensions
[
pb2
.
optional_int32_extension
]
=
101
extensions
[
pb2
.
optional_int64_extension
]
=
102
extensions
[
pb2
.
optional_uint32_extension
]
=
103
extensions
[
pb2
.
optional_uint64_extension
]
=
104
extensions
[
pb2
.
optional_sint32_extension
]
=
105
extensions
[
pb2
.
optional_sint64_extension
]
=
106
extensions
[
pb2
.
optional_fixed32_extension
]
=
107
extensions
[
pb2
.
optional_fixed64_extension
]
=
108
extensions
[
pb2
.
optional_sfixed32_extension
]
=
109
extensions
[
pb2
.
optional_sfixed64_extension
]
=
110
extensions
[
pb2
.
optional_float_extension
]
=
111
extensions
[
pb2
.
optional_double_extension
]
=
112
extensions
[
pb2
.
optional_bool_extension
]
=
True
extensions
[
pb2
.
optional_string_extension
]
=
'115'
extensions
[
pb2
.
optional_bytes_extension
]
=
'116'
extensions
[
pb2
.
optionalgroup_extension
]
.
a
=
117
extensions
[
pb2
.
optional_nested_message_extension
]
.
bb
=
118
extensions
[
pb2
.
optional_foreign_message_extension
]
.
c
=
119
extensions
[
pb2
.
optional_import_message_extension
]
.
d
=
120
extensions
[
pb2
.
optional_public_import_message_extension
]
.
e
=
126
extensions
[
pb2
.
optional_lazy_message_extension
]
.
bb
=
127
extensions
[
pb2
.
optional_nested_enum_extension
]
=
pb2
.
TestAllTypes
.
BAZ
extensions
[
pb2
.
optional_nested_enum_extension
]
=
pb2
.
TestAllTypes
.
BAZ
extensions
[
pb2
.
optional_foreign_enum_extension
]
=
pb2
.
FOREIGN_BAZ
extensions
[
pb2
.
optional_import_enum_extension
]
=
import_pb2
.
IMPORT_BAZ
extensions
[
pb2
.
optional_string_piece_extension
]
=
'124'
extensions
[
pb2
.
optional_cord_extension
]
=
'125'
#
# Repeated fields.
#
extensions
[
pb2
.
repeated_int32_extension
]
.
append
(
201
)
extensions
[
pb2
.
repeated_int64_extension
]
.
append
(
202
)
extensions
[
pb2
.
repeated_uint32_extension
]
.
append
(
203
)
extensions
[
pb2
.
repeated_uint64_extension
]
.
append
(
204
)
extensions
[
pb2
.
repeated_sint32_extension
]
.
append
(
205
)
extensions
[
pb2
.
repeated_sint64_extension
]
.
append
(
206
)
extensions
[
pb2
.
repeated_fixed32_extension
]
.
append
(
207
)
extensions
[
pb2
.
repeated_fixed64_extension
]
.
append
(
208
)
extensions
[
pb2
.
repeated_sfixed32_extension
]
.
append
(
209
)
extensions
[
pb2
.
repeated_sfixed64_extension
]
.
append
(
210
)
extensions
[
pb2
.
repeated_float_extension
]
.
append
(
211
)
extensions
[
pb2
.
repeated_double_extension
]
.
append
(
212
)
extensions
[
pb2
.
repeated_bool_extension
]
.
append
(
True
)
extensions
[
pb2
.
repeated_string_extension
]
.
append
(
'215'
)
extensions
[
pb2
.
repeated_bytes_extension
]
.
append
(
'216'
)
extensions
[
pb2
.
repeatedgroup_extension
]
.
add
()
.
a
=
217
extensions
[
pb2
.
repeated_nested_message_extension
]
.
add
()
.
bb
=
218
extensions
[
pb2
.
repeated_foreign_message_extension
]
.
add
()
.
c
=
219
extensions
[
pb2
.
repeated_import_message_extension
]
.
add
()
.
d
=
220
extensions
[
pb2
.
repeated_lazy_message_extension
]
.
add
()
.
bb
=
227
extensions
[
pb2
.
repeated_nested_enum_extension
]
.
append
(
pb2
.
TestAllTypes
.
BAR
)
extensions
[
pb2
.
repeated_foreign_enum_extension
]
.
append
(
pb2
.
FOREIGN_BAR
)
extensions
[
pb2
.
repeated_import_enum_extension
]
.
append
(
import_pb2
.
IMPORT_BAR
)
extensions
[
pb2
.
repeated_string_piece_extension
]
.
append
(
'224'
)
extensions
[
pb2
.
repeated_cord_extension
]
.
append
(
'225'
)
# Append a second one of each field.
extensions
[
pb2
.
repeated_int32_extension
]
.
append
(
301
)
extensions
[
pb2
.
repeated_int64_extension
]
.
append
(
302
)
extensions
[
pb2
.
repeated_uint32_extension
]
.
append
(
303
)
extensions
[
pb2
.
repeated_uint64_extension
]
.
append
(
304
)
extensions
[
pb2
.
repeated_sint32_extension
]
.
append
(
305
)
extensions
[
pb2
.
repeated_sint64_extension
]
.
append
(
306
)
extensions
[
pb2
.
repeated_fixed32_extension
]
.
append
(
307
)
extensions
[
pb2
.
repeated_fixed64_extension
]
.
append
(
308
)
extensions
[
pb2
.
repeated_sfixed32_extension
]
.
append
(
309
)
extensions
[
pb2
.
repeated_sfixed64_extension
]
.
append
(
310
)
extensions
[
pb2
.
repeated_float_extension
]
.
append
(
311
)
extensions
[
pb2
.
repeated_double_extension
]
.
append
(
312
)
extensions
[
pb2
.
repeated_bool_extension
]
.
append
(
False
)
extensions
[
pb2
.
repeated_string_extension
]
.
append
(
'315'
)
extensions
[
pb2
.
repeated_bytes_extension
]
.
append
(
'316'
)
extensions
[
pb2
.
repeatedgroup_extension
]
.
add
()
.
a
=
317
extensions
[
pb2
.
repeated_nested_message_extension
]
.
add
()
.
bb
=
318
extensions
[
pb2
.
repeated_foreign_message_extension
]
.
add
()
.
c
=
319
extensions
[
pb2
.
repeated_import_message_extension
]
.
add
()
.
d
=
320
extensions
[
pb2
.
repeated_lazy_message_extension
]
.
add
()
.
bb
=
327
extensions
[
pb2
.
repeated_nested_enum_extension
]
.
append
(
pb2
.
TestAllTypes
.
BAZ
)
extensions
[
pb2
.
repeated_foreign_enum_extension
]
.
append
(
pb2
.
FOREIGN_BAZ
)
extensions
[
pb2
.
repeated_import_enum_extension
]
.
append
(
import_pb2
.
IMPORT_BAZ
)
extensions
[
pb2
.
repeated_string_piece_extension
]
.
append
(
'324'
)
extensions
[
pb2
.
repeated_cord_extension
]
.
append
(
'325'
)
#
# Fields with defaults.
#
extensions
[
pb2
.
default_int32_extension
]
=
401
extensions
[
pb2
.
default_int64_extension
]
=
402
extensions
[
pb2
.
default_uint32_extension
]
=
403
extensions
[
pb2
.
default_uint64_extension
]
=
404
extensions
[
pb2
.
default_sint32_extension
]
=
405
extensions
[
pb2
.
default_sint64_extension
]
=
406
extensions
[
pb2
.
default_fixed32_extension
]
=
407
extensions
[
pb2
.
default_fixed64_extension
]
=
408
extensions
[
pb2
.
default_sfixed32_extension
]
=
409
extensions
[
pb2
.
default_sfixed64_extension
]
=
410
extensions
[
pb2
.
default_float_extension
]
=
411
extensions
[
pb2
.
default_double_extension
]
=
412
extensions
[
pb2
.
default_bool_extension
]
=
False
extensions
[
pb2
.
default_string_extension
]
=
'415'
extensions
[
pb2
.
default_bytes_extension
]
=
'416'
extensions
[
pb2
.
default_nested_enum_extension
]
=
pb2
.
TestAllTypes
.
FOO
extensions
[
pb2
.
default_foreign_enum_extension
]
=
pb2
.
FOREIGN_FOO
extensions
[
pb2
.
default_import_enum_extension
]
=
import_pb2
.
IMPORT_FOO
extensions
[
pb2
.
default_string_piece_extension
]
=
'424'
extensions
[
pb2
.
default_cord_extension
]
=
'425'
def
SetAllFieldsAndExtensions
(
message
):
"""Sets every field and extension in the message to a unique value.
Args:
message: A unittest_pb2.TestAllExtensions message.
"""
message
.
my_int
=
1
message
.
my_string
=
'foo'
message
.
my_float
=
1.0
message
.
Extensions
[
unittest_pb2
.
my_extension_int
]
=
23
message
.
Extensions
[
unittest_pb2
.
my_extension_string
]
=
'bar'
def
ExpectAllFieldsAndExtensionsInOrder
(
serialized
):
"""Ensures that serialized is the serialization we expect for a message
filled with SetAllFieldsAndExtensions(). (Specifically, ensures that the
serialization is in canonical, tag-number order).
"""
my_extension_int
=
unittest_pb2
.
my_extension_int
my_extension_string
=
unittest_pb2
.
my_extension_string
expected_strings
=
[]
message
=
unittest_pb2
.
TestFieldOrderings
()
message
.
my_int
=
1
# Field 1.
expected_strings
.
append
(
message
.
SerializeToString
())
message
.
Clear
()
message
.
Extensions
[
my_extension_int
]
=
23
# Field 5.
expected_strings
.
append
(
message
.
SerializeToString
())
message
.
Clear
()
message
.
my_string
=
'foo'
# Field 11.
expected_strings
.
append
(
message
.
SerializeToString
())
message
.
Clear
()
message
.
Extensions
[
my_extension_string
]
=
'bar'
# Field 50.
expected_strings
.
append
(
message
.
SerializeToString
())
message
.
Clear
()
message
.
my_float
=
1.0
expected_strings
.
append
(
message
.
SerializeToString
())
message
.
Clear
()
expected
=
''
.
join
(
expected_strings
)
if
expected
!=
serialized
:
raise
ValueError
(
'Expected
%
r, found
%
r'
%
(
expected
,
serialized
))
def
ExpectAllFieldsSet
(
test_case
,
message
):
"""Check all fields for correct values have after Set*Fields() is called."""
test_case
.
assertTrue
(
message
.
HasField
(
'optional_int32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_int64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_uint32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_uint64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_sint32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_sint64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_fixed32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_fixed64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_sfixed32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_sfixed64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_float'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_double'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_bool'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_string'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_bytes'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optionalgroup'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_nested_message'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_foreign_message'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_import_message'
))
test_case
.
assertTrue
(
message
.
optionalgroup
.
HasField
(
'a'
))
test_case
.
assertTrue
(
message
.
optional_nested_message
.
HasField
(
'bb'
))
test_case
.
assertTrue
(
message
.
optional_foreign_message
.
HasField
(
'c'
))
test_case
.
assertTrue
(
message
.
optional_import_message
.
HasField
(
'd'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_nested_enum'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_foreign_enum'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_import_enum'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_string_piece'
))
test_case
.
assertTrue
(
message
.
HasField
(
'optional_cord'
))
test_case
.
assertEqual
(
101
,
message
.
optional_int32
)
test_case
.
assertEqual
(
102
,
message
.
optional_int64
)
test_case
.
assertEqual
(
103
,
message
.
optional_uint32
)
test_case
.
assertEqual
(
104
,
message
.
optional_uint64
)
test_case
.
assertEqual
(
105
,
message
.
optional_sint32
)
test_case
.
assertEqual
(
106
,
message
.
optional_sint64
)
test_case
.
assertEqual
(
107
,
message
.
optional_fixed32
)
test_case
.
assertEqual
(
108
,
message
.
optional_fixed64
)
test_case
.
assertEqual
(
109
,
message
.
optional_sfixed32
)
test_case
.
assertEqual
(
110
,
message
.
optional_sfixed64
)
test_case
.
assertEqual
(
111
,
message
.
optional_float
)
test_case
.
assertEqual
(
112
,
message
.
optional_double
)
test_case
.
assertEqual
(
True
,
message
.
optional_bool
)
test_case
.
assertEqual
(
'115'
,
message
.
optional_string
)
test_case
.
assertEqual
(
'116'
,
message
.
optional_bytes
)
test_case
.
assertEqual
(
117
,
message
.
optionalgroup
.
a
)
test_case
.
assertEqual
(
118
,
message
.
optional_nested_message
.
bb
)
test_case
.
assertEqual
(
119
,
message
.
optional_foreign_message
.
c
)
test_case
.
assertEqual
(
120
,
message
.
optional_import_message
.
d
)
test_case
.
assertEqual
(
126
,
message
.
optional_public_import_message
.
e
)
test_case
.
assertEqual
(
127
,
message
.
optional_lazy_message
.
bb
)
test_case
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
BAZ
,
message
.
optional_nested_enum
)
test_case
.
assertEqual
(
unittest_pb2
.
FOREIGN_BAZ
,
message
.
optional_foreign_enum
)
test_case
.
assertEqual
(
unittest_import_pb2
.
IMPORT_BAZ
,
message
.
optional_import_enum
)
# -----------------------------------------------------------------
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_int32
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_int64
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_uint32
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_uint64
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_sint32
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_sint64
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_fixed32
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_fixed64
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_sfixed32
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_sfixed64
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_float
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_double
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_bool
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_string
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_bytes
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeatedgroup
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_nested_message
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_foreign_message
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_import_message
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_nested_enum
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_foreign_enum
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_import_enum
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_string_piece
))
test_case
.
assertEqual
(
2
,
len
(
message
.
repeated_cord
))
test_case
.
assertEqual
(
201
,
message
.
repeated_int32
[
0
])
test_case
.
assertEqual
(
202
,
message
.
repeated_int64
[
0
])
test_case
.
assertEqual
(
203
,
message
.
repeated_uint32
[
0
])
test_case
.
assertEqual
(
204
,
message
.
repeated_uint64
[
0
])
test_case
.
assertEqual
(
205
,
message
.
repeated_sint32
[
0
])
test_case
.
assertEqual
(
206
,
message
.
repeated_sint64
[
0
])
test_case
.
assertEqual
(
207
,
message
.
repeated_fixed32
[
0
])
test_case
.
assertEqual
(
208
,
message
.
repeated_fixed64
[
0
])
test_case
.
assertEqual
(
209
,
message
.
repeated_sfixed32
[
0
])
test_case
.
assertEqual
(
210
,
message
.
repeated_sfixed64
[
0
])
test_case
.
assertEqual
(
211
,
message
.
repeated_float
[
0
])
test_case
.
assertEqual
(
212
,
message
.
repeated_double
[
0
])
test_case
.
assertEqual
(
True
,
message
.
repeated_bool
[
0
])
test_case
.
assertEqual
(
'215'
,
message
.
repeated_string
[
0
])
test_case
.
assertEqual
(
'216'
,
message
.
repeated_bytes
[
0
])
test_case
.
assertEqual
(
217
,
message
.
repeatedgroup
[
0
]
.
a
)
test_case
.
assertEqual
(
218
,
message
.
repeated_nested_message
[
0
]
.
bb
)
test_case
.
assertEqual
(
219
,
message
.
repeated_foreign_message
[
0
]
.
c
)
test_case
.
assertEqual
(
220
,
message
.
repeated_import_message
[
0
]
.
d
)
test_case
.
assertEqual
(
227
,
message
.
repeated_lazy_message
[
0
]
.
bb
)
test_case
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
BAR
,
message
.
repeated_nested_enum
[
0
])
test_case
.
assertEqual
(
unittest_pb2
.
FOREIGN_BAR
,
message
.
repeated_foreign_enum
[
0
])
test_case
.
assertEqual
(
unittest_import_pb2
.
IMPORT_BAR
,
message
.
repeated_import_enum
[
0
])
test_case
.
assertEqual
(
301
,
message
.
repeated_int32
[
1
])
test_case
.
assertEqual
(
302
,
message
.
repeated_int64
[
1
])
test_case
.
assertEqual
(
303
,
message
.
repeated_uint32
[
1
])
test_case
.
assertEqual
(
304
,
message
.
repeated_uint64
[
1
])
test_case
.
assertEqual
(
305
,
message
.
repeated_sint32
[
1
])
test_case
.
assertEqual
(
306
,
message
.
repeated_sint64
[
1
])
test_case
.
assertEqual
(
307
,
message
.
repeated_fixed32
[
1
])
test_case
.
assertEqual
(
308
,
message
.
repeated_fixed64
[
1
])
test_case
.
assertEqual
(
309
,
message
.
repeated_sfixed32
[
1
])
test_case
.
assertEqual
(
310
,
message
.
repeated_sfixed64
[
1
])
test_case
.
assertEqual
(
311
,
message
.
repeated_float
[
1
])
test_case
.
assertEqual
(
312
,
message
.
repeated_double
[
1
])
test_case
.
assertEqual
(
False
,
message
.
repeated_bool
[
1
])
test_case
.
assertEqual
(
'315'
,
message
.
repeated_string
[
1
])
test_case
.
assertEqual
(
'316'
,
message
.
repeated_bytes
[
1
])
test_case
.
assertEqual
(
317
,
message
.
repeatedgroup
[
1
]
.
a
)
test_case
.
assertEqual
(
318
,
message
.
repeated_nested_message
[
1
]
.
bb
)
test_case
.
assertEqual
(
319
,
message
.
repeated_foreign_message
[
1
]
.
c
)
test_case
.
assertEqual
(
320
,
message
.
repeated_import_message
[
1
]
.
d
)
test_case
.
assertEqual
(
327
,
message
.
repeated_lazy_message
[
1
]
.
bb
)
test_case
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
BAZ
,
message
.
repeated_nested_enum
[
1
])
test_case
.
assertEqual
(
unittest_pb2
.
FOREIGN_BAZ
,
message
.
repeated_foreign_enum
[
1
])
test_case
.
assertEqual
(
unittest_import_pb2
.
IMPORT_BAZ
,
message
.
repeated_import_enum
[
1
])
# -----------------------------------------------------------------
test_case
.
assertTrue
(
message
.
HasField
(
'default_int32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_int64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_uint32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_uint64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_sint32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_sint64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_fixed32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_fixed64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_sfixed32'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_sfixed64'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_float'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_double'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_bool'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_string'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_bytes'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_nested_enum'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_foreign_enum'
))
test_case
.
assertTrue
(
message
.
HasField
(
'default_import_enum'
))
test_case
.
assertEqual
(
401
,
message
.
default_int32
)
test_case
.
assertEqual
(
402
,
message
.
default_int64
)
test_case
.
assertEqual
(
403
,
message
.
default_uint32
)
test_case
.
assertEqual
(
404
,
message
.
default_uint64
)
test_case
.
assertEqual
(
405
,
message
.
default_sint32
)
test_case
.
assertEqual
(
406
,
message
.
default_sint64
)
test_case
.
assertEqual
(
407
,
message
.
default_fixed32
)
test_case
.
assertEqual
(
408
,
message
.
default_fixed64
)
test_case
.
assertEqual
(
409
,
message
.
default_sfixed32
)
test_case
.
assertEqual
(
410
,
message
.
default_sfixed64
)
test_case
.
assertEqual
(
411
,
message
.
default_float
)
test_case
.
assertEqual
(
412
,
message
.
default_double
)
test_case
.
assertEqual
(
False
,
message
.
default_bool
)
test_case
.
assertEqual
(
'415'
,
message
.
default_string
)
test_case
.
assertEqual
(
'416'
,
message
.
default_bytes
)
test_case
.
assertEqual
(
unittest_pb2
.
TestAllTypes
.
FOO
,
message
.
default_nested_enum
)
test_case
.
assertEqual
(
unittest_pb2
.
FOREIGN_FOO
,
message
.
default_foreign_enum
)
test_case
.
assertEqual
(
unittest_import_pb2
.
IMPORT_FOO
,
message
.
default_import_enum
)
def
GoldenFile
(
filename
):
"""Finds the given golden file and returns a file object representing it."""
# Search up the directory tree looking for the C++ protobuf source code.
path
=
'.'
while
os
.
path
.
exists
(
path
):
if
os
.
path
.
exists
(
os
.
path
.
join
(
path
,
'tests/google/protobuf/internal'
)):
# Found it. Load the golden file from the testdata directory.
full_path
=
os
.
path
.
join
(
path
,
'tests/google/protobuf/internal'
,
filename
)
return
open
(
full_path
,
'rb'
)
path
=
os
.
path
.
join
(
path
,
'..'
)
raise
RuntimeError
(
'Could not find golden files. This test must be run from within the '
'protobuf source package so that it can read test data files from the '
'C++ source tree.'
)
def
SetAllPackedFields
(
message
):
"""Sets every field in the message to a unique value.
Args:
message: A unittest_pb2.TestPackedTypes instance.
"""
message
.
packed_int32
.
extend
([
601
,
701
])
message
.
packed_int64
.
extend
([
602
,
702
])
message
.
packed_uint32
.
extend
([
603
,
703
])
message
.
packed_uint64
.
extend
([
604
,
704
])
message
.
packed_sint32
.
extend
([
605
,
705
])
message
.
packed_sint64
.
extend
([
606
,
706
])
message
.
packed_fixed32
.
extend
([
607
,
707
])
message
.
packed_fixed64
.
extend
([
608
,
708
])
message
.
packed_sfixed32
.
extend
([
609
,
709
])
message
.
packed_sfixed64
.
extend
([
610
,
710
])
message
.
packed_float
.
extend
([
611.0
,
711.0
])
message
.
packed_double
.
extend
([
612.0
,
712.0
])
message
.
packed_bool
.
extend
([
True
,
False
])
message
.
packed_enum
.
extend
([
unittest_pb2
.
FOREIGN_BAR
,
unittest_pb2
.
FOREIGN_BAZ
])
def
SetAllPackedExtensions
(
message
):
"""Sets every extension in the message to a unique value.
Args:
message: A unittest_pb2.TestPackedExtensions instance.
"""
extensions
=
message
.
Extensions
pb2
=
unittest_pb2
extensions
[
pb2
.
packed_int32_extension
]
.
extend
([
601
,
701
])
extensions
[
pb2
.
packed_int64_extension
]
.
extend
([
602
,
702
])
extensions
[
pb2
.
packed_uint32_extension
]
.
extend
([
603
,
703
])
extensions
[
pb2
.
packed_uint64_extension
]
.
extend
([
604
,
704
])
extensions
[
pb2
.
packed_sint32_extension
]
.
extend
([
605
,
705
])
extensions
[
pb2
.
packed_sint64_extension
]
.
extend
([
606
,
706
])
extensions
[
pb2
.
packed_fixed32_extension
]
.
extend
([
607
,
707
])
extensions
[
pb2
.
packed_fixed64_extension
]
.
extend
([
608
,
708
])
extensions
[
pb2
.
packed_sfixed32_extension
]
.
extend
([
609
,
709
])
extensions
[
pb2
.
packed_sfixed64_extension
]
.
extend
([
610
,
710
])
extensions
[
pb2
.
packed_float_extension
]
.
extend
([
611.0
,
711.0
])
extensions
[
pb2
.
packed_double_extension
]
.
extend
([
612.0
,
712.0
])
extensions
[
pb2
.
packed_bool_extension
]
.
extend
([
True
,
False
])
extensions
[
pb2
.
packed_enum_extension
]
.
extend
([
unittest_pb2
.
FOREIGN_BAR
,
unittest_pb2
.
FOREIGN_BAZ
])
def
SetAllUnpackedFields
(
message
):
"""Sets every field in the message to a unique value.
Args:
message: A unittest_pb2.TestUnpackedTypes instance.
"""
message
.
unpacked_int32
.
extend
([
601
,
701
])
message
.
unpacked_int64
.
extend
([
602
,
702
])
message
.
unpacked_uint32
.
extend
([
603
,
703
])
message
.
unpacked_uint64
.
extend
([
604
,
704
])
message
.
unpacked_sint32
.
extend
([
605
,
705
])
message
.
unpacked_sint64
.
extend
([
606
,
706
])
message
.
unpacked_fixed32
.
extend
([
607
,
707
])
message
.
unpacked_fixed64
.
extend
([
608
,
708
])
message
.
unpacked_sfixed32
.
extend
([
609
,
709
])
message
.
unpacked_sfixed64
.
extend
([
610
,
710
])
message
.
unpacked_float
.
extend
([
611.0
,
711.0
])
message
.
unpacked_double
.
extend
([
612.0
,
712.0
])
message
.
unpacked_bool
.
extend
([
True
,
False
])
message
.
unpacked_enum
.
extend
([
unittest_pb2
.
FOREIGN_BAR
,
unittest_pb2
.
FOREIGN_BAZ
])
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/text_format_test.py
0 → 100755
View file @
5af0b547
#! /usr/bin/python
#
# Protocol Buffers - Google's data interchange format
# Copyright 2008 Google Inc. All rights reserved.
# http://code.google.com/p/protobuf/
#
# 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.
"""Test for google.protobuf.text_format."""
__author__
=
'kenton@google.com (Kenton Varda)'
import
difflib
import
re
import
unittest
from
google.protobuf
import
text_format
from
google.protobuf.internal
import
test_util
from
google.protobuf
import
unittest_pb2
from
google.protobuf
import
unittest_mset_pb2
class
TextFormatTest
(
unittest
.
TestCase
):
def
ReadGolden
(
self
,
golden_filename
):
f
=
test_util
.
GoldenFile
(
golden_filename
)
golden_lines
=
f
.
readlines
()
f
.
close
()
return
golden_lines
def
CompareToGoldenFile
(
self
,
text
,
golden_filename
):
golden_lines
=
self
.
ReadGolden
(
golden_filename
)
self
.
CompareToGoldenLines
(
text
,
golden_lines
)
def
CompareToGoldenText
(
self
,
text
,
golden_text
):
self
.
CompareToGoldenLines
(
text
,
golden_text
.
splitlines
(
1
))
def
CompareToGoldenLines
(
self
,
text
,
golden_lines
):
actual_lines
=
text
.
splitlines
(
1
)
self
.
assertEqual
(
golden_lines
,
actual_lines
,
"Text doesn't match golden. Diff:
\n
"
+
''
.
join
(
difflib
.
ndiff
(
golden_lines
,
actual_lines
)))
def
testPrintAllFields
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
test_util
.
SetAllFields
(
message
)
self
.
CompareToGoldenFile
(
self
.
RemoveRedundantZeros
(
text_format
.
MessageToString
(
message
)),
'text_format_unittest_data.txt'
)
def
testPrintAllExtensions
(
self
):
message
=
unittest_pb2
.
TestAllExtensions
()
test_util
.
SetAllExtensions
(
message
)
self
.
CompareToGoldenFile
(
self
.
RemoveRedundantZeros
(
text_format
.
MessageToString
(
message
)),
'text_format_unittest_extensions_data.txt'
)
def
testPrintMessageSet
(
self
):
message
=
unittest_mset_pb2
.
TestMessageSetContainer
()
ext1
=
unittest_mset_pb2
.
TestMessageSetExtension1
.
message_set_extension
ext2
=
unittest_mset_pb2
.
TestMessageSetExtension2
.
message_set_extension
message
.
message_set
.
Extensions
[
ext1
]
.
i
=
23
message
.
message_set
.
Extensions
[
ext2
]
.
str
=
'foo'
self
.
CompareToGoldenText
(
text_format
.
MessageToString
(
message
),
'message_set {
\n
'
' [protobuf_unittest.TestMessageSetExtension1] {
\n
'
' i: 23
\n
'
' }
\n
'
' [protobuf_unittest.TestMessageSetExtension2] {
\n
'
' str:
\"
foo
\"\n
'
' }
\n
'
'}
\n
'
)
"""
def testPrintBadEnumValue(self):
message = unittest_pb2.TestAllTypes()
message.optional_nested_enum = 100
message.optional_foreign_enum = 101
message.optional_import_enum = 102
self.CompareToGoldenText(
text_format.MessageToString(message),
'optional_nested_enum: 100
\n
'
'optional_foreign_enum: 101
\n
'
'optional_import_enum: 102
\n
')
def testPrintBadEnumValueExtensions(self):
message = unittest_pb2.TestAllExtensions()
message.Extensions[unittest_pb2.optional_nested_enum_extension] = 100
message.Extensions[unittest_pb2.optional_foreign_enum_extension] = 101
message.Extensions[unittest_pb2.optional_import_enum_extension] = 102
self.CompareToGoldenText(
text_format.MessageToString(message),
'[protobuf_unittest.optional_nested_enum_extension]: 100
\n
'
'[protobuf_unittest.optional_foreign_enum_extension]: 101
\n
'
'[protobuf_unittest.optional_import_enum_extension]: 102
\n
')
"""
def
testPrintExotic
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
message
.
repeated_int64
.
append
(
-
9223372036854775808
)
message
.
repeated_uint64
.
append
(
18446744073709551615
)
message
.
repeated_double
.
append
(
123.456
)
message
.
repeated_double
.
append
(
1.23e22
)
message
.
repeated_double
.
append
(
1.23e-18
)
message
.
repeated_string
.
append
(
'
\000\001\a\b\f\n\r\t\v\\\'
"'
)
message
.
repeated_string
.
append
(
u'
\u00fc\ua71f
'
)
self
.
CompareToGoldenText
(
self
.
RemoveRedundantZeros
(
text_format
.
MessageToString
(
message
)),
'repeated_int64: -9223372036854775808
\n
'
'repeated_uint64: 18446744073709551615
\n
'
'repeated_double: 123.456
\n
'
'repeated_double: 1.23e+22
\n
'
'repeated_double: 1.23e-18
\n
'
'repeated_string: '
'"
\\
000
\\
001
\\
007
\\
010
\\
014
\\
n
\\
r
\\
t
\\
013
\\\\\\\'\\
""
\n
'
'repeated_string: "
\\
303
\\
274
\\
352
\\
234
\\
237"
\n
'
)
def
testPrintNestedMessageAsOneLine
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
msg
=
message
.
repeated_nested_message
.
add
()
msg
.
bb
=
42
;
self
.
CompareToGoldenText
(
text_format
.
MessageToString
(
message
,
as_one_line
=
True
),
'repeated_nested_message { bb: 42 }'
)
def
testPrintRepeatedFieldsAsOneLine
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
message
.
repeated_int32
.
append
(
1
)
message
.
repeated_int32
.
append
(
1
)
message
.
repeated_int32
.
append
(
3
)
message
.
repeated_string
.
append
(
"Google"
)
message
.
repeated_string
.
append
(
"Zurich"
)
self
.
CompareToGoldenText
(
text_format
.
MessageToString
(
message
,
as_one_line
=
True
),
'repeated_int32: 1 repeated_int32: 1 repeated_int32: 3 '
'repeated_string: "Google" repeated_string: "Zurich"'
)
def
testPrintNestedNewLineInStringAsOneLine
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
message
.
optional_string
=
"a
\n
new
\n
line"
self
.
CompareToGoldenText
(
text_format
.
MessageToString
(
message
,
as_one_line
=
True
),
'optional_string: "a
\\
nnew
\\
nline"'
)
def
testPrintMessageSetAsOneLine
(
self
):
message
=
unittest_mset_pb2
.
TestMessageSetContainer
()
ext1
=
unittest_mset_pb2
.
TestMessageSetExtension1
.
message_set_extension
ext2
=
unittest_mset_pb2
.
TestMessageSetExtension2
.
message_set_extension
message
.
message_set
.
Extensions
[
ext1
]
.
i
=
23
message
.
message_set
.
Extensions
[
ext2
]
.
str
=
'foo'
self
.
CompareToGoldenText
(
text_format
.
MessageToString
(
message
,
as_one_line
=
True
),
'message_set {'
' [protobuf_unittest.TestMessageSetExtension1] {'
' i: 23'
' }'
' [protobuf_unittest.TestMessageSetExtension2] {'
' str:
\"
foo
\"
'
' }'
' }'
)
def
testPrintExoticAsOneLine
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
message
.
repeated_int64
.
append
(
-
9223372036854775808
)
message
.
repeated_uint64
.
append
(
18446744073709551615
)
message
.
repeated_double
.
append
(
123.456
)
message
.
repeated_double
.
append
(
1.23e22
)
message
.
repeated_double
.
append
(
1.23e-18
)
message
.
repeated_string
.
append
(
'
\000\001\a\b\f\n\r\t\v\\\'
"'
)
message
.
repeated_string
.
append
(
u'
\u00fc\ua71f
'
)
self
.
CompareToGoldenText
(
self
.
RemoveRedundantZeros
(
text_format
.
MessageToString
(
message
,
as_one_line
=
True
)),
'repeated_int64: -9223372036854775808'
' repeated_uint64: 18446744073709551615'
' repeated_double: 123.456'
' repeated_double: 1.23e+22'
' repeated_double: 1.23e-18'
' repeated_string: '
'"
\\
000
\\
001
\\
007
\\
010
\\
014
\\
n
\\
r
\\
t
\\
013
\\\\\\\'\\
""'
' repeated_string: "
\\
303
\\
274
\\
352
\\
234
\\
237"'
)
def
testRoundTripExoticAsOneLine
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
message
.
repeated_int64
.
append
(
-
9223372036854775808
)
message
.
repeated_uint64
.
append
(
18446744073709551615
)
message
.
repeated_double
.
append
(
123.456
)
message
.
repeated_double
.
append
(
1.23e22
)
message
.
repeated_double
.
append
(
1.23e-18
)
message
.
repeated_string
.
append
(
'
\000\001\a\b\f\n\r\t\v\\\'
"'
)
message
.
repeated_string
.
append
(
u'
\u00fc\ua71f
'
)
# Test as_utf8 = False.
wire_text
=
text_format
.
MessageToString
(
message
,
as_one_line
=
True
,
as_utf8
=
False
)
parsed_message
=
unittest_pb2
.
TestAllTypes
()
text_format
.
Merge
(
wire_text
,
parsed_message
)
self
.
assertEquals
(
message
,
parsed_message
)
# Test as_utf8 = True.
wire_text
=
text_format
.
MessageToString
(
message
,
as_one_line
=
True
,
as_utf8
=
True
)
parsed_message
=
unittest_pb2
.
TestAllTypes
()
text_format
.
Merge
(
wire_text
,
parsed_message
)
self
.
assertEquals
(
message
,
parsed_message
)
def
testPrintRawUtf8String
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
message
.
repeated_string
.
append
(
u'
\u00fc\ua71f
'
)
text
=
text_format
.
MessageToString
(
message
,
as_utf8
=
True
)
self
.
CompareToGoldenText
(
text
,
'repeated_string: "
\303\274\352\234\237
"
\n
'
)
parsed_message
=
unittest_pb2
.
TestAllTypes
()
text_format
.
Merge
(
text
,
parsed_message
)
self
.
assertEquals
(
message
,
parsed_message
)
def
testMessageToString
(
self
):
message
=
unittest_pb2
.
ForeignMessage
()
message
.
c
=
123
self
.
assertEqual
(
'c: 123
\n
'
,
str
(
message
))
def
RemoveRedundantZeros
(
self
,
text
):
# Some platforms print 1e+5 as 1e+005. This is fine, but we need to remove
# these zeros in order to match the golden file.
text
=
text
.
replace
(
'e+0'
,
'e+'
)
.
replace
(
'e+0'
,
'e+'
)
\
.
replace
(
'e-0'
,
'e-'
)
.
replace
(
'e-0'
,
'e-'
)
# Floating point fields are printed with .0 suffix even if they are
# actualy integer numbers.
text
=
re
.
compile
(
'
\
.0$'
,
re
.
MULTILINE
)
.
sub
(
''
,
text
)
return
text
def
testMergeGolden
(
self
):
golden_text
=
'
\n
'
.
join
(
self
.
ReadGolden
(
'text_format_unittest_data.txt'
))
parsed_message
=
unittest_pb2
.
TestAllTypes
()
text_format
.
Merge
(
golden_text
,
parsed_message
)
message
=
unittest_pb2
.
TestAllTypes
()
test_util
.
SetAllFields
(
message
)
self
.
assertEquals
(
message
,
parsed_message
)
def
testMergeGoldenExtensions
(
self
):
golden_text
=
'
\n
'
.
join
(
self
.
ReadGolden
(
'text_format_unittest_extensions_data.txt'
))
parsed_message
=
unittest_pb2
.
TestAllExtensions
()
text_format
.
Merge
(
golden_text
,
parsed_message
)
message
=
unittest_pb2
.
TestAllExtensions
()
test_util
.
SetAllExtensions
(
message
)
self
.
assertEquals
(
message
,
parsed_message
)
def
testMergeAllFields
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
test_util
.
SetAllFields
(
message
)
ascii_text
=
text_format
.
MessageToString
(
message
)
parsed_message
=
unittest_pb2
.
TestAllTypes
()
text_format
.
Merge
(
ascii_text
,
parsed_message
)
self
.
assertEqual
(
message
,
parsed_message
)
test_util
.
ExpectAllFieldsSet
(
self
,
message
)
def
testMergeAllExtensions
(
self
):
message
=
unittest_pb2
.
TestAllExtensions
()
test_util
.
SetAllExtensions
(
message
)
ascii_text
=
text_format
.
MessageToString
(
message
)
parsed_message
=
unittest_pb2
.
TestAllExtensions
()
text_format
.
Merge
(
ascii_text
,
parsed_message
)
self
.
assertEqual
(
message
,
parsed_message
)
def
testMergeMessageSet
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
(
'repeated_uint64: 1
\n
'
'repeated_uint64: 2
\n
'
)
text_format
.
Merge
(
text
,
message
)
self
.
assertEqual
(
1
,
message
.
repeated_uint64
[
0
])
self
.
assertEqual
(
2
,
message
.
repeated_uint64
[
1
])
message
=
unittest_mset_pb2
.
TestMessageSetContainer
()
text
=
(
'message_set {
\n
'
' [protobuf_unittest.TestMessageSetExtension1] {
\n
'
' i: 23
\n
'
' }
\n
'
' [protobuf_unittest.TestMessageSetExtension2] {
\n
'
' str:
\"
foo
\"\n
'
' }
\n
'
'}
\n
'
)
text_format
.
Merge
(
text
,
message
)
ext1
=
unittest_mset_pb2
.
TestMessageSetExtension1
.
message_set_extension
ext2
=
unittest_mset_pb2
.
TestMessageSetExtension2
.
message_set_extension
self
.
assertEquals
(
23
,
message
.
message_set
.
Extensions
[
ext1
]
.
i
)
self
.
assertEquals
(
'foo'
,
message
.
message_set
.
Extensions
[
ext2
]
.
str
)
def
testMergeExotic
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
(
'repeated_int64: -9223372036854775808
\n
'
'repeated_uint64: 18446744073709551615
\n
'
'repeated_double: 123.456
\n
'
'repeated_double: 1.23e+22
\n
'
'repeated_double: 1.23e-18
\n
'
'repeated_string:
\n
'
'"
\\
000
\\
001
\\
007
\\
010
\\
014
\\
n
\\
r
\\
t
\\
013
\\\\\\\'\\
""
\n
'
'repeated_string: "foo"
\'
corge
\'
"grault"
\n
'
'repeated_string: "
\\
303
\\
274
\\
352
\\
234
\\
237"
\n
'
'repeated_string: "
\\
xc3
\\
xbc"
\n
'
'repeated_string: "
\xc3\xbc
"
\n
'
)
text_format
.
Merge
(
text
,
message
)
self
.
assertEqual
(
-
9223372036854775808
,
message
.
repeated_int64
[
0
])
self
.
assertEqual
(
18446744073709551615
,
message
.
repeated_uint64
[
0
])
self
.
assertEqual
(
123.456
,
message
.
repeated_double
[
0
])
self
.
assertEqual
(
1.23e22
,
message
.
repeated_double
[
1
])
self
.
assertEqual
(
1.23e-18
,
message
.
repeated_double
[
2
])
self
.
assertEqual
(
'
\000\001\a\b\f\n\r\t\v\\\'
"'
,
message
.
repeated_string
[
0
])
self
.
assertEqual
(
'foocorgegrault'
,
message
.
repeated_string
[
1
])
self
.
assertEqual
(
u'
\u00fc\ua71f
'
,
message
.
repeated_string
[
2
])
self
.
assertEqual
(
u'
\u00fc
'
,
message
.
repeated_string
[
3
])
def
testMergeEmptyText
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
''
text_format
.
Merge
(
text
,
message
)
self
.
assertEquals
(
unittest_pb2
.
TestAllTypes
(),
message
)
def
testMergeInvalidUtf8
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
'repeated_string: "
\\
xc3
\\
xc3"'
self
.
assertRaises
(
text_format
.
ParseError
,
text_format
.
Merge
,
text
,
message
)
def
testMergeSingleWord
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
'foo'
self
.
assertRaisesWithMessage
(
text_format
.
ParseError
,
(
'1:1 : Message type "protobuf_unittest.TestAllTypes" has no field named '
'"foo".'
),
text_format
.
Merge
,
text
,
message
)
def
testMergeUnknownField
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
'unknown_field: 8
\n
'
self
.
assertRaisesWithMessage
(
text_format
.
ParseError
,
(
'1:1 : Message type "protobuf_unittest.TestAllTypes" has no field named '
'"unknown_field".'
),
text_format
.
Merge
,
text
,
message
)
def
testMergeBadExtension
(
self
):
message
=
unittest_pb2
.
TestAllExtensions
()
text
=
'[unknown_extension]: 8
\n
'
self
.
assertRaisesWithMessage
(
text_format
.
ParseError
,
'1:2 : Extension "unknown_extension" not registered.'
,
text_format
.
Merge
,
text
,
message
)
message
=
unittest_pb2
.
TestAllTypes
()
self
.
assertRaisesWithMessage
(
text_format
.
ParseError
,
(
'1:2 : Message type "protobuf_unittest.TestAllTypes" does not have '
'extensions.'
),
text_format
.
Merge
,
text
,
message
)
def
testMergeGroupNotClosed
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
'RepeatedGroup: <'
self
.
assertRaisesWithMessage
(
text_format
.
ParseError
,
'1:16 : Expected ">".'
,
text_format
.
Merge
,
text
,
message
)
text
=
'RepeatedGroup: {'
self
.
assertRaisesWithMessage
(
text_format
.
ParseError
,
'1:16 : Expected "}".'
,
text_format
.
Merge
,
text
,
message
)
def
testMergeEmptyGroup
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
'OptionalGroup: {}'
text_format
.
Merge
(
text
,
message
)
self
.
assertTrue
(
message
.
HasField
(
'optionalgroup'
))
message
.
Clear
()
message
=
unittest_pb2
.
TestAllTypes
()
text
=
'OptionalGroup: <>'
text_format
.
Merge
(
text
,
message
)
self
.
assertTrue
(
message
.
HasField
(
'optionalgroup'
))
def
testMergeBadEnumValue
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
'optional_nested_enum: BARR'
self
.
assertRaisesWithMessage
(
text_format
.
ParseError
,
(
'1:23 : Enum type "protobuf_unittest.TestAllTypes.NestedEnum" '
'has no value named BARR.'
),
text_format
.
Merge
,
text
,
message
)
message
=
unittest_pb2
.
TestAllTypes
()
text
=
'optional_nested_enum: 100'
self
.
assertRaisesWithMessage
(
text_format
.
ParseError
,
(
'1:23 : Enum type "protobuf_unittest.TestAllTypes.NestedEnum" '
'has no value with number 100.'
),
text_format
.
Merge
,
text
,
message
)
def
testMergeBadIntValue
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
'optional_int32: bork'
self
.
assertRaisesWithMessage
(
text_format
.
ParseError
,
(
'1:17 : Couldn
\'
t parse integer: bork'
),
text_format
.
Merge
,
text
,
message
)
def
testMergeStringFieldUnescape
(
self
):
message
=
unittest_pb2
.
TestAllTypes
()
text
=
r'''repeated_string: "\xf\x62"
repeated_string: "\\xf\\x62"
repeated_string: "\\\xf\\\x62"
repeated_string: "\\\\xf\\\\x62"
repeated_string: "\\\\\xf\\\\\x62"
repeated_string: "\x5cx20"'''
text_format
.
Merge
(
text
,
message
)
SLASH
=
'
\\
'
self
.
assertEqual
(
'
\x0f
b'
,
message
.
repeated_string
[
0
])
self
.
assertEqual
(
SLASH
+
'xf'
+
SLASH
+
'x62'
,
message
.
repeated_string
[
1
])
self
.
assertEqual
(
SLASH
+
'
\x0f
'
+
SLASH
+
'b'
,
message
.
repeated_string
[
2
])
self
.
assertEqual
(
SLASH
+
SLASH
+
'xf'
+
SLASH
+
SLASH
+
'x62'
,
message
.
repeated_string
[
3
])
self
.
assertEqual
(
SLASH
+
SLASH
+
'
\x0f
'
+
SLASH
+
SLASH
+
'b'
,
message
.
repeated_string
[
4
])
self
.
assertEqual
(
SLASH
+
'x20'
,
message
.
repeated_string
[
5
])
def
assertRaisesWithMessage
(
self
,
e_class
,
e
,
func
,
*
args
,
**
kwargs
):
"""Same as assertRaises, but also compares the exception message."""
if
hasattr
(
e_class
,
'__name__'
):
exc_name
=
e_class
.
__name__
else
:
exc_name
=
str
(
e_class
)
try
:
func
(
*
args
,
**
kwargs
)
except
e_class
as
expr
:
if
str
(
expr
)
!=
e
:
msg
=
'
%
s raised, but with wrong message: "
%
s" instead of "
%
s"'
raise
self
.
failureException
(
msg
%
(
exc_name
,
str
(
expr
)
.
encode
(
'string_escape'
),
e
.
encode
(
'string_escape'
)))
return
else
:
raise
self
.
failureException
(
'
%
s not raised'
%
exc_name
)
class
TokenizerTest
(
unittest
.
TestCase
):
"""
def testSimpleTokenCases(self):
text = ('identifier1:"string1"
\n
\n\n
'
'identifier2 :
\n
\n
123
\n
identifier3 :
\'
string
\'\n
'
'identifiER_4 : 1.1e+2 ID5:-0.23 ID6:
\'
aaaa
\\\'
bbbb
\'\n
'
'ID7 : "aa
\\
"bb"
\n\n\n\n
ID8: {A:inf B:-inf C:true D:false}
\n
'
'ID9: 22 ID10: -111111111111111111 ID11: -22
\n
'
'ID12: 2222222222222222222 ID13: 1.23456f ID14: 1.2e+2f '
'false_bool: 0 true_BOOL:t
\n
true_bool1: 1 false_BOOL1:f ' )
tokenizer = text_format._Tokenizer(text)
methods = [(tokenizer.ConsumeIdentifier, 'identifier1'),
':',
(tokenizer.ConsumeString, 'string1'),
(tokenizer.ConsumeIdentifier, 'identifier2'),
':',
(tokenizer.ConsumeInt32, 123),
(tokenizer.ConsumeIdentifier, 'identifier3'),
':',
(tokenizer.ConsumeString, 'string'),
(tokenizer.ConsumeIdentifier, 'identifiER_4'),
':',
(tokenizer.ConsumeFloat, 1.1e+2),
(tokenizer.ConsumeIdentifier, 'ID5'),
':',
(tokenizer.ConsumeFloat, -0.23),
(tokenizer.ConsumeIdentifier, 'ID6'),
':',
(tokenizer.ConsumeString, 'aaaa
\'
bbbb'),
(tokenizer.ConsumeIdentifier, 'ID7'),
':',
(tokenizer.ConsumeString, 'aa
\"
bb'),
(tokenizer.ConsumeIdentifier, 'ID8'),
':',
'{',
(tokenizer.ConsumeIdentifier, 'A'),
':',
(tokenizer.ConsumeFloat, float('inf')),
(tokenizer.ConsumeIdentifier, 'B'),
':',
(tokenizer.ConsumeFloat, -float('inf')),
(tokenizer.ConsumeIdentifier, 'C'),
':',
(tokenizer.ConsumeBool, True),
(tokenizer.ConsumeIdentifier, 'D'),
':',
(tokenizer.ConsumeBool, False),
'}',
(tokenizer.ConsumeIdentifier, 'ID9'),
':',
(tokenizer.ConsumeUint32, 22),
(tokenizer.ConsumeIdentifier, 'ID10'),
':',
(tokenizer.ConsumeInt64, -111111111111111111),
(tokenizer.ConsumeIdentifier, 'ID11'),
':',
(tokenizer.ConsumeInt32, -22),
(tokenizer.ConsumeIdentifier, 'ID12'),
':',
(tokenizer.ConsumeUint64, 2222222222222222222),
(tokenizer.ConsumeIdentifier, 'ID13'),
':',
(tokenizer.ConsumeFloat, 1.23456),
(tokenizer.ConsumeIdentifier, 'ID14'),
':',
(tokenizer.ConsumeFloat, 1.2e+2),
(tokenizer.ConsumeIdentifier, 'false_bool'),
':',
(tokenizer.ConsumeBool, False),
(tokenizer.ConsumeIdentifier, 'true_BOOL'),
':',
(tokenizer.ConsumeBool, True),
(tokenizer.ConsumeIdentifier, 'true_bool1'),
':',
(tokenizer.ConsumeBool, True),
(tokenizer.ConsumeIdentifier, 'false_BOOL1'),
':',
(tokenizer.ConsumeBool, False)]
i = 0
while not tokenizer.AtEnd():
m = methods[i]
if type(m) == str:
token = tokenizer.token
self.assertEqual(token, m)
tokenizer.NextToken()
else:
self.assertEqual(m[1], m[0]())
i += 1
def testConsumeIntegers(self):
# This test only tests the failures in the integer parsing methods as well
# as the '0' special cases.
int64_max = (1 << 63) - 1
uint32_max = (1 << 32) - 1
text = '-1
%
d
%
d'
%
(uint32_max + 1, int64_max + 1)
tokenizer = text_format._Tokenizer(text)
self.assertRaises(text_format.ParseError, tokenizer.ConsumeUint32)
self.assertRaises(text_format.ParseError, tokenizer.ConsumeUint64)
self.assertEqual(-1, tokenizer.ConsumeInt32())
self.assertRaises(text_format.ParseError, tokenizer.ConsumeUint32)
self.assertRaises(text_format.ParseError, tokenizer.ConsumeInt32)
self.assertEqual(uint32_max + 1, tokenizer.ConsumeInt64())
self.assertRaises(text_format.ParseError, tokenizer.ConsumeInt64)
self.assertEqual(int64_max + 1, tokenizer.ConsumeUint64())
self.assertTrue(tokenizer.AtEnd())
text = '-0 -0 0 0'
tokenizer = text_format._Tokenizer(text)
self.assertEqual(0, tokenizer.ConsumeUint32())
self.assertEqual(0, tokenizer.ConsumeUint64())
self.assertEqual(0, tokenizer.ConsumeUint32())
self.assertEqual(0, tokenizer.ConsumeUint64())
self.assertTrue(tokenizer.AtEnd())
"""
def
testConsumeByteString
(
self
):
text
=
'"string1
\'
'
tokenizer
=
text_format
.
_Tokenizer
(
text
)
self
.
assertRaises
(
text_format
.
ParseError
,
tokenizer
.
ConsumeByteString
)
text
=
'string1"'
tokenizer
=
text_format
.
_Tokenizer
(
text
)
self
.
assertRaises
(
text_format
.
ParseError
,
tokenizer
.
ConsumeByteString
)
text
=
'
\n
"
\\
xt"'
tokenizer
=
text_format
.
_Tokenizer
(
text
)
self
.
assertRaises
(
text_format
.
ParseError
,
tokenizer
.
ConsumeByteString
)
text
=
'
\n
"
\\
"'
tokenizer
=
text_format
.
_Tokenizer
(
text
)
self
.
assertRaises
(
text_format
.
ParseError
,
tokenizer
.
ConsumeByteString
)
text
=
'
\n
"
\\
x"'
tokenizer
=
text_format
.
_Tokenizer
(
text
)
self
.
assertRaises
(
text_format
.
ParseError
,
tokenizer
.
ConsumeByteString
)
def
testConsumeBool
(
self
):
text
=
'not-a-bool'
tokenizer
=
text_format
.
_Tokenizer
(
text
)
self
.
assertRaises
(
text_format
.
ParseError
,
tokenizer
.
ConsumeBool
)
if
__name__
==
'__main__'
:
unittest
.
main
()
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/text_format_unittest_data.txt
0 → 100644
View file @
5af0b547
optional_int32: 101
optional_int64: 102
optional_uint32: 103
optional_uint64: 104
optional_sint32: 105
optional_sint64: 106
optional_fixed32: 107
optional_fixed64: 108
optional_sfixed32: 109
optional_sfixed64: 110
optional_float: 111
optional_double: 112
optional_bool: true
optional_string: "115"
optional_bytes: "116"
OptionalGroup {
a: 117
}
optional_nested_message {
bb: 118
}
optional_foreign_message {
c: 119
}
optional_import_message {
d: 120
}
optional_nested_enum: BAZ
optional_foreign_enum: FOREIGN_BAZ
optional_import_enum: IMPORT_BAZ
optional_string_piece: "124"
optional_cord: "125"
optional_public_import_message {
e: 126
}
optional_lazy_message {
bb: 127
}
repeated_int32: 201
repeated_int32: 301
repeated_int64: 202
repeated_int64: 302
repeated_uint32: 203
repeated_uint32: 303
repeated_uint64: 204
repeated_uint64: 304
repeated_sint32: 205
repeated_sint32: 305
repeated_sint64: 206
repeated_sint64: 306
repeated_fixed32: 207
repeated_fixed32: 307
repeated_fixed64: 208
repeated_fixed64: 308
repeated_sfixed32: 209
repeated_sfixed32: 309
repeated_sfixed64: 210
repeated_sfixed64: 310
repeated_float: 211
repeated_float: 311
repeated_double: 212
repeated_double: 312
repeated_bool: true
repeated_bool: false
repeated_string: "215"
repeated_string: "315"
repeated_bytes: "216"
repeated_bytes: "316"
RepeatedGroup {
a: 217
}
RepeatedGroup {
a: 317
}
repeated_nested_message {
bb: 218
}
repeated_nested_message {
bb: 318
}
repeated_foreign_message {
c: 219
}
repeated_foreign_message {
c: 319
}
repeated_import_message {
d: 220
}
repeated_import_message {
d: 320
}
repeated_nested_enum: BAR
repeated_nested_enum: BAZ
repeated_foreign_enum: FOREIGN_BAR
repeated_foreign_enum: FOREIGN_BAZ
repeated_import_enum: IMPORT_BAR
repeated_import_enum: IMPORT_BAZ
repeated_string_piece: "224"
repeated_string_piece: "324"
repeated_cord: "225"
repeated_cord: "325"
repeated_lazy_message {
bb: 227
}
repeated_lazy_message {
bb: 327
}
default_int32: 401
default_int64: 402
default_uint32: 403
default_uint64: 404
default_sint32: 405
default_sint64: 406
default_fixed32: 407
default_fixed64: 408
default_sfixed32: 409
default_sfixed64: 410
default_float: 411
default_double: 412
default_bool: false
default_string: "415"
default_bytes: "416"
default_nested_enum: FOO
default_foreign_enum: FOREIGN_FOO
default_import_enum: IMPORT_FOO
default_string_piece: "424"
default_cord: "425"
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/text_format_unittest_extensions_data.txt
0 → 100644
View file @
5af0b547
[protobuf_unittest.optional_int32_extension]: 101
[protobuf_unittest.optional_int64_extension]: 102
[protobuf_unittest.optional_uint32_extension]: 103
[protobuf_unittest.optional_uint64_extension]: 104
[protobuf_unittest.optional_sint32_extension]: 105
[protobuf_unittest.optional_sint64_extension]: 106
[protobuf_unittest.optional_fixed32_extension]: 107
[protobuf_unittest.optional_fixed64_extension]: 108
[protobuf_unittest.optional_sfixed32_extension]: 109
[protobuf_unittest.optional_sfixed64_extension]: 110
[protobuf_unittest.optional_float_extension]: 111
[protobuf_unittest.optional_double_extension]: 112
[protobuf_unittest.optional_bool_extension]: true
[protobuf_unittest.optional_string_extension]: "115"
[protobuf_unittest.optional_bytes_extension]: "116"
[protobuf_unittest.optionalgroup_extension] {
a: 117
}
[protobuf_unittest.optional_nested_message_extension] {
bb: 118
}
[protobuf_unittest.optional_foreign_message_extension] {
c: 119
}
[protobuf_unittest.optional_import_message_extension] {
d: 120
}
[protobuf_unittest.optional_nested_enum_extension]: BAZ
[protobuf_unittest.optional_foreign_enum_extension]: FOREIGN_BAZ
[protobuf_unittest.optional_import_enum_extension]: IMPORT_BAZ
[protobuf_unittest.optional_string_piece_extension]: "124"
[protobuf_unittest.optional_cord_extension]: "125"
[protobuf_unittest.optional_public_import_message_extension] {
e: 126
}
[protobuf_unittest.optional_lazy_message_extension] {
bb: 127
}
[protobuf_unittest.repeated_int32_extension]: 201
[protobuf_unittest.repeated_int32_extension]: 301
[protobuf_unittest.repeated_int64_extension]: 202
[protobuf_unittest.repeated_int64_extension]: 302
[protobuf_unittest.repeated_uint32_extension]: 203
[protobuf_unittest.repeated_uint32_extension]: 303
[protobuf_unittest.repeated_uint64_extension]: 204
[protobuf_unittest.repeated_uint64_extension]: 304
[protobuf_unittest.repeated_sint32_extension]: 205
[protobuf_unittest.repeated_sint32_extension]: 305
[protobuf_unittest.repeated_sint64_extension]: 206
[protobuf_unittest.repeated_sint64_extension]: 306
[protobuf_unittest.repeated_fixed32_extension]: 207
[protobuf_unittest.repeated_fixed32_extension]: 307
[protobuf_unittest.repeated_fixed64_extension]: 208
[protobuf_unittest.repeated_fixed64_extension]: 308
[protobuf_unittest.repeated_sfixed32_extension]: 209
[protobuf_unittest.repeated_sfixed32_extension]: 309
[protobuf_unittest.repeated_sfixed64_extension]: 210
[protobuf_unittest.repeated_sfixed64_extension]: 310
[protobuf_unittest.repeated_float_extension]: 211
[protobuf_unittest.repeated_float_extension]: 311
[protobuf_unittest.repeated_double_extension]: 212
[protobuf_unittest.repeated_double_extension]: 312
[protobuf_unittest.repeated_bool_extension]: true
[protobuf_unittest.repeated_bool_extension]: false
[protobuf_unittest.repeated_string_extension]: "215"
[protobuf_unittest.repeated_string_extension]: "315"
[protobuf_unittest.repeated_bytes_extension]: "216"
[protobuf_unittest.repeated_bytes_extension]: "316"
[protobuf_unittest.repeatedgroup_extension] {
a: 217
}
[protobuf_unittest.repeatedgroup_extension] {
a: 317
}
[protobuf_unittest.repeated_nested_message_extension] {
bb: 218
}
[protobuf_unittest.repeated_nested_message_extension] {
bb: 318
}
[protobuf_unittest.repeated_foreign_message_extension] {
c: 219
}
[protobuf_unittest.repeated_foreign_message_extension] {
c: 319
}
[protobuf_unittest.repeated_import_message_extension] {
d: 220
}
[protobuf_unittest.repeated_import_message_extension] {
d: 320
}
[protobuf_unittest.repeated_nested_enum_extension]: BAR
[protobuf_unittest.repeated_nested_enum_extension]: BAZ
[protobuf_unittest.repeated_foreign_enum_extension]: FOREIGN_BAR
[protobuf_unittest.repeated_foreign_enum_extension]: FOREIGN_BAZ
[protobuf_unittest.repeated_import_enum_extension]: IMPORT_BAR
[protobuf_unittest.repeated_import_enum_extension]: IMPORT_BAZ
[protobuf_unittest.repeated_string_piece_extension]: "224"
[protobuf_unittest.repeated_string_piece_extension]: "324"
[protobuf_unittest.repeated_cord_extension]: "225"
[protobuf_unittest.repeated_cord_extension]: "325"
[protobuf_unittest.repeated_lazy_message_extension] {
bb: 227
}
[protobuf_unittest.repeated_lazy_message_extension] {
bb: 327
}
[protobuf_unittest.default_int32_extension]: 401
[protobuf_unittest.default_int64_extension]: 402
[protobuf_unittest.default_uint32_extension]: 403
[protobuf_unittest.default_uint64_extension]: 404
[protobuf_unittest.default_sint32_extension]: 405
[protobuf_unittest.default_sint64_extension]: 406
[protobuf_unittest.default_fixed32_extension]: 407
[protobuf_unittest.default_fixed64_extension]: 408
[protobuf_unittest.default_sfixed32_extension]: 409
[protobuf_unittest.default_sfixed64_extension]: 410
[protobuf_unittest.default_float_extension]: 411
[protobuf_unittest.default_double_extension]: 412
[protobuf_unittest.default_bool_extension]: false
[protobuf_unittest.default_string_extension]: "415"
[protobuf_unittest.default_bytes_extension]: "416"
[protobuf_unittest.default_nested_enum_extension]: FOO
[protobuf_unittest.default_foreign_enum_extension]: FOREIGN_FOO
[protobuf_unittest.default_import_enum_extension]: IMPORT_FOO
[protobuf_unittest.default_string_piece_extension]: "424"
[protobuf_unittest.default_cord_extension]: "425"
python/compatibility_tests/v2.5.0/tests/google/protobuf/internal/wire_format_test.py
0 → 100755
View file @
5af0b547
#! /usr/bin/python
#
# Protocol Buffers - Google's data interchange format
# Copyright 2008 Google Inc. All rights reserved.
# http://code.google.com/p/protobuf/
#
# 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.
"""Test for google.protobuf.internal.wire_format."""
__author__
=
'robinson@google.com (Will Robinson)'
import
unittest
from
google.protobuf
import
message
from
google.protobuf.internal
import
wire_format
class
WireFormatTest
(
unittest
.
TestCase
):
def
testPackTag
(
self
):
field_number
=
0xabc
tag_type
=
2
self
.
assertEqual
((
field_number
<<
3
)
|
tag_type
,
wire_format
.
PackTag
(
field_number
,
tag_type
))
PackTag
=
wire_format
.
PackTag
# Number too high.
self
.
assertRaises
(
message
.
EncodeError
,
PackTag
,
field_number
,
6
)
# Number too low.
self
.
assertRaises
(
message
.
EncodeError
,
PackTag
,
field_number
,
-
1
)
def
testUnpackTag
(
self
):
# Test field numbers that will require various varint sizes.
for
expected_field_number
in
(
1
,
15
,
16
,
2047
,
2048
):
for
expected_wire_type
in
range
(
6
):
# Highest-numbered wiretype is 5.
field_number
,
wire_type
=
wire_format
.
UnpackTag
(
wire_format
.
PackTag
(
expected_field_number
,
expected_wire_type
))
self
.
assertEqual
(
expected_field_number
,
field_number
)
self
.
assertEqual
(
expected_wire_type
,
wire_type
)
self
.
assertRaises
(
TypeError
,
wire_format
.
UnpackTag
,
None
)
self
.
assertRaises
(
TypeError
,
wire_format
.
UnpackTag
,
'abc'
)
self
.
assertRaises
(
TypeError
,
wire_format
.
UnpackTag
,
0.0
)
self
.
assertRaises
(
TypeError
,
wire_format
.
UnpackTag
,
object
())
def
testZigZagEncode
(
self
):
Z
=
wire_format
.
ZigZagEncode
self
.
assertEqual
(
0
,
Z
(
0
))
self
.
assertEqual
(
1
,
Z
(
-
1
))
self
.
assertEqual
(
2
,
Z
(
1
))
self
.
assertEqual
(
3
,
Z
(
-
2
))
self
.
assertEqual
(
4
,
Z
(
2
))
self
.
assertEqual
(
0xfffffffe
,
Z
(
0x7fffffff
))
self
.
assertEqual
(
0xffffffff
,
Z
(
-
0x80000000
))
self
.
assertEqual
(
0xfffffffffffffffe
,
Z
(
0x7fffffffffffffff
))
self
.
assertEqual
(
0xffffffffffffffff
,
Z
(
-
0x8000000000000000
))
self
.
assertRaises
(
TypeError
,
Z
,
None
)
self
.
assertRaises
(
TypeError
,
Z
,
'abcd'
)
self
.
assertRaises
(
TypeError
,
Z
,
0.0
)
self
.
assertRaises
(
TypeError
,
Z
,
object
())
def
testZigZagDecode
(
self
):
Z
=
wire_format
.
ZigZagDecode
self
.
assertEqual
(
0
,
Z
(
0
))
self
.
assertEqual
(
-
1
,
Z
(
1
))
self
.
assertEqual
(
1
,
Z
(
2
))
self
.
assertEqual
(
-
2
,
Z
(
3
))
self
.
assertEqual
(
2
,
Z
(
4
))
self
.
assertEqual
(
0x7fffffff
,
Z
(
0xfffffffe
))
self
.
assertEqual
(
-
0x80000000
,
Z
(
0xffffffff
))
self
.
assertEqual
(
0x7fffffffffffffff
,
Z
(
0xfffffffffffffffe
))
self
.
assertEqual
(
-
0x8000000000000000
,
Z
(
0xffffffffffffffff
))
self
.
assertRaises
(
TypeError
,
Z
,
None
)
self
.
assertRaises
(
TypeError
,
Z
,
'abcd'
)
self
.
assertRaises
(
TypeError
,
Z
,
0.0
)
self
.
assertRaises
(
TypeError
,
Z
,
object
())
def
NumericByteSizeTestHelper
(
self
,
byte_size_fn
,
value
,
expected_value_size
):
# Use field numbers that cause various byte sizes for the tag information.
for
field_number
,
tag_bytes
in
((
15
,
1
),
(
16
,
2
),
(
2047
,
2
),
(
2048
,
3
)):
expected_size
=
expected_value_size
+
tag_bytes
actual_size
=
byte_size_fn
(
field_number
,
value
)
self
.
assertEqual
(
expected_size
,
actual_size
,
'byte_size_fn:
%
s, field_number:
%
d, value:
%
r
\n
'
'Expected:
%
d, Actual:
%
d'
%
(
byte_size_fn
,
field_number
,
value
,
expected_size
,
actual_size
))
def
testByteSizeFunctions
(
self
):
# Test all numeric *ByteSize() functions.
NUMERIC_ARGS
=
[
# Int32ByteSize().
[
wire_format
.
Int32ByteSize
,
0
,
1
],
[
wire_format
.
Int32ByteSize
,
127
,
1
],
[
wire_format
.
Int32ByteSize
,
128
,
2
],
[
wire_format
.
Int32ByteSize
,
-
1
,
10
],
# Int64ByteSize().
[
wire_format
.
Int64ByteSize
,
0
,
1
],
[
wire_format
.
Int64ByteSize
,
127
,
1
],
[
wire_format
.
Int64ByteSize
,
128
,
2
],
[
wire_format
.
Int64ByteSize
,
-
1
,
10
],
# UInt32ByteSize().
[
wire_format
.
UInt32ByteSize
,
0
,
1
],
[
wire_format
.
UInt32ByteSize
,
127
,
1
],
[
wire_format
.
UInt32ByteSize
,
128
,
2
],
[
wire_format
.
UInt32ByteSize
,
wire_format
.
UINT32_MAX
,
5
],
# UInt64ByteSize().
[
wire_format
.
UInt64ByteSize
,
0
,
1
],
[
wire_format
.
UInt64ByteSize
,
127
,
1
],
[
wire_format
.
UInt64ByteSize
,
128
,
2
],
[
wire_format
.
UInt64ByteSize
,
wire_format
.
UINT64_MAX
,
10
],
# SInt32ByteSize().
[
wire_format
.
SInt32ByteSize
,
0
,
1
],
[
wire_format
.
SInt32ByteSize
,
-
1
,
1
],
[
wire_format
.
SInt32ByteSize
,
1
,
1
],
[
wire_format
.
SInt32ByteSize
,
-
63
,
1
],
[
wire_format
.
SInt32ByteSize
,
63
,
1
],
[
wire_format
.
SInt32ByteSize
,
-
64
,
1
],
[
wire_format
.
SInt32ByteSize
,
64
,
2
],
# SInt64ByteSize().
[
wire_format
.
SInt64ByteSize
,
0
,
1
],
[
wire_format
.
SInt64ByteSize
,
-
1
,
1
],
[
wire_format
.
SInt64ByteSize
,
1
,
1
],
[
wire_format
.
SInt64ByteSize
,
-
63
,
1
],
[
wire_format
.
SInt64ByteSize
,
63
,
1
],
[
wire_format
.
SInt64ByteSize
,
-
64
,
1
],
[
wire_format
.
SInt64ByteSize
,
64
,
2
],
# Fixed32ByteSize().
[
wire_format
.
Fixed32ByteSize
,
0
,
4
],
[
wire_format
.
Fixed32ByteSize
,
wire_format
.
UINT32_MAX
,
4
],
# Fixed64ByteSize().
[
wire_format
.
Fixed64ByteSize
,
0
,
8
],
[
wire_format
.
Fixed64ByteSize
,
wire_format
.
UINT64_MAX
,
8
],
# SFixed32ByteSize().
[
wire_format
.
SFixed32ByteSize
,
0
,
4
],
[
wire_format
.
SFixed32ByteSize
,
wire_format
.
INT32_MIN
,
4
],
[
wire_format
.
SFixed32ByteSize
,
wire_format
.
INT32_MAX
,
4
],
# SFixed64ByteSize().
[
wire_format
.
SFixed64ByteSize
,
0
,
8
],
[
wire_format
.
SFixed64ByteSize
,
wire_format
.
INT64_MIN
,
8
],
[
wire_format
.
SFixed64ByteSize
,
wire_format
.
INT64_MAX
,
8
],
# FloatByteSize().
[
wire_format
.
FloatByteSize
,
0.0
,
4
],
[
wire_format
.
FloatByteSize
,
1000000000.0
,
4
],
[
wire_format
.
FloatByteSize
,
-
1000000000.0
,
4
],
# DoubleByteSize().
[
wire_format
.
DoubleByteSize
,
0.0
,
8
],
[
wire_format
.
DoubleByteSize
,
1000000000.0
,
8
],
[
wire_format
.
DoubleByteSize
,
-
1000000000.0
,
8
],
# BoolByteSize().
[
wire_format
.
BoolByteSize
,
False
,
1
],
[
wire_format
.
BoolByteSize
,
True
,
1
],
# EnumByteSize().
[
wire_format
.
EnumByteSize
,
0
,
1
],
[
wire_format
.
EnumByteSize
,
127
,
1
],
[
wire_format
.
EnumByteSize
,
128
,
2
],
[
wire_format
.
EnumByteSize
,
wire_format
.
UINT32_MAX
,
5
],
]
for
args
in
NUMERIC_ARGS
:
self
.
NumericByteSizeTestHelper
(
*
args
)
# Test strings and bytes.
for
byte_size_fn
in
(
wire_format
.
StringByteSize
,
wire_format
.
BytesByteSize
):
# 1 byte for tag, 1 byte for length, 3 bytes for contents.
self
.
assertEqual
(
5
,
byte_size_fn
(
10
,
'abc'
))
# 2 bytes for tag, 1 byte for length, 3 bytes for contents.
self
.
assertEqual
(
6
,
byte_size_fn
(
16
,
'abc'
))
# 2 bytes for tag, 2 bytes for length, 128 bytes for contents.
self
.
assertEqual
(
132
,
byte_size_fn
(
16
,
'a'
*
128
))
# Test UTF-8 string byte size calculation.
# 1 byte for tag, 1 byte for length, 8 bytes for content.
self
.
assertEqual
(
10
,
wire_format
.
StringByteSize
(
5
,
unicode
(
'
\xd0\xa2\xd0\xb5\xd1\x81\xd1\x82
'
,
'utf-8'
)))
class
MockMessage
(
object
):
def
__init__
(
self
,
byte_size
):
self
.
byte_size
=
byte_size
def
ByteSize
(
self
):
return
self
.
byte_size
message_byte_size
=
10
mock_message
=
MockMessage
(
byte_size
=
message_byte_size
)
# Test groups.
# (2 * 1) bytes for begin and end tags, plus message_byte_size.
self
.
assertEqual
(
2
+
message_byte_size
,
wire_format
.
GroupByteSize
(
1
,
mock_message
))
# (2 * 2) bytes for begin and end tags, plus message_byte_size.
self
.
assertEqual
(
4
+
message_byte_size
,
wire_format
.
GroupByteSize
(
16
,
mock_message
))
# Test messages.
# 1 byte for tag, plus 1 byte for length, plus contents.
self
.
assertEqual
(
2
+
mock_message
.
byte_size
,
wire_format
.
MessageByteSize
(
1
,
mock_message
))
# 2 bytes for tag, plus 1 byte for length, plus contents.
self
.
assertEqual
(
3
+
mock_message
.
byte_size
,
wire_format
.
MessageByteSize
(
16
,
mock_message
))
# 2 bytes for tag, plus 2 bytes for length, plus contents.
mock_message
.
byte_size
=
128
self
.
assertEqual
(
4
+
mock_message
.
byte_size
,
wire_format
.
MessageByteSize
(
16
,
mock_message
))
# Test message set item byte size.
# 4 bytes for tags, plus 1 byte for length, plus 1 byte for type_id,
# plus contents.
mock_message
.
byte_size
=
10
self
.
assertEqual
(
mock_message
.
byte_size
+
6
,
wire_format
.
MessageSetItemByteSize
(
1
,
mock_message
))
# 4 bytes for tags, plus 2 bytes for length, plus 1 byte for type_id,
# plus contents.
mock_message
.
byte_size
=
128
self
.
assertEqual
(
mock_message
.
byte_size
+
7
,
wire_format
.
MessageSetItemByteSize
(
1
,
mock_message
))
# 4 bytes for tags, plus 2 bytes for length, plus 2 byte for type_id,
# plus contents.
self
.
assertEqual
(
mock_message
.
byte_size
+
8
,
wire_format
.
MessageSetItemByteSize
(
128
,
mock_message
))
# Too-long varint.
self
.
assertRaises
(
message
.
EncodeError
,
wire_format
.
UInt64ByteSize
,
1
,
1
<<
128
)
if
__name__
==
'__main__'
:
unittest
.
main
()
tests.sh
View file @
5af0b547
...
...
@@ -62,7 +62,8 @@ build_cpp_distcheck() {
# List all files that should be included in the distribution package.
git ls-files |
grep
"^
\(
java
\|
python
\|
objectivec
\|
csharp
\|
js
\|
ruby
\|
php
\|
cmake
\|
examples
\)
"
|
\
grep
-v
".gitignore"
|
grep
-v
"java/compatibility_tests"
>
dist.lst
grep
-v
".gitignore"
|
grep
-v
"java/compatibility_tests"
|
\
grep
-v
"python/compatibility_tests"
>
dist.lst
# Unzip the dist tar file.
DIST
=
`
ls
*
.tar.gz
`
tar
-xf
$DIST
...
...
@@ -311,6 +312,16 @@ build_python_cpp() {
cd
..
}
build_python_compatibility
()
{
internal_build_cpp
# Use the unit-tests extraced from 2.5.0 to test the compatibilty.
cd
python/compatibility_tests/v2.5.0
# Test between 2.5.0 and the current version.
./test.sh 2.5.0
# Test between 3.0.0-beta-1 and the current version.
./test.sh 3.0.0-beta-1
}
build_ruby21
()
{
internal_build_cpp
# For conformance tests.
cd
ruby
&&
bash travis-test.sh ruby-2.1
&&
cd
..
...
...
@@ -513,6 +524,7 @@ Usage: $0 { cpp |
objectivec_cocoapods_integration |
python |
python_cpp |
python_compatibility |
ruby21 |
ruby22 |
jruby |
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment