/thirdparty/breakpad/third_party/protobuf/protobuf/java/src/test/java/com/google/protobuf/AbstractMessageTest.java

http://github.com/tomahawk-player/tomahawk · Java · 460 lines · 329 code · 64 blank · 67 comment · 1 complexity · 19d7881396959accc5faf78b94fa83d3 MD5 · raw file

  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. package com.google.protobuf;
  31. import protobuf_unittest.UnittestOptimizeFor.TestOptimizedForSize;
  32. import protobuf_unittest.UnittestProto;
  33. import protobuf_unittest.UnittestProto.ForeignMessage;
  34. import protobuf_unittest.UnittestProto.TestAllExtensions;
  35. import protobuf_unittest.UnittestProto.TestAllTypes;
  36. import protobuf_unittest.UnittestProto.TestPackedTypes;
  37. import protobuf_unittest.UnittestProto.TestRequired;
  38. import protobuf_unittest.UnittestProto.TestRequiredForeign;
  39. import protobuf_unittest.UnittestProto.TestUnpackedTypes;
  40. import junit.framework.TestCase;
  41. import java.util.Map;
  42. /**
  43. * Unit test for {@link AbstractMessage}.
  44. *
  45. * @author kenton@google.com Kenton Varda
  46. */
  47. public class AbstractMessageTest extends TestCase {
  48. /**
  49. * Extends AbstractMessage and wraps some other message object. The methods
  50. * of the Message interface which aren't explicitly implemented by
  51. * AbstractMessage are forwarded to the wrapped object. This allows us to
  52. * test that AbstractMessage's implementations work even if the wrapped
  53. * object does not use them.
  54. */
  55. private static class AbstractMessageWrapper extends AbstractMessage {
  56. private final Message wrappedMessage;
  57. public AbstractMessageWrapper(Message wrappedMessage) {
  58. this.wrappedMessage = wrappedMessage;
  59. }
  60. public Descriptors.Descriptor getDescriptorForType() {
  61. return wrappedMessage.getDescriptorForType();
  62. }
  63. public AbstractMessageWrapper getDefaultInstanceForType() {
  64. return new AbstractMessageWrapper(
  65. wrappedMessage.getDefaultInstanceForType());
  66. }
  67. public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
  68. return wrappedMessage.getAllFields();
  69. }
  70. public boolean hasField(Descriptors.FieldDescriptor field) {
  71. return wrappedMessage.hasField(field);
  72. }
  73. public Object getField(Descriptors.FieldDescriptor field) {
  74. return wrappedMessage.getField(field);
  75. }
  76. public int getRepeatedFieldCount(Descriptors.FieldDescriptor field) {
  77. return wrappedMessage.getRepeatedFieldCount(field);
  78. }
  79. public Object getRepeatedField(
  80. Descriptors.FieldDescriptor field, int index) {
  81. return wrappedMessage.getRepeatedField(field, index);
  82. }
  83. public UnknownFieldSet getUnknownFields() {
  84. return wrappedMessage.getUnknownFields();
  85. }
  86. public Builder newBuilderForType() {
  87. return new Builder(wrappedMessage.newBuilderForType());
  88. }
  89. public Builder toBuilder() {
  90. return new Builder(wrappedMessage.toBuilder());
  91. }
  92. static class Builder extends AbstractMessage.Builder<Builder> {
  93. private final Message.Builder wrappedBuilder;
  94. public Builder(Message.Builder wrappedBuilder) {
  95. this.wrappedBuilder = wrappedBuilder;
  96. }
  97. public AbstractMessageWrapper build() {
  98. return new AbstractMessageWrapper(wrappedBuilder.build());
  99. }
  100. public AbstractMessageWrapper buildPartial() {
  101. return new AbstractMessageWrapper(wrappedBuilder.buildPartial());
  102. }
  103. public Builder clone() {
  104. return new Builder(wrappedBuilder.clone());
  105. }
  106. public boolean isInitialized() {
  107. return clone().buildPartial().isInitialized();
  108. }
  109. public Descriptors.Descriptor getDescriptorForType() {
  110. return wrappedBuilder.getDescriptorForType();
  111. }
  112. public AbstractMessageWrapper getDefaultInstanceForType() {
  113. return new AbstractMessageWrapper(
  114. wrappedBuilder.getDefaultInstanceForType());
  115. }
  116. public Map<Descriptors.FieldDescriptor, Object> getAllFields() {
  117. return wrappedBuilder.getAllFields();
  118. }
  119. public Builder newBuilderForField(Descriptors.FieldDescriptor field) {
  120. return new Builder(wrappedBuilder.newBuilderForField(field));
  121. }
  122. public boolean hasField(Descriptors.FieldDescriptor field) {
  123. return wrappedBuilder.hasField(field);
  124. }
  125. public Object getField(Descriptors.FieldDescriptor field) {
  126. return wrappedBuilder.getField(field);
  127. }
  128. public Builder setField(Descriptors.FieldDescriptor field, Object value) {
  129. wrappedBuilder.setField(field, value);
  130. return this;
  131. }
  132. public Builder clearField(Descriptors.FieldDescriptor field) {
  133. wrappedBuilder.clearField(field);
  134. return this;
  135. }
  136. public int getRepeatedFieldCount(Descriptors.FieldDescriptor field) {
  137. return wrappedBuilder.getRepeatedFieldCount(field);
  138. }
  139. public Object getRepeatedField(
  140. Descriptors.FieldDescriptor field, int index) {
  141. return wrappedBuilder.getRepeatedField(field, index);
  142. }
  143. public Builder setRepeatedField(Descriptors.FieldDescriptor field,
  144. int index, Object value) {
  145. wrappedBuilder.setRepeatedField(field, index, value);
  146. return this;
  147. }
  148. public Builder addRepeatedField(
  149. Descriptors.FieldDescriptor field, Object value) {
  150. wrappedBuilder.addRepeatedField(field, value);
  151. return this;
  152. }
  153. public UnknownFieldSet getUnknownFields() {
  154. return wrappedBuilder.getUnknownFields();
  155. }
  156. public Builder setUnknownFields(UnknownFieldSet unknownFields) {
  157. wrappedBuilder.setUnknownFields(unknownFields);
  158. return this;
  159. }
  160. }
  161. }
  162. // =================================================================
  163. TestUtil.ReflectionTester reflectionTester =
  164. new TestUtil.ReflectionTester(TestAllTypes.getDescriptor(), null);
  165. TestUtil.ReflectionTester extensionsReflectionTester =
  166. new TestUtil.ReflectionTester(TestAllExtensions.getDescriptor(),
  167. TestUtil.getExtensionRegistry());
  168. public void testClear() throws Exception {
  169. AbstractMessageWrapper message =
  170. new AbstractMessageWrapper.Builder(
  171. TestAllTypes.newBuilder(TestUtil.getAllSet()))
  172. .clear().build();
  173. TestUtil.assertClear((TestAllTypes) message.wrappedMessage);
  174. }
  175. public void testCopy() throws Exception {
  176. AbstractMessageWrapper message =
  177. new AbstractMessageWrapper.Builder(TestAllTypes.newBuilder())
  178. .mergeFrom(TestUtil.getAllSet()).build();
  179. TestUtil.assertAllFieldsSet((TestAllTypes) message.wrappedMessage);
  180. }
  181. public void testSerializedSize() throws Exception {
  182. TestAllTypes message = TestUtil.getAllSet();
  183. Message abstractMessage = new AbstractMessageWrapper(TestUtil.getAllSet());
  184. assertEquals(message.getSerializedSize(),
  185. abstractMessage.getSerializedSize());
  186. }
  187. public void testSerialization() throws Exception {
  188. Message abstractMessage = new AbstractMessageWrapper(TestUtil.getAllSet());
  189. TestUtil.assertAllFieldsSet(
  190. TestAllTypes.parseFrom(abstractMessage.toByteString()));
  191. assertEquals(TestUtil.getAllSet().toByteString(),
  192. abstractMessage.toByteString());
  193. }
  194. public void testParsing() throws Exception {
  195. AbstractMessageWrapper.Builder builder =
  196. new AbstractMessageWrapper.Builder(TestAllTypes.newBuilder());
  197. AbstractMessageWrapper message =
  198. builder.mergeFrom(TestUtil.getAllSet().toByteString()).build();
  199. TestUtil.assertAllFieldsSet((TestAllTypes) message.wrappedMessage);
  200. }
  201. public void testPackedSerialization() throws Exception {
  202. Message abstractMessage =
  203. new AbstractMessageWrapper(TestUtil.getPackedSet());
  204. TestUtil.assertPackedFieldsSet(
  205. TestPackedTypes.parseFrom(abstractMessage.toByteString()));
  206. assertEquals(TestUtil.getPackedSet().toByteString(),
  207. abstractMessage.toByteString());
  208. }
  209. public void testPackedParsing() throws Exception {
  210. AbstractMessageWrapper.Builder builder =
  211. new AbstractMessageWrapper.Builder(TestPackedTypes.newBuilder());
  212. AbstractMessageWrapper message =
  213. builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build();
  214. TestUtil.assertPackedFieldsSet((TestPackedTypes) message.wrappedMessage);
  215. }
  216. public void testUnpackedSerialization() throws Exception {
  217. Message abstractMessage =
  218. new AbstractMessageWrapper(TestUtil.getUnpackedSet());
  219. TestUtil.assertUnpackedFieldsSet(
  220. TestUnpackedTypes.parseFrom(abstractMessage.toByteString()));
  221. assertEquals(TestUtil.getUnpackedSet().toByteString(),
  222. abstractMessage.toByteString());
  223. }
  224. public void testParsePackedToUnpacked() throws Exception {
  225. AbstractMessageWrapper.Builder builder =
  226. new AbstractMessageWrapper.Builder(TestUnpackedTypes.newBuilder());
  227. AbstractMessageWrapper message =
  228. builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build();
  229. TestUtil.assertUnpackedFieldsSet(
  230. (TestUnpackedTypes) message.wrappedMessage);
  231. }
  232. public void testParseUnpackedToPacked() throws Exception {
  233. AbstractMessageWrapper.Builder builder =
  234. new AbstractMessageWrapper.Builder(TestPackedTypes.newBuilder());
  235. AbstractMessageWrapper message =
  236. builder.mergeFrom(TestUtil.getUnpackedSet().toByteString()).build();
  237. TestUtil.assertPackedFieldsSet((TestPackedTypes) message.wrappedMessage);
  238. }
  239. public void testUnpackedParsing() throws Exception {
  240. AbstractMessageWrapper.Builder builder =
  241. new AbstractMessageWrapper.Builder(TestUnpackedTypes.newBuilder());
  242. AbstractMessageWrapper message =
  243. builder.mergeFrom(TestUtil.getUnpackedSet().toByteString()).build();
  244. TestUtil.assertUnpackedFieldsSet(
  245. (TestUnpackedTypes) message.wrappedMessage);
  246. }
  247. public void testOptimizedForSize() throws Exception {
  248. // We're mostly only checking that this class was compiled successfully.
  249. TestOptimizedForSize message =
  250. TestOptimizedForSize.newBuilder().setI(1).build();
  251. message = TestOptimizedForSize.parseFrom(message.toByteString());
  252. assertEquals(2, message.getSerializedSize());
  253. }
  254. // -----------------------------------------------------------------
  255. // Tests for isInitialized().
  256. private static final TestRequired TEST_REQUIRED_UNINITIALIZED =
  257. TestRequired.getDefaultInstance();
  258. private static final TestRequired TEST_REQUIRED_INITIALIZED =
  259. TestRequired.newBuilder().setA(1).setB(2).setC(3).build();
  260. public void testIsInitialized() throws Exception {
  261. TestRequired.Builder builder = TestRequired.newBuilder();
  262. AbstractMessageWrapper.Builder abstractBuilder =
  263. new AbstractMessageWrapper.Builder(builder);
  264. assertFalse(abstractBuilder.isInitialized());
  265. builder.setA(1);
  266. assertFalse(abstractBuilder.isInitialized());
  267. builder.setB(1);
  268. assertFalse(abstractBuilder.isInitialized());
  269. builder.setC(1);
  270. assertTrue(abstractBuilder.isInitialized());
  271. }
  272. public void testForeignIsInitialized() throws Exception {
  273. TestRequiredForeign.Builder builder = TestRequiredForeign.newBuilder();
  274. AbstractMessageWrapper.Builder abstractBuilder =
  275. new AbstractMessageWrapper.Builder(builder);
  276. assertTrue(abstractBuilder.isInitialized());
  277. builder.setOptionalMessage(TEST_REQUIRED_UNINITIALIZED);
  278. assertFalse(abstractBuilder.isInitialized());
  279. builder.setOptionalMessage(TEST_REQUIRED_INITIALIZED);
  280. assertTrue(abstractBuilder.isInitialized());
  281. builder.addRepeatedMessage(TEST_REQUIRED_UNINITIALIZED);
  282. assertFalse(abstractBuilder.isInitialized());
  283. builder.setRepeatedMessage(0, TEST_REQUIRED_INITIALIZED);
  284. assertTrue(abstractBuilder.isInitialized());
  285. }
  286. // -----------------------------------------------------------------
  287. // Tests for mergeFrom
  288. static final TestAllTypes MERGE_SOURCE =
  289. TestAllTypes.newBuilder()
  290. .setOptionalInt32(1)
  291. .setOptionalString("foo")
  292. .setOptionalForeignMessage(ForeignMessage.getDefaultInstance())
  293. .addRepeatedString("bar")
  294. .build();
  295. static final TestAllTypes MERGE_DEST =
  296. TestAllTypes.newBuilder()
  297. .setOptionalInt64(2)
  298. .setOptionalString("baz")
  299. .setOptionalForeignMessage(ForeignMessage.newBuilder().setC(3).build())
  300. .addRepeatedString("qux")
  301. .build();
  302. static final String MERGE_RESULT_TEXT =
  303. "optional_int32: 1\n" +
  304. "optional_int64: 2\n" +
  305. "optional_string: \"foo\"\n" +
  306. "optional_foreign_message {\n" +
  307. " c: 3\n" +
  308. "}\n" +
  309. "repeated_string: \"qux\"\n" +
  310. "repeated_string: \"bar\"\n";
  311. public void testMergeFrom() throws Exception {
  312. AbstractMessageWrapper result =
  313. new AbstractMessageWrapper.Builder(
  314. TestAllTypes.newBuilder(MERGE_DEST))
  315. .mergeFrom(MERGE_SOURCE).build();
  316. assertEquals(MERGE_RESULT_TEXT, result.toString());
  317. }
  318. // -----------------------------------------------------------------
  319. // Tests for equals and hashCode
  320. public void testEqualsAndHashCode() throws Exception {
  321. TestAllTypes a = TestUtil.getAllSet();
  322. TestAllTypes b = TestAllTypes.newBuilder().build();
  323. TestAllTypes c = TestAllTypes.newBuilder(b).addRepeatedString("x").build();
  324. TestAllTypes d = TestAllTypes.newBuilder(c).addRepeatedString("y").build();
  325. TestAllExtensions e = TestUtil.getAllExtensionsSet();
  326. TestAllExtensions f = TestAllExtensions.newBuilder(e)
  327. .addExtension(UnittestProto.repeatedInt32Extension, 999).build();
  328. checkEqualsIsConsistent(a);
  329. checkEqualsIsConsistent(b);
  330. checkEqualsIsConsistent(c);
  331. checkEqualsIsConsistent(d);
  332. checkEqualsIsConsistent(e);
  333. checkEqualsIsConsistent(f);
  334. checkNotEqual(a, b);
  335. checkNotEqual(a, c);
  336. checkNotEqual(a, d);
  337. checkNotEqual(a, e);
  338. checkNotEqual(a, f);
  339. checkNotEqual(b, c);
  340. checkNotEqual(b, d);
  341. checkNotEqual(b, e);
  342. checkNotEqual(b, f);
  343. checkNotEqual(c, d);
  344. checkNotEqual(c, e);
  345. checkNotEqual(c, f);
  346. checkNotEqual(d, e);
  347. checkNotEqual(d, f);
  348. checkNotEqual(e, f);
  349. // Deserializing into the TestEmptyMessage such that every field
  350. // is an {@link UnknownFieldSet.Field}.
  351. UnittestProto.TestEmptyMessage eUnknownFields =
  352. UnittestProto.TestEmptyMessage.parseFrom(e.toByteArray());
  353. UnittestProto.TestEmptyMessage fUnknownFields =
  354. UnittestProto.TestEmptyMessage.parseFrom(f.toByteArray());
  355. checkNotEqual(eUnknownFields, fUnknownFields);
  356. checkEqualsIsConsistent(eUnknownFields);
  357. checkEqualsIsConsistent(fUnknownFields);
  358. // Subsequent reconstitutions should be identical
  359. UnittestProto.TestEmptyMessage eUnknownFields2 =
  360. UnittestProto.TestEmptyMessage.parseFrom(e.toByteArray());
  361. checkEqualsIsConsistent(eUnknownFields, eUnknownFields2);
  362. }
  363. /**
  364. * Asserts that the given proto has symetric equals and hashCode methods.
  365. */
  366. private void checkEqualsIsConsistent(Message message) {
  367. // Object should be equal to itself.
  368. assertEquals(message, message);
  369. // Object should be equal to a dynamic copy of itself.
  370. DynamicMessage dynamic = DynamicMessage.newBuilder(message).build();
  371. checkEqualsIsConsistent(message, dynamic);
  372. }
  373. /**
  374. * Asserts that the given protos are equal and have the same hash code.
  375. */
  376. private void checkEqualsIsConsistent(Message message1, Message message2) {
  377. assertEquals(message1, message2);
  378. assertEquals(message2, message1);
  379. assertEquals(message2.hashCode(), message1.hashCode());
  380. }
  381. /**
  382. * Asserts that the given protos are not equal and have different hash codes.
  383. *
  384. * @warning It's valid for non-equal objects to have the same hash code, so
  385. * this test is stricter than it needs to be. However, this should happen
  386. * relatively rarely.
  387. */
  388. private void checkNotEqual(Message m1, Message m2) {
  389. String equalsError = String.format("%s should not be equal to %s", m1, m2);
  390. assertFalse(equalsError, m1.equals(m2));
  391. assertFalse(equalsError, m2.equals(m1));
  392. assertFalse(
  393. String.format("%s should have a different hash code from %s", m1, m2),
  394. m1.hashCode() == m2.hashCode());
  395. }
  396. }