third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/java/compatibility_tests/v2.5.0/tests/src/main/java/com/google/protobuf/test/DescriptorsTest.java

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// https://developers.google.com/protocol-buffers/
+// http://code.google.com/p/protobuf/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
-package com.google.protobuf;
+package com.google.protobuf.test;
+import com.google.protobuf.*;
 
 import com.google.protobuf.DescriptorProtos.DescriptorProto;
 import com.google.protobuf.DescriptorProtos.EnumDescriptorProto;
 import com.google.protobuf.DescriptorProtos.EnumValueDescriptorProto;
 import com.google.protobuf.DescriptorProtos.FieldDescriptorProto;
 import com.google.protobuf.DescriptorProtos.FileDescriptorProto;
+import com.google.protobuf.Descriptors.DescriptorValidationException;
+import com.google.protobuf.Descriptors.FileDescriptor;
 import com.google.protobuf.Descriptors.Descriptor;
-import com.google.protobuf.Descriptors.DescriptorValidationException;
+import com.google.protobuf.Descriptors.FieldDescriptor;
 import com.google.protobuf.Descriptors.EnumDescriptor;
 import com.google.protobuf.Descriptors.EnumValueDescriptor;
-import com.google.protobuf.Descriptors.FieldDescriptor;
-import com.google.protobuf.Descriptors.FileDescriptor;
+import com.google.protobuf.Descriptors.ServiceDescriptor;
 import com.google.protobuf.Descriptors.MethodDescriptor;
-import com.google.protobuf.Descriptors.OneofDescriptor;
-import com.google.protobuf.Descriptors.ServiceDescriptor;
+
 import com.google.protobuf.test.UnittestImport;
 import com.google.protobuf.test.UnittestImport.ImportEnum;
-import com.google.protobuf.test.UnittestImport.ImportEnumForMap;
-import protobuf_unittest.TestCustomOptions;
-import protobuf_unittest.UnittestCustomOptions;
+import com.google.protobuf.test.UnittestImport.ImportMessage;
 import protobuf_unittest.UnittestProto;
 import protobuf_unittest.UnittestProto.ForeignEnum;
 import protobuf_unittest.UnittestProto.ForeignMessage;
+import protobuf_unittest.UnittestProto.TestAllTypes;
 import protobuf_unittest.UnittestProto.TestAllExtensions;
-import protobuf_unittest.UnittestProto.TestAllTypes;
 import protobuf_unittest.UnittestProto.TestExtremeDefaultValues;
-import protobuf_unittest.UnittestProto.TestMultipleExtensionRanges;
 import protobuf_unittest.UnittestProto.TestRequired;
-import protobuf_unittest.UnittestProto.TestReservedFields;
 import protobuf_unittest.UnittestProto.TestService;
