Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(241)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/protobuf/java/compatibility_tests/v2.5.0/tests/src/main/java/com/google/protobuf/test/TestUtil.java

Issue 2495533002: third_party/protobuf: Update to HEAD (83d681ee2c) (Closed)
Patch Set: Make chrome settings proto generated file a component Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « third_party/protobuf/java/compatibility_tests/v2.5.0/tests/src/main/java/com/google/protobuf/test/TestBadIdentifiers.java ('k') | third_party/protobuf/java/compatibility_tests/v2.5.0/tests/src/main/java/com/google/protobuf/test/TextFormatTest.java » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Protocol Buffers - Google's data interchange format 1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2008 Google Inc. All rights reserved. 2 // Copyright 2008 Google Inc. All rights reserved.
3 // https://developers.google.com/protocol-buffers/ 3 // http://code.google.com/p/protobuf/
4 // 4 //
5 // Redistribution and use in source and binary forms, with or without 5 // Redistribution and use in source and binary forms, with or without
6 // modification, are permitted provided that the following conditions are 6 // modification, are permitted provided that the following conditions are
7 // met: 7 // met:
8 // 8 //
9 // * Redistributions of source code must retain the above copyright 9 // * Redistributions of source code must retain the above copyright
10 // notice, this list of conditions and the following disclaimer. 10 // notice, this list of conditions and the following disclaimer.
11 // * Redistributions in binary form must reproduce the above 11 // * Redistributions in binary form must reproduce the above
12 // copyright notice, this list of conditions and the following disclaimer 12 // copyright notice, this list of conditions and the following disclaimer
13 // in the documentation and/or other materials provided with the 13 // in the documentation and/or other materials provided with the
14 // distribution. 14 // distribution.
15 // * Neither the name of Google Inc. nor the names of its 15 // * Neither the name of Google Inc. nor the names of its
16 // contributors may be used to endorse or promote products derived from 16 // contributors may be used to endorse or promote products derived from
17 // this software without specific prior written permission. 17 // this software without specific prior written permission.
18 // 18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 30
31 package com.google.protobuf; 31 package com.google.protobuf.test;
32 import com.google.protobuf.*;
32 33
33 import static com.google.protobuf.UnittestLite.defaultBoolExtensionLite; 34 import protobuf_unittest.UnittestProto;
34 import static com.google.protobuf.UnittestLite.defaultBytesExtensionLite; 35
35 import static com.google.protobuf.UnittestLite.defaultCordExtensionLite;
36 import static com.google.protobuf.UnittestLite.defaultDoubleExtensionLite;
37 import static com.google.protobuf.UnittestLite.defaultFixed32ExtensionLite;
38 import static com.google.protobuf.UnittestLite.defaultFixed64ExtensionLite;
39 import static com.google.protobuf.UnittestLite.defaultFloatExtensionLite;
40 import static com.google.protobuf.UnittestLite.defaultForeignEnumExtensionLite;
41 import static com.google.protobuf.UnittestLite.defaultImportEnumExtensionLite;
42 import static com.google.protobuf.UnittestLite.defaultInt32ExtensionLite;
43 import static com.google.protobuf.UnittestLite.defaultInt64ExtensionLite;
44 import static com.google.protobuf.UnittestLite.defaultNestedEnumExtensionLite;
45 import static com.google.protobuf.UnittestLite.defaultSfixed32ExtensionLite;
46 import static com.google.protobuf.UnittestLite.defaultSfixed64ExtensionLite;
47 import static com.google.protobuf.UnittestLite.defaultSint32ExtensionLite;
48 import static com.google.protobuf.UnittestLite.defaultSint64ExtensionLite;
49 import static com.google.protobuf.UnittestLite.defaultStringExtensionLite;
50 import static com.google.protobuf.UnittestLite.defaultStringPieceExtensionLite;
51 import static com.google.protobuf.UnittestLite.defaultUint32ExtensionLite;
52 import static com.google.protobuf.UnittestLite.defaultUint64ExtensionLite;
53 import static com.google.protobuf.UnittestLite.oneofBytesExtensionLite;
54 import static com.google.protobuf.UnittestLite.oneofNestedMessageExtensionLite;
55 import static com.google.protobuf.UnittestLite.oneofStringExtensionLite;
56 import static com.google.protobuf.UnittestLite.oneofUint32ExtensionLite;
57 import static com.google.protobuf.UnittestLite.optionalBoolExtensionLite;
58 import static com.google.protobuf.UnittestLite.optionalBytesExtensionLite;
59 import static com.google.protobuf.UnittestLite.optionalCordExtensionLite;
60 import static com.google.protobuf.UnittestLite.optionalDoubleExtensionLite;
61 import static com.google.protobuf.UnittestLite.optionalFixed32ExtensionLite;
62 import static com.google.protobuf.UnittestLite.optionalFixed64ExtensionLite;
63 import static com.google.protobuf.UnittestLite.optionalFloatExtensionLite;
64 import static com.google.protobuf.UnittestLite.optionalForeignEnumExtensionLite;
65 import static com.google.protobuf.UnittestLite.optionalForeignMessageExtensionLi te;
66 import static com.google.protobuf.UnittestLite.optionalGroupExtensionLite;
67 import static com.google.protobuf.UnittestLite.optionalImportEnumExtensionLite;
68 import static com.google.protobuf.UnittestLite.optionalImportMessageExtensionLit e;
69 import static com.google.protobuf.UnittestLite.optionalInt32ExtensionLite;
70 import static com.google.protobuf.UnittestLite.optionalInt64ExtensionLite;
71 import static com.google.protobuf.UnittestLite.optionalLazyMessageExtensionLite;
72 import static com.google.protobuf.UnittestLite.optionalNestedEnumExtensionLite;
73 import static com.google.protobuf.UnittestLite.optionalNestedMessageExtensionLit e;
74 import static com.google.protobuf.UnittestLite.optionalPublicImportMessageExtens ionLite;
75 import static com.google.protobuf.UnittestLite.optionalSfixed32ExtensionLite;
76 import static com.google.protobuf.UnittestLite.optionalSfixed64ExtensionLite;
77 import static com.google.protobuf.UnittestLite.optionalSint32ExtensionLite;
78 import static com.google.protobuf.UnittestLite.optionalSint64ExtensionLite;
79 import static com.google.protobuf.UnittestLite.optionalStringExtensionLite;
80 import static com.google.protobuf.UnittestLite.optionalStringPieceExtensionLite;
81 import static com.google.protobuf.UnittestLite.optionalUint32ExtensionLite;
82 import static com.google.protobuf.UnittestLite.optionalUint64ExtensionLite;
83 import static com.google.protobuf.UnittestLite.packedBoolExtensionLite;
84 import static com.google.protobuf.UnittestLite.packedDoubleExtensionLite;
85 import static com.google.protobuf.UnittestLite.packedEnumExtensionLite;
86 import static com.google.protobuf.UnittestLite.packedFixed32ExtensionLite;
87 import static com.google.protobuf.UnittestLite.packedFixed64ExtensionLite;
88 import static com.google.protobuf.UnittestLite.packedFloatExtensionLite;
89 import static com.google.protobuf.UnittestLite.packedInt32ExtensionLite;
90 import static com.google.protobuf.UnittestLite.packedInt64ExtensionLite;
91 import static com.google.protobuf.UnittestLite.packedSfixed32ExtensionLite;
92 import static com.google.protobuf.UnittestLite.packedSfixed64ExtensionLite;
93 import static com.google.protobuf.UnittestLite.packedSint32ExtensionLite;
94 import static com.google.protobuf.UnittestLite.packedSint64ExtensionLite;
95 import static com.google.protobuf.UnittestLite.packedUint32ExtensionLite;
96 import static com.google.protobuf.UnittestLite.packedUint64ExtensionLite;
97 import static com.google.protobuf.UnittestLite.repeatedBoolExtensionLite;
98 import static com.google.protobuf.UnittestLite.repeatedBytesExtensionLite;
99 import static com.google.protobuf.UnittestLite.repeatedCordExtensionLite;
100 import static com.google.protobuf.UnittestLite.repeatedDoubleExtensionLite;
101 import static com.google.protobuf.UnittestLite.repeatedFixed32ExtensionLite;
102 import static com.google.protobuf.UnittestLite.repeatedFixed64ExtensionLite;
103 import static com.google.protobuf.UnittestLite.repeatedFloatExtensionLite;
104 import static com.google.protobuf.UnittestLite.repeatedForeignEnumExtensionLite;
105 import static com.google.protobuf.UnittestLite.repeatedForeignMessageExtensionLi te;
106 import static com.google.protobuf.UnittestLite.repeatedGroupExtensionLite;
107 import static com.google.protobuf.UnittestLite.repeatedImportEnumExtensionLite;
108 import static com.google.protobuf.UnittestLite.repeatedImportMessageExtensionLit e;
109 import static com.google.protobuf.UnittestLite.repeatedInt32ExtensionLite;
110 import static com.google.protobuf.UnittestLite.repeatedInt64ExtensionLite;
111 import static com.google.protobuf.UnittestLite.repeatedLazyMessageExtensionLite;
112 import static com.google.protobuf.UnittestLite.repeatedNestedEnumExtensionLite;
113 import static com.google.protobuf.UnittestLite.repeatedNestedMessageExtensionLit e;
114 import static com.google.protobuf.UnittestLite.repeatedSfixed32ExtensionLite;
115 import static com.google.protobuf.UnittestLite.repeatedSfixed64ExtensionLite;
116 import static com.google.protobuf.UnittestLite.repeatedSint32ExtensionLite;
117 import static com.google.protobuf.UnittestLite.repeatedSint64ExtensionLite;
118 import static com.google.protobuf.UnittestLite.repeatedStringExtensionLite;
119 import static com.google.protobuf.UnittestLite.repeatedStringPieceExtensionLite;
120 import static com.google.protobuf.UnittestLite.repeatedUint32ExtensionLite;
121 import static com.google.protobuf.UnittestLite.repeatedUint64ExtensionLite;
122 import static protobuf_unittest.UnittestProto.OptionalGroup_extension;
123 import static protobuf_unittest.UnittestProto.RepeatedGroup_extension;
124 import static protobuf_unittest.UnittestProto.defaultBoolExtension;
125 import static protobuf_unittest.UnittestProto.defaultBytesExtension;
126 import static protobuf_unittest.UnittestProto.defaultCordExtension;
127 import static protobuf_unittest.UnittestProto.defaultDoubleExtension;
128 import static protobuf_unittest.UnittestProto.defaultFixed32Extension;
129 import static protobuf_unittest.UnittestProto.defaultFixed64Extension;
130 import static protobuf_unittest.UnittestProto.defaultFloatExtension;
131 import static protobuf_unittest.UnittestProto.defaultForeignEnumExtension;
132 import static protobuf_unittest.UnittestProto.defaultImportEnumExtension;
133 // The static imports are to avoid 100+ char lines. The following is roughly eq uivalent to 36 // The static imports are to avoid 100+ char lines. The following is roughly eq uivalent to
134 // import static protobuf_unittest.UnittestProto.*; 37 // import static protobuf_unittest.UnittestProto.*;
135 import static protobuf_unittest.UnittestProto.defaultInt32Extension; 38 import static protobuf_unittest.UnittestProto.defaultInt32Extension;
136 import static protobuf_unittest.UnittestProto.defaultInt64Extension; 39 import static protobuf_unittest.UnittestProto.defaultInt64Extension;
137 import static protobuf_unittest.UnittestProto.defaultNestedEnumExtension; 40 import static protobuf_unittest.UnittestProto.defaultUint32Extension;
41 import static protobuf_unittest.UnittestProto.defaultUint64Extension;
42 import static protobuf_unittest.UnittestProto.defaultSint32Extension;
43 import static protobuf_unittest.UnittestProto.defaultSint64Extension;
44 import static protobuf_unittest.UnittestProto.defaultFixed32Extension;
45 import static protobuf_unittest.UnittestProto.defaultFixed64Extension;
138 import static protobuf_unittest.UnittestProto.defaultSfixed32Extension; 46 import static protobuf_unittest.UnittestProto.defaultSfixed32Extension;
139 import static protobuf_unittest.UnittestProto.defaultSfixed64Extension; 47 import static protobuf_unittest.UnittestProto.defaultSfixed64Extension;
140 import static protobuf_unittest.UnittestProto.defaultSint32Extension; 48 import static protobuf_unittest.UnittestProto.defaultFloatExtension;
141 import static protobuf_unittest.UnittestProto.defaultSint64Extension; 49 import static protobuf_unittest.UnittestProto.defaultDoubleExtension;
50 import static protobuf_unittest.UnittestProto.defaultBoolExtension;
142 import static protobuf_unittest.UnittestProto.defaultStringExtension; 51 import static protobuf_unittest.UnittestProto.defaultStringExtension;
52 import static protobuf_unittest.UnittestProto.defaultBytesExtension;
53 import static protobuf_unittest.UnittestProto.defaultNestedEnumExtension;
54 import static protobuf_unittest.UnittestProto.defaultForeignEnumExtension;
55 import static protobuf_unittest.UnittestProto.defaultImportEnumExtension;
143 import static protobuf_unittest.UnittestProto.defaultStringPieceExtension; 56 import static protobuf_unittest.UnittestProto.defaultStringPieceExtension;
144 import static protobuf_unittest.UnittestProto.defaultUint32Extension; 57 import static protobuf_unittest.UnittestProto.defaultCordExtension;
145 import static protobuf_unittest.UnittestProto.defaultUint64Extension; 58
146 import static protobuf_unittest.UnittestProto.oneofBytesExtension; 59 import static protobuf_unittest.UnittestProto.optionalInt32Extension;
147 import static protobuf_unittest.UnittestProto.oneofNestedMessageExtension; 60 import static protobuf_unittest.UnittestProto.optionalInt64Extension;
148 import static protobuf_unittest.UnittestProto.oneofStringExtension; 61 import static protobuf_unittest.UnittestProto.optionalUint32Extension;
149 import static protobuf_unittest.UnittestProto.oneofUint32Extension; 62 import static protobuf_unittest.UnittestProto.optionalUint64Extension;
150 import static protobuf_unittest.UnittestProto.optionalBoolExtension; 63 import static protobuf_unittest.UnittestProto.optionalSint32Extension;
151 import static protobuf_unittest.UnittestProto.optionalBytesExtension; 64 import static protobuf_unittest.UnittestProto.optionalSint64Extension;
152 import static protobuf_unittest.UnittestProto.optionalCordExtension;
153 import static protobuf_unittest.UnittestProto.optionalDoubleExtension;
154 import static protobuf_unittest.UnittestProto.optionalFixed32Extension; 65 import static protobuf_unittest.UnittestProto.optionalFixed32Extension;
155 import static protobuf_unittest.UnittestProto.optionalFixed64Extension; 66 import static protobuf_unittest.UnittestProto.optionalFixed64Extension;
67 import static protobuf_unittest.UnittestProto.optionalSfixed32Extension;
68 import static protobuf_unittest.UnittestProto.optionalSfixed64Extension;
156 import static protobuf_unittest.UnittestProto.optionalFloatExtension; 69 import static protobuf_unittest.UnittestProto.optionalFloatExtension;
70 import static protobuf_unittest.UnittestProto.optionalDoubleExtension;
71 import static protobuf_unittest.UnittestProto.optionalBoolExtension;
72 import static protobuf_unittest.UnittestProto.optionalStringExtension;
73 import static protobuf_unittest.UnittestProto.optionalBytesExtension;
74 import static protobuf_unittest.UnittestProto.optionalGroupExtension;
75 import static protobuf_unittest.UnittestProto.optionalCordExtension;
157 import static protobuf_unittest.UnittestProto.optionalForeignEnumExtension; 76 import static protobuf_unittest.UnittestProto.optionalForeignEnumExtension;
158 import static protobuf_unittest.UnittestProto.optionalForeignMessageExtension; 77 import static protobuf_unittest.UnittestProto.optionalForeignMessageExtension;
159 import static protobuf_unittest.UnittestProto.optionalGroupExtension;
160 import static protobuf_unittest.UnittestProto.optionalImportEnumExtension; 78 import static protobuf_unittest.UnittestProto.optionalImportEnumExtension;
161 import static protobuf_unittest.UnittestProto.optionalImportMessageExtension; 79 import static protobuf_unittest.UnittestProto.optionalImportMessageExtension;
162 import static protobuf_unittest.UnittestProto.optionalInt32Extension;
163 import static protobuf_unittest.UnittestProto.optionalInt64Extension;
164 import static protobuf_unittest.UnittestProto.optionalLazyMessageExtension;
165 import static protobuf_unittest.UnittestProto.optionalNestedEnumExtension; 80 import static protobuf_unittest.UnittestProto.optionalNestedEnumExtension;
166 import static protobuf_unittest.UnittestProto.optionalNestedMessageExtension; 81 import static protobuf_unittest.UnittestProto.optionalNestedMessageExtension;
167 import static protobuf_unittest.UnittestProto.optionalPublicImportMessageExtensi on; 82 import static protobuf_unittest.UnittestProto.optionalPublicImportMessageExtensi on;
168 import static protobuf_unittest.UnittestProto.optionalSfixed32Extension; 83 import static protobuf_unittest.UnittestProto.optionalLazyMessageExtension;
169 import static protobuf_unittest.UnittestProto.optionalSfixed64Extension;
170 import static protobuf_unittest.UnittestProto.optionalSint32Extension;
171 import static protobuf_unittest.UnittestProto.optionalSint64Extension;
172 import static protobuf_unittest.UnittestProto.optionalStringExtension;
173 import static protobuf_unittest.UnittestProto.optionalStringPieceExtension; 84 import static protobuf_unittest.UnittestProto.optionalStringPieceExtension;
174 import static protobuf_unittest.UnittestProto.optionalUint32Extension; 85
175 import static protobuf_unittest.UnittestProto.optionalUint64Extension; 86 import static protobuf_unittest.UnittestProto.repeatedInt32Extension;
176 import static protobuf_unittest.UnittestProto.packedBoolExtension; 87 import static protobuf_unittest.UnittestProto.repeatedInt64Extension;
177 import static protobuf_unittest.UnittestProto.packedDoubleExtension; 88 import static protobuf_unittest.UnittestProto.repeatedUint32Extension;
178 import static protobuf_unittest.UnittestProto.packedEnumExtension; 89 import static protobuf_unittest.UnittestProto.repeatedUint64Extension;
90 import static protobuf_unittest.UnittestProto.repeatedSint32Extension;
91 import static protobuf_unittest.UnittestProto.repeatedSint64Extension;
92 import static protobuf_unittest.UnittestProto.repeatedFixed32Extension;
93 import static protobuf_unittest.UnittestProto.repeatedFixed64Extension;
94 import static protobuf_unittest.UnittestProto.repeatedSfixed32Extension;
95 import static protobuf_unittest.UnittestProto.repeatedSfixed64Extension;
96 import static protobuf_unittest.UnittestProto.repeatedFloatExtension;
97 import static protobuf_unittest.UnittestProto.repeatedDoubleExtension;
98 import static protobuf_unittest.UnittestProto.repeatedBoolExtension;
99 import static protobuf_unittest.UnittestProto.repeatedStringExtension;
100 import static protobuf_unittest.UnittestProto.repeatedBytesExtension;
101 import static protobuf_unittest.UnittestProto.repeatedGroupExtension;
102 import static protobuf_unittest.UnittestProto.repeatedNestedMessageExtension;
103 import static protobuf_unittest.UnittestProto.repeatedForeignMessageExtension;
104 import static protobuf_unittest.UnittestProto.repeatedImportMessageExtension;
105 import static protobuf_unittest.UnittestProto.repeatedLazyMessageExtension;
106 import static protobuf_unittest.UnittestProto.repeatedNestedEnumExtension;
107 import static protobuf_unittest.UnittestProto.repeatedForeignEnumExtension;
108 import static protobuf_unittest.UnittestProto.repeatedImportEnumExtension;
109 import static protobuf_unittest.UnittestProto.repeatedStringPieceExtension;
110 import static protobuf_unittest.UnittestProto.repeatedCordExtension;
111
112 import static protobuf_unittest.UnittestProto.OptionalGroup_extension;
113 import static protobuf_unittest.UnittestProto.RepeatedGroup_extension;
114
115 import static protobuf_unittest.UnittestProto.packedInt32Extension;
116 import static protobuf_unittest.UnittestProto.packedInt64Extension;
117 import static protobuf_unittest.UnittestProto.packedUint32Extension;
118 import static protobuf_unittest.UnittestProto.packedUint64Extension;
119 import static protobuf_unittest.UnittestProto.packedSint32Extension;
120 import static protobuf_unittest.UnittestProto.packedSint64Extension;
179 import static protobuf_unittest.UnittestProto.packedFixed32Extension; 121 import static protobuf_unittest.UnittestProto.packedFixed32Extension;
180 import static protobuf_unittest.UnittestProto.packedFixed64Extension; 122 import static protobuf_unittest.UnittestProto.packedFixed64Extension;
181 import static protobuf_unittest.UnittestProto.packedFloatExtension;
182 import static protobuf_unittest.UnittestProto.packedInt32Extension;
183 import static protobuf_unittest.UnittestProto.packedInt64Extension;
184 import static protobuf_unittest.UnittestProto.packedSfixed32Extension; 123 import static protobuf_unittest.UnittestProto.packedSfixed32Extension;
185 import static protobuf_unittest.UnittestProto.packedSfixed64Extension; 124 import static protobuf_unittest.UnittestProto.packedSfixed64Extension;
186 import static protobuf_unittest.UnittestProto.packedSint32Extension; 125 import static protobuf_unittest.UnittestProto.packedFloatExtension;
187 import static protobuf_unittest.UnittestProto.packedSint64Extension; 126 import static protobuf_unittest.UnittestProto.packedDoubleExtension;
188 import static protobuf_unittest.UnittestProto.packedUint32Extension; 127 import static protobuf_unittest.UnittestProto.packedBoolExtension;
189 import static protobuf_unittest.UnittestProto.packedUint64Extension; 128 import static protobuf_unittest.UnittestProto.packedEnumExtension;
190 import static protobuf_unittest.UnittestProto.repeatedBoolExtension;
191 import static protobuf_unittest.UnittestProto.repeatedBytesExtension;
192 import static protobuf_unittest.UnittestProto.repeatedCordExtension;
193 import static protobuf_unittest.UnittestProto.repeatedDoubleExtension;
194 import static protobuf_unittest.UnittestProto.repeatedFixed32Extension;
195 import static protobuf_unittest.UnittestProto.repeatedFixed64Extension;
196 import static protobuf_unittest.UnittestProto.repeatedFloatExtension;
197 import static protobuf_unittest.UnittestProto.repeatedForeignEnumExtension;
198 import static protobuf_unittest.UnittestProto.repeatedForeignMessageExtension;
199 import static protobuf_unittest.UnittestProto.repeatedGroupExtension;
200 import static protobuf_unittest.UnittestProto.repeatedImportEnumExtension;
201 import static protobuf_unittest.UnittestProto.repeatedImportMessageExtension;
202 import static protobuf_unittest.UnittestProto.repeatedInt32Extension;
203 import static protobuf_unittest.UnittestProto.repeatedInt64Extension;
204 import static protobuf_unittest.UnittestProto.repeatedLazyMessageExtension;
205 import static protobuf_unittest.UnittestProto.repeatedNestedEnumExtension;
206 import static protobuf_unittest.UnittestProto.repeatedNestedMessageExtension;
207 import static protobuf_unittest.UnittestProto.repeatedSfixed32Extension;
208 import static protobuf_unittest.UnittestProto.repeatedSfixed64Extension;
209 import static protobuf_unittest.UnittestProto.repeatedSint32Extension;
210 import static protobuf_unittest.UnittestProto.repeatedSint64Extension;
211 import static protobuf_unittest.UnittestProto.repeatedStringExtension;
212 import static protobuf_unittest.UnittestProto.repeatedStringPieceExtension;
213 import static protobuf_unittest.UnittestProto.repeatedUint32Extension;
214 import static protobuf_unittest.UnittestProto.repeatedUint64Extension;
215 129
216 import com.google.protobuf.UnittestImportLite.ImportEnumLite; 130
217 import com.google.protobuf.UnittestLite.ForeignEnumLite;
218 import com.google.protobuf.UnittestLite.TestAllExtensionsLiteOrBuilder;
219 import com.google.protobuf.UnittestLite.TestAllTypesLite;
220 import com.google.protobuf.UnittestLite.TestPackedExtensionsLite;
221 import com.google.protobuf.test.UnittestImport.ImportEnum;
222 import com.google.protobuf.test.UnittestImport.ImportMessage;
223 import com.google.protobuf.test.UnittestImportPublic.PublicImportMessage;
224 import protobuf_unittest.UnittestProto;
225 import protobuf_unittest.UnittestProto.ForeignEnum;
226 import protobuf_unittest.UnittestProto.ForeignMessage;
227 import protobuf_unittest.UnittestProto.TestAllExtensions; 131 import protobuf_unittest.UnittestProto.TestAllExtensions;
228 import protobuf_unittest.UnittestProto.TestAllExtensionsOrBuilder; 132 import protobuf_unittest.UnittestProto.TestAllExtensionsOrBuilder;
229 import protobuf_unittest.UnittestProto.TestAllTypes; 133 import protobuf_unittest.UnittestProto.TestAllTypes;
230 import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder; 134 import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder;
231 import protobuf_unittest.UnittestProto.TestOneof2;
232 import protobuf_unittest.UnittestProto.TestPackedExtensions; 135 import protobuf_unittest.UnittestProto.TestPackedExtensions;
233 import protobuf_unittest.UnittestProto.TestPackedTypes; 136 import protobuf_unittest.UnittestProto.TestPackedTypes;
234 import protobuf_unittest.UnittestProto.TestUnpackedTypes; 137 import protobuf_unittest.UnittestProto.TestUnpackedTypes;
138 import protobuf_unittest.UnittestProto.ForeignMessage;
139 import protobuf_unittest.UnittestProto.ForeignEnum;
140 import com.google.protobuf.test.UnittestImport.ImportEnum;
141 import com.google.protobuf.test.UnittestImport.ImportMessage;
142 import com.google.protobuf.test.UnittestImportPublic.PublicImportMessage;
235 143
236 import junit.framework.Assert; 144 import junit.framework.Assert;
237 145
238 import java.io.File; 146 import java.io.File;
239 import java.io.IOException; 147 import java.io.IOException;
240 import java.io.RandomAccessFile; 148 import java.io.RandomAccessFile;
241 149
242 /** 150 /**
243 * Contains methods for setting all fields of {@code TestAllTypes} to 151 * Contains methods for setting all fields of {@code TestAllTypes} to
244 * some values as well as checking that all the fields are set to those values. 152 * some values as well as checking that all the fields are set to those values.
245 * These are useful for testing various protocol message features, e.g. 153 * These are useful for testing various protocol message features, e.g.
246 * set all fields of a message, serialize it, parse it, and check that all 154 * set all fields of a message, serialize it, parse it, and check that all
247 * fields are set. 155 * fields are set.
248 * 156 *
249 * <p>This code is not to be used outside of {@code com.google.protobuf} and 157 * <p>This code is not to be used outside of {@code com.google.protobuf} and
250 * subpackages. 158 * subpackages.
251 * 159 *
252 * @author kenton@google.com Kenton Varda 160 * @author kenton@google.com Kenton Varda
253 */ 161 */
254 public final class TestUtil { 162 public final class TestUtil {
255 private TestUtil() {} 163 private TestUtil() {}
256 164
257 /** Helper to convert a String to ByteString. */ 165 /** Helper to convert a String to ByteString. */
258 static ByteString toBytes(String str) { 166 static ByteString toBytes(String str) {
259 return ByteString.copyFrom(str.getBytes(Internal.UTF_8)); 167 try {
168 return ByteString.copyFrom(str.getBytes("UTF-8"));
169 } catch(java.io.UnsupportedEncodingException e) {
170 throw new RuntimeException("UTF-8 not supported.", e);
171 }
260 } 172 }
261 173
262 /** 174 /**
263 * Get a {@code TestAllTypes} with all fields set as they would be by 175 * Get a {@code TestAllTypes} with all fields set as they would be by
264 * {@link #setAllFields(TestAllTypes.Builder)}. 176 * {@link #setAllFields(TestAllTypes.Builder)}.
265 */ 177 */
266 public static TestAllTypes getAllSet() { 178 public static TestAllTypes getAllSet() {
267 TestAllTypes.Builder builder = TestAllTypes.newBuilder(); 179 TestAllTypes.Builder builder = TestAllTypes.newBuilder();
268 setAllFields(builder); 180 setAllFields(builder);
269 return builder.build(); 181 return builder.build();
(...skipping 166 matching lines...) Expand 10 before | Expand all | Expand 10 after
436 message.setDefaultBool (false); 348 message.setDefaultBool (false);
437 message.setDefaultString ("415"); 349 message.setDefaultString ("415");
438 message.setDefaultBytes (toBytes("416")); 350 message.setDefaultBytes (toBytes("416"));
439 351
440 message.setDefaultNestedEnum (TestAllTypes.NestedEnum.FOO); 352 message.setDefaultNestedEnum (TestAllTypes.NestedEnum.FOO);
441 message.setDefaultForeignEnum(ForeignEnum.FOREIGN_FOO); 353 message.setDefaultForeignEnum(ForeignEnum.FOREIGN_FOO);
442 message.setDefaultImportEnum (ImportEnum.IMPORT_FOO); 354 message.setDefaultImportEnum (ImportEnum.IMPORT_FOO);
443 355
444 message.setDefaultStringPiece("424"); 356 message.setDefaultStringPiece("424");
445 message.setDefaultCord("425"); 357 message.setDefaultCord("425");
446
447 message.setOneofUint32(601);
448 message.setOneofNestedMessage(
449 TestAllTypes.NestedMessage.newBuilder().setBb(602).build());
450 message.setOneofString("603");
451 message.setOneofBytes(toBytes("604"));
452 } 358 }
453 359
454 // ------------------------------------------------------------------- 360 // -------------------------------------------------------------------
455 361
456 /** 362 /**
457 * Modify the repeated fields of {@code message} to contain the values 363 * Modify the repeated fields of {@code message} to contain the values
458 * expected by {@code assertRepeatedFieldsModified()}. 364 * expected by {@code assertRepeatedFieldsModified()}.
459 */ 365 */
460 public static void modifyRepeatedFields(TestAllTypes.Builder message) { 366 public static void modifyRepeatedFields(TestAllTypes.Builder message) {
461 message.setRepeatedInt32 (1, 501); 367 message.setRepeatedInt32 (1, 501);
(...skipping 229 matching lines...) Expand 10 before | Expand all | Expand 10 after
691 Assert.assertEquals(false, message.getDefaultBool ()); 597 Assert.assertEquals(false, message.getDefaultBool ());
692 Assert.assertEquals("415", message.getDefaultString ()); 598 Assert.assertEquals("415", message.getDefaultString ());
693 Assert.assertEquals(toBytes("416"), message.getDefaultBytes()); 599 Assert.assertEquals(toBytes("416"), message.getDefaultBytes());
694 600
695 Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getDefaultNestedEnu m ()); 601 Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getDefaultNestedEnu m ());
696 Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getDefaultForeignEnum() ); 602 Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getDefaultForeignEnum() );
697 Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getDefaultImportEnum()); 603 Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getDefaultImportEnum());
698 604
699 Assert.assertEquals("424", message.getDefaultStringPiece()); 605 Assert.assertEquals("424", message.getDefaultStringPiece());
700 Assert.assertEquals("425", message.getDefaultCord()); 606 Assert.assertEquals("425", message.getDefaultCord());
701
702 Assert.assertEquals(TestAllTypes.OneofFieldCase.ONEOF_BYTES, message.getOneo fFieldCase());
703 Assert.assertFalse(message.hasOneofUint32());
704 Assert.assertFalse(message.hasOneofNestedMessage());
705 Assert.assertFalse(message.hasOneofString());
706 Assert.assertTrue(message.hasOneofBytes());
707
708 Assert.assertEquals(toBytes("604"), message.getOneofBytes());
709 } 607 }
710 608
711 // ------------------------------------------------------------------- 609 // -------------------------------------------------------------------
712 /** 610 /**
713 * Assert (using {@code junit.framework.Assert}} that all fields of 611 * Assert (using {@code junit.framework.Assert}} that all fields of
714 * {@code message} are cleared, and that getting the fields returns their 612 * {@code message} are cleared, and that getting the fields returns their
715 * default values. 613 * default values.
716 */ 614 */
717 public static void assertClear(TestAllTypesOrBuilder message) { 615 public static void assertClear(TestAllTypesOrBuilder message) {
718 // hasBlah() should initially be false for all optional fields. 616 // hasBlah() should initially be false for all optional fields.
(...skipping 134 matching lines...) Expand 10 before | Expand all | Expand 10 after
853 Assert.assertEquals(true , message.getDefaultBool ()); 751 Assert.assertEquals(true , message.getDefaultBool ());
854 Assert.assertEquals("hello", message.getDefaultString ()); 752 Assert.assertEquals("hello", message.getDefaultString ());
855 Assert.assertEquals(toBytes("world"), message.getDefaultBytes()); 753 Assert.assertEquals(toBytes("world"), message.getDefaultBytes());
856 754
857 Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getDefaultNestedEnu m ()); 755 Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getDefaultNestedEnu m ());
858 Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getDefaultForeignEnum() ); 756 Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getDefaultForeignEnum() );
859 Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getDefaultImportEnum()); 757 Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getDefaultImportEnum());
860 758
861 Assert.assertEquals("abc", message.getDefaultStringPiece()); 759 Assert.assertEquals("abc", message.getDefaultStringPiece());
862 Assert.assertEquals("123", message.getDefaultCord()); 760 Assert.assertEquals("123", message.getDefaultCord());
863
864 Assert.assertFalse(message.hasOneofUint32());
865 Assert.assertFalse(message.hasOneofNestedMessage());
866 Assert.assertFalse(message.hasOneofString());
867 Assert.assertFalse(message.hasOneofBytes());
868 } 761 }
869 762
870 // ------------------------------------------------------------------- 763 // -------------------------------------------------------------------
871 764
872 /** 765 /**
873 * Assert (using {@code junit.framework.Assert}} that all fields of 766 * Assert (using {@code junit.framework.Assert}} that all fields of
874 * {@code message} are set to the values assigned by {@code setAllFields} 767 * {@code message} are set to the values assigned by {@code setAllFields}
875 * followed by {@code modifyRepeatedFields}. 768 * followed by {@code modifyRepeatedFields}.
876 */ 769 */
877 public static void assertRepeatedFieldsModified( 770 public static void assertRepeatedFieldsModified(
(...skipping 288 matching lines...) Expand 10 before | Expand all | Expand 10 after
1166 private static void assertEqualsExactType(TestAllTypes.NestedEnum a, 1059 private static void assertEqualsExactType(TestAllTypes.NestedEnum a,
1167 TestAllTypes.NestedEnum b) { 1060 TestAllTypes.NestedEnum b) {
1168 Assert.assertEquals(a, b); 1061 Assert.assertEquals(a, b);
1169 } 1062 }
1170 private static void assertEqualsExactType(ForeignEnum a, ForeignEnum b) { 1063 private static void assertEqualsExactType(ForeignEnum a, ForeignEnum b) {
1171 Assert.assertEquals(a, b); 1064 Assert.assertEquals(a, b);
1172 } 1065 }
1173 private static void assertEqualsExactType(ImportEnum a, ImportEnum b) { 1066 private static void assertEqualsExactType(ImportEnum a, ImportEnum b) {
1174 Assert.assertEquals(a, b); 1067 Assert.assertEquals(a, b);
1175 } 1068 }
1176 private static void assertEqualsExactType(TestAllTypesLite.NestedEnum a,
1177 TestAllTypesLite.NestedEnum b) {
1178 Assert.assertEquals(a, b);
1179 }
1180 private static void assertEqualsExactType(ForeignEnumLite a,
1181 ForeignEnumLite b) {
1182 Assert.assertEquals(a, b);
1183 }
1184 private static void assertEqualsExactType(ImportEnumLite a,
1185 ImportEnumLite b) {
1186 Assert.assertEquals(a, b);
1187 }
1188
1189 /** 1069 /**
1190 * Get an unmodifiable {@link ExtensionRegistry} containing all the 1070 * Get an unmodifiable {@link ExtensionRegistry} containing all the
1191 * extensions of {@code TestAllExtensions}. 1071 * extensions of {@code TestAllExtensions}.
1192 */ 1072 */
1193 public static ExtensionRegistry getExtensionRegistry() { 1073 public static ExtensionRegistry getExtensionRegistry() {
1194 ExtensionRegistry registry = ExtensionRegistry.newInstance(); 1074 ExtensionRegistry registry = ExtensionRegistry.newInstance();
1195 registerAllExtensions(registry); 1075 registerAllExtensions(registry);
1196 return registry.getUnmodifiable(); 1076 return registry.getUnmodifiable();
1197 } 1077 }
1198 1078
1079
1199 /** 1080 /**
1200 * Register all of {@code TestAllExtensions}'s extensions with the 1081 * Register all of {@code TestAllExtensions}'s extensions with the
1201 * given {@link ExtensionRegistry}. 1082 * given {@link ExtensionRegistry}.
1202 */ 1083 */
1203 public static void registerAllExtensions(ExtensionRegistry registry) { 1084 public static void registerAllExtensions(ExtensionRegistry registry) {
1204 UnittestProto.registerAllExtensions(registry); 1085 UnittestProto.registerAllExtensions(registry);
1205 TestUtilLite.registerAllExtensionsLite(registry);
1206 } 1086 }
1207 1087
1088
1208 /** 1089 /**
1209 * Set every field of {@code message} to the values expected by 1090 * Set every field of {@code message} to the values expected by
1210 * {@code assertAllExtensionsSet()}. 1091 * {@code assertAllExtensionsSet()}.
1211 */ 1092 */
1212 public static void setAllExtensions(TestAllExtensions.Builder message) { 1093 public static void setAllExtensions(TestAllExtensions.Builder message) {
1213 message.setExtension(optionalInt32Extension , 101); 1094 message.setExtension(optionalInt32Extension , 101);
1214 message.setExtension(optionalInt64Extension , 102L); 1095 message.setExtension(optionalInt64Extension , 102L);
1215 message.setExtension(optionalUint32Extension , 103); 1096 message.setExtension(optionalUint32Extension , 103);
1216 message.setExtension(optionalUint64Extension , 104L); 1097 message.setExtension(optionalUint64Extension , 104L);
1217 message.setExtension(optionalSint32Extension , 105); 1098 message.setExtension(optionalSint32Extension , 105);
(...skipping 116 matching lines...) Expand 10 before | Expand all | Expand 10 after
1334 message.setExtension(defaultBoolExtension , false); 1215 message.setExtension(defaultBoolExtension , false);
1335 message.setExtension(defaultStringExtension , "415"); 1216 message.setExtension(defaultStringExtension , "415");
1336 message.setExtension(defaultBytesExtension , toBytes("416")); 1217 message.setExtension(defaultBytesExtension , toBytes("416"));
1337 1218
1338 message.setExtension(defaultNestedEnumExtension, TestAllTypes.NestedEnum.FOO ); 1219 message.setExtension(defaultNestedEnumExtension, TestAllTypes.NestedEnum.FOO );
1339 message.setExtension(defaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO); 1220 message.setExtension(defaultForeignEnumExtension, ForeignEnum.FOREIGN_FOO);
1340 message.setExtension(defaultImportEnumExtension, ImportEnum.IMPORT_FOO); 1221 message.setExtension(defaultImportEnumExtension, ImportEnum.IMPORT_FOO);
1341 1222
1342 message.setExtension(defaultStringPieceExtension, "424"); 1223 message.setExtension(defaultStringPieceExtension, "424");
1343 message.setExtension(defaultCordExtension, "425"); 1224 message.setExtension(defaultCordExtension, "425");
1344
1345 message.setExtension(oneofUint32Extension, 601);
1346 message.setExtension(oneofNestedMessageExtension,
1347 TestAllTypes.NestedMessage.newBuilder().setBb(602).build());
1348 message.setExtension(oneofStringExtension, "603");
1349 message.setExtension(oneofBytesExtension, toBytes("604"));
1350 } 1225 }
1351 1226
1352 // ------------------------------------------------------------------- 1227 // -------------------------------------------------------------------
1353 1228
1354 /** 1229 /**
1355 * Modify the repeated extensions of {@code message} to contain the values 1230 * Modify the repeated extensions of {@code message} to contain the values
1356 * expected by {@code assertRepeatedExtensionsModified()}. 1231 * expected by {@code assertRepeatedExtensionsModified()}.
1357 */ 1232 */
1358 public static void modifyRepeatedExtensions( 1233 public static void modifyRepeatedExtensions(
1359 TestAllExtensions.Builder message) { 1234 TestAllExtensions.Builder message) {
(...skipping 243 matching lines...) Expand 10 before | Expand all | Expand 10 after
1603 1478
1604 assertEqualsExactType(TestAllTypes.NestedEnum.FOO, 1479 assertEqualsExactType(TestAllTypes.NestedEnum.FOO,
1605 message.getExtension(defaultNestedEnumExtension )); 1480 message.getExtension(defaultNestedEnumExtension ));
1606 assertEqualsExactType(ForeignEnum.FOREIGN_FOO, 1481 assertEqualsExactType(ForeignEnum.FOREIGN_FOO,
1607 message.getExtension(defaultForeignEnumExtension)); 1482 message.getExtension(defaultForeignEnumExtension));
1608 assertEqualsExactType(ImportEnum.IMPORT_FOO, 1483 assertEqualsExactType(ImportEnum.IMPORT_FOO,
1609 message.getExtension(defaultImportEnumExtension)); 1484 message.getExtension(defaultImportEnumExtension));
1610 1485
1611 assertEqualsExactType("424", message.getExtension(defaultStringPieceExtensio n)); 1486 assertEqualsExactType("424", message.getExtension(defaultStringPieceExtensio n));
1612 assertEqualsExactType("425", message.getExtension(defaultCordExtension)); 1487 assertEqualsExactType("425", message.getExtension(defaultCordExtension));
1613
1614 Assert.assertTrue(message.hasExtension(oneofBytesExtension));
1615
1616 assertEqualsExactType(toBytes("604"), message.getExtension(oneofBytesExtensi on));
1617 } 1488 }
1618 1489
1619 // ------------------------------------------------------------------- 1490 // -------------------------------------------------------------------
1620 1491
1621 /** 1492 /**
1622 * Assert (using {@code junit.framework.Assert}} that all extensions of 1493 * Assert (using {@code junit.framework.Assert}} that all extensions of
1623 * {@code message} are cleared, and that getting the extensions returns their 1494 * {@code message} are cleared, and that getting the extensions returns their
1624 * default values. 1495 * default values.
1625 */ 1496 */
1626 public static void assertExtensionsClear(TestAllExtensionsOrBuilder message) { 1497 public static void assertExtensionsClear(TestAllExtensionsOrBuilder message) {
(...skipping 166 matching lines...) Expand 10 before | Expand all | Expand 10 after
1793 1664
1794 assertEqualsExactType(TestAllTypes.NestedEnum.BAR, 1665 assertEqualsExactType(TestAllTypes.NestedEnum.BAR,
1795 message.getExtension(defaultNestedEnumExtension )); 1666 message.getExtension(defaultNestedEnumExtension ));
1796 assertEqualsExactType(ForeignEnum.FOREIGN_BAR, 1667 assertEqualsExactType(ForeignEnum.FOREIGN_BAR,
1797 message.getExtension(defaultForeignEnumExtension)); 1668 message.getExtension(defaultForeignEnumExtension));
1798 assertEqualsExactType(ImportEnum.IMPORT_BAR, 1669 assertEqualsExactType(ImportEnum.IMPORT_BAR,
1799 message.getExtension(defaultImportEnumExtension)); 1670 message.getExtension(defaultImportEnumExtension));
1800 1671
1801 assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtensio n)); 1672 assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtensio n));
1802 assertEqualsExactType("123", message.getExtension(defaultCordExtension)); 1673 assertEqualsExactType("123", message.getExtension(defaultCordExtension));
1803
1804 Assert.assertFalse(message.hasExtension(oneofUint32Extension));
1805 Assert.assertFalse(message.hasExtension(oneofNestedMessageExtension));
1806 Assert.assertFalse(message.hasExtension(oneofStringExtension));
1807 Assert.assertFalse(message.hasExtension(oneofBytesExtension));
1808 } 1674 }
1809 1675
1810 // ------------------------------------------------------------------- 1676 // -------------------------------------------------------------------
1811 1677
1812 /** 1678 /**
1813 * Assert (using {@code junit.framework.Assert}} that all extensions of 1679 * Assert (using {@code junit.framework.Assert}} that all extensions of
1814 * {@code message} are set to the values assigned by {@code setAllExtensions} 1680 * {@code message} are set to the values assigned by {@code setAllExtensions}
1815 * followed by {@code modifyRepeatedExtensions}. 1681 * followed by {@code modifyRepeatedExtensions}.
1816 */ 1682 */
1817 public static void assertRepeatedExtensionsModified( 1683 public static void assertRepeatedExtensionsModified(
(...skipping 167 matching lines...) Expand 10 before | Expand all | Expand 10 after
1985 assertEqualsExactType(708L , message.getExtension(packedFixed64Extension , 1 )); 1851 assertEqualsExactType(708L , message.getExtension(packedFixed64Extension , 1 ));
1986 assertEqualsExactType(709 , message.getExtension(packedSfixed32Extension, 1 )); 1852 assertEqualsExactType(709 , message.getExtension(packedSfixed32Extension, 1 ));
1987 assertEqualsExactType(710L , message.getExtension(packedSfixed64Extension, 1 )); 1853 assertEqualsExactType(710L , message.getExtension(packedSfixed64Extension, 1 ));
1988 assertEqualsExactType(711F , message.getExtension(packedFloatExtension , 1 )); 1854 assertEqualsExactType(711F , message.getExtension(packedFloatExtension , 1 ));
1989 assertEqualsExactType(712D , message.getExtension(packedDoubleExtension , 1 )); 1855 assertEqualsExactType(712D , message.getExtension(packedDoubleExtension , 1 ));
1990 assertEqualsExactType(false, message.getExtension(packedBoolExtension , 1 )); 1856 assertEqualsExactType(false, message.getExtension(packedBoolExtension , 1 ));
1991 assertEqualsExactType(ForeignEnum.FOREIGN_BAZ, 1857 assertEqualsExactType(ForeignEnum.FOREIGN_BAZ,
1992 message.getExtension(packedEnumExtension, 1)); 1858 message.getExtension(packedEnumExtension, 1));
1993 } 1859 }
1994 1860
1995 // ===================================================================
1996 // Lite extensions
1997
1998 /**
1999 * Assert (using {@code junit.framework.Assert}} that all extensions of
2000 * {@code message} are set to the values assigned by {@code setAllExtensions}.
2001 */
2002 public static void assertAllExtensionsSet(
2003 TestAllExtensionsLiteOrBuilder message) {
2004 Assert.assertTrue(message.hasExtension(optionalInt32ExtensionLite ));
2005 Assert.assertTrue(message.hasExtension(optionalInt64ExtensionLite ));
2006 Assert.assertTrue(message.hasExtension(optionalUint32ExtensionLite ));
2007 Assert.assertTrue(message.hasExtension(optionalUint64ExtensionLite ));
2008 Assert.assertTrue(message.hasExtension(optionalSint32ExtensionLite ));
2009 Assert.assertTrue(message.hasExtension(optionalSint64ExtensionLite ));
2010 Assert.assertTrue(message.hasExtension(optionalFixed32ExtensionLite ));
2011 Assert.assertTrue(message.hasExtension(optionalFixed64ExtensionLite ));
2012 Assert.assertTrue(message.hasExtension(optionalSfixed32ExtensionLite));
2013 Assert.assertTrue(message.hasExtension(optionalSfixed64ExtensionLite));
2014 Assert.assertTrue(message.hasExtension(optionalFloatExtensionLite ));
2015 Assert.assertTrue(message.hasExtension(optionalDoubleExtensionLite ));
2016 Assert.assertTrue(message.hasExtension(optionalBoolExtensionLite ));
2017 Assert.assertTrue(message.hasExtension(optionalStringExtensionLite ));
2018 Assert.assertTrue(message.hasExtension(optionalBytesExtensionLite ));
2019
2020 Assert.assertTrue(message.hasExtension(optionalGroupExtensionLite )) ;
2021 Assert.assertTrue(message.hasExtension(optionalNestedMessageExtensionLite )) ;
2022 Assert.assertTrue(message.hasExtension(optionalForeignMessageExtensionLite)) ;
2023 Assert.assertTrue(message.hasExtension(optionalImportMessageExtensionLite )) ;
2024
2025 Assert.assertTrue(message.getExtension(optionalGroupExtensionLite ). hasA());
2026 Assert.assertTrue(message.getExtension(optionalNestedMessageExtensionLite ). hasBb());
2027 Assert.assertTrue(message.getExtension(optionalForeignMessageExtensionLite). hasC());
2028 Assert.assertTrue(message.getExtension(optionalImportMessageExtensionLite ). hasD());
2029
2030 Assert.assertTrue(message.hasExtension(optionalNestedEnumExtensionLite ));
2031 Assert.assertTrue(message.hasExtension(optionalForeignEnumExtensionLite));
2032 Assert.assertTrue(message.hasExtension(optionalImportEnumExtensionLite ));
2033
2034 Assert.assertTrue(message.hasExtension(optionalStringPieceExtensionLite));
2035 Assert.assertTrue(message.hasExtension(optionalCordExtensionLite));
2036
2037 assertEqualsExactType(101 , message.getExtension(optionalInt32ExtensionLite ));
2038 assertEqualsExactType(102L , message.getExtension(optionalInt64ExtensionLite ));
2039 assertEqualsExactType(103 , message.getExtension(optionalUint32ExtensionLit e ));
2040 assertEqualsExactType(104L , message.getExtension(optionalUint64ExtensionLit e ));
2041 assertEqualsExactType(105 , message.getExtension(optionalSint32ExtensionLit e ));
2042 assertEqualsExactType(106L , message.getExtension(optionalSint64ExtensionLit e ));
2043 assertEqualsExactType(107 , message.getExtension(optionalFixed32ExtensionLi te ));
2044 assertEqualsExactType(108L , message.getExtension(optionalFixed64ExtensionLi te ));
2045 assertEqualsExactType(109 , message.getExtension(optionalSfixed32ExtensionL ite));
2046 assertEqualsExactType(110L , message.getExtension(optionalSfixed64ExtensionL ite));
2047 assertEqualsExactType(111F , message.getExtension(optionalFloatExtensionLite ));
2048 assertEqualsExactType(112D , message.getExtension(optionalDoubleExtensionLit e ));
2049 assertEqualsExactType(true , message.getExtension(optionalBoolExtensionLite ));
2050 assertEqualsExactType("115", message.getExtension(optionalStringExtensionLit e ));
2051 assertEqualsExactType(toBytes("116"), message.getExtension(optionalBytesExte nsionLite));
2052
2053 assertEqualsExactType(117, message.getExtension(optionalGroupExtensionLite ).getA());
2054 assertEqualsExactType(118, message.getExtension(optionalNestedMessageExtensi onLite ).getBb());
2055 assertEqualsExactType(119, message.getExtension(optionalForeignMessageExtens ionLite).getC());
2056 assertEqualsExactType(120, message.getExtension(optionalImportMessageExtensi onLite ).getD());
2057 assertEqualsExactType(126, message.getExtension(
2058 optionalPublicImportMessageExtensionLite).getE());
2059 assertEqualsExactType(127, message.getExtension(optionalLazyMessageExtension Lite).getBb());
2060
2061 assertEqualsExactType(TestAllTypesLite.NestedEnum.BAZ,
2062 message.getExtension(optionalNestedEnumExtensionLite));
2063 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAZ,
2064 message.getExtension(optionalForeignEnumExtensionLite));
2065 assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAZ,
2066 message.getExtension(optionalImportEnumExtensionLite));
2067
2068 assertEqualsExactType("124", message.getExtension(optionalStringPieceExtensi onLite));
2069 assertEqualsExactType("125", message.getExtension(optionalCordExtensionLite) );
2070
2071 // -----------------------------------------------------------------
2072
2073 Assert.assertEquals(2, message.getExtensionCount(repeatedInt32ExtensionLite ));
2074 Assert.assertEquals(2, message.getExtensionCount(repeatedInt64ExtensionLite ));
2075 Assert.assertEquals(2, message.getExtensionCount(repeatedUint32ExtensionLite ));
2076 Assert.assertEquals(2, message.getExtensionCount(repeatedUint64ExtensionLite ));
2077 Assert.assertEquals(2, message.getExtensionCount(repeatedSint32ExtensionLite ));
2078 Assert.assertEquals(2, message.getExtensionCount(repeatedSint64ExtensionLite ));
2079 Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32ExtensionLit e ));
2080 Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64ExtensionLit e ));
2081 Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32ExtensionLi te));
2082 Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64ExtensionLi te));
2083 Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtensionLite ));
2084 Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtensionLite ));
2085 Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtensionLite ));
2086 Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtensionLite ));
2087 Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtensionLite ));
2088
2089 Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtensionLite ));
2090 Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtens ionLite ));
2091 Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExten sionLite));
2092 Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtens ionLite ));
2093 Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtensio nLite ));
2094 Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension Lite ));
2095 Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensio nLite ));
2096 Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension Lite ));
2097
2098 Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensio nLite));
2099 Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtensionLite)) ;
2100
2101 assertEqualsExactType(201 , message.getExtension(repeatedInt32ExtensionLite , 0));
2102 assertEqualsExactType(202L , message.getExtension(repeatedInt64ExtensionLite , 0));
2103 assertEqualsExactType(203 , message.getExtension(repeatedUint32ExtensionLit e , 0));
2104 assertEqualsExactType(204L , message.getExtension(repeatedUint64ExtensionLit e , 0));
2105 assertEqualsExactType(205 , message.getExtension(repeatedSint32ExtensionLit e , 0));
2106 assertEqualsExactType(206L , message.getExtension(repeatedSint64ExtensionLit e , 0));
2107 assertEqualsExactType(207 , message.getExtension(repeatedFixed32ExtensionLi te , 0));
2108 assertEqualsExactType(208L , message.getExtension(repeatedFixed64ExtensionLi te , 0));
2109 assertEqualsExactType(209 , message.getExtension(repeatedSfixed32ExtensionL ite, 0));
2110 assertEqualsExactType(210L , message.getExtension(repeatedSfixed64ExtensionL ite, 0));
2111 assertEqualsExactType(211F , message.getExtension(repeatedFloatExtensionLite , 0));
2112 assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtensionLit e , 0));
2113 assertEqualsExactType(true , message.getExtension(repeatedBoolExtensionLite , 0));
2114 assertEqualsExactType("215", message.getExtension(repeatedStringExtensionLit e , 0));
2115 assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExte nsionLite, 0));
2116
2117 assertEqualsExactType(217, message.getExtension(repeatedGroupExtensionLite ,0).getA());
2118 assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensi onLite ,0).getBb());
2119 assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtens ionLite,0).getC());
2120 assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensi onLite ,0).getD());
2121 assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension Lite ,0).getBb());
2122
2123 assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,
2124 message.getExtension(repeatedNestedEnumExtensionLite, 0));
2125 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
2126 message.getExtension(repeatedForeignEnumExtensionLite, 0));
2127 assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAR,
2128 message.getExtension(repeatedImportEnumExtensionLite, 0));
2129
2130 assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensi onLite, 0));
2131 assertEqualsExactType("225", message.getExtension(repeatedCordExtensionLite, 0));
2132
2133 assertEqualsExactType(301 , message.getExtension(repeatedInt32ExtensionLite , 1));
2134 assertEqualsExactType(302L , message.getExtension(repeatedInt64ExtensionLite , 1));
2135 assertEqualsExactType(303 , message.getExtension(repeatedUint32ExtensionLit e , 1));
2136 assertEqualsExactType(304L , message.getExtension(repeatedUint64ExtensionLit e , 1));
2137 assertEqualsExactType(305 , message.getExtension(repeatedSint32ExtensionLit e , 1));
2138 assertEqualsExactType(306L , message.getExtension(repeatedSint64ExtensionLit e , 1));
2139 assertEqualsExactType(307 , message.getExtension(repeatedFixed32ExtensionLi te , 1));
2140 assertEqualsExactType(308L , message.getExtension(repeatedFixed64ExtensionLi te , 1));
2141 assertEqualsExactType(309 , message.getExtension(repeatedSfixed32ExtensionL ite, 1));
2142 assertEqualsExactType(310L , message.getExtension(repeatedSfixed64ExtensionL ite, 1));
2143 assertEqualsExactType(311F , message.getExtension(repeatedFloatExtensionLite , 1));
2144 assertEqualsExactType(312D , message.getExtension(repeatedDoubleExtensionLit e , 1));
2145 assertEqualsExactType(false, message.getExtension(repeatedBoolExtensionLite , 1));
2146 assertEqualsExactType("315", message.getExtension(repeatedStringExtensionLit e , 1));
2147 assertEqualsExactType(toBytes("316"), message.getExtension(repeatedBytesExte nsionLite, 1));
2148
2149 assertEqualsExactType(317, message.getExtension(repeatedGroupExtensionLite ,1).getA());
2150 assertEqualsExactType(318, message.getExtension(repeatedNestedMessageExtensi onLite ,1).getBb());
2151 assertEqualsExactType(319, message.getExtension(repeatedForeignMessageExtens ionLite,1).getC());
2152 assertEqualsExactType(320, message.getExtension(repeatedImportMessageExtensi onLite ,1).getD());
2153 assertEqualsExactType(327, message.getExtension(repeatedLazyMessageExtension Lite ,1).getBb());
2154
2155 assertEqualsExactType(TestAllTypesLite.NestedEnum.BAZ,
2156 message.getExtension(repeatedNestedEnumExtensionLite, 1));
2157 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAZ,
2158 message.getExtension(repeatedForeignEnumExtensionLite, 1));
2159 assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAZ,
2160 message.getExtension(repeatedImportEnumExtensionLite, 1));
2161
2162 assertEqualsExactType("324", message.getExtension(repeatedStringPieceExtensi onLite, 1));
2163 assertEqualsExactType("325", message.getExtension(repeatedCordExtensionLite, 1));
2164
2165 // -----------------------------------------------------------------
2166
2167 Assert.assertTrue(message.hasExtension(defaultInt32ExtensionLite ));
2168 Assert.assertTrue(message.hasExtension(defaultInt64ExtensionLite ));
2169 Assert.assertTrue(message.hasExtension(defaultUint32ExtensionLite ));
2170 Assert.assertTrue(message.hasExtension(defaultUint64ExtensionLite ));
2171 Assert.assertTrue(message.hasExtension(defaultSint32ExtensionLite ));
2172 Assert.assertTrue(message.hasExtension(defaultSint64ExtensionLite ));
2173 Assert.assertTrue(message.hasExtension(defaultFixed32ExtensionLite ));
2174 Assert.assertTrue(message.hasExtension(defaultFixed64ExtensionLite ));
2175 Assert.assertTrue(message.hasExtension(defaultSfixed32ExtensionLite));
2176 Assert.assertTrue(message.hasExtension(defaultSfixed64ExtensionLite));
2177 Assert.assertTrue(message.hasExtension(defaultFloatExtensionLite ));
2178 Assert.assertTrue(message.hasExtension(defaultDoubleExtensionLite ));
2179 Assert.assertTrue(message.hasExtension(defaultBoolExtensionLite ));
2180 Assert.assertTrue(message.hasExtension(defaultStringExtensionLite ));
2181 Assert.assertTrue(message.hasExtension(defaultBytesExtensionLite ));
2182
2183 Assert.assertTrue(message.hasExtension(defaultNestedEnumExtensionLite ));
2184 Assert.assertTrue(message.hasExtension(defaultForeignEnumExtensionLite));
2185 Assert.assertTrue(message.hasExtension(defaultImportEnumExtensionLite ));
2186
2187 Assert.assertTrue(message.hasExtension(defaultStringPieceExtensionLite));
2188 Assert.assertTrue(message.hasExtension(defaultCordExtensionLite));
2189
2190 assertEqualsExactType(401 , message.getExtension(defaultInt32ExtensionLite ));
2191 assertEqualsExactType(402L , message.getExtension(defaultInt64ExtensionLite ));
2192 assertEqualsExactType(403 , message.getExtension(defaultUint32ExtensionLite ));
2193 assertEqualsExactType(404L , message.getExtension(defaultUint64ExtensionLite ));
2194 assertEqualsExactType(405 , message.getExtension(defaultSint32ExtensionLite ));
2195 assertEqualsExactType(406L , message.getExtension(defaultSint64ExtensionLite ));
2196 assertEqualsExactType(407 , message.getExtension(defaultFixed32ExtensionLit e ));
2197 assertEqualsExactType(408L , message.getExtension(defaultFixed64ExtensionLit e ));
2198 assertEqualsExactType(409 , message.getExtension(defaultSfixed32ExtensionLi te));
2199 assertEqualsExactType(410L , message.getExtension(defaultSfixed64ExtensionLi te));
2200 assertEqualsExactType(411F , message.getExtension(defaultFloatExtensionLite ));
2201 assertEqualsExactType(412D , message.getExtension(defaultDoubleExtensionLite ));
2202 assertEqualsExactType(false, message.getExtension(defaultBoolExtensionLite ));
2203 assertEqualsExactType("415", message.getExtension(defaultStringExtensionLite ));
2204 assertEqualsExactType(toBytes("416"), message.getExtension(defaultBytesExten sionLite));
2205
2206 assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,
2207 message.getExtension(defaultNestedEnumExtensionLite ));
2208 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_FOO,
2209 message.getExtension(defaultForeignEnumExtensionLite));
2210 assertEqualsExactType(ImportEnumLite.IMPORT_LITE_FOO,
2211 message.getExtension(defaultImportEnumExtensionLite));
2212
2213 assertEqualsExactType("424", message.getExtension(defaultStringPieceExtensio nLite));
2214 assertEqualsExactType("425", message.getExtension(defaultCordExtensionLite)) ;
2215
2216 Assert.assertTrue(message.hasExtension(oneofBytesExtensionLite));
2217
2218 assertEqualsExactType(toBytes("604"), message.getExtension(oneofBytesExtensi onLite));
2219 }
2220
2221 // -------------------------------------------------------------------
2222
2223 /**
2224 * Assert (using {@code junit.framework.Assert}} that all extensions of
2225 * {@code message} are cleared, and that getting the extensions returns their
2226 * default values.
2227 */
2228 public static void assertExtensionsClear(
2229 TestAllExtensionsLiteOrBuilder message) {
2230 // hasBlah() should initially be false for all optional fields.
2231 Assert.assertFalse(message.hasExtension(optionalInt32ExtensionLite ));
2232 Assert.assertFalse(message.hasExtension(optionalInt64ExtensionLite ));
2233 Assert.assertFalse(message.hasExtension(optionalUint32ExtensionLite ));
2234 Assert.assertFalse(message.hasExtension(optionalUint64ExtensionLite ));
2235 Assert.assertFalse(message.hasExtension(optionalSint32ExtensionLite ));
2236 Assert.assertFalse(message.hasExtension(optionalSint64ExtensionLite ));
2237 Assert.assertFalse(message.hasExtension(optionalFixed32ExtensionLite ));
2238 Assert.assertFalse(message.hasExtension(optionalFixed64ExtensionLite ));
2239 Assert.assertFalse(message.hasExtension(optionalSfixed32ExtensionLite));
2240 Assert.assertFalse(message.hasExtension(optionalSfixed64ExtensionLite));
2241 Assert.assertFalse(message.hasExtension(optionalFloatExtensionLite ));
2242 Assert.assertFalse(message.hasExtension(optionalDoubleExtensionLite ));
2243 Assert.assertFalse(message.hasExtension(optionalBoolExtensionLite ));
2244 Assert.assertFalse(message.hasExtension(optionalStringExtensionLite ));
2245 Assert.assertFalse(message.hasExtension(optionalBytesExtensionLite ));
2246
2247 Assert.assertFalse(message.hasExtension(optionalGroupExtensionLite ));
2248 Assert.assertFalse(message.hasExtension(optionalNestedMessageExtensionLite ));
2249 Assert.assertFalse(message.hasExtension(optionalForeignMessageExtensionLite ));
2250 Assert.assertFalse(message.hasExtension(optionalImportMessageExtensionLite ));
2251 Assert.assertFalse(message.hasExtension(optionalPublicImportMessageExtension Lite));
2252 Assert.assertFalse(message.hasExtension(optionalLazyMessageExtensionLite ));
2253
2254 Assert.assertFalse(message.hasExtension(optionalNestedEnumExtensionLite ));
2255 Assert.assertFalse(message.hasExtension(optionalForeignEnumExtensionLite));
2256 Assert.assertFalse(message.hasExtension(optionalImportEnumExtensionLite ));
2257
2258 Assert.assertFalse(message.hasExtension(optionalStringPieceExtensionLite));
2259 Assert.assertFalse(message.hasExtension(optionalCordExtensionLite));
2260
2261 // Optional fields without defaults are set to zero or something like it.
2262 assertEqualsExactType(0 , message.getExtension(optionalInt32ExtensionLite ));
2263 assertEqualsExactType(0L , message.getExtension(optionalInt64ExtensionLite ));
2264 assertEqualsExactType(0 , message.getExtension(optionalUint32ExtensionLit e ));
2265 assertEqualsExactType(0L , message.getExtension(optionalUint64ExtensionLit e ));
2266 assertEqualsExactType(0 , message.getExtension(optionalSint32ExtensionLit e ));
2267 assertEqualsExactType(0L , message.getExtension(optionalSint64ExtensionLit e ));
2268 assertEqualsExactType(0 , message.getExtension(optionalFixed32ExtensionLi te ));
2269 assertEqualsExactType(0L , message.getExtension(optionalFixed64ExtensionLi te ));
2270 assertEqualsExactType(0 , message.getExtension(optionalSfixed32ExtensionL ite));
2271 assertEqualsExactType(0L , message.getExtension(optionalSfixed64ExtensionL ite));
2272 assertEqualsExactType(0F , message.getExtension(optionalFloatExtensionLite ));
2273 assertEqualsExactType(0D , message.getExtension(optionalDoubleExtensionLit e ));
2274 assertEqualsExactType(false, message.getExtension(optionalBoolExtensionLite ));
2275 assertEqualsExactType("" , message.getExtension(optionalStringExtensionLit e ));
2276 assertEqualsExactType(ByteString.EMPTY, message.getExtension(optionalBytesEx tensionLite));
2277
2278 // Embedded messages should also be clear.
2279 Assert.assertFalse(message.getExtension(optionalGroupExtensionLite ).hasA());
2280 Assert.assertFalse(message.getExtension(optionalNestedMessageExtensionLite ).hasBb());
2281 Assert.assertFalse(message.getExtension(optionalForeignMessageExtensionLite ).hasC());
2282 Assert.assertFalse(message.getExtension(optionalImportMessageExtensionLite ).hasD());
2283 Assert.assertFalse(message.getExtension(optionalPublicImportMessageExtension Lite).hasE());
2284 Assert.assertFalse(message.getExtension(optionalLazyMessageExtensionLite ).hasBb());
2285
2286 assertEqualsExactType(0, message.getExtension(optionalGroupExtensionLite ).getA());
2287 assertEqualsExactType(0, message.getExtension(optionalNestedMessageExtension Lite ).getBb());
2288 assertEqualsExactType(0, message.getExtension(optionalForeignMessageExtensio nLite).getC());
2289 assertEqualsExactType(0, message.getExtension(optionalImportMessageExtension Lite ).getD());
2290 assertEqualsExactType(0, message.getExtension(
2291 optionalPublicImportMessageExtensionLite).getE());
2292 assertEqualsExactType(0, message.getExtension(optionalLazyMessageExtensionLi te ).getBb());
2293
2294 // Enums without defaults are set to the first value in the enum.
2295 assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,
2296 message.getExtension(optionalNestedEnumExtensionLite ));
2297 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_FOO,
2298 message.getExtension(optionalForeignEnumExtensionLite));
2299 assertEqualsExactType(ImportEnumLite.IMPORT_LITE_FOO,
2300 message.getExtension(optionalImportEnumExtensionLite));
2301
2302 assertEqualsExactType("", message.getExtension(optionalStringPieceExtensionL ite));
2303 assertEqualsExactType("", message.getExtension(optionalCordExtensionLite));
2304
2305 // Repeated fields are empty.
2306 Assert.assertEquals(0, message.getExtensionCount(repeatedInt32ExtensionLite ));
2307 Assert.assertEquals(0, message.getExtensionCount(repeatedInt64ExtensionLite ));
2308 Assert.assertEquals(0, message.getExtensionCount(repeatedUint32ExtensionLite ));
2309 Assert.assertEquals(0, message.getExtensionCount(repeatedUint64ExtensionLite ));
2310 Assert.assertEquals(0, message.getExtensionCount(repeatedSint32ExtensionLite ));
2311 Assert.assertEquals(0, message.getExtensionCount(repeatedSint64ExtensionLite ));
2312 Assert.assertEquals(0, message.getExtensionCount(repeatedFixed32ExtensionLit e ));
2313 Assert.assertEquals(0, message.getExtensionCount(repeatedFixed64ExtensionLit e ));
2314 Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed32ExtensionLi te));
2315 Assert.assertEquals(0, message.getExtensionCount(repeatedSfixed64ExtensionLi te));
2316 Assert.assertEquals(0, message.getExtensionCount(repeatedFloatExtensionLite ));
2317 Assert.assertEquals(0, message.getExtensionCount(repeatedDoubleExtensionLite ));
2318 Assert.assertEquals(0, message.getExtensionCount(repeatedBoolExtensionLite ));
2319 Assert.assertEquals(0, message.getExtensionCount(repeatedStringExtensionLite ));
2320 Assert.assertEquals(0, message.getExtensionCount(repeatedBytesExtensionLite ));
2321
2322 Assert.assertEquals(0, message.getExtensionCount(repeatedGroupExtensionLite ));
2323 Assert.assertEquals(0, message.getExtensionCount(repeatedNestedMessageExtens ionLite ));
2324 Assert.assertEquals(0, message.getExtensionCount(repeatedForeignMessageExten sionLite));
2325 Assert.assertEquals(0, message.getExtensionCount(repeatedImportMessageExtens ionLite ));
2326 Assert.assertEquals(0, message.getExtensionCount(repeatedLazyMessageExtensio nLite ));
2327 Assert.assertEquals(0, message.getExtensionCount(repeatedNestedEnumExtension Lite ));
2328 Assert.assertEquals(0, message.getExtensionCount(repeatedForeignEnumExtensio nLite ));
2329 Assert.assertEquals(0, message.getExtensionCount(repeatedImportEnumExtension Lite ));
2330
2331 Assert.assertEquals(0, message.getExtensionCount(repeatedStringPieceExtensio nLite));
2332 Assert.assertEquals(0, message.getExtensionCount(repeatedCordExtensionLite)) ;
2333
2334 // hasBlah() should also be false for all default fields.
2335 Assert.assertFalse(message.hasExtension(defaultInt32ExtensionLite ));
2336 Assert.assertFalse(message.hasExtension(defaultInt64ExtensionLite ));
2337 Assert.assertFalse(message.hasExtension(defaultUint32ExtensionLite ));
2338 Assert.assertFalse(message.hasExtension(defaultUint64ExtensionLite ));
2339 Assert.assertFalse(message.hasExtension(defaultSint32ExtensionLite ));
2340 Assert.assertFalse(message.hasExtension(defaultSint64ExtensionLite ));
2341 Assert.assertFalse(message.hasExtension(defaultFixed32ExtensionLite ));
2342 Assert.assertFalse(message.hasExtension(defaultFixed64ExtensionLite ));
2343 Assert.assertFalse(message.hasExtension(defaultSfixed32ExtensionLite));
2344 Assert.assertFalse(message.hasExtension(defaultSfixed64ExtensionLite));
2345 Assert.assertFalse(message.hasExtension(defaultFloatExtensionLite ));
2346 Assert.assertFalse(message.hasExtension(defaultDoubleExtensionLite ));
2347 Assert.assertFalse(message.hasExtension(defaultBoolExtensionLite ));
2348 Assert.assertFalse(message.hasExtension(defaultStringExtensionLite ));
2349 Assert.assertFalse(message.hasExtension(defaultBytesExtensionLite ));
2350
2351 Assert.assertFalse(message.hasExtension(defaultNestedEnumExtensionLite ));
2352 Assert.assertFalse(message.hasExtension(defaultForeignEnumExtensionLite));
2353 Assert.assertFalse(message.hasExtension(defaultImportEnumExtensionLite ));
2354
2355 Assert.assertFalse(message.hasExtension(defaultStringPieceExtensionLite));
2356 Assert.assertFalse(message.hasExtension(defaultCordExtensionLite));
2357
2358 // Fields with defaults have their default values (duh).
2359 assertEqualsExactType( 41 , message.getExtension(defaultInt32ExtensionLit e ));
2360 assertEqualsExactType( 42L , message.getExtension(defaultInt64ExtensionLit e ));
2361 assertEqualsExactType( 43 , message.getExtension(defaultUint32ExtensionLi te ));
2362 assertEqualsExactType( 44L , message.getExtension(defaultUint64ExtensionLi te ));
2363 assertEqualsExactType(-45 , message.getExtension(defaultSint32ExtensionLi te ));
2364 assertEqualsExactType( 46L , message.getExtension(defaultSint64ExtensionLi te ));
2365 assertEqualsExactType( 47 , message.getExtension(defaultFixed32ExtensionL ite ));
2366 assertEqualsExactType( 48L , message.getExtension(defaultFixed64ExtensionL ite ));
2367 assertEqualsExactType( 49 , message.getExtension(defaultSfixed32Extension Lite));
2368 assertEqualsExactType(-50L , message.getExtension(defaultSfixed64Extension Lite));
2369 assertEqualsExactType( 51.5F , message.getExtension(defaultFloatExtensionLit e ));
2370 assertEqualsExactType( 52e3D , message.getExtension(defaultDoubleExtensionLi te ));
2371 assertEqualsExactType(true , message.getExtension(defaultBoolExtensionLite ));
2372 assertEqualsExactType("hello", message.getExtension(defaultStringExtensionLi te ));
2373 assertEqualsExactType(toBytes("world"), message.getExtension(defaultBytesExt ensionLite));
2374
2375 assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,
2376 message.getExtension(defaultNestedEnumExtensionLite ));
2377 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
2378 message.getExtension(defaultForeignEnumExtensionLite));
2379 assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAR,
2380 message.getExtension(defaultImportEnumExtensionLite));
2381
2382 assertEqualsExactType("abc", message.getExtension(defaultStringPieceExtensio nLite));
2383 assertEqualsExactType("123", message.getExtension(defaultCordExtensionLite)) ;
2384
2385 Assert.assertFalse(message.hasExtension(oneofUint32ExtensionLite));
2386 Assert.assertFalse(message.hasExtension(oneofNestedMessageExtensionLite));
2387 Assert.assertFalse(message.hasExtension(oneofStringExtensionLite));
2388 Assert.assertFalse(message.hasExtension(oneofBytesExtensionLite));
2389 }
2390
2391 // -------------------------------------------------------------------
2392
2393 /**
2394 * Assert (using {@code junit.framework.Assert}} that all extensions of
2395 * {@code message} are set to the values assigned by {@code setAllExtensions}
2396 * followed by {@code modifyRepeatedExtensions}.
2397 */
2398 public static void assertRepeatedExtensionsModified(
2399 TestAllExtensionsLiteOrBuilder message) {
2400 // ModifyRepeatedFields only sets the second repeated element of each
2401 // field. In addition to verifying this, we also verify that the first
2402 // element and size were *not* modified.
2403 Assert.assertEquals(2, message.getExtensionCount(repeatedInt32ExtensionLite ));
2404 Assert.assertEquals(2, message.getExtensionCount(repeatedInt64ExtensionLite ));
2405 Assert.assertEquals(2, message.getExtensionCount(repeatedUint32ExtensionLite ));
2406 Assert.assertEquals(2, message.getExtensionCount(repeatedUint64ExtensionLite ));
2407 Assert.assertEquals(2, message.getExtensionCount(repeatedSint32ExtensionLite ));
2408 Assert.assertEquals(2, message.getExtensionCount(repeatedSint64ExtensionLite ));
2409 Assert.assertEquals(2, message.getExtensionCount(repeatedFixed32ExtensionLit e ));
2410 Assert.assertEquals(2, message.getExtensionCount(repeatedFixed64ExtensionLit e ));
2411 Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed32ExtensionLi te));
2412 Assert.assertEquals(2, message.getExtensionCount(repeatedSfixed64ExtensionLi te));
2413 Assert.assertEquals(2, message.getExtensionCount(repeatedFloatExtensionLite ));
2414 Assert.assertEquals(2, message.getExtensionCount(repeatedDoubleExtensionLite ));
2415 Assert.assertEquals(2, message.getExtensionCount(repeatedBoolExtensionLite ));
2416 Assert.assertEquals(2, message.getExtensionCount(repeatedStringExtensionLite ));
2417 Assert.assertEquals(2, message.getExtensionCount(repeatedBytesExtensionLite ));
2418
2419 Assert.assertEquals(2, message.getExtensionCount(repeatedGroupExtensionLite ));
2420 Assert.assertEquals(2, message.getExtensionCount(repeatedNestedMessageExtens ionLite ));
2421 Assert.assertEquals(2, message.getExtensionCount(repeatedForeignMessageExten sionLite));
2422 Assert.assertEquals(2, message.getExtensionCount(repeatedImportMessageExtens ionLite ));
2423 Assert.assertEquals(2, message.getExtensionCount(repeatedLazyMessageExtensio nLite ));
2424 Assert.assertEquals(2, message.getExtensionCount(repeatedNestedEnumExtension Lite ));
2425 Assert.assertEquals(2, message.getExtensionCount(repeatedForeignEnumExtensio nLite ));
2426 Assert.assertEquals(2, message.getExtensionCount(repeatedImportEnumExtension Lite ));
2427
2428 Assert.assertEquals(2, message.getExtensionCount(repeatedStringPieceExtensio nLite));
2429 Assert.assertEquals(2, message.getExtensionCount(repeatedCordExtensionLite)) ;
2430
2431 assertEqualsExactType(201 , message.getExtension(repeatedInt32ExtensionLite , 0));
2432 assertEqualsExactType(202L , message.getExtension(repeatedInt64ExtensionLite , 0));
2433 assertEqualsExactType(203 , message.getExtension(repeatedUint32ExtensionLit e , 0));
2434 assertEqualsExactType(204L , message.getExtension(repeatedUint64ExtensionLit e , 0));
2435 assertEqualsExactType(205 , message.getExtension(repeatedSint32ExtensionLit e , 0));
2436 assertEqualsExactType(206L , message.getExtension(repeatedSint64ExtensionLit e , 0));
2437 assertEqualsExactType(207 , message.getExtension(repeatedFixed32ExtensionLi te , 0));
2438 assertEqualsExactType(208L , message.getExtension(repeatedFixed64ExtensionLi te , 0));
2439 assertEqualsExactType(209 , message.getExtension(repeatedSfixed32ExtensionL ite, 0));
2440 assertEqualsExactType(210L , message.getExtension(repeatedSfixed64ExtensionL ite, 0));
2441 assertEqualsExactType(211F , message.getExtension(repeatedFloatExtensionLite , 0));
2442 assertEqualsExactType(212D , message.getExtension(repeatedDoubleExtensionLit e , 0));
2443 assertEqualsExactType(true , message.getExtension(repeatedBoolExtensionLite , 0));
2444 assertEqualsExactType("215", message.getExtension(repeatedStringExtensionLit e , 0));
2445 assertEqualsExactType(toBytes("216"), message.getExtension(repeatedBytesExte nsionLite, 0));
2446
2447 assertEqualsExactType(217, message.getExtension(repeatedGroupExtensionLite ,0).getA());
2448 assertEqualsExactType(218, message.getExtension(repeatedNestedMessageExtensi onLite ,0).getBb());
2449 assertEqualsExactType(219, message.getExtension(repeatedForeignMessageExtens ionLite,0).getC());
2450 assertEqualsExactType(220, message.getExtension(repeatedImportMessageExtensi onLite ,0).getD());
2451 assertEqualsExactType(227, message.getExtension(repeatedLazyMessageExtension Lite ,0).getBb());
2452
2453 assertEqualsExactType(TestAllTypesLite.NestedEnum.BAR,
2454 message.getExtension(repeatedNestedEnumExtensionLite, 0));
2455 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
2456 message.getExtension(repeatedForeignEnumExtensionLite, 0));
2457 assertEqualsExactType(ImportEnumLite.IMPORT_LITE_BAR,
2458 message.getExtension(repeatedImportEnumExtensionLite, 0));
2459
2460 assertEqualsExactType("224", message.getExtension(repeatedStringPieceExtensi onLite, 0));
2461 assertEqualsExactType("225", message.getExtension(repeatedCordExtensionLite, 0));
2462
2463 // Actually verify the second (modified) elements now.
2464 assertEqualsExactType(501 , message.getExtension(repeatedInt32ExtensionLite , 1));
2465 assertEqualsExactType(502L , message.getExtension(repeatedInt64ExtensionLite , 1));
2466 assertEqualsExactType(503 , message.getExtension(repeatedUint32ExtensionLit e , 1));
2467 assertEqualsExactType(504L , message.getExtension(repeatedUint64ExtensionLit e , 1));
2468 assertEqualsExactType(505 , message.getExtension(repeatedSint32ExtensionLit e , 1));
2469 assertEqualsExactType(506L , message.getExtension(repeatedSint64ExtensionLit e , 1));
2470 assertEqualsExactType(507 , message.getExtension(repeatedFixed32ExtensionLi te , 1));
2471 assertEqualsExactType(508L , message.getExtension(repeatedFixed64ExtensionLi te , 1));
2472 assertEqualsExactType(509 , message.getExtension(repeatedSfixed32ExtensionL ite, 1));
2473 assertEqualsExactType(510L , message.getExtension(repeatedSfixed64ExtensionL ite, 1));
2474 assertEqualsExactType(511F , message.getExtension(repeatedFloatExtensionLite , 1));
2475 assertEqualsExactType(512D , message.getExtension(repeatedDoubleExtensionLit e , 1));
2476 assertEqualsExactType(true , message.getExtension(repeatedBoolExtensionLite , 1));
2477 assertEqualsExactType("515", message.getExtension(repeatedStringExtensionLit e , 1));
2478 assertEqualsExactType(toBytes("516"), message.getExtension(repeatedBytesExte nsionLite, 1));
2479
2480 assertEqualsExactType(517, message.getExtension(repeatedGroupExtensionLite ,1).getA());
2481 assertEqualsExactType(518, message.getExtension(repeatedNestedMessageExtensi onLite ,1).getBb());
2482 assertEqualsExactType(519, message.getExtension(repeatedForeignMessageExtens ionLite,1).getC());
2483 assertEqualsExactType(520, message.getExtension(repeatedImportMessageExtensi onLite ,1).getD());
2484 assertEqualsExactType(527, message.getExtension(repeatedLazyMessageExtension Lite ,1).getBb());
2485
2486 assertEqualsExactType(TestAllTypesLite.NestedEnum.FOO,
2487 message.getExtension(repeatedNestedEnumExtensionLite, 1));
2488 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_FOO,
2489 message.getExtension(repeatedForeignEnumExtensionLite, 1));
2490 assertEqualsExactType(ImportEnumLite.IMPORT_LITE_FOO,
2491 message.getExtension(repeatedImportEnumExtensionLite, 1));
2492
2493 assertEqualsExactType("524", message.getExtension(repeatedStringPieceExtensi onLite, 1));
2494 assertEqualsExactType("525", message.getExtension(repeatedCordExtensionLite, 1));
2495 }
2496
2497 public static void assertPackedExtensionsSet(TestPackedExtensionsLite message) {
2498 Assert.assertEquals(2, message.getExtensionCount(packedInt32ExtensionLite ));
2499 Assert.assertEquals(2, message.getExtensionCount(packedInt64ExtensionLite ));
2500 Assert.assertEquals(2, message.getExtensionCount(packedUint32ExtensionLite ));
2501 Assert.assertEquals(2, message.getExtensionCount(packedUint64ExtensionLite ));
2502 Assert.assertEquals(2, message.getExtensionCount(packedSint32ExtensionLite ));
2503 Assert.assertEquals(2, message.getExtensionCount(packedSint64ExtensionLite ));
2504 Assert.assertEquals(2, message.getExtensionCount(packedFixed32ExtensionLite ));
2505 Assert.assertEquals(2, message.getExtensionCount(packedFixed64ExtensionLite ));
2506 Assert.assertEquals(2, message.getExtensionCount(packedSfixed32ExtensionLite ));
2507 Assert.assertEquals(2, message.getExtensionCount(packedSfixed64ExtensionLite ));
2508 Assert.assertEquals(2, message.getExtensionCount(packedFloatExtensionLite ));
2509 Assert.assertEquals(2, message.getExtensionCount(packedDoubleExtensionLite ));
2510 Assert.assertEquals(2, message.getExtensionCount(packedBoolExtensionLite ));
2511 Assert.assertEquals(2, message.getExtensionCount(packedEnumExtensionLite));
2512 assertEqualsExactType(601 , message.getExtension(packedInt32ExtensionLite , 0));
2513 assertEqualsExactType(602L , message.getExtension(packedInt64ExtensionLite , 0));
2514 assertEqualsExactType(603 , message.getExtension(packedUint32ExtensionLite , 0));
2515 assertEqualsExactType(604L , message.getExtension(packedUint64ExtensionLite , 0));
2516 assertEqualsExactType(605 , message.getExtension(packedSint32ExtensionLite , 0));
2517 assertEqualsExactType(606L , message.getExtension(packedSint64ExtensionLite , 0));
2518 assertEqualsExactType(607 , message.getExtension(packedFixed32ExtensionLite , 0));
2519 assertEqualsExactType(608L , message.getExtension(packedFixed64ExtensionLite , 0));
2520 assertEqualsExactType(609 , message.getExtension(packedSfixed32ExtensionLit e, 0));
2521 assertEqualsExactType(610L , message.getExtension(packedSfixed64ExtensionLit e, 0));
2522 assertEqualsExactType(611F , message.getExtension(packedFloatExtensionLite , 0));
2523 assertEqualsExactType(612D , message.getExtension(packedDoubleExtensionLite , 0));
2524 assertEqualsExactType(true , message.getExtension(packedBoolExtensionLite , 0));
2525 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAR,
2526 message.getExtension(packedEnumExtensionLite, 0));
2527 assertEqualsExactType(701 , message.getExtension(packedInt32ExtensionLite , 1));
2528 assertEqualsExactType(702L , message.getExtension(packedInt64ExtensionLite , 1));
2529 assertEqualsExactType(703 , message.getExtension(packedUint32ExtensionLite , 1));
2530 assertEqualsExactType(704L , message.getExtension(packedUint64ExtensionLite , 1));
2531 assertEqualsExactType(705 , message.getExtension(packedSint32ExtensionLite , 1));
2532 assertEqualsExactType(706L , message.getExtension(packedSint64ExtensionLite , 1));
2533 assertEqualsExactType(707 , message.getExtension(packedFixed32ExtensionLite , 1));
2534 assertEqualsExactType(708L , message.getExtension(packedFixed64ExtensionLite , 1));
2535 assertEqualsExactType(709 , message.getExtension(packedSfixed32ExtensionLit e, 1));
2536 assertEqualsExactType(710L , message.getExtension(packedSfixed64ExtensionLit e, 1));
2537 assertEqualsExactType(711F , message.getExtension(packedFloatExtensionLite , 1));
2538 assertEqualsExactType(712D , message.getExtension(packedDoubleExtensionLite , 1));
2539 assertEqualsExactType(false, message.getExtension(packedBoolExtensionLite , 1));
2540 assertEqualsExactType(ForeignEnumLite.FOREIGN_LITE_BAZ,
2541 message.getExtension(packedEnumExtensionLite, 1));
2542 }
2543
2544 // ===================================================================
2545 // oneof
2546 public static void setOneof(TestOneof2.Builder message) {
2547 message.setFooLazyMessage(
2548 TestOneof2.NestedMessage.newBuilder().setQuxInt(100).build());
2549 message.setBarString("101");
2550 message.setBazInt(102);
2551 message.setBazString("103");
2552 }
2553
2554 public static void assertOneofSet(TestOneof2 message) {
2555 Assert.assertTrue(message.hasFooLazyMessage ());
2556 Assert.assertTrue(message.getFooLazyMessage().hasQuxInt());
2557
2558 Assert.assertTrue(message.hasBarString());
2559 Assert.assertTrue(message.hasBazInt ());
2560 Assert.assertTrue(message.hasBazString());
2561
2562 Assert.assertEquals(100 , message.getFooLazyMessage().getQuxInt());
2563 Assert.assertEquals("101", message.getBarString ());
2564 Assert.assertEquals(102 , message.getBazInt ());
2565 Assert.assertEquals("103", message.getBazString ());
2566 }
2567
2568 public static void assertAtMostOneFieldSetOneof(TestOneof2 message) {
2569 int count = 0;
2570 if (message.hasFooInt()) { ++count; }
2571 if (message.hasFooString()) { ++count; }
2572 if (message.hasFooCord()) { ++count; }
2573 if (message.hasFooStringPiece()) { ++count; }
2574 if (message.hasFooBytes()) { ++count; }
2575 if (message.hasFooEnum()) { ++count; }
2576 if (message.hasFooMessage()) { ++count; }
2577 if (message.hasFooGroup()) { ++count; }
2578 if (message.hasFooLazyMessage()) { ++count; }
2579 Assert.assertTrue(count <= 1);
2580
2581 count = 0;
2582 if (message.hasBarInt()) { ++count; }
2583 if (message.hasBarString()) { ++count; }
2584 if (message.hasBarCord()) { ++count; }
2585 if (message.hasBarStringPiece()) { ++count; }
2586 if (message.hasBarBytes()) { ++count; }
2587 if (message.hasBarEnum()) { ++count; }
2588 Assert.assertTrue(count <= 1);
2589
2590 switch (message.getFooCase()) {
2591 case FOO_INT:
2592 Assert.assertTrue(message.hasFooInt());
2593 break;
2594 case FOO_STRING:
2595 Assert.assertTrue(message.hasFooString());
2596 break;
2597 case FOO_CORD:
2598 Assert.assertTrue(message.hasFooCord());
2599 break;
2600 case FOO_BYTES:
2601 Assert.assertTrue(message.hasFooBytes());
2602 break;
2603 case FOO_ENUM:
2604 Assert.assertTrue(message.hasFooEnum());
2605 break;
2606 case FOO_MESSAGE:
2607 Assert.assertTrue(message.hasFooMessage());
2608 break;
2609 case FOOGROUP:
2610 Assert.assertTrue(message.hasFooGroup());
2611 break;
2612 case FOO_LAZY_MESSAGE:
2613 Assert.assertTrue(message.hasFooLazyMessage());
2614 break;
2615 case FOO_NOT_SET:
2616 break;
2617 }
2618 }
2619
2620 // ================================================================= 1861 // =================================================================
2621 1862
2622 /** 1863 /**
2623 * Performs the same things that the methods of {@code TestUtil} do, but 1864 * Performs the same things that the methods of {@code TestUtil} do, but
2624 * via the reflection interface. This is its own class because it needs 1865 * via the reflection interface. This is its own class because it needs
2625 * to know what descriptor to use. 1866 * to know what descriptor to use.
2626 */ 1867 */
2627 public static class ReflectionTester { 1868 public static class ReflectionTester {
2628 private final Descriptors.Descriptor baseDescriptor; 1869 private final Descriptors.Descriptor baseDescriptor;
2629 private final ExtensionRegistry extensionRegistry; 1870 private final ExtensionRegistry extensionRegistry;
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after
2776 * Calls {@code parent.newBuilderForField()} or uses the 2017 * Calls {@code parent.newBuilderForField()} or uses the
2777 * {@code ExtensionRegistry} to find an appropriate builder, depending 2018 * {@code ExtensionRegistry} to find an appropriate builder, depending
2778 * on what type is being tested. 2019 * on what type is being tested.
2779 */ 2020 */
2780 private Message.Builder newBuilderForField( 2021 private Message.Builder newBuilderForField(
2781 Message.Builder parent, Descriptors.FieldDescriptor field) { 2022 Message.Builder parent, Descriptors.FieldDescriptor field) {
2782 if (extensionRegistry == null) { 2023 if (extensionRegistry == null) {
2783 return parent.newBuilderForField(field); 2024 return parent.newBuilderForField(field);
2784 } else { 2025 } else {
2785 ExtensionRegistry.ExtensionInfo extension = 2026 ExtensionRegistry.ExtensionInfo extension =
2786 extensionRegistry.findImmutableExtensionByNumber( 2027 extensionRegistry.findExtensionByNumber(field.getContainingType(),
2787 field.getContainingType(), field.getNumber()); 2028 field.getNumber());
2788 Assert.assertNotNull(extension); 2029 Assert.assertNotNull(extension);
2789 Assert.assertNotNull(extension.defaultInstance); 2030 Assert.assertNotNull(extension.defaultInstance);
2790 return extension.defaultInstance.newBuilderForType(); 2031 return extension.defaultInstance.newBuilderForType();
2791 } 2032 }
2792 } 2033 }
2793 2034
2794 // ------------------------------------------------------------------- 2035 // -------------------------------------------------------------------
2795 2036
2796 /** 2037 /**
2797 * Set every field of {@code message} to the values expected by 2038 * Set every field of {@code message} to the values expected by
(...skipping 141 matching lines...) Expand 10 before | Expand all | Expand 10 after
2939 message.setField(f("default_bool" ), false); 2180 message.setField(f("default_bool" ), false);
2940 message.setField(f("default_string" ), "415"); 2181 message.setField(f("default_string" ), "415");
2941 message.setField(f("default_bytes" ), toBytes("416")); 2182 message.setField(f("default_bytes" ), toBytes("416"));
2942 2183
2943 message.setField(f("default_nested_enum" ), nestedFoo); 2184 message.setField(f("default_nested_enum" ), nestedFoo);
2944 message.setField(f("default_foreign_enum"), foreignFoo); 2185 message.setField(f("default_foreign_enum"), foreignFoo);
2945 message.setField(f("default_import_enum" ), importFoo); 2186 message.setField(f("default_import_enum" ), importFoo);
2946 2187
2947 message.setField(f("default_string_piece" ), "424"); 2188 message.setField(f("default_string_piece" ), "424");
2948 message.setField(f("default_cord" ), "425"); 2189 message.setField(f("default_cord" ), "425");
2949
2950 message.setField(f("oneof_uint32" ), 601);
2951 message.setField(f("oneof_nested_message"),
2952 newBuilderForField(message, f("oneof_nested_message"))
2953 .setField(nestedB, 602).build());
2954 message.setField(f("oneof_string" ), "603");
2955 message.setField(f("oneof_bytes" ), toBytes("604"));
2956 } 2190 }
2957 2191
2958 // ------------------------------------------------------------------- 2192 // -------------------------------------------------------------------
2959 2193
2960 /** 2194 /**
2961 * Modify the repeated fields of {@code message} to contain the values 2195 * Modify the repeated fields of {@code message} to contain the values
2962 * expected by {@code assertRepeatedFieldsModified()}, using the 2196 * expected by {@code assertRepeatedFieldsModified()}, using the
2963 * {@link Message.Builder} reflection interface. 2197 * {@link Message.Builder} reflection interface.
2964 */ 2198 */
2965 void modifyRepeatedFieldsViaReflection(Message.Builder message) { 2199 void modifyRepeatedFieldsViaReflection(Message.Builder message) {
(...skipping 274 matching lines...) Expand 10 before | Expand all | Expand 10 after
3240 Assert.assertEquals(false, message.getField(f("default_bool" ))); 2474 Assert.assertEquals(false, message.getField(f("default_bool" )));
3241 Assert.assertEquals("415", message.getField(f("default_string" ))); 2475 Assert.assertEquals("415", message.getField(f("default_string" )));
3242 Assert.assertEquals(toBytes("416"), message.getField(f("default_bytes"))); 2476 Assert.assertEquals(toBytes("416"), message.getField(f("default_bytes")));
3243 2477
3244 Assert.assertEquals( nestedFoo, message.getField(f("default_nested_enum" ) )); 2478 Assert.assertEquals( nestedFoo, message.getField(f("default_nested_enum" ) ));
3245 Assert.assertEquals(foreignFoo, message.getField(f("default_foreign_enum") )); 2479 Assert.assertEquals(foreignFoo, message.getField(f("default_foreign_enum") ));
3246 Assert.assertEquals( importFoo, message.getField(f("default_import_enum" ) )); 2480 Assert.assertEquals( importFoo, message.getField(f("default_import_enum" ) ));
3247 2481
3248 Assert.assertEquals("424", message.getField(f("default_string_piece"))); 2482 Assert.assertEquals("424", message.getField(f("default_string_piece")));
3249 Assert.assertEquals("425", message.getField(f("default_cord"))); 2483 Assert.assertEquals("425", message.getField(f("default_cord")));
3250
3251 Assert.assertTrue(message.hasField(f("oneof_bytes")));
3252 Assert.assertEquals(toBytes("604"), message.getField(f("oneof_bytes")));
3253
3254 if (extensionRegistry == null) {
3255 Assert.assertFalse(message.hasField(f("oneof_uint32")));
3256 Assert.assertFalse(message.hasField(f("oneof_nested_message")));
3257 Assert.assertFalse(message.hasField(f("oneof_string")));
3258 } else {
3259 Assert.assertTrue(message.hasField(f("oneof_uint32")));
3260 Assert.assertTrue(message.hasField(f("oneof_nested_message")));
3261 Assert.assertTrue(message.hasField(f("oneof_string")));
3262 Assert.assertEquals(601, message.getField(f("oneof_uint32")));
3263 Assert.assertEquals(602,
3264 ((MessageOrBuilder) message.getField(f("oneof_nested_message")))
3265 .getField(nestedB));
3266 Assert.assertEquals("603", message.getField(f("oneof_string")));
3267 }
3268 } 2484 }
3269 2485
3270 // ------------------------------------------------------------------- 2486 // -------------------------------------------------------------------
3271 2487
3272 /** 2488 /**
3273 * Assert (using {@code junit.framework.Assert}} that all fields of 2489 * Assert (using {@code junit.framework.Assert}} that all fields of
3274 * {@code message} are cleared, and that getting the fields returns their 2490 * {@code message} are cleared, and that getting the fields returns their
3275 * default values, using the {@link Message} reflection interface. 2491 * default values, using the {@link Message} reflection interface.
3276 */ 2492 */
3277 public void assertClearViaReflection(MessageOrBuilder message) { 2493 public void assertClearViaReflection(MessageOrBuilder message) {
(...skipping 157 matching lines...) Expand 10 before | Expand all | Expand 10 after
3435 Assert.assertEquals(true , message.getField(f("default_bool" ))); 2651 Assert.assertEquals(true , message.getField(f("default_bool" )));
3436 Assert.assertEquals("hello", message.getField(f("default_string" ))); 2652 Assert.assertEquals("hello", message.getField(f("default_string" )));
3437 Assert.assertEquals(toBytes("world"), message.getField(f("default_bytes")) ); 2653 Assert.assertEquals(toBytes("world"), message.getField(f("default_bytes")) );
3438 2654
3439 Assert.assertEquals( nestedBar, message.getField(f("default_nested_enum" ) )); 2655 Assert.assertEquals( nestedBar, message.getField(f("default_nested_enum" ) ));
3440 Assert.assertEquals(foreignBar, message.getField(f("default_foreign_enum") )); 2656 Assert.assertEquals(foreignBar, message.getField(f("default_foreign_enum") ));
3441 Assert.assertEquals( importBar, message.getField(f("default_import_enum" ) )); 2657 Assert.assertEquals( importBar, message.getField(f("default_import_enum" ) ));
3442 2658
3443 Assert.assertEquals("abc", message.getField(f("default_string_piece"))); 2659 Assert.assertEquals("abc", message.getField(f("default_string_piece")));
3444 Assert.assertEquals("123", message.getField(f("default_cord"))); 2660 Assert.assertEquals("123", message.getField(f("default_cord")));
3445
3446 Assert.assertFalse(message.hasField(f("oneof_uint32")));
3447 Assert.assertFalse(message.hasField(f("oneof_nested_message")));
3448 Assert.assertFalse(message.hasField(f("oneof_string")));
3449 Assert.assertFalse(message.hasField(f("oneof_bytes")));
3450
3451 Assert.assertEquals(0, message.getField(f("oneof_uint32")));
3452 Assert.assertEquals("", message.getField(f("oneof_string")));
3453 Assert.assertEquals(toBytes(""), message.getField(f("oneof_bytes")));
3454 } 2661 }
3455 2662
3456 2663
3457 // --------------------------------------------------------------- 2664 // ---------------------------------------------------------------
3458 2665
3459 public void assertRepeatedFieldsModifiedViaReflection( 2666 public void assertRepeatedFieldsModifiedViaReflection(
3460 MessageOrBuilder message) { 2667 MessageOrBuilder message) {
3461 // ModifyRepeatedFields only sets the second repeated element of each 2668 // ModifyRepeatedFields only sets the second repeated element of each
3462 // field. In addition to verifying this, we also verify that the first 2669 // field. In addition to verifying this, we also verify that the first
3463 // element and size were *not* modified. 2670 // element and size were *not* modified.
(...skipping 310 matching lines...) Expand 10 before | Expand all | Expand 10 after
3774 while (ancestor != null && ancestor.exists()) { 2981 while (ancestor != null && ancestor.exists()) {
3775 if (new File(ancestor, "src/google/protobuf").exists()) { 2982 if (new File(ancestor, "src/google/protobuf").exists()) {
3776 return new File(ancestor, "src/google/protobuf/testdata"); 2983 return new File(ancestor, "src/google/protobuf/testdata");
3777 } 2984 }
3778 ancestor = ancestor.getParentFile(); 2985 ancestor = ancestor.getParentFile();
3779 } 2986 }
3780 2987
3781 throw new RuntimeException( 2988 throw new RuntimeException(
3782 "Could not find golden files. This test must be run from within the " + 2989 "Could not find golden files. This test must be run from within the " +
3783 "protobuf source package so that it can read test data files from the " + 2990 "protobuf source package so that it can read test data files from the " +
3784 "C++ source tree."); 2991 "C++ source tree: " + new File(".").getAbsolutePath());
3785 } 2992 }
3786 2993
3787 /** 2994 /**
3788 * @param filename The path relative to 2995 * @param filename The path relative to
3789 * {@link #getTestDataDir}. 2996 * {@link #getTestDataDir}.
3790 */ 2997 */
3791 public static ByteString readBytesFromFile(String filename) { 2998 public static ByteString readBytesFromFile(String filename) {
3792 File fullPath = new File(getTestDataDir(), filename); 2999 File fullPath = new File(getTestDataDir(), filename);
3793 try { 3000 try {
3794 RandomAccessFile file = new RandomAccessFile(fullPath, "r"); 3001 RandomAccessFile file = new RandomAccessFile(fullPath, "r");
(...skipping 10 matching lines...) Expand all
3805 3012
3806 /** 3013 /**
3807 * Get the bytes of the "golden message". This is a serialized TestAllTypes 3014 * Get the bytes of the "golden message". This is a serialized TestAllTypes
3808 * with all fields set as they would be by 3015 * with all fields set as they would be by
3809 * {@link #setAllFields(TestAllTypes.Builder)}, but it is loaded from a file 3016 * {@link #setAllFields(TestAllTypes.Builder)}, but it is loaded from a file
3810 * on disk rather than generated dynamically. The file is actually generated 3017 * on disk rather than generated dynamically. The file is actually generated
3811 * by C++ code, so testing against it verifies compatibility with C++. 3018 * by C++ code, so testing against it verifies compatibility with C++.
3812 */ 3019 */
3813 public static ByteString getGoldenMessage() { 3020 public static ByteString getGoldenMessage() {
3814 if (goldenMessage == null) { 3021 if (goldenMessage == null) {
3815 goldenMessage = readBytesFromFile("golden_message_oneof_implemented"); 3022 goldenMessage = readBytesFromFile("golden_message");
3816 } 3023 }
3817 return goldenMessage; 3024 return goldenMessage;
3818 } 3025 }
3819 private static ByteString goldenMessage = null; 3026 private static ByteString goldenMessage = null;
3820 3027
3821 /** 3028 /**
3822 * Get the bytes of the "golden packed fields message". This is a serialized 3029 * Get the bytes of the "golden packed fields message". This is a serialized
3823 * TestPackedTypes with all fields set as they would be by 3030 * TestPackedTypes with all fields set as they would be by
3824 * {@link #setPackedFields(TestPackedTypes.Builder)}, but it is loaded from a 3031 * {@link #setPackedFields(TestPackedTypes.Builder)}, but it is loaded from a
3825 * file on disk rather than generated dynamically. The file is actually 3032 * file on disk rather than generated dynamically. The file is actually
3826 * generated by C++ code, so testing against it verifies compatibility with 3033 * generated by C++ code, so testing against it verifies compatibility with
3827 * C++. 3034 * C++.
3828 */ 3035 */
3829 public static ByteString getGoldenPackedFieldsMessage() { 3036 public static ByteString getGoldenPackedFieldsMessage() {
3830 if (goldenPackedFieldsMessage == null) { 3037 if (goldenPackedFieldsMessage == null) {
3831 goldenPackedFieldsMessage = 3038 goldenPackedFieldsMessage =
3832 readBytesFromFile("golden_packed_fields_message"); 3039 readBytesFromFile("golden_packed_fields_message");
3833 } 3040 }
3834 return goldenPackedFieldsMessage; 3041 return goldenPackedFieldsMessage;
3835 } 3042 }
3836 private static ByteString goldenPackedFieldsMessage = null; 3043 private static ByteString goldenPackedFieldsMessage = null;
3837 3044
3045 public static abstract class HackMessage extends GeneratedMessage {
3046 public interface MyInterface extends BuilderParent {
3047 }
3048 }
3838 /** 3049 /**
3839 * Mock implementation of {@link GeneratedMessage.BuilderParent} for testing. 3050 * Mock implementation of {@link GeneratedMessage.BuilderParent} for testing.
3840 * 3051 *
3841 * @author jonp@google.com (Jon Perlow) 3052 * @author jonp@google.com (Jon Perlow)
3842 */ 3053 */
3843 public static class MockBuilderParent 3054 public static class MockBuilderParent
3844 implements GeneratedMessage.BuilderParent { 3055 implements HackMessage.MyInterface {
3845 3056
3846 private int invalidations; 3057 private int invalidations;
3847 3058
3848 @Override 3059 //@Override (Java 1.6 override semantics, but we must support 1.5)
3849 public void markDirty() { 3060 public void markDirty() {
3850 invalidations++; 3061 invalidations++;
3851 } 3062 }
3852 3063
3853 public int getInvalidationCount() { 3064 public int getInvalidationCount() {
3854 return invalidations; 3065 return invalidations;
3855 } 3066 }
3856 } 3067 }
3857 } 3068 }
OLDNEW
« no previous file with comments | « third_party/protobuf/java/compatibility_tests/v2.5.0/tests/src/main/java/com/google/protobuf/test/TestBadIdentifiers.java ('k') | third_party/protobuf/java/compatibility_tests/v2.5.0/tests/src/main/java/com/google/protobuf/test/TextFormatTest.java » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698