review.tizen.org Git - tools/dynpart-tools.git/blob

   1 // Protocol Buffers - Google's data interchange format
   2 // Copyright 2008 Google Inc.  All rights reserved.
   3 // http://code.google.com/p/protobuf/
   4 //
   5 // Redistribution and use in source and binary forms, with or without
   6 // modification, are permitted provided that the following conditions are
   7 // met:
   8 //
   9 //     * Redistributions of source code must retain the above copyright
  10 // notice, this list of conditions and the following disclaimer.
  11 //     * Redistributions in binary form must reproduce the above
  12 // copyright notice, this list of conditions and the following disclaimer
  13 // in the documentation and/or other materials provided with the
  14 // distribution.
  15 //     * Neither the name of Google Inc. nor the names of its
  16 // contributors may be used to endorse or promote products derived from
  17 // this software without specific prior written permission.
  18 //
  19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  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.
  30
  31 package com.google.protobuf.test;
  32 import com.google.protobuf.*;
  33
  34 import com.google.protobuf.DescriptorProtos.DescriptorProto;
  35 import com.google.protobuf.DescriptorProtos.EnumDescriptorProto;
  36 import com.google.protobuf.DescriptorProtos.EnumValueDescriptorProto;
  37 import com.google.protobuf.DescriptorProtos.FieldDescriptorProto;
  38 import com.google.protobuf.DescriptorProtos.FileDescriptorProto;
  39 import com.google.protobuf.Descriptors.DescriptorValidationException;
  40 import com.google.protobuf.Descriptors.FileDescriptor;
  41 import com.google.protobuf.Descriptors.Descriptor;
  42 import com.google.protobuf.Descriptors.FieldDescriptor;
  43 import com.google.protobuf.Descriptors.EnumDescriptor;
  44 import com.google.protobuf.Descriptors.EnumValueDescriptor;
  45 import com.google.protobuf.Descriptors.ServiceDescriptor;
  46 import com.google.protobuf.Descriptors.MethodDescriptor;
  47
  48 import com.google.protobuf.test.UnittestImport;
  49 import com.google.protobuf.test.UnittestImport.ImportEnum;
  50 import com.google.protobuf.test.UnittestImport.ImportMessage;
  51 import protobuf_unittest.UnittestProto;
  52 import protobuf_unittest.UnittestProto.ForeignEnum;
  53 import protobuf_unittest.UnittestProto.ForeignMessage;
  54 import protobuf_unittest.UnittestProto.TestAllTypes;
  55 import protobuf_unittest.UnittestProto.TestAllExtensions;
  56 import protobuf_unittest.UnittestProto.TestExtremeDefaultValues;
  57 import protobuf_unittest.UnittestProto.TestRequired;
  58 import protobuf_unittest.UnittestProto.TestService;
  59 import protobuf_unittest.UnittestCustomOptions;
  60
  61
  62 import junit.framework.TestCase;
  63
  64 import java.util.Arrays;
  65 import java.util.Collections;
  66 import java.util.List;
  67
  68 /**
  69  * Unit test for {@link Descriptors}.
  70  *
  71  * @author kenton@google.com Kenton Varda
  72  */
  73 public class DescriptorsTest extends TestCase {
  74
  75   // Regression test for bug where referencing a FieldDescriptor.Type value
  76   // before a FieldDescriptorProto.Type value would yield a
  77   // ExceptionInInitializerError.
  78   @SuppressWarnings("unused")
  79   private static final Object STATIC_INIT_TEST = FieldDescriptor.Type.BOOL;
  80
  81   public void testFieldTypeEnumMapping() throws Exception {
  82     assertEquals(FieldDescriptor.Type.values().length,
  83         FieldDescriptorProto.Type.values().length);
  84     for (FieldDescriptor.Type type : FieldDescriptor.Type.values()) {
  85       FieldDescriptorProto.Type protoType = type.toProto();
  86       assertEquals("TYPE_" + type.name(), protoType.name());
  87       assertEquals(type, FieldDescriptor.Type.valueOf(protoType));
  88     }
  89   }
  90
  91   public void testFileDescriptor() throws Exception {
  92     FileDescriptor file = UnittestProto.getDescriptor();
  93
  94     assertEquals("google/protobuf/unittest.proto", file.getName());
  95     assertEquals("protobuf_unittest", file.getPackage());
  96
  97     assertEquals("UnittestProto", file.getOptions().getJavaOuterClassname());
  98     assertEquals("google/protobuf/unittest.proto",
  99                  file.toProto().getName());
 100
 101     assertEquals(Arrays.asList(UnittestImport.getDescriptor()),
 102                  file.getDependencies());
 103
 104     Descriptor messageType = TestAllTypes.getDescriptor();
 105     assertEquals(messageType, file.getMessageTypes().get(0));
 106     assertEquals(messageType, file.findMessageTypeByName("TestAllTypes"));
 107     assertNull(file.findMessageTypeByName("NoSuchType"));
 108     assertNull(file.findMessageTypeByName("protobuf_unittest.TestAllTypes"));
 109     for (int i = 0; i < file.getMessageTypes().size(); i++) {
 110       assertEquals(i, file.getMessageTypes().get(i).getIndex());
 111     }
 112
 113     EnumDescriptor enumType = ForeignEnum.getDescriptor();
 114     assertEquals(enumType, file.getEnumTypes().get(0));
 115     assertEquals(enumType, file.findEnumTypeByName("ForeignEnum"));
 116     assertNull(file.findEnumTypeByName("NoSuchType"));
 117     assertNull(file.findEnumTypeByName("protobuf_unittest.ForeignEnum"));
 118     assertEquals(Arrays.asList(ImportEnum.getDescriptor()),
 119                  UnittestImport.getDescriptor().getEnumTypes());
 120     for (int i = 0; i < file.getEnumTypes().size(); i++) {
 121       assertEquals(i, file.getEnumTypes().get(i).getIndex());
 122     }
 123
 124     ServiceDescriptor service = TestService.getDescriptor();
 125     assertEquals(service, file.getServices().get(0));
 126     assertEquals(service, file.findServiceByName("TestService"));
 127     assertNull(file.findServiceByName("NoSuchType"));
 128     assertNull(file.findServiceByName("protobuf_unittest.TestService"));
 129     assertEquals(Collections.emptyList(),
 130                  UnittestImport.getDescriptor().getServices());
 131     for (int i = 0; i < file.getServices().size(); i++) {
 132       assertEquals(i, file.getServices().get(i).getIndex());
 133     }
 134
 135     FieldDescriptor extension =
 136       UnittestProto.optionalInt32Extension.getDescriptor();
 137     assertEquals(extension, file.getExtensions().get(0));
 138     assertEquals(extension,
 139                  file.findExtensionByName("optional_int32_extension"));
 140     assertNull(file.findExtensionByName("no_such_ext"));
 141     assertNull(file.findExtensionByName(
 142       "protobuf_unittest.optional_int32_extension"));
 143     assertEquals(Collections.emptyList(),
 144                  UnittestImport.getDescriptor().getExtensions());
 145     for (int i = 0; i < file.getExtensions().size(); i++) {
 146       assertEquals(i, file.getExtensions().get(i).getIndex());
 147     }
 148   }
 149
 150   public void testDescriptor() throws Exception {
 151     Descriptor messageType = TestAllTypes.getDescriptor();
 152     Descriptor nestedType = TestAllTypes.NestedMessage.getDescriptor();
 153
 154     assertEquals("TestAllTypes", messageType.getName());
 155     assertEquals("protobuf_unittest.TestAllTypes", messageType.getFullName());
 156     assertEquals(UnittestProto.getDescriptor(), messageType.getFile());
 157     assertNull(messageType.getContainingType());
 158     assertEquals(DescriptorProtos.MessageOptions.getDefaultInstance(),
 159                  messageType.getOptions());
 160     assertEquals("TestAllTypes", messageType.toProto().getName());
 161
 162     assertEquals("NestedMessage", nestedType.getName());
 163     assertEquals("protobuf_unittest.TestAllTypes.NestedMessage",
 164                  nestedType.getFullName());
 165     assertEquals(UnittestProto.getDescriptor(), nestedType.getFile());
 166     assertEquals(messageType, nestedType.getContainingType());
 167
 168     FieldDescriptor field = messageType.getFields().get(0);
 169     assertEquals("optional_int32", field.getName());
 170     assertEquals(field, messageType.findFieldByName("optional_int32"));
 171     assertNull(messageType.findFieldByName("no_such_field"));
 172     assertEquals(field, messageType.findFieldByNumber(1));
 173     assertNull(messageType.findFieldByNumber(571283));
 174     for (int i = 0; i < messageType.getFields().size(); i++) {
 175       assertEquals(i, messageType.getFields().get(i).getIndex());
 176     }
 177
 178     assertEquals(nestedType, messageType.getNestedTypes().get(0));
 179     assertEquals(nestedType, messageType.findNestedTypeByName("NestedMessage"));
 180     assertNull(messageType.findNestedTypeByName("NoSuchType"));
 181     for (int i = 0; i < messageType.getNestedTypes().size(); i++) {
 182       assertEquals(i, messageType.getNestedTypes().get(i).getIndex());
 183     }
 184
 185     EnumDescriptor enumType = TestAllTypes.NestedEnum.getDescriptor();
 186     assertEquals(enumType, messageType.getEnumTypes().get(0));
 187     assertEquals(enumType, messageType.findEnumTypeByName("NestedEnum"));
 188     assertNull(messageType.findEnumTypeByName("NoSuchType"));
 189     for (int i = 0; i < messageType.getEnumTypes().size(); i++) {
 190       assertEquals(i, messageType.getEnumTypes().get(i).getIndex());
 191     }
 192   }
 193
 194   public void testFieldDescriptor() throws Exception {
 195     Descriptor messageType = TestAllTypes.getDescriptor();
 196     FieldDescriptor primitiveField =
 197       messageType.findFieldByName("optional_int32");
 198     FieldDescriptor enumField =
 199       messageType.findFieldByName("optional_nested_enum");
 200     FieldDescriptor messageField =
 201       messageType.findFieldByName("optional_foreign_message");
 202     FieldDescriptor cordField =
 203       messageType.findFieldByName("optional_cord");
 204     FieldDescriptor extension =
 205       UnittestProto.optionalInt32Extension.getDescriptor();
 206     FieldDescriptor nestedExtension = TestRequired.single.getDescriptor();
 207
 208     assertEquals("optional_int32", primitiveField.getName());
 209     assertEquals("protobuf_unittest.TestAllTypes.optional_int32",
 210                  primitiveField.getFullName());
 211     assertEquals(1, primitiveField.getNumber());
 212     assertEquals(messageType, primitiveField.getContainingType());
 213     assertEquals(UnittestProto.getDescriptor(), primitiveField.getFile());
 214     assertEquals(FieldDescriptor.Type.INT32, primitiveField.getType());
 215     assertEquals(FieldDescriptor.JavaType.INT, primitiveField.getJavaType());
 216     assertEquals(DescriptorProtos.FieldOptions.getDefaultInstance(),
 217                  primitiveField.getOptions());
 218     assertFalse(primitiveField.isExtension());
 219     assertEquals("optional_int32", primitiveField.toProto().getName());
 220
 221     assertEquals("optional_nested_enum", enumField.getName());
 222     assertEquals(FieldDescriptor.Type.ENUM, enumField.getType());
 223     assertEquals(FieldDescriptor.JavaType.ENUM, enumField.getJavaType());
 224     assertEquals(TestAllTypes.NestedEnum.getDescriptor(),
 225                  enumField.getEnumType());
 226
 227     assertEquals("optional_foreign_message", messageField.getName());
 228     assertEquals(FieldDescriptor.Type.MESSAGE, messageField.getType());
 229     assertEquals(FieldDescriptor.JavaType.MESSAGE, messageField.getJavaType());
 230     assertEquals(ForeignMessage.getDescriptor(), messageField.getMessageType());
 231
 232     assertEquals("optional_cord", cordField.getName());
 233     assertEquals(FieldDescriptor.Type.STRING, cordField.getType());
 234     assertEquals(FieldDescriptor.JavaType.STRING, cordField.getJavaType());
 235     assertEquals(DescriptorProtos.FieldOptions.CType.CORD,
 236                  cordField.getOptions().getCtype());
 237
 238     assertEquals("optional_int32_extension", extension.getName());
 239     assertEquals("protobuf_unittest.optional_int32_extension",
 240                  extension.getFullName());
 241     assertEquals(1, extension.getNumber());
 242     assertEquals(TestAllExtensions.getDescriptor(),
 243                  extension.getContainingType());
 244     assertEquals(UnittestProto.getDescriptor(), extension.getFile());
 245     assertEquals(FieldDescriptor.Type.INT32, extension.getType());
 246     assertEquals(FieldDescriptor.JavaType.INT, extension.getJavaType());
 247     assertEquals(DescriptorProtos.FieldOptions.getDefaultInstance(),
 248                  extension.getOptions());
 249     assertTrue(extension.isExtension());
 250     assertEquals(null, extension.getExtensionScope());
 251     assertEquals("optional_int32_extension", extension.toProto().getName());
 252
 253     assertEquals("single", nestedExtension.getName());
 254     assertEquals("protobuf_unittest.TestRequired.single",
 255                  nestedExtension.getFullName());
 256     assertEquals(TestRequired.getDescriptor(),
 257                  nestedExtension.getExtensionScope());
 258   }
 259
 260   public void testFieldDescriptorLabel() throws Exception {
 261     FieldDescriptor requiredField =
 262       TestRequired.getDescriptor().findFieldByName("a");
 263     FieldDescriptor optionalField =
 264       TestAllTypes.getDescriptor().findFieldByName("optional_int32");
 265     FieldDescriptor repeatedField =
 266       TestAllTypes.getDescriptor().findFieldByName("repeated_int32");
 267
 268     assertTrue(requiredField.isRequired());
 269     assertFalse(requiredField.isRepeated());
 270     assertFalse(optionalField.isRequired());
 271     assertFalse(optionalField.isRepeated());
 272     assertFalse(repeatedField.isRequired());
 273     assertTrue(repeatedField.isRepeated());
 274   }
 275
 276   public void testFieldDescriptorDefault() throws Exception {
 277     Descriptor d = TestAllTypes.getDescriptor();
 278     assertFalse(d.findFieldByName("optional_int32").hasDefaultValue());
 279     assertEquals(0, d.findFieldByName("optional_int32").getDefaultValue());
 280     assertTrue(d.findFieldByName("default_int32").hasDefaultValue());
 281     assertEquals(41, d.findFieldByName("default_int32").getDefaultValue());
 282
 283     d = TestExtremeDefaultValues.getDescriptor();
 284     assertEquals(
 285       ByteString.copyFrom(
 286         "\0\001\007\b\f\n\r\t\013\\\'\"\u00fe".getBytes("ISO-8859-1")),
 287       d.findFieldByName("escaped_bytes").getDefaultValue());
 288     assertEquals(-1, d.findFieldByName("large_uint32").getDefaultValue());
 289     assertEquals(-1L, d.findFieldByName("large_uint64").getDefaultValue());
 290   }
 291
 292   public void testEnumDescriptor() throws Exception {
 293     EnumDescriptor enumType = ForeignEnum.getDescriptor();
 294     EnumDescriptor nestedType = TestAllTypes.NestedEnum.getDescriptor();
 295
 296     assertEquals("ForeignEnum", enumType.getName());
 297     assertEquals("protobuf_unittest.ForeignEnum", enumType.getFullName());
 298     assertEquals(UnittestProto.getDescriptor(), enumType.getFile());
 299     assertNull(enumType.getContainingType());
 300     assertEquals(DescriptorProtos.EnumOptions.getDefaultInstance(),
 301                  enumType.getOptions());
 302
 303     assertEquals("NestedEnum", nestedType.getName());
 304     assertEquals("protobuf_unittest.TestAllTypes.NestedEnum",
 305                  nestedType.getFullName());
 306     assertEquals(UnittestProto.getDescriptor(), nestedType.getFile());
 307     assertEquals(TestAllTypes.getDescriptor(), nestedType.getContainingType());
 308
 309     EnumValueDescriptor value = ForeignEnum.FOREIGN_FOO.getValueDescriptor();
 310     assertEquals(value, enumType.getValues().get(0));
 311     assertEquals("FOREIGN_FOO", value.getName());
 312     assertEquals(4, value.getNumber());
 313     assertEquals(value, enumType.findValueByName("FOREIGN_FOO"));
 314     assertEquals(value, enumType.findValueByNumber(4));
 315     assertNull(enumType.findValueByName("NO_SUCH_VALUE"));
 316     for (int i = 0; i < enumType.getValues().size(); i++) {
 317       assertEquals(i, enumType.getValues().get(i).getIndex());
 318     }
 319   }
 320
 321   public void testServiceDescriptor() throws Exception {
 322     ServiceDescriptor service = TestService.getDescriptor();
 323
 324     assertEquals("TestService", service.getName());
 325     assertEquals("protobuf_unittest.TestService", service.getFullName());
 326     assertEquals(UnittestProto.getDescriptor(), service.getFile());
 327
 328     assertEquals(2, service.getMethods().size());
 329
 330     MethodDescriptor fooMethod = service.getMethods().get(0);
 331     assertEquals("Foo", fooMethod.getName());
 332     assertEquals(UnittestProto.FooRequest.getDescriptor(),
 333                  fooMethod.getInputType());
 334     assertEquals(UnittestProto.FooResponse.getDescriptor(),
 335                  fooMethod.getOutputType());
 336     assertEquals(fooMethod, service.findMethodByName("Foo"));
 337
 338     MethodDescriptor barMethod = service.getMethods().get(1);
 339     assertEquals("Bar", barMethod.getName());
 340     assertEquals(UnittestProto.BarRequest.getDescriptor(),
 341                  barMethod.getInputType());
 342     assertEquals(UnittestProto.BarResponse.getDescriptor(),
 343                  barMethod.getOutputType());
 344     assertEquals(barMethod, service.findMethodByName("Bar"));
 345
 346     assertNull(service.findMethodByName("NoSuchMethod"));
 347
 348     for (int i = 0; i < service.getMethods().size(); i++) {
 349       assertEquals(i, service.getMethods().get(i).getIndex());
 350     }
 351   }
 352
 353
 354   public void testCustomOptions() throws Exception {
 355     Descriptor descriptor =
 356       UnittestCustomOptions.TestMessageWithCustomOptions.getDescriptor();
 357
 358     assertTrue(
 359       descriptor.getOptions().hasExtension(UnittestCustomOptions.messageOpt1));
 360     assertEquals(Integer.valueOf(-56),
 361       descriptor.getOptions().getExtension(UnittestCustomOptions.messageOpt1));
 362
 363     FieldDescriptor field = descriptor.findFieldByName("field1");
 364     assertNotNull(field);
 365
 366     assertTrue(
 367       field.getOptions().hasExtension(UnittestCustomOptions.fieldOpt1));
 368     assertEquals(Long.valueOf(8765432109L),
 369       field.getOptions().getExtension(UnittestCustomOptions.fieldOpt1));
 370
 371     EnumDescriptor enumType =
 372       UnittestCustomOptions.TestMessageWithCustomOptions.AnEnum.getDescriptor();
 373
 374     assertTrue(
 375       enumType.getOptions().hasExtension(UnittestCustomOptions.enumOpt1));
 376     assertEquals(Integer.valueOf(-789),
 377       enumType.getOptions().getExtension(UnittestCustomOptions.enumOpt1));
 378
 379     ServiceDescriptor service =
 380       UnittestCustomOptions.TestServiceWithCustomOptions.getDescriptor();
 381
 382     assertTrue(
 383       service.getOptions().hasExtension(UnittestCustomOptions.serviceOpt1));
 384     assertEquals(Long.valueOf(-9876543210L),
 385       service.getOptions().getExtension(UnittestCustomOptions.serviceOpt1));
 386
 387     MethodDescriptor method = service.findMethodByName("Foo");
 388     assertNotNull(method);
 389
 390     assertTrue(
 391       method.getOptions().hasExtension(UnittestCustomOptions.methodOpt1));
 392     assertEquals(UnittestCustomOptions.MethodOpt1.METHODOPT1_VAL2,
 393       method.getOptions().getExtension(UnittestCustomOptions.methodOpt1));
 394   }
 395
 396   /**
 397    * Test that the FieldDescriptor.Type enum is the same as the
 398    * WireFormat.FieldType enum.
 399    */
 400   public void testFieldTypeTablesMatch() throws Exception {
 401     FieldDescriptor.Type[] values1 = FieldDescriptor.Type.values();
 402     WireFormat.FieldType[] values2 = WireFormat.FieldType.values();
 403
 404     assertEquals(values1.length, values2.length);
 405
 406     for (int i = 0; i < values1.length; i++) {
 407       assertEquals(values1[i].toString(), values2[i].toString());
 408     }
 409   }
 410
 411   /**
 412    * Test that the FieldDescriptor.JavaType enum is the same as the
 413    * WireFormat.JavaType enum.
 414    */
 415   public void testJavaTypeTablesMatch() throws Exception {
 416     FieldDescriptor.JavaType[] values1 = FieldDescriptor.JavaType.values();
 417     WireFormat.JavaType[] values2 = WireFormat.JavaType.values();
 418
 419     assertEquals(values1.length, values2.length);
 420
 421     for (int i = 0; i < values1.length; i++) {
 422       assertEquals(values1[i].toString(), values2[i].toString());
 423     }
 424   }
 425
 426   public void testEnormousDescriptor() throws Exception {
 427     // The descriptor for this file is larger than 64k, yet it did not cause
 428     // a compiler error due to an over-long string literal.
 429     assertTrue(
 430         UnittestEnormousDescriptor.getDescriptor()
 431           .toProto().getSerializedSize() > 65536);
 432   }
 433
 434   /**
 435    * Tests that the DescriptorValidationException works as intended.
 436    */
 437   public void testDescriptorValidatorException() throws Exception {
 438     FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
 439       .setName("foo.proto")
 440       .addMessageType(DescriptorProto.newBuilder()
 441       .setName("Foo")
 442         .addField(FieldDescriptorProto.newBuilder()
 443           .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
 444           .setType(FieldDescriptorProto.Type.TYPE_INT32)
 445           .setName("foo")
 446           .setNumber(1)
 447           .setDefaultValue("invalid")
 448           .build())
 449         .build())
 450       .build();
 451     try {
 452       Descriptors.FileDescriptor.buildFrom(fileDescriptorProto,
 453           new FileDescriptor[0]);
 454       fail("DescriptorValidationException expected");
 455     } catch (DescriptorValidationException e) {
 456       // Expected; check that the error message contains some useful hints
 457       assertTrue(e.getMessage().indexOf("foo") != -1);
 458       assertTrue(e.getMessage().indexOf("Foo") != -1);
 459       assertTrue(e.getMessage().indexOf("invalid") != -1);
 460       assertTrue(e.getCause() instanceof NumberFormatException);
 461       assertTrue(e.getCause().getMessage().indexOf("invalid") != -1);
 462     }
 463   }
 464
 465   /**
 466    * Tests the translate/crosslink for an example where a message field's name
 467    * and type name are the same.
 468    */
 469   public void testDescriptorComplexCrosslink() throws Exception {
 470     FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
 471       .setName("foo.proto")
 472       .addMessageType(DescriptorProto.newBuilder()
 473         .setName("Foo")
 474         .addField(FieldDescriptorProto.newBuilder()
 475           .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
 476           .setType(FieldDescriptorProto.Type.TYPE_INT32)
 477           .setName("foo")
 478           .setNumber(1)
 479           .build())
 480         .build())
 481       .addMessageType(DescriptorProto.newBuilder()
 482         .setName("Bar")
 483         .addField(FieldDescriptorProto.newBuilder()
 484           .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
 485           .setTypeName("Foo")
 486           .setName("Foo")
 487           .setNumber(1)
 488           .build())
 489         .build())
 490       .build();
 491     // translate and crosslink
 492     FileDescriptor file =
 493       Descriptors.FileDescriptor.buildFrom(fileDescriptorProto,
 494           new FileDescriptor[0]);
 495     // verify resulting descriptors
 496     assertNotNull(file);
 497     List<Descriptor> msglist = file.getMessageTypes();
 498     assertNotNull(msglist);
 499     assertTrue(msglist.size() == 2);
 500     boolean barFound = false;
 501     for (Descriptor desc : msglist) {
 502       if (desc.getName().equals("Bar")) {
 503         barFound = true;
 504         assertNotNull(desc.getFields());
 505         List<FieldDescriptor> fieldlist = desc.getFields();
 506         assertNotNull(fieldlist);
 507         assertTrue(fieldlist.size() == 1);
 508         assertTrue(fieldlist.get(0).getType() == FieldDescriptor.Type.MESSAGE);
 509         assertTrue(fieldlist.get(0).getMessageType().getName().equals("Foo"));
 510       }
 511     }
 512     assertTrue(barFound);
 513   }
 514
 515   public void testInvalidPublicDependency() throws Exception {
 516     FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
 517         .setName("foo.proto") .build();
 518     FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
 519         .setName("boo.proto")
 520         .addDependency("foo.proto")
 521         .addPublicDependency(1)  // Error, should be 0.
 522         .build();
 523     FileDescriptor fooFile = Descriptors.FileDescriptor.buildFrom(fooProto,
 524         new FileDescriptor[0]);
 525     try {
 526       Descriptors.FileDescriptor.buildFrom(barProto,
 527           new FileDescriptor[] {fooFile});
 528       fail("DescriptorValidationException expected");
 529     } catch (DescriptorValidationException e) {
 530       assertTrue(
 531           e.getMessage().indexOf("Invalid public dependency index.") != -1);
 532     }
 533   }
 534
 535   public void testHiddenDependency() throws Exception {
 536     FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
 537         .setName("bar.proto")
 538         .addMessageType(DescriptorProto.newBuilder().setName("Bar"))
 539         .build();
 540     FileDescriptorProto forwardProto = FileDescriptorProto.newBuilder()
 541         .setName("forward.proto")
 542         .addDependency("bar.proto")
 543         .build();
 544     FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
 545         .setName("foo.proto")
 546         .addDependency("forward.proto")
 547         .addMessageType(DescriptorProto.newBuilder()
 548             .setName("Foo")
 549             .addField(FieldDescriptorProto.newBuilder()
 550                 .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
 551                 .setTypeName("Bar")
 552                 .setName("bar")
 553                 .setNumber(1)))
 554         .build();
 555     FileDescriptor barFile = Descriptors.FileDescriptor.buildFrom(
 556         barProto, new FileDescriptor[0]);
 557     FileDescriptor forwardFile = Descriptors.FileDescriptor.buildFrom(
 558         forwardProto, new FileDescriptor[] {barFile});
 559
 560     try {
 561       Descriptors.FileDescriptor.buildFrom(
 562           fooProto, new FileDescriptor[] {forwardFile});
 563       fail("DescriptorValidationException expected");
 564     } catch (DescriptorValidationException e) {
 565       assertTrue(e.getMessage().indexOf("Bar") != -1);
 566       assertTrue(e.getMessage().indexOf("is not defined") != -1);
 567     }
 568   }
 569
 570   public void testPublicDependency() throws Exception {
 571     FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
 572         .setName("bar.proto")
 573         .addMessageType(DescriptorProto.newBuilder().setName("Bar"))
 574         .build();
 575     FileDescriptorProto forwardProto = FileDescriptorProto.newBuilder()
 576         .setName("forward.proto")
 577         .addDependency("bar.proto")
 578         .addPublicDependency(0)
 579         .build();
 580     FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
 581         .setName("foo.proto")
 582         .addDependency("forward.proto")
 583         .addMessageType(DescriptorProto.newBuilder()
 584             .setName("Foo")
 585             .addField(FieldDescriptorProto.newBuilder()
 586                 .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
 587                 .setTypeName("Bar")
 588                 .setName("bar")
 589                 .setNumber(1)))
 590         .build();
 591     FileDescriptor barFile = Descriptors.FileDescriptor.buildFrom(
 592         barProto, new FileDescriptor[0]);
 593     FileDescriptor forwardFile = Descriptors.FileDescriptor.buildFrom(
 594         forwardProto, new FileDescriptor[]{barFile});
 595     Descriptors.FileDescriptor.buildFrom(
 596         fooProto, new FileDescriptor[] {forwardFile});
 597   }
 598
 599   /**
 600    * Tests the translate/crosslink for an example with a more complex namespace
 601    * referencing.
 602    */
 603   public void testComplexNamespacePublicDependency() throws Exception {
 604     FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
 605         .setName("bar.proto")
 606         .setPackage("a.b.c.d.bar.shared")
 607         .addEnumType(EnumDescriptorProto.newBuilder()
 608             .setName("MyEnum")
 609             .addValue(EnumValueDescriptorProto.newBuilder()
 610                 .setName("BLAH")
 611                 .setNumber(1)))
 612         .build();
 613     FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
 614         .setName("foo.proto")
 615         .addDependency("bar.proto")
 616         .setPackage("a.b.c.d.foo.shared")
 617         .addMessageType(DescriptorProto.newBuilder()
 618             .setName("MyMessage")
 619             .addField(FieldDescriptorProto.newBuilder()
 620                 .setLabel(FieldDescriptorProto.Label.LABEL_REPEATED)
 621                 .setTypeName("bar.shared.MyEnum")
 622                 .setName("MyField")
 623                 .setNumber(1)))
 624         .build();
 625     // translate and crosslink
 626     FileDescriptor fooFile = Descriptors.FileDescriptor.buildFrom(
 627         fooProto, new FileDescriptor[0]);
 628     FileDescriptor barFile = Descriptors.FileDescriptor.buildFrom(
 629         barProto, new FileDescriptor[]{fooFile});
 630     // verify resulting descriptors
 631     assertNotNull(barFile);
 632     List<Descriptor> msglist = barFile.getMessageTypes();
 633     assertNotNull(msglist);
 634     assertTrue(msglist.size() == 1);
 635     Descriptor desc = msglist.get(0);
 636     if (desc.getName().equals("MyMessage")) {
 637       assertNotNull(desc.getFields());
 638       List<FieldDescriptor> fieldlist = desc.getFields();
 639       assertNotNull(fieldlist);
 640       assertTrue(fieldlist.size() == 1);
 641       FieldDescriptor field = fieldlist.get(0);
 642       assertTrue(field.getType() == FieldDescriptor.Type.ENUM);
 643       assertTrue(field.getEnumType().getName().equals("MyEnum"));
 644       assertTrue(field.getEnumType().getFile().getName().equals("bar.proto"));
 645       assertTrue(field.getEnumType().getFile().getPackage().equals(
 646           "a.b.c.d.bar.shared"));
 647     }
 648   }
 649 }