Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / protobuf-javalite / 5e48fef659b571db38be18afb61bea0cffcdfdca / . / src / ProtocolBuffers.Test / DescriptorsTest.cs
blob: 671fb5a8462d47e3efd16abd7b1cc11e6dba7e97 [file] [log] [blame]
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]1#region Copyright notice and license
csharptestf1816be2011-05-19 12:01:16 -0500[diff] [blame]2
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]3// Protocol Buffers - Google's data interchange format
4// Copyright 2008 Google Inc. All rights reserved.
5// http://github.com/jskeet/dotnet-protobufs/
6// Original C++/Java/Python code:
7// http://code.google.com/p/protobuf/
8//
9// Redistribution and use in source and binary forms, with or without
10// modification, are permitted provided that the following conditions are
11// met:
12//
13// * Redistributions of source code must retain the above copyright
14// notice, this list of conditions and the following disclaimer.
15// * Redistributions in binary form must reproduce the above
16// copyright notice, this list of conditions and the following disclaimer
17// in the documentation and/or other materials provided with the
18// distribution.
19// * Neither the name of Google Inc. nor the names of its
20// contributors may be used to endorse or promote products derived from
21// this software without specific prior written permission.
22//
23// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
24// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
25// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
26// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
27// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
28// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
29// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
30// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
31// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
32// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
33// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
csharptestf1816be2011-05-19 12:01:16 -0500[diff] [blame]34
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]35#endregion
36
37using System.Text;
38using Google.ProtocolBuffers.Descriptors;
39using Google.ProtocolBuffers.TestProtos;
40using NUnit.Framework;
41
42namespace Google.ProtocolBuffers
43{
44 /// <summary>
45 /// Tests for descriptors. (Not in its own namespace or broken up into individual classes as the
46 /// size doesn't warrant it. On the other hand, this makes me feel a bit dirty...)
47 /// </summary>
48 [TestFixture]
49 public class DescriptorsTest
50 {
51 [Test]
52 public void FileDescriptor()
53 {
54 FileDescriptor file = UnitTestProtoFile.Descriptor;
55
56 Assert.AreEqual("google/protobuf/unittest.proto", file.Name);
57 Assert.AreEqual("protobuf_unittest", file.Package);
58
59 Assert.AreEqual("UnittestProto", file.Options.JavaOuterClassname);
60 Assert.AreEqual("google/protobuf/unittest.proto", file.Proto.Name);
61
62// TODO(jonskeet): Either change to expect 2 dependencies, or don't emit them.
63// Assert.AreEqual(2, file.Dependencies.Count);
64 Assert.AreEqual(UnitTestImportProtoFile.Descriptor, file.Dependencies[1]);
65
66 MessageDescriptor messageType = TestAllTypes.Descriptor;
67 Assert.AreEqual(messageType, file.MessageTypes[0]);
68 Assert.AreEqual(messageType, file.FindTypeByName<MessageDescriptor>("TestAllTypes"));
69 Assert.IsNull(file.FindTypeByName<MessageDescriptor>("NoSuchType"));
70 Assert.IsNull(file.FindTypeByName<MessageDescriptor>("protobuf_unittest.TestAllTypes"));
71 for (int i = 0; i < file.MessageTypes.Count; i++)
72 {
73 Assert.AreEqual(i, file.MessageTypes[i].Index);
74 }
75
76 Assert.AreEqual(file.EnumTypes[0], file.FindTypeByName<EnumDescriptor>("ForeignEnum"));
77 Assert.IsNull(file.FindTypeByName<EnumDescriptor>("NoSuchType"));
78 Assert.IsNull(file.FindTypeByName<EnumDescriptor>("protobuf_unittest.ForeignEnum"));
79 Assert.AreEqual(1, UnitTestImportProtoFile.Descriptor.EnumTypes.Count);
80 Assert.AreEqual("ImportEnum", UnitTestImportProtoFile.Descriptor.EnumTypes[0].Name);
81 for (int i = 0; i < file.EnumTypes.Count; i++)
82 {
83 Assert.AreEqual(i, file.EnumTypes[i].Index);
84 }
85
86 ServiceDescriptor service = TestGenericService.Descriptor;
87 Assert.AreEqual(service, UnitTestGenericServices.Descriptor.Services[0]);
88 Assert.AreEqual(service,
89 UnitTestGenericServices.Descriptor.FindTypeByName<ServiceDescriptor>("TestGenericService"));
90 Assert.IsNull(UnitTestGenericServices.Descriptor.FindTypeByName<ServiceDescriptor>("NoSuchType"));
91 Assert.IsNull(
92 UnitTestGenericServices.Descriptor.FindTypeByName<ServiceDescriptor>(
93 "protobuf_unittest.TestGenericService"));
94 Assert.AreEqual(0, UnitTestImportProtoFile.Descriptor.Services.Count);
95 for (int i = 0; i < file.Services.Count; i++)
96 {
97 Assert.AreEqual(i, file.Services[i].Index);
98 }
99
100 FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor;
101 Assert.AreEqual(extension, file.Extensions[0]);
102 Assert.AreEqual(extension, file.FindTypeByName<FieldDescriptor>("optional_int32_extension"));
103 Assert.IsNull(file.FindTypeByName<FieldDescriptor>("no_such_ext"));
104 Assert.IsNull(file.FindTypeByName<FieldDescriptor>("protobuf_unittest.optional_int32_extension"));
105 Assert.AreEqual(0, UnitTestImportProtoFile.Descriptor.Extensions.Count);
106 for (int i = 0; i < file.Extensions.Count; i++)
107 {
108 Assert.AreEqual(i, file.Extensions[i].Index);
109 }
110 }
111
112 [Test]
113 public void MessageDescriptor()
114 {
115 MessageDescriptor messageType = TestAllTypes.Descriptor;
116 MessageDescriptor nestedType = TestAllTypes.Types.NestedMessage.Descriptor;
117
118 Assert.AreEqual("TestAllTypes", messageType.Name);
119 Assert.AreEqual("protobuf_unittest.TestAllTypes", messageType.FullName);
120 Assert.AreEqual(UnitTestProtoFile.Descriptor, messageType.File);
121 Assert.IsNull(messageType.ContainingType);
122 Assert.AreEqual(DescriptorProtos.MessageOptions.DefaultInstance, messageType.Options);
123 Assert.AreEqual("TestAllTypes", messageType.Proto.Name);
124
125 Assert.AreEqual("NestedMessage", nestedType.Name);
126 Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedMessage", nestedType.FullName);
127 Assert.AreEqual(UnitTestProtoFile.Descriptor, nestedType.File);
128 Assert.AreEqual(messageType, nestedType.ContainingType);
129
130 FieldDescriptor field = messageType.Fields[0];
131 Assert.AreEqual("optional_int32", field.Name);
132 Assert.AreEqual(field, messageType.FindDescriptor<FieldDescriptor>("optional_int32"));
133 Assert.IsNull(messageType.FindDescriptor<FieldDescriptor>("no_such_field"));
134 Assert.AreEqual(field, messageType.FindFieldByNumber(1));
135 Assert.IsNull(messageType.FindFieldByNumber(571283));
136 for (int i = 0; i < messageType.Fields.Count; i++)
137 {
138 Assert.AreEqual(i, messageType.Fields[i].Index);
139 }
140
141 Assert.AreEqual(nestedType, messageType.NestedTypes[0]);
142 Assert.AreEqual(nestedType, messageType.FindDescriptor<MessageDescriptor>("NestedMessage"));
143 Assert.IsNull(messageType.FindDescriptor<MessageDescriptor>("NoSuchType"));
144 for (int i = 0; i < messageType.NestedTypes.Count; i++)
145 {
146 Assert.AreEqual(i, messageType.NestedTypes[i].Index);
147 }
148
149 Assert.AreEqual(messageType.EnumTypes[0], messageType.FindDescriptor<EnumDescriptor>("NestedEnum"));
150 Assert.IsNull(messageType.FindDescriptor<EnumDescriptor>("NoSuchType"));
151 for (int i = 0; i < messageType.EnumTypes.Count; i++)
152 {
153 Assert.AreEqual(i, messageType.EnumTypes[i].Index);
154 }
155 }
156
157 [Test]
158 public void FieldDescriptor()
159 {
160 MessageDescriptor messageType = TestAllTypes.Descriptor;
161 FieldDescriptor primitiveField = messageType.FindDescriptor<FieldDescriptor>("optional_int32");
162 FieldDescriptor enumField = messageType.FindDescriptor<FieldDescriptor>("optional_nested_enum");
163 FieldDescriptor messageField = messageType.FindDescriptor<FieldDescriptor>("optional_foreign_message");
164 FieldDescriptor cordField = messageType.FindDescriptor<FieldDescriptor>("optional_cord");
165 FieldDescriptor extension = UnitTestProtoFile.OptionalInt32Extension.Descriptor;
166 FieldDescriptor nestedExtension = TestRequired.Single.Descriptor;
167
168 Assert.AreEqual("optional_int32", primitiveField.Name);
169 Assert.AreEqual("protobuf_unittest.TestAllTypes.optional_int32",
170 primitiveField.FullName);
171 Assert.AreEqual(1, primitiveField.FieldNumber);
172 Assert.AreEqual(messageType, primitiveField.ContainingType);
173 Assert.AreEqual(UnitTestProtoFile.Descriptor, primitiveField.File);
174 Assert.AreEqual(FieldType.Int32, primitiveField.FieldType);
175 Assert.AreEqual(MappedType.Int32, primitiveField.MappedType);
176 Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance, primitiveField.Options);
177 Assert.IsFalse(primitiveField.IsExtension);
178 Assert.AreEqual("optional_int32", primitiveField.Proto.Name);
179
180 Assert.AreEqual("optional_nested_enum", enumField.Name);
181 Assert.AreEqual(FieldType.Enum, enumField.FieldType);
182 Assert.AreEqual(MappedType.Enum, enumField.MappedType);
183 // Assert.AreEqual(TestAllTypes.Types.NestedEnum.Descriptor, enumField.EnumType);
184
185 Assert.AreEqual("optional_foreign_message", messageField.Name);
186 Assert.AreEqual(FieldType.Message, messageField.FieldType);
187 Assert.AreEqual(MappedType.Message, messageField.MappedType);
188 Assert.AreEqual(ForeignMessage.Descriptor, messageField.MessageType);
189
190 Assert.AreEqual("optional_cord", cordField.Name);
191 Assert.AreEqual(FieldType.String, cordField.FieldType);
192 Assert.AreEqual(MappedType.String, cordField.MappedType);
193 Assert.AreEqual(DescriptorProtos.FieldOptions.Types.CType.CORD, cordField.Options.Ctype);
194
195 Assert.AreEqual("optional_int32_extension", extension.Name);
196 Assert.AreEqual("protobuf_unittest.optional_int32_extension", extension.FullName);
197 Assert.AreEqual(1, extension.FieldNumber);
198 Assert.AreEqual(TestAllExtensions.Descriptor, extension.ContainingType);
199 Assert.AreEqual(UnitTestProtoFile.Descriptor, extension.File);
200 Assert.AreEqual(FieldType.Int32, extension.FieldType);
201 Assert.AreEqual(MappedType.Int32, extension.MappedType);
202 Assert.AreEqual(DescriptorProtos.FieldOptions.DefaultInstance,
203 extension.Options);
204 Assert.IsTrue(extension.IsExtension);
205 Assert.AreEqual(null, extension.ExtensionScope);
206 Assert.AreEqual("optional_int32_extension", extension.Proto.Name);
207
208 Assert.AreEqual("single", nestedExtension.Name);
209 Assert.AreEqual("protobuf_unittest.TestRequired.single",
210 nestedExtension.FullName);
211 Assert.AreEqual(TestRequired.Descriptor,
212 nestedExtension.ExtensionScope);
213 }
214
215 [Test]
216 public void FieldDescriptorLabel()
217 {
218 FieldDescriptor requiredField =
219 TestRequired.Descriptor.FindDescriptor<FieldDescriptor>("a");
220 FieldDescriptor optionalField =
221 TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("optional_int32");
222 FieldDescriptor repeatedField =
223 TestAllTypes.Descriptor.FindDescriptor<FieldDescriptor>("repeated_int32");
224
225 Assert.IsTrue(requiredField.IsRequired);
226 Assert.IsFalse(requiredField.IsRepeated);
227 Assert.IsFalse(optionalField.IsRequired);
228 Assert.IsFalse(optionalField.IsRepeated);
229 Assert.IsFalse(repeatedField.IsRequired);
230 Assert.IsTrue(repeatedField.IsRepeated);
231 }
232
233 [Test]
234 public void FieldDescriptorDefault()
235 {
236 MessageDescriptor d = TestAllTypes.Descriptor;
237 Assert.IsFalse(d.FindDescriptor<FieldDescriptor>("optional_int32").HasDefaultValue);
238 Assert.AreEqual(0, d.FindDescriptor<FieldDescriptor>("optional_int32").DefaultValue);
239 Assert.IsTrue(d.FindDescriptor<FieldDescriptor>("default_int32").HasDefaultValue);
240 Assert.AreEqual(41, d.FindDescriptor<FieldDescriptor>("default_int32").DefaultValue);
241
242 d = TestExtremeDefaultValues.Descriptor;
243 Assert.AreEqual(
244 ByteString.CopyFrom("\u0000\u0001\u0007\b\f\n\r\t\u000b\\\'\"\u00fe", Encoding.GetEncoding(28591)),
245 d.FindDescriptor<FieldDescriptor>("escaped_bytes").DefaultValue);
246 Assert.AreEqual(uint.MaxValue, d.FindDescriptor<FieldDescriptor>("large_uint32").DefaultValue);
247 Assert.AreEqual(ulong.MaxValue, d.FindDescriptor<FieldDescriptor>("large_uint64").DefaultValue);
248 }
249
250 [Test]
251 public void EnumDescriptor()
252 {
253 // Note: this test is a bit different to the Java version because there's no static way of getting to the descriptor
254 EnumDescriptor enumType = UnitTestProtoFile.Descriptor.FindTypeByName<EnumDescriptor>("ForeignEnum");
255 EnumDescriptor nestedType = TestAllTypes.Descriptor.FindDescriptor<EnumDescriptor>("NestedEnum");
256
257 Assert.AreEqual("ForeignEnum", enumType.Name);
258 Assert.AreEqual("protobuf_unittest.ForeignEnum", enumType.FullName);
259 Assert.AreEqual(UnitTestProtoFile.Descriptor, enumType.File);
260 Assert.IsNull(enumType.ContainingType);
261 Assert.AreEqual(DescriptorProtos.EnumOptions.DefaultInstance,
262 enumType.Options);
263
264 Assert.AreEqual("NestedEnum", nestedType.Name);
265 Assert.AreEqual("protobuf_unittest.TestAllTypes.NestedEnum",
266 nestedType.FullName);
267 Assert.AreEqual(UnitTestProtoFile.Descriptor, nestedType.File);
268 Assert.AreEqual(TestAllTypes.Descriptor, nestedType.ContainingType);
269
270 EnumValueDescriptor value = enumType.FindValueByName("FOREIGN_FOO");
271 Assert.AreEqual(value, enumType.Values[0]);
272 Assert.AreEqual("FOREIGN_FOO", value.Name);
273 Assert.AreEqual(4, value.Number);
274 Assert.AreEqual((int) ForeignEnum.FOREIGN_FOO, value.Number);
275 Assert.AreEqual(value, enumType.FindValueByNumber(4));
276 Assert.IsNull(enumType.FindValueByName("NO_SUCH_VALUE"));
277 for (int i = 0; i < enumType.Values.Count; i++)
278 {
279 Assert.AreEqual(i, enumType.Values[i].Index);
280 }
281 }
282
283 [Test]
284 public void ServiceDescriptor()
285 {
286 ServiceDescriptor service = TestGenericService.Descriptor;
287
288 Assert.AreEqual("TestGenericService", service.Name);
289 Assert.AreEqual("protobuf_unittest.TestGenericService", service.FullName);
290 Assert.AreEqual(UnitTestGenericServices.Descriptor, service.File);
291
292 Assert.AreEqual(2, service.Methods.Count);
293
294 MethodDescriptor fooMethod = service.Methods[0];
295 Assert.AreEqual("Foo", fooMethod.Name);
296 Assert.AreEqual(FooRequest.Descriptor, fooMethod.InputType);
297 Assert.AreEqual(FooResponse.Descriptor, fooMethod.OutputType);
298 Assert.AreEqual(fooMethod, service.FindMethodByName("Foo"));
299
300 MethodDescriptor barMethod = service.Methods[1];
301 Assert.AreEqual("Bar", barMethod.Name);
302 Assert.AreEqual(BarRequest.Descriptor, barMethod.InputType);
303 Assert.AreEqual(BarResponse.Descriptor, barMethod.OutputType);
304 Assert.AreEqual(barMethod, service.FindMethodByName("Bar"));
305
306 Assert.IsNull(service.FindMethodByName("NoSuchMethod"));
307
308 for (int i = 0; i < service.Methods.Count; i++)
309 {
310 Assert.AreEqual(i, service.Methods[i].Index);
311 }
312 }
313
314 [Test]
315 public void CustomOptions()
316 {
317 MessageDescriptor descriptor = TestMessageWithCustomOptions.Descriptor;
318 Assert.IsTrue(descriptor.Options.HasExtension(UnitTestCustomOptionsProtoFile.MessageOpt1));
319 Assert.AreEqual(-56, descriptor.Options.GetExtension(UnitTestCustomOptionsProtoFile.MessageOpt1));
320
321
322 FieldDescriptor field = descriptor.FindFieldByName("field1");
323 Assert.IsNotNull(field);
324
325 Assert.IsTrue(field.Options.HasExtension(UnitTestCustomOptionsProtoFile.FieldOpt1));
326 Assert.AreEqual(8765432109L, field.Options.GetExtension(UnitTestCustomOptionsProtoFile.FieldOpt1));
327
328 // TODO: Write out enum descriptors
329 /*
330 EnumDescriptor enumType = TestMessageWithCustomOptions.Types.
331 UnittestCustomOptions.TestMessageWithCustomOptions.AnEnum.getDescriptor();
332
333 Assert.IsTrue(
334 enumType.getOptions().hasExtension(UnittestCustomOptions.enumOpt1));
335 Assert.AreEqual(Integer.valueOf(-789),
336 enumType.getOptions().getExtension(UnittestCustomOptions.enumOpt1));
csharptestf1816be2011-05-19 12:01:16 -0500[diff] [blame]337 */
338
csharptest71f662c2011-05-20 15:15:34 -0500[diff] [blame]339 ServiceDescriptor service = TestGenericServiceWithCustomOptions.Descriptor;
340
341 Assert.IsTrue(service.Options.HasExtension(UnitTestCustomOptionsProtoFile.ServiceOpt1));
342 Assert.AreEqual(-9876543210L, service.Options.GetExtension(UnitTestCustomOptionsProtoFile.ServiceOpt1));
343
344 MethodDescriptor method = service.FindMethodByName("Foo");
345 Assert.IsNotNull(method);
346
347 Assert.IsTrue(method.Options.HasExtension(UnitTestCustomOptionsProtoFile.MethodOpt1));
348 Assert.AreEqual(MethodOpt1.METHODOPT1_VAL2,
349 method.Options.GetExtension(UnitTestCustomOptionsProtoFile.MethodOpt1));
350 }
351 }
352}