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 protobuf_unittest.UnittestProto.TestAllExtensions;
  35 import protobuf_unittest.UnittestProto.TestAllTypes;
  36 import protobuf_unittest.UnittestProto.TestEmptyMessage;
  37 import protobuf_unittest.UnittestProto.TestPackedTypes;
  38
  39 import junit.framework.TestCase;
  40 import java.util.Arrays;
  41
  42 /**
  43  * Unit test for {@link DynamicMessage}.  See also {@link MessageTest}, which
  44  * tests some {@link DynamicMessage} functionality.
  45  *
  46  * @author kenton@google.com Kenton Varda
  47  */
  48 public class DynamicMessageTest extends TestCase {
  49   TestUtil.ReflectionTester reflectionTester =
  50     new TestUtil.ReflectionTester(TestAllTypes.getDescriptor(), null);
  51
  52   TestUtil.ReflectionTester extensionsReflectionTester =
  53     new TestUtil.ReflectionTester(TestAllExtensions.getDescriptor(),
  54                                   TestUtil.getExtensionRegistry());
  55   TestUtil.ReflectionTester packedReflectionTester =
  56     new TestUtil.ReflectionTester(TestPackedTypes.getDescriptor(), null);
  57
  58   public void testDynamicMessageAccessors() throws Exception {
  59     Message.Builder builder =
  60       DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
  61     reflectionTester.setAllFieldsViaReflection(builder);
  62     Message message = builder.build();
  63     reflectionTester.assertAllFieldsSetViaReflection(message);
  64   }
  65
  66   public void testSettersAfterBuild() throws Exception {
  67     Message.Builder builder =
  68       DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
  69     Message firstMessage = builder.build();
  70     // double build()
  71     builder.build();
  72     // clear() after build()
  73     builder.clear();
  74     // setters after build()
  75     reflectionTester.setAllFieldsViaReflection(builder);
  76     Message message = builder.build();
  77     reflectionTester.assertAllFieldsSetViaReflection(message);
  78     // repeated setters after build()
  79     reflectionTester.modifyRepeatedFieldsViaReflection(builder);
  80     message = builder.build();
  81     reflectionTester.assertRepeatedFieldsModifiedViaReflection(message);
  82     // firstMessage shouldn't have been modified.
  83     reflectionTester.assertClearViaReflection(firstMessage);
  84   }
  85
  86   public void testUnknownFields() throws Exception {
  87     Message.Builder builder =
  88         DynamicMessage.newBuilder(TestEmptyMessage.getDescriptor());
  89     builder.setUnknownFields(UnknownFieldSet.newBuilder()
  90         .addField(1, UnknownFieldSet.Field.newBuilder().addVarint(1).build())
  91         .addField(2, UnknownFieldSet.Field.newBuilder().addFixed32(1).build())
  92         .build());
  93     Message message = builder.build();
  94     assertEquals(2, message.getUnknownFields().asMap().size());
  95     // clone() with unknown fields
  96     Message.Builder newBuilder = builder.clone();
  97     assertEquals(2, newBuilder.getUnknownFields().asMap().size());
  98     // clear() with unknown fields
  99     newBuilder.clear();
 100     assertTrue(newBuilder.getUnknownFields().asMap().isEmpty());
 101     // serialize/parse with unknown fields
 102     newBuilder.mergeFrom(message.toByteString());
 103     assertEquals(2, newBuilder.getUnknownFields().asMap().size());
 104   }
 105
 106   public void testDynamicMessageSettersRejectNull() throws Exception {
 107     Message.Builder builder =
 108       DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
 109     reflectionTester.assertReflectionSettersRejectNull(builder);
 110   }
 111
 112   public void testDynamicMessageExtensionAccessors() throws Exception {
 113     // We don't need to extensively test DynamicMessage's handling of
 114     // extensions because, frankly, it doesn't do anything special with them.
 115     // It treats them just like any other fields.
 116     Message.Builder builder =
 117       DynamicMessage.newBuilder(TestAllExtensions.getDescriptor());
 118     extensionsReflectionTester.setAllFieldsViaReflection(builder);
 119     Message message = builder.build();
 120     extensionsReflectionTester.assertAllFieldsSetViaReflection(message);
 121   }
 122
 123   public void testDynamicMessageExtensionSettersRejectNull() throws Exception {
 124     Message.Builder builder =
 125       DynamicMessage.newBuilder(TestAllExtensions.getDescriptor());
 126     extensionsReflectionTester.assertReflectionSettersRejectNull(builder);
 127   }
 128
 129   public void testDynamicMessageRepeatedSetters() throws Exception {
 130     Message.Builder builder =
 131       DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
 132     reflectionTester.setAllFieldsViaReflection(builder);
 133     reflectionTester.modifyRepeatedFieldsViaReflection(builder);
 134     Message message = builder.build();
 135     reflectionTester.assertRepeatedFieldsModifiedViaReflection(message);
 136   }
 137
 138   public void testDynamicMessageRepeatedSettersRejectNull() throws Exception {
 139     Message.Builder builder =
 140       DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
 141     reflectionTester.assertReflectionRepeatedSettersRejectNull(builder);
 142   }
 143
 144   public void testDynamicMessageDefaults() throws Exception {
 145     reflectionTester.assertClearViaReflection(
 146       DynamicMessage.getDefaultInstance(TestAllTypes.getDescriptor()));
 147     reflectionTester.assertClearViaReflection(
 148       DynamicMessage.newBuilder(TestAllTypes.getDescriptor()).build());
 149   }
 150
 151   public void testDynamicMessageSerializedSize() throws Exception {
 152     TestAllTypes message = TestUtil.getAllSet();
 153
 154     Message.Builder dynamicBuilder =
 155       DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
 156     reflectionTester.setAllFieldsViaReflection(dynamicBuilder);
 157     Message dynamicMessage = dynamicBuilder.build();
 158
 159     assertEquals(message.getSerializedSize(),
 160                  dynamicMessage.getSerializedSize());
 161   }
 162
 163   public void testDynamicMessageSerialization() throws Exception {
 164     Message.Builder builder =
 165       DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
 166     reflectionTester.setAllFieldsViaReflection(builder);
 167     Message message = builder.build();
 168
 169     ByteString rawBytes = message.toByteString();
 170     TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes);
 171
 172     TestUtil.assertAllFieldsSet(message2);
 173
 174     // In fact, the serialized forms should be exactly the same, byte-for-byte.
 175     assertEquals(TestUtil.getAllSet().toByteString(), rawBytes);
 176   }
 177
 178   public void testDynamicMessageParsing() throws Exception {
 179     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 180     TestUtil.setAllFields(builder);
 181     TestAllTypes message = builder.build();
 182
 183     ByteString rawBytes = message.toByteString();
 184
 185     Message message2 =
 186       DynamicMessage.parseFrom(TestAllTypes.getDescriptor(), rawBytes);
 187     reflectionTester.assertAllFieldsSetViaReflection(message2);
 188
 189     // Test Parser interface.
 190     Message message3 = message2.getParserForType().parseFrom(rawBytes);
 191     reflectionTester.assertAllFieldsSetViaReflection(message3);
 192   }
 193
 194   public void testDynamicMessageExtensionParsing() throws Exception {
 195     ByteString rawBytes = TestUtil.getAllExtensionsSet().toByteString();
 196     Message message = DynamicMessage.parseFrom(
 197         TestAllExtensions.getDescriptor(), rawBytes,
 198         TestUtil.getExtensionRegistry());
 199     extensionsReflectionTester.assertAllFieldsSetViaReflection(message);
 200
 201     // Test Parser interface.
 202     Message message2 = message.getParserForType().parseFrom(
 203         rawBytes, TestUtil.getExtensionRegistry());
 204     extensionsReflectionTester.assertAllFieldsSetViaReflection(message2);
 205   }
 206
 207   public void testDynamicMessagePackedSerialization() throws Exception {
 208     Message.Builder builder =
 209         DynamicMessage.newBuilder(TestPackedTypes.getDescriptor());
 210     packedReflectionTester.setPackedFieldsViaReflection(builder);
 211     Message message = builder.build();
 212
 213     ByteString rawBytes = message.toByteString();
 214     TestPackedTypes message2 = TestPackedTypes.parseFrom(rawBytes);
 215
 216     TestUtil.assertPackedFieldsSet(message2);
 217
 218     // In fact, the serialized forms should be exactly the same, byte-for-byte.
 219     assertEquals(TestUtil.getPackedSet().toByteString(), rawBytes);
 220   }
 221
 222   public void testDynamicMessagePackedParsing() throws Exception {
 223     TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
 224     TestUtil.setPackedFields(builder);
 225     TestPackedTypes message = builder.build();
 226
 227     ByteString rawBytes = message.toByteString();
 228
 229     Message message2 =
 230       DynamicMessage.parseFrom(TestPackedTypes.getDescriptor(), rawBytes);
 231     packedReflectionTester.assertPackedFieldsSetViaReflection(message2);
 232
 233     // Test Parser interface.
 234     Message message3 = message2.getParserForType().parseFrom(rawBytes);
 235     packedReflectionTester.assertPackedFieldsSetViaReflection(message3);
 236   }
 237
 238   public void testDynamicMessageCopy() throws Exception {
 239     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 240     TestUtil.setAllFields(builder);
 241     TestAllTypes message = builder.build();
 242
 243     DynamicMessage copy = DynamicMessage.newBuilder(message).build();
 244     reflectionTester.assertAllFieldsSetViaReflection(copy);
 245   }
 246
 247   public void testToBuilder() throws Exception {
 248     DynamicMessage.Builder builder =
 249         DynamicMessage.newBuilder(TestAllTypes.getDescriptor());
 250     reflectionTester.setAllFieldsViaReflection(builder);
 251     int unknownFieldNum = 9;
 252     long unknownFieldVal = 90;
 253     builder.setUnknownFields(UnknownFieldSet.newBuilder()
 254         .addField(unknownFieldNum,
 255             UnknownFieldSet.Field.newBuilder()
 256                 .addVarint(unknownFieldVal).build())
 257         .build());
 258     DynamicMessage message = builder.build();
 259
 260     DynamicMessage derived = message.toBuilder().build();
 261     reflectionTester.assertAllFieldsSetViaReflection(derived);
 262     assertEquals(Arrays.asList(unknownFieldVal),
 263         derived.getUnknownFields().getField(unknownFieldNum).getVarintList());
 264   }
 265 }