+import protobuf_unittest.UnittestCustomOptions;
+
+
 import junit.framework.TestCase;
 
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
 /**
  * Unit test for {@link Descriptors}.
  *
  * @author kenton@google.com Kenton Varda
@@ skipping 36 matching lines @@
     assertNull(file.findMessageTypeByName("protobuf_unittest.TestAllTypes"));
     for (int i = 0; i < file.getMessageTypes().size(); i++) {
       assertEquals(i, file.getMessageTypes().get(i).getIndex());
     }
 
     EnumDescriptor enumType = ForeignEnum.getDescriptor();
     assertEquals(enumType, file.getEnumTypes().get(0));
     assertEquals(enumType, file.findEnumTypeByName("ForeignEnum"));
     assertNull(file.findEnumTypeByName("NoSuchType"));
     assertNull(file.findEnumTypeByName("protobuf_unittest.ForeignEnum"));
-    assertEquals(Arrays.asList(ImportEnum.getDescriptor(),
-                               ImportEnumForMap.getDescriptor()),
+    assertEquals(Arrays.asList(ImportEnum.getDescriptor()),
                  UnittestImport.getDescriptor().getEnumTypes());
     for (int i = 0; i < file.getEnumTypes().size(); i++) {
       assertEquals(i, file.getEnumTypes().get(i).getIndex());
     }
 
     ServiceDescriptor service = TestService.getDescriptor();
     assertEquals(service, file.getServices().get(0));
     assertEquals(service, file.findServiceByName("TestService"));
     assertNull(file.findServiceByName("NoSuchType"));
     assertNull(file.findServiceByName("protobuf_unittest.TestService"));
@@ skipping 136 matching lines @@
     FieldDescriptor repeatedField =
       TestAllTypes.getDescriptor().findFieldByName("repeated_int32");
 
     assertTrue(requiredField.isRequired());
     assertFalse(requiredField.isRepeated());
     assertFalse(optionalField.isRequired());
     assertFalse(optionalField.isRepeated());
     assertFalse(repeatedField.isRequired());
     assertTrue(repeatedField.isRepeated());
   }
-  
-  public void testFieldDescriptorJsonName() throws Exception {
-    FieldDescriptor requiredField = TestRequired.getDescriptor().findFieldByName("a");
-    FieldDescriptor optionalField = TestAllTypes.getDescriptor().findFieldByName("optional_int32");
-    FieldDescriptor repeatedField = TestAllTypes.getDescriptor().findFieldByName("repeated_int32");
-    assertEquals("a", requiredField.getJsonName());
-    assertEquals("optionalInt32", optionalField.getJsonName());
-    assertEquals("repeatedInt32", repeatedField.getJsonName());
-  }
 
   public void testFieldDescriptorDefault() throws Exception {
     Descriptor d = TestAllTypes.getDescriptor();
     assertFalse(d.findFieldByName("optional_int32").hasDefaultValue());
     assertEquals(0, d.findFieldByName("optional_int32").getDefaultValue());
     assertTrue(d.findFieldByName("default_int32").hasDefaultValue());
     assertEquals(41, d.findFieldByName("default_int32").getDefaultValue());
 
     d = TestExtremeDefaultValues.getDescriptor();
     assertEquals(
       ByteString.copyFrom(
-        "\0\001\007\b\f\n\r\t\013\\\'\"\u00fe".getBytes(Internal.ISO_8859_1)),
+        "\0\001\007\b\f\n\r\t\013\\\'\"\u00fe".getBytes("ISO-8859-1")),
       d.findFieldByName("escaped_bytes").getDefaultValue());
     assertEquals(-1, d.findFieldByName("large_uint32").getDefaultValue());
     assertEquals(-1L, d.findFieldByName("large_uint64").getDefaultValue());
   }
 
   public void testEnumDescriptor() throws Exception {
     EnumDescriptor enumType = ForeignEnum.getDescriptor();
     EnumDescriptor nestedType = TestAllTypes.NestedEnum.getDescriptor();
 
     assertEquals("ForeignEnum", enumType.getName());
     assertEquals("protobuf_unittest.ForeignEnum", enumType.getFullName());
     assertEquals(UnittestProto.getDescriptor(), enumType.getFile());
     assertNull(enumType.getContainingType());
     assertEquals(DescriptorProtos.EnumOptions.getDefaultInstance(),
                  enumType.getOptions());
 
     assertEquals("NestedEnum", nestedType.getName());
     assertEquals("protobuf_unittest.TestAllTypes.NestedEnum",
                  nestedType.getFullName());
     assertEquals(UnittestProto.getDescriptor(), nestedType.getFile());
     assertEquals(TestAllTypes.getDescriptor(), nestedType.getContainingType());
 
     EnumValueDescriptor value = ForeignEnum.FOREIGN_FOO.getValueDescriptor();
     assertEquals(value, enumType.getValues().get(0));
     assertEquals("FOREIGN_FOO", value.getName());
-    assertEquals("FOREIGN_FOO", value.toString());
     assertEquals(4, value.getNumber());
     assertEquals(value, enumType.findValueByName("FOREIGN_FOO"));
     assertEquals(value, enumType.findValueByNumber(4));
     assertNull(enumType.findValueByName("NO_SUCH_VALUE"));
     for (int i = 0; i < enumType.getValues().size(); i++) {
       assertEquals(i, enumType.getValues().get(i).getIndex());
     }
   }
 
   public void testServiceDescriptor() throws Exception {
     ServiceDescriptor service = TestService.getDescriptor();
 
     assertEquals("TestService", service.getName());
     assertEquals("protobuf_unittest.TestService", service.getFullName());
     assertEquals(UnittestProto.getDescriptor(), service.getFile());
 
+    assertEquals(2, service.getMethods().size());
 
     MethodDescriptor fooMethod = service.getMethods().get(0);
     assertEquals("Foo", fooMethod.getName());
     assertEquals(UnittestProto.FooRequest.getDescriptor(),
                  fooMethod.getInputType());
     assertEquals(UnittestProto.FooResponse.getDescriptor(),
                  fooMethod.getOutputType());
     assertEquals(fooMethod, service.findMethodByName("Foo"));
 
     MethodDescriptor barMethod = service.getMethods().get(1);
     assertEquals("Bar", barMethod.getName());
     assertEquals(UnittestProto.BarRequest.getDescriptor(),
                  barMethod.getInputType());
     assertEquals(UnittestProto.BarResponse.getDescriptor(),
                  barMethod.getOutputType());
     assertEquals(barMethod, service.findMethodByName("Bar"));
 
     assertNull(service.findMethodByName("NoSuchMethod"));
 
     for (int i = 0; i < service.getMethods().size(); i++) {
       assertEquals(i, service.getMethods().get(i).getIndex());
     }
   }
 
 
   public void testCustomOptions() throws Exception {
-    // Get the descriptor indirectly from a dependent proto class. This is to
-    // ensure that when a proto class is loaded, custom options defined in its
-    // dependencies are also properly initialized.
     Descriptor descriptor =
-        TestCustomOptions.TestMessageWithCustomOptionsContainer.getDescriptor()
-        .findFieldByName("field").getMessageType();
+      UnittestCustomOptions.TestMessageWithCustomOptions.getDescriptor();
 
     assertTrue(
       descriptor.getOptions().hasExtension(UnittestCustomOptions.messageOpt1));
     assertEquals(Integer.valueOf(-56),
       descriptor.getOptions().getExtension(UnittestCustomOptions.messageOpt1));
 
     FieldDescriptor field = descriptor.findFieldByName("field1");
     assertNotNull(field);
 
     assertTrue(
@@ skipping 116 matching lines @@
         .addField(FieldDescriptorProto.newBuilder()
           .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
           .setTypeName("Foo")
           .setName("Foo")
           .setNumber(1)
           .build())
         .build())
       .build();
     // translate and crosslink
     FileDescriptor file =
-      Descriptors.FileDescriptor.buildFrom(fileDescriptorProto,
+      Descriptors.FileDescriptor.buildFrom(fileDescriptorProto, 
           new FileDescriptor[0]);
     // verify resulting descriptors
     assertNotNull(file);
     List<Descriptor> msglist = file.getMessageTypes();
     assertNotNull(msglist);
     assertTrue(msglist.size() == 2);
     boolean barFound = false;
     for (Descriptor desc : msglist) {
       if (desc.getName().equals("Bar")) {
         barFound = true;
         assertNotNull(desc.getFields());
         List<FieldDescriptor> fieldlist = desc.getFields();
         assertNotNull(fieldlist);
         assertTrue(fieldlist.size() == 1);
         assertTrue(fieldlist.get(0).getType() == FieldDescriptor.Type.MESSAGE);
         assertTrue(fieldlist.get(0).getMessageType().getName().equals("Foo"));
       }
     }
     assertTrue(barFound);
   }
-
-  public void testDependencyOrder() throws Exception {
-    FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
-        .setName("foo.proto").build();
-    FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
-        .setName("bar.proto")
-        .addDependency("foo.proto")
-        .build();
-    FileDescriptorProto bazProto = FileDescriptorProto.newBuilder()
-        .setName("baz.proto")
-        .addDependency("foo.proto")
-        .addDependency("bar.proto")
-        .addPublicDependency(0)
-        .addPublicDependency(1)
-        .build();
-    FileDescriptor fooFile = Descriptors.FileDescriptor.buildFrom(fooProto,
-        new FileDescriptor[0]);
-    FileDescriptor barFile = Descriptors.FileDescriptor.buildFrom(barProto,
-        new FileDescriptor[] {fooFile});
-
-    // Items in the FileDescriptor array can be in any order.
-    Descriptors.FileDescriptor.buildFrom(bazProto,
-        new FileDescriptor[] {fooFile, barFile});
-    Descriptors.FileDescriptor.buildFrom(bazProto,
-        new FileDescriptor[] {barFile, fooFile});
-  }
-
+  
   public void testInvalidPublicDependency() throws Exception {
     FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
-        .setName("foo.proto").build();
+        .setName("foo.proto") .build();
     FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
         .setName("boo.proto")
         .addDependency("foo.proto")
         .addPublicDependency(1)  // Error, should be 0.
         .build();
     FileDescriptor fooFile = Descriptors.FileDescriptor.buildFrom(fooProto,
         new FileDescriptor[0]);
     try {
       Descriptors.FileDescriptor.buildFrom(barProto,
           new FileDescriptor[] {fooFile});
       fail("DescriptorValidationException expected");
     } catch (DescriptorValidationException e) {
       assertTrue(
           e.getMessage().indexOf("Invalid public dependency index.") != -1);
     }
   }
 
-  public void testUnknownFieldsDenied() throws Exception {
-    FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
-        .setName("foo.proto")
-        .addMessageType(DescriptorProto.newBuilder()
-            .setName("Foo")
-            .addField(FieldDescriptorProto.newBuilder()
-                .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
-                .setTypeName("Bar")
-                .setName("bar")
-                .setNumber(1)))
-        .build();
-
-    try {
-      Descriptors.FileDescriptor.buildFrom(fooProto, new FileDescriptor[0]);
-      fail("DescriptorValidationException expected");
-    } catch (DescriptorValidationException e) {
-      assertTrue(e.getMessage().indexOf("Bar") != -1);
-      assertTrue(e.getMessage().indexOf("is not defined") != -1);
-    }
-  }
-
-  public void testUnknownFieldsAllowed() throws Exception {
-    FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
-        .setName("foo.proto")
-        .addDependency("bar.proto")
-        .addMessageType(DescriptorProto.newBuilder()
-            .setName("Foo")
-            .addField(FieldDescriptorProto.newBuilder()
-                .setLabel(FieldDescriptorProto.Label.LABEL_OPTIONAL)
-                .setTypeName("Bar")
-                .setName("bar")
-                .setNumber(1)))
-        .build();
-    Descriptors.FileDescriptor.buildFrom(fooProto, new FileDescriptor[0], true);
-  }
-
   public void testHiddenDependency() throws Exception {
     FileDescriptorProto barProto = FileDescriptorProto.newBuilder()
         .setName("bar.proto")
         .addMessageType(DescriptorProto.newBuilder().setName("Bar"))
         .build();
     FileDescriptorProto forwardProto = FileDescriptorProto.newBuilder()
         .setName("forward.proto")
         .addDependency("bar.proto")
         .build();
     FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
@@ skipping 43 matching lines @@
                 .setName("bar")
                 .setNumber(1)))
         .build();
     FileDescriptor barFile = Descriptors.FileDescriptor.buildFrom(
         barProto, new FileDescriptor[0]);
     FileDescriptor forwardFile = Descriptors.FileDescriptor.buildFrom(
         forwardProto, new FileDescriptor[]{barFile});
     Descriptors.FileDescriptor.buildFrom(
         fooProto, new FileDescriptor[] {forwardFile});
   }
-
+  
   /**
    * Tests the translate/crosslink for an example with a more complex namespace
    * referencing.
    */
   public void testComplexNamespacePublicDependency() throws Exception {
     FileDescriptorProto fooProto = FileDescriptorProto.newBuilder()
         .setName("bar.proto")
         .setPackage("a.b.c.d.bar.shared")
         .addEnumType(EnumDescriptorProto.newBuilder()
             .setName("MyEnum")
@@ skipping 28 matching lines @@
       assertNotNull(desc.getFields());
       List<FieldDescriptor> fieldlist = desc.getFields();
       assertNotNull(fieldlist);
       assertTrue(fieldlist.size() == 1);
       FieldDescriptor field = fieldlist.get(0);
       assertTrue(field.getType() == FieldDescriptor.Type.ENUM);
       assertTrue(field.getEnumType().getName().equals("MyEnum"));
       assertTrue(field.getEnumType().getFile().getName().equals("bar.proto"));
       assertTrue(field.getEnumType().getFile().getPackage().equals(
           "a.b.c.d.bar.shared"));
-    }
-  }
-
-  public void testOneofDescriptor() throws Exception {
-    Descriptor messageType = TestAllTypes.getDescriptor();
-    FieldDescriptor field =
-        messageType.findFieldByName("oneof_nested_message");
-    OneofDescriptor oneofDescriptor = field.getContainingOneof();
-    assertNotNull(oneofDescriptor);
-    assertSame(oneofDescriptor, messageType.getOneofs().get(0));
-    assertEquals("oneof_field", oneofDescriptor.getName());
-
-    assertEquals(4, oneofDescriptor.getFieldCount());
-    assertSame(oneofDescriptor.getField(1), field);
-
-    assertEquals(4, oneofDescriptor.getFields().size());
-    assertEquals(oneofDescriptor.getFields().get(1), field);
-  }
-
-  public void testMessageDescriptorExtensions() throws Exception {
-    assertFalse(TestAllTypes.getDescriptor().isExtendable());
-    assertTrue(TestAllExtensions.getDescriptor().isExtendable());
-    assertTrue(TestMultipleExtensionRanges.getDescriptor().isExtendable());
-
-    assertFalse(TestAllTypes.getDescriptor().isExtensionNumber(3));
-    assertTrue(TestAllExtensions.getDescriptor().isExtensionNumber(3));
-    assertTrue(TestMultipleExtensionRanges.getDescriptor().isExtensionNumber(42));
-    assertFalse(TestMultipleExtensionRanges.getDescriptor().isExtensionNumber(43));
-    assertFalse(TestMultipleExtensionRanges.getDescriptor().isExtensionNumber(4142));
-    assertTrue(TestMultipleExtensionRanges.getDescriptor().isExtensionNumber(4143));
-  }
-
-  public void testReservedFields() {
-    Descriptor d = TestReservedFields.getDescriptor();
-    assertTrue(d.isReservedNumber(2));
-    assertFalse(d.isReservedNumber(8));
-    assertTrue(d.isReservedNumber(9));
-    assertTrue(d.isReservedNumber(10));
-    assertTrue(d.isReservedNumber(11));
-    assertFalse(d.isReservedNumber(12));
-    assertFalse(d.isReservedName("foo"));
-    assertTrue(d.isReservedName("bar"));
-    assertTrue(d.isReservedName("baz"));
-  }
-
-  public void testToString() {
-    assertEquals("protobuf_unittest.TestAllTypes.optional_uint64",
-        UnittestProto.TestAllTypes.getDescriptor().findFieldByNumber(
-            UnittestProto.TestAllTypes.OPTIONAL_UINT64_FIELD_NUMBER).toString());
-  }
-
-  public void testPackedEnumField() throws Exception {
-    FileDescriptorProto fileDescriptorProto = FileDescriptorProto.newBuilder()
-        .setName("foo.proto")
-        .addEnumType(EnumDescriptorProto.newBuilder()
-          .setName("Enum")
-          .addValue(EnumValueDescriptorProto.newBuilder()
-            .setName("FOO")
-            .setNumber(1)
-            .build())
-          .build())
-        .addMessageType(DescriptorProto.newBuilder()
-          .setName("Message")
-          .addField(FieldDescriptorProto.newBuilder()
-            .setName("foo")
-            .setTypeName("Enum")
-            .setNumber(1)
-            .setLabel(FieldDescriptorProto.Label.LABEL_REPEATED)
-            .setOptions(DescriptorProtos.FieldOptions.newBuilder()
-              .setPacked(true)
-              .build())
-            .build())
-          .build())
-        .build();
-    Descriptors.FileDescriptor.buildFrom(
-        fileDescriptorProto, new FileDescriptor[0]);
+    }   
   }
 }