third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/java/compatibility_tests/v2.5.0/tests/src/main/java/com/google/protobuf/test/AbstractMessageTest.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.Descriptors.FieldDescriptor;
 import protobuf_unittest.UnittestOptimizeFor.TestOptimizedForSize;
 import protobuf_unittest.UnittestProto;
 import protobuf_unittest.UnittestProto.ForeignMessage;
 import protobuf_unittest.UnittestProto.TestAllExtensions;
 import protobuf_unittest.UnittestProto.TestAllTypes;
 import protobuf_unittest.UnittestProto.TestPackedTypes;
 import protobuf_unittest.UnittestProto.TestRequired;
 import protobuf_unittest.UnittestProto.TestRequiredForeign;
 import protobuf_unittest.UnittestProto.TestUnpackedTypes;
+
 import junit.framework.TestCase;
 
 import java.util.Map;
 
 /**
  * Unit test for {@link AbstractMessage}.
  *
  * @author kenton@google.com Kenton Varda
  */
 public class AbstractMessageTest extends TestCase {
   /**
    * Extends AbstractMessage and wraps some other message object.  The methods
    * of the Message interface which aren't explicitly implemented by
    * AbstractMessage are forwarded to the wrapped object.  This allows us to
    * test that AbstractMessage's implementations work even if the wrapped
    * object does not use them.
    */
   private static class AbstractMessageWrapper extends AbstractMessage {
     private final Message wrappedMessage;
 
     public AbstractMessageWrapper(Message wrappedMessage) {
       this.wrappedMessage = wrappedMessage;
     }
 
-    @Override
     public Descriptors.Descriptor getDescriptorForType() {
       return wrappedMessage.getDescriptorForType();
     }
-    @Override
     public AbstractMessageWrapper getDefaultInstanceForType() {
       return new AbstractMessageWrapper(
         wrappedMessage.getDefaultInstanceForType());
     }
-    @Override
     public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
       return wrappedMessage.getAllFields();
     }
-    @Override
     public boolean hasField(Descriptors.FieldDescriptor field) {
       return wrappedMessage.hasField(field);
     }
-    @Override
     public Object getField(Descriptors.FieldDescriptor field) {
       return wrappedMessage.getField(field);
     }
-    @Override
     public int getRepeatedFieldCount(Descriptors.FieldDescriptor field) {
       return wrappedMessage.getRepeatedFieldCount(field);
     }
-    @Override
-    public Object getRepeatedField(Descriptors.FieldDescriptor field, int index) {
+    public Object getRepeatedField(
+        Descriptors.FieldDescriptor field, int index) {
       return wrappedMessage.getRepeatedField(field, index);
     }
-    @Override
     public UnknownFieldSet getUnknownFields() {
       return wrappedMessage.getUnknownFields();
     }
-    @Override
     public Builder newBuilderForType() {
       return new Builder(wrappedMessage.newBuilderForType());
     }
-    @Override
     public Builder toBuilder() {
       return new Builder(wrappedMessage.toBuilder());
     }
 
     static class Builder extends AbstractMessage.Builder<Builder> {
       private final Message.Builder wrappedBuilder;
 
       public Builder(Message.Builder wrappedBuilder) {
         this.wrappedBuilder = wrappedBuilder;
       }
 
-      @Override
       public AbstractMessageWrapper build() {
         return new AbstractMessageWrapper(wrappedBuilder.build());
       }
-      @Override
       public AbstractMessageWrapper buildPartial() {
         return new AbstractMessageWrapper(wrappedBuilder.buildPartial());
       }
-      @Override
       public Builder clone() {
         return new Builder(wrappedBuilder.clone());
       }
-      @Override
       public boolean isInitialized() {
         return clone().buildPartial().isInitialized();
       }
-      @Override
       public Descriptors.Descriptor getDescriptorForType() {
         return wrappedBuilder.getDescriptorForType();
       }
-      @Override
       public AbstractMessageWrapper getDefaultInstanceForType() {
         return new AbstractMessageWrapper(
           wrappedBuilder.getDefaultInstanceForType());
       }
-      @Override
       public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
         return wrappedBuilder.getAllFields();
       }
-      @Override
       public Builder newBuilderForField(Descriptors.FieldDescriptor field) {
         return new Builder(wrappedBuilder.newBuilderForField(field));
       }
-      @Override
       public boolean hasField(Descriptors.FieldDescriptor field) {
         return wrappedBuilder.hasField(field);
       }
-      @Override
       public Object getField(Descriptors.FieldDescriptor field) {
         return wrappedBuilder.getField(field);
       }
-      @Override
       public Builder setField(Descriptors.FieldDescriptor field, Object value) {
         wrappedBuilder.setField(field, value);
         return this;
       }
-      @Override
       public Builder clearField(Descriptors.FieldDescriptor field) {
         wrappedBuilder.clearField(field);
         return this;
       }
-      @Override
       public int getRepeatedFieldCount(Descriptors.FieldDescriptor field) {
         return wrappedBuilder.getRepeatedFieldCount(field);
       }
-      @Override
-      public Object getRepeatedField(Descriptors.FieldDescriptor field, int index) {
+      public Object getRepeatedField(
+          Descriptors.FieldDescriptor field, int index) {
         return wrappedBuilder.getRepeatedField(field, index);
       }
-      @Override
-      public Builder setRepeatedField(Descriptors.FieldDescriptor field, int index, Object value) {
+      public Builder setRepeatedField(Descriptors.FieldDescriptor field,
+                                      int index, Object value) {
         wrappedBuilder.setRepeatedField(field, index, value);
         return this;
       }
-      @Override
-      public Builder addRepeatedField(Descriptors.FieldDescriptor field, Object value) {
+      public Builder addRepeatedField(
+          Descriptors.FieldDescriptor field, Object value) {
         wrappedBuilder.addRepeatedField(field, value);
         return this;
       }
-      @Override
       public UnknownFieldSet getUnknownFields() {
         return wrappedBuilder.getUnknownFields();
       }
-      @Override
       public Builder setUnknownFields(UnknownFieldSet unknownFields) {
         wrappedBuilder.setUnknownFields(unknownFields);
         return this;
       }
       @Override
       public Message.Builder getFieldBuilder(FieldDescriptor field) {
         return wrappedBuilder.getFieldBuilder(field);
       }
     }
-    @Override
     public Parser<? extends Message> getParserForType() {
       return wrappedMessage.getParserForType();
     }
   }
 
   // =================================================================
 
   TestUtil.ReflectionTester reflectionTester =
     new TestUtil.ReflectionTester(TestAllTypes.getDescriptor(), null);
 
@@ skipping 313 matching lines @@
    */
   private void checkNotEqual(Message m1, Message m2) {
     String equalsError = String.format("%s should not be equal to %s", m1, m2);
     assertFalse(equalsError, m1.equals(m2));
     assertFalse(equalsError, m2.equals(m1));
 
     assertFalse(
         String.format("%s should have a different hash code from %s", m1, m2),
         m1.hashCode() == m2.hashCode());
   }
-
-  public void testCheckByteStringIsUtf8OnUtf8() {
-    ByteString byteString = ByteString.copyFromUtf8("some text");
-    AbstractMessageLite.checkByteStringIsUtf8(byteString);
-    // No exception thrown.
-  }
-
-  public void testCheckByteStringIsUtf8OnNonUtf8() {
-    ByteString byteString =
-        ByteString.copyFrom(new byte[]{(byte) 0x80}); // A lone continuation byte.
-    try {
-      AbstractMessageLite.checkByteStringIsUtf8(byteString);
-      fail("Expected AbstractMessageLite.checkByteStringIsUtf8 to throw IllegalArgumentException");
-    } catch (IllegalArgumentException exception) {
-      assertEquals("Byte string is not UTF-8.", exception.getMessage());
-    }
-  }
-
 }