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

http://github.com/tomahawk-player/tomahawk · Java · 980 lines · 757 code · 129 blank · 94 comment · 8 complexity · b485e319e865fc085ccbfbc4d33a2f43 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 com.google.protobuf.UnittestLite.TestAllExtensionsLite;
  32. import com.google.protobuf.test.UnittestImport;
  33. import protobuf_unittest.EnumWithNoOuter;
  34. import protobuf_unittest.MessageWithNoOuter;
  35. import protobuf_unittest.MultipleFilesTestProto;
  36. import protobuf_unittest.NestedExtension.MyNestedExtension;
  37. import protobuf_unittest.NestedExtensionLite.MyNestedExtensionLite;
  38. import protobuf_unittest.NonNestedExtension;
  39. import protobuf_unittest.NonNestedExtension.MessageToBeExtended;
  40. import protobuf_unittest.NonNestedExtension.MyNonNestedExtension;
  41. import protobuf_unittest.NonNestedExtensionLite;
  42. import protobuf_unittest.NonNestedExtensionLite.MessageLiteToBeExtended;
  43. import protobuf_unittest.NonNestedExtensionLite.MyNonNestedExtensionLite;
  44. import protobuf_unittest.ServiceWithNoOuter;
  45. import protobuf_unittest.UnittestOptimizeFor.TestOptimizedForSize;
  46. import protobuf_unittest.UnittestOptimizeFor.TestOptionalOptimizedForSize;
  47. import protobuf_unittest.UnittestOptimizeFor.TestRequiredOptimizedForSize;
  48. import protobuf_unittest.UnittestProto;
  49. import protobuf_unittest.UnittestProto.ForeignEnum;
  50. import protobuf_unittest.UnittestProto.ForeignMessage;
  51. import protobuf_unittest.UnittestProto.ForeignMessageOrBuilder;
  52. import protobuf_unittest.UnittestProto.TestAllExtensions;
  53. import protobuf_unittest.UnittestProto.TestAllTypes;
  54. import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder;
  55. import protobuf_unittest.UnittestProto.TestExtremeDefaultValues;
  56. import protobuf_unittest.UnittestProto.TestPackedTypes;
  57. import protobuf_unittest.UnittestProto.TestUnpackedTypes;
  58. import junit.framework.TestCase;
  59. import java.io.ByteArrayInputStream;
  60. import java.io.ByteArrayOutputStream;
  61. import java.io.ObjectInputStream;
  62. import java.io.ObjectOutputStream;
  63. import java.util.Arrays;
  64. import java.util.Collections;
  65. import java.util.List;
  66. /**
  67. * Unit test for generated messages and generated code. See also
  68. * {@link MessageTest}, which tests some generated message functionality.
  69. *
  70. * @author kenton@google.com Kenton Varda
  71. */
  72. public class GeneratedMessageTest extends TestCase {
  73. TestUtil.ReflectionTester reflectionTester =
  74. new TestUtil.ReflectionTester(TestAllTypes.getDescriptor(), null);
  75. public void testDefaultInstance() throws Exception {
  76. assertSame(TestAllTypes.getDefaultInstance(),
  77. TestAllTypes.getDefaultInstance().getDefaultInstanceForType());
  78. assertSame(TestAllTypes.getDefaultInstance(),
  79. TestAllTypes.newBuilder().getDefaultInstanceForType());
  80. }
  81. public void testMessageOrBuilder() throws Exception {
  82. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  83. TestUtil.setAllFields(builder);
  84. TestAllTypes message = builder.build();
  85. TestUtil.assertAllFieldsSet(message);
  86. }
  87. public void testUsingBuilderMultipleTimes() throws Exception {
  88. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  89. // primitive field scalar and repeated
  90. builder.setOptionalSfixed64(100);
  91. builder.addRepeatedInt32(100);
  92. // enum field scalar and repeated
  93. builder.setOptionalImportEnum(UnittestImport.ImportEnum.IMPORT_BAR);
  94. builder.addRepeatedImportEnum(UnittestImport.ImportEnum.IMPORT_BAR);
  95. // proto field scalar and repeated
  96. builder.setOptionalForeignMessage(ForeignMessage.newBuilder().setC(1));
  97. builder.addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(1));
  98. TestAllTypes value1 = builder.build();
  99. assertEquals(100, value1.getOptionalSfixed64());
  100. assertEquals(100, value1.getRepeatedInt32(0));
  101. assertEquals(UnittestImport.ImportEnum.IMPORT_BAR,
  102. value1.getOptionalImportEnum());
  103. assertEquals(UnittestImport.ImportEnum.IMPORT_BAR,
  104. value1.getRepeatedImportEnum(0));
  105. assertEquals(1, value1.getOptionalForeignMessage().getC());
  106. assertEquals(1, value1.getRepeatedForeignMessage(0).getC());
  107. // Make sure that builder didn't update previously created values
  108. builder.setOptionalSfixed64(200);
  109. builder.setRepeatedInt32(0, 200);
  110. builder.setOptionalImportEnum(UnittestImport.ImportEnum.IMPORT_FOO);
  111. builder.setRepeatedImportEnum(0, UnittestImport.ImportEnum.IMPORT_FOO);
  112. builder.setOptionalForeignMessage(ForeignMessage.newBuilder().setC(2));
  113. builder.setRepeatedForeignMessage(0, ForeignMessage.newBuilder().setC(2));
  114. TestAllTypes value2 = builder.build();
  115. // Make sure value1 didn't change.
  116. assertEquals(100, value1.getOptionalSfixed64());
  117. assertEquals(100, value1.getRepeatedInt32(0));
  118. assertEquals(UnittestImport.ImportEnum.IMPORT_BAR,
  119. value1.getOptionalImportEnum());
  120. assertEquals(UnittestImport.ImportEnum.IMPORT_BAR,
  121. value1.getRepeatedImportEnum(0));
  122. assertEquals(1, value1.getOptionalForeignMessage().getC());
  123. assertEquals(1, value1.getRepeatedForeignMessage(0).getC());
  124. // Make sure value2 is correct
  125. assertEquals(200, value2.getOptionalSfixed64());
  126. assertEquals(200, value2.getRepeatedInt32(0));
  127. assertEquals(UnittestImport.ImportEnum.IMPORT_FOO,
  128. value2.getOptionalImportEnum());
  129. assertEquals(UnittestImport.ImportEnum.IMPORT_FOO,
  130. value2.getRepeatedImportEnum(0));
  131. assertEquals(2, value2.getOptionalForeignMessage().getC());
  132. assertEquals(2, value2.getRepeatedForeignMessage(0).getC());
  133. }
  134. public void testProtosShareRepeatedArraysIfDidntChange() throws Exception {
  135. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  136. builder.addRepeatedInt32(100);
  137. builder.addRepeatedImportEnum(UnittestImport.ImportEnum.IMPORT_BAR);
  138. builder.addRepeatedForeignMessage(ForeignMessage.getDefaultInstance());
  139. TestAllTypes value1 = builder.build();
  140. TestAllTypes value2 = value1.toBuilder().build();
  141. assertSame(value1.getRepeatedInt32List(), value2.getRepeatedInt32List());
  142. assertSame(value1.getRepeatedImportEnumList(),
  143. value2.getRepeatedImportEnumList());
  144. assertSame(value1.getRepeatedForeignMessageList(),
  145. value2.getRepeatedForeignMessageList());
  146. }
  147. public void testRepeatedArraysAreImmutable() throws Exception {
  148. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  149. builder.addRepeatedInt32(100);
  150. builder.addRepeatedImportEnum(UnittestImport.ImportEnum.IMPORT_BAR);
  151. builder.addRepeatedForeignMessage(ForeignMessage.getDefaultInstance());
  152. assertIsUnmodifiable(builder.getRepeatedInt32List());
  153. assertIsUnmodifiable(builder.getRepeatedImportEnumList());
  154. assertIsUnmodifiable(builder.getRepeatedForeignMessageList());
  155. assertIsUnmodifiable(builder.getRepeatedFloatList());
  156. TestAllTypes value = builder.build();
  157. assertIsUnmodifiable(value.getRepeatedInt32List());
  158. assertIsUnmodifiable(value.getRepeatedImportEnumList());
  159. assertIsUnmodifiable(value.getRepeatedForeignMessageList());
  160. assertIsUnmodifiable(value.getRepeatedFloatList());
  161. }
  162. private void assertIsUnmodifiable(List<?> list) {
  163. if (list == Collections.emptyList()) {
  164. // OKAY -- Need to check this b/c EmptyList allows you to call clear.
  165. } else {
  166. try {
  167. list.clear();
  168. fail("List wasn't immutable");
  169. } catch (UnsupportedOperationException e) {
  170. // good
  171. }
  172. }
  173. }
  174. public void testSettersRejectNull() throws Exception {
  175. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  176. try {
  177. builder.setOptionalString(null);
  178. fail("Exception was not thrown");
  179. } catch (NullPointerException e) {
  180. // We expect this exception.
  181. }
  182. try {
  183. builder.setOptionalBytes(null);
  184. fail("Exception was not thrown");
  185. } catch (NullPointerException e) {
  186. // We expect this exception.
  187. }
  188. try {
  189. builder.setOptionalNestedMessage((TestAllTypes.NestedMessage) null);
  190. fail("Exception was not thrown");
  191. } catch (NullPointerException e) {
  192. // We expect this exception.
  193. }
  194. try {
  195. builder.setOptionalNestedMessage(
  196. (TestAllTypes.NestedMessage.Builder) null);
  197. fail("Exception was not thrown");
  198. } catch (NullPointerException e) {
  199. // We expect this exception.
  200. }
  201. try {
  202. builder.setOptionalNestedEnum(null);
  203. fail("Exception was not thrown");
  204. } catch (NullPointerException e) {
  205. // We expect this exception.
  206. }
  207. try {
  208. builder.addRepeatedString(null);
  209. fail("Exception was not thrown");
  210. } catch (NullPointerException e) {
  211. // We expect this exception.
  212. }
  213. try {
  214. builder.addRepeatedBytes(null);
  215. fail("Exception was not thrown");
  216. } catch (NullPointerException e) {
  217. // We expect this exception.
  218. }
  219. try {
  220. builder.addRepeatedNestedMessage((TestAllTypes.NestedMessage) null);
  221. fail("Exception was not thrown");
  222. } catch (NullPointerException e) {
  223. // We expect this exception.
  224. }
  225. try {
  226. builder.addRepeatedNestedMessage(
  227. (TestAllTypes.NestedMessage.Builder) null);
  228. fail("Exception was not thrown");
  229. } catch (NullPointerException e) {
  230. // We expect this exception.
  231. }
  232. try {
  233. builder.addRepeatedNestedEnum(null);
  234. fail("Exception was not thrown");
  235. } catch (NullPointerException e) {
  236. // We expect this exception.
  237. }
  238. }
  239. public void testRepeatedSetters() throws Exception {
  240. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  241. TestUtil.setAllFields(builder);
  242. TestUtil.modifyRepeatedFields(builder);
  243. TestAllTypes message = builder.build();
  244. TestUtil.assertRepeatedFieldsModified(message);
  245. }
  246. public void testRepeatedSettersRejectNull() throws Exception {
  247. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  248. builder.addRepeatedString("one");
  249. builder.addRepeatedString("two");
  250. try {
  251. builder.setRepeatedString(1, null);
  252. fail("Exception was not thrown");
  253. } catch (NullPointerException e) {
  254. // We expect this exception.
  255. }
  256. builder.addRepeatedBytes(TestUtil.toBytes("one"));
  257. builder.addRepeatedBytes(TestUtil.toBytes("two"));
  258. try {
  259. builder.setRepeatedBytes(1, null);
  260. fail("Exception was not thrown");
  261. } catch (NullPointerException e) {
  262. // We expect this exception.
  263. }
  264. builder.addRepeatedNestedMessage(
  265. TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
  266. builder.addRepeatedNestedMessage(
  267. TestAllTypes.NestedMessage.newBuilder().setBb(456).build());
  268. try {
  269. builder.setRepeatedNestedMessage(1, (TestAllTypes.NestedMessage) null);
  270. fail("Exception was not thrown");
  271. } catch (NullPointerException e) {
  272. // We expect this exception.
  273. }
  274. try {
  275. builder.setRepeatedNestedMessage(
  276. 1, (TestAllTypes.NestedMessage.Builder) null);
  277. fail("Exception was not thrown");
  278. } catch (NullPointerException e) {
  279. // We expect this exception.
  280. }
  281. builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.FOO);
  282. builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR);
  283. try {
  284. builder.setRepeatedNestedEnum(1, null);
  285. fail("Exception was not thrown");
  286. } catch (NullPointerException e) {
  287. // We expect this exception.
  288. }
  289. }
  290. public void testRepeatedAppend() throws Exception {
  291. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  292. builder.addAllRepeatedInt32(Arrays.asList(1, 2, 3, 4));
  293. builder.addAllRepeatedForeignEnum(Arrays.asList(ForeignEnum.FOREIGN_BAZ));
  294. ForeignMessage foreignMessage =
  295. ForeignMessage.newBuilder().setC(12).build();
  296. builder.addAllRepeatedForeignMessage(Arrays.asList(foreignMessage));
  297. TestAllTypes message = builder.build();
  298. assertEquals(message.getRepeatedInt32List(), Arrays.asList(1, 2, 3, 4));
  299. assertEquals(message.getRepeatedForeignEnumList(),
  300. Arrays.asList(ForeignEnum.FOREIGN_BAZ));
  301. assertEquals(1, message.getRepeatedForeignMessageCount());
  302. assertEquals(12, message.getRepeatedForeignMessage(0).getC());
  303. }
  304. public void testRepeatedAppendRejectsNull() throws Exception {
  305. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  306. ForeignMessage foreignMessage =
  307. ForeignMessage.newBuilder().setC(12).build();
  308. try {
  309. builder.addAllRepeatedForeignMessage(
  310. Arrays.asList(foreignMessage, (ForeignMessage) null));
  311. fail("Exception was not thrown");
  312. } catch (NullPointerException e) {
  313. // We expect this exception.
  314. }
  315. try {
  316. builder.addAllRepeatedForeignEnum(
  317. Arrays.asList(ForeignEnum.FOREIGN_BAZ, null));
  318. fail("Exception was not thrown");
  319. } catch (NullPointerException e) {
  320. // We expect this exception.
  321. }
  322. try {
  323. builder.addAllRepeatedString(Arrays.asList("one", null));
  324. fail("Exception was not thrown");
  325. } catch (NullPointerException e) {
  326. // We expect this exception.
  327. }
  328. try {
  329. builder.addAllRepeatedBytes(Arrays.asList(TestUtil.toBytes("one"), null));
  330. fail("Exception was not thrown");
  331. } catch (NullPointerException e) {
  332. // We expect this exception.
  333. }
  334. }
  335. public void testSettingForeignMessageUsingBuilder() throws Exception {
  336. TestAllTypes message = TestAllTypes.newBuilder()
  337. // Pass builder for foreign message instance.
  338. .setOptionalForeignMessage(ForeignMessage.newBuilder().setC(123))
  339. .build();
  340. TestAllTypes expectedMessage = TestAllTypes.newBuilder()
  341. // Create expected version passing foreign message instance explicitly.
  342. .setOptionalForeignMessage(
  343. ForeignMessage.newBuilder().setC(123).build())
  344. .build();
  345. // TODO(ngd): Upgrade to using real #equals method once implemented
  346. assertEquals(expectedMessage.toString(), message.toString());
  347. }
  348. public void testSettingRepeatedForeignMessageUsingBuilder() throws Exception {
  349. TestAllTypes message = TestAllTypes.newBuilder()
  350. // Pass builder for foreign message instance.
  351. .addRepeatedForeignMessage(ForeignMessage.newBuilder().setC(456))
  352. .build();
  353. TestAllTypes expectedMessage = TestAllTypes.newBuilder()
  354. // Create expected version passing foreign message instance explicitly.
  355. .addRepeatedForeignMessage(
  356. ForeignMessage.newBuilder().setC(456).build())
  357. .build();
  358. assertEquals(expectedMessage.toString(), message.toString());
  359. }
  360. public void testDefaults() throws Exception {
  361. TestUtil.assertClear(TestAllTypes.getDefaultInstance());
  362. TestUtil.assertClear(TestAllTypes.newBuilder().build());
  363. TestExtremeDefaultValues message =
  364. TestExtremeDefaultValues.getDefaultInstance();
  365. assertEquals("\u1234", message.getUtf8String());
  366. assertEquals(Double.POSITIVE_INFINITY, message.getInfDouble());
  367. assertEquals(Double.NEGATIVE_INFINITY, message.getNegInfDouble());
  368. assertTrue(Double.isNaN(message.getNanDouble()));
  369. assertEquals(Float.POSITIVE_INFINITY, message.getInfFloat());
  370. assertEquals(Float.NEGATIVE_INFINITY, message.getNegInfFloat());
  371. assertTrue(Float.isNaN(message.getNanFloat()));
  372. assertEquals("? ? ?? ?? ??? ??/ ??-", message.getCppTrigraph());
  373. }
  374. public void testClear() throws Exception {
  375. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  376. TestUtil.assertClear(builder);
  377. TestUtil.setAllFields(builder);
  378. builder.clear();
  379. TestUtil.assertClear(builder);
  380. }
  381. public void testReflectionGetters() throws Exception {
  382. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  383. TestUtil.setAllFields(builder);
  384. reflectionTester.assertAllFieldsSetViaReflection(builder);
  385. TestAllTypes message = builder.build();
  386. reflectionTester.assertAllFieldsSetViaReflection(message);
  387. }
  388. public void testReflectionSetters() throws Exception {
  389. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  390. reflectionTester.setAllFieldsViaReflection(builder);
  391. TestUtil.assertAllFieldsSet(builder);
  392. TestAllTypes message = builder.build();
  393. TestUtil.assertAllFieldsSet(message);
  394. }
  395. public void testReflectionSettersRejectNull() throws Exception {
  396. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  397. reflectionTester.assertReflectionSettersRejectNull(builder);
  398. }
  399. public void testReflectionRepeatedSetters() throws Exception {
  400. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  401. reflectionTester.setAllFieldsViaReflection(builder);
  402. reflectionTester.modifyRepeatedFieldsViaReflection(builder);
  403. TestUtil.assertRepeatedFieldsModified(builder);
  404. TestAllTypes message = builder.build();
  405. TestUtil.assertRepeatedFieldsModified(message);
  406. }
  407. public void testReflectionRepeatedSettersRejectNull() throws Exception {
  408. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  409. reflectionTester.assertReflectionRepeatedSettersRejectNull(builder);
  410. }
  411. public void testReflectionDefaults() throws Exception {
  412. reflectionTester.assertClearViaReflection(
  413. TestAllTypes.getDefaultInstance());
  414. reflectionTester.assertClearViaReflection(
  415. TestAllTypes.newBuilder().build());
  416. }
  417. public void testEnumInterface() throws Exception {
  418. assertTrue(TestAllTypes.getDefaultInstance().getDefaultNestedEnum()
  419. instanceof ProtocolMessageEnum);
  420. }
  421. public void testEnumMap() throws Exception {
  422. Internal.EnumLiteMap<ForeignEnum> map = ForeignEnum.internalGetValueMap();
  423. for (ForeignEnum value : ForeignEnum.values()) {
  424. assertEquals(value, map.findValueByNumber(value.getNumber()));
  425. }
  426. assertTrue(map.findValueByNumber(12345) == null);
  427. }
  428. public void testParsePackedToUnpacked() throws Exception {
  429. TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder();
  430. TestUnpackedTypes message =
  431. builder.mergeFrom(TestUtil.getPackedSet().toByteString()).build();
  432. TestUtil.assertUnpackedFieldsSet(message);
  433. }
  434. public void testParseUnpackedToPacked() throws Exception {
  435. TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
  436. TestPackedTypes message =
  437. builder.mergeFrom(TestUtil.getUnpackedSet().toByteString()).build();
  438. TestUtil.assertPackedFieldsSet(message);
  439. }
  440. // =================================================================
  441. // Extensions.
  442. TestUtil.ReflectionTester extensionsReflectionTester =
  443. new TestUtil.ReflectionTester(TestAllExtensions.getDescriptor(),
  444. TestUtil.getExtensionRegistry());
  445. public void testExtensionMessageOrBuilder() throws Exception {
  446. TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
  447. TestUtil.setAllExtensions(builder);
  448. TestAllExtensions message = builder.build();
  449. TestUtil.assertAllExtensionsSet(message);
  450. }
  451. public void testExtensionRepeatedSetters() throws Exception {
  452. TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
  453. TestUtil.setAllExtensions(builder);
  454. TestUtil.modifyRepeatedExtensions(builder);
  455. TestAllExtensions message = builder.build();
  456. TestUtil.assertRepeatedExtensionsModified(message);
  457. }
  458. public void testExtensionDefaults() throws Exception {
  459. TestUtil.assertExtensionsClear(TestAllExtensions.getDefaultInstance());
  460. TestUtil.assertExtensionsClear(TestAllExtensions.newBuilder().build());
  461. }
  462. public void testExtensionReflectionGetters() throws Exception {
  463. TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
  464. TestUtil.setAllExtensions(builder);
  465. extensionsReflectionTester.assertAllFieldsSetViaReflection(builder);
  466. TestAllExtensions message = builder.build();
  467. extensionsReflectionTester.assertAllFieldsSetViaReflection(message);
  468. }
  469. public void testExtensionReflectionSetters() throws Exception {
  470. TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
  471. extensionsReflectionTester.setAllFieldsViaReflection(builder);
  472. TestUtil.assertAllExtensionsSet(builder);
  473. TestAllExtensions message = builder.build();
  474. TestUtil.assertAllExtensionsSet(message);
  475. }
  476. public void testExtensionReflectionSettersRejectNull() throws Exception {
  477. TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
  478. extensionsReflectionTester.assertReflectionSettersRejectNull(builder);
  479. }
  480. public void testExtensionReflectionRepeatedSetters() throws Exception {
  481. TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
  482. extensionsReflectionTester.setAllFieldsViaReflection(builder);
  483. extensionsReflectionTester.modifyRepeatedFieldsViaReflection(builder);
  484. TestUtil.assertRepeatedExtensionsModified(builder);
  485. TestAllExtensions message = builder.build();
  486. TestUtil.assertRepeatedExtensionsModified(message);
  487. }
  488. public void testExtensionReflectionRepeatedSettersRejectNull()
  489. throws Exception {
  490. TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
  491. extensionsReflectionTester.assertReflectionRepeatedSettersRejectNull(
  492. builder);
  493. }
  494. public void testExtensionReflectionDefaults() throws Exception {
  495. extensionsReflectionTester.assertClearViaReflection(
  496. TestAllExtensions.getDefaultInstance());
  497. extensionsReflectionTester.assertClearViaReflection(
  498. TestAllExtensions.newBuilder().build());
  499. }
  500. public void testClearExtension() throws Exception {
  501. // clearExtension() is not actually used in TestUtil, so try it manually.
  502. assertFalse(
  503. TestAllExtensions.newBuilder()
  504. .setExtension(UnittestProto.optionalInt32Extension, 1)
  505. .clearExtension(UnittestProto.optionalInt32Extension)
  506. .hasExtension(UnittestProto.optionalInt32Extension));
  507. assertEquals(0,
  508. TestAllExtensions.newBuilder()
  509. .addExtension(UnittestProto.repeatedInt32Extension, 1)
  510. .clearExtension(UnittestProto.repeatedInt32Extension)
  511. .getExtensionCount(UnittestProto.repeatedInt32Extension));
  512. }
  513. public void testExtensionCopy() throws Exception {
  514. TestAllExtensions original = TestUtil.getAllExtensionsSet();
  515. TestAllExtensions copy = TestAllExtensions.newBuilder(original).build();
  516. TestUtil.assertAllExtensionsSet(copy);
  517. }
  518. public void testExtensionMergeFrom() throws Exception {
  519. TestAllExtensions original =
  520. TestAllExtensions.newBuilder()
  521. .setExtension(UnittestProto.optionalInt32Extension, 1).build();
  522. TestAllExtensions merged =
  523. TestAllExtensions.newBuilder().mergeFrom(original).build();
  524. assertTrue(merged.hasExtension(UnittestProto.optionalInt32Extension));
  525. assertEquals(
  526. 1, (int) merged.getExtension(UnittestProto.optionalInt32Extension));
  527. }
  528. // =================================================================
  529. // Lite Extensions.
  530. // We test lite extensions directly because they have a separate
  531. // implementation from full extensions. In contrast, we do not test
  532. // lite fields directly since they are implemented exactly the same as
  533. // regular fields.
  534. public void testLiteExtensionMessageOrBuilder() throws Exception {
  535. TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
  536. TestUtil.setAllExtensions(builder);
  537. TestUtil.assertAllExtensionsSet(builder);
  538. TestAllExtensionsLite message = builder.build();
  539. TestUtil.assertAllExtensionsSet(message);
  540. }
  541. public void testLiteExtensionRepeatedSetters() throws Exception {
  542. TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
  543. TestUtil.setAllExtensions(builder);
  544. TestUtil.modifyRepeatedExtensions(builder);
  545. TestUtil.assertRepeatedExtensionsModified(builder);
  546. TestAllExtensionsLite message = builder.build();
  547. TestUtil.assertRepeatedExtensionsModified(message);
  548. }
  549. public void testLiteExtensionDefaults() throws Exception {
  550. TestUtil.assertExtensionsClear(TestAllExtensionsLite.getDefaultInstance());
  551. TestUtil.assertExtensionsClear(TestAllExtensionsLite.newBuilder().build());
  552. }
  553. public void testClearLiteExtension() throws Exception {
  554. // clearExtension() is not actually used in TestUtil, so try it manually.
  555. assertFalse(
  556. TestAllExtensionsLite.newBuilder()
  557. .setExtension(UnittestLite.optionalInt32ExtensionLite, 1)
  558. .clearExtension(UnittestLite.optionalInt32ExtensionLite)
  559. .hasExtension(UnittestLite.optionalInt32ExtensionLite));
  560. assertEquals(0,
  561. TestAllExtensionsLite.newBuilder()
  562. .addExtension(UnittestLite.repeatedInt32ExtensionLite, 1)
  563. .clearExtension(UnittestLite.repeatedInt32ExtensionLite)
  564. .getExtensionCount(UnittestLite.repeatedInt32ExtensionLite));
  565. }
  566. public void testLiteExtensionCopy() throws Exception {
  567. TestAllExtensionsLite original = TestUtil.getAllLiteExtensionsSet();
  568. TestAllExtensionsLite copy =
  569. TestAllExtensionsLite.newBuilder(original).build();
  570. TestUtil.assertAllExtensionsSet(copy);
  571. }
  572. public void testLiteExtensionMergeFrom() throws Exception {
  573. TestAllExtensionsLite original =
  574. TestAllExtensionsLite.newBuilder()
  575. .setExtension(UnittestLite.optionalInt32ExtensionLite, 1).build();
  576. TestAllExtensionsLite merged =
  577. TestAllExtensionsLite.newBuilder().mergeFrom(original).build();
  578. assertTrue(merged.hasExtension(UnittestLite.optionalInt32ExtensionLite));
  579. assertEquals(
  580. 1, (int) merged.getExtension(UnittestLite.optionalInt32ExtensionLite));
  581. }
  582. // =================================================================
  583. // multiple_files_test
  584. public void testMultipleFilesOption() throws Exception {
  585. // We mostly just want to check that things compile.
  586. MessageWithNoOuter message =
  587. MessageWithNoOuter.newBuilder()
  588. .setNested(MessageWithNoOuter.NestedMessage.newBuilder().setI(1))
  589. .addForeign(TestAllTypes.newBuilder().setOptionalInt32(1))
  590. .setNestedEnum(MessageWithNoOuter.NestedEnum.BAZ)
  591. .setForeignEnum(EnumWithNoOuter.BAR)
  592. .build();
  593. assertEquals(message, MessageWithNoOuter.parseFrom(message.toByteString()));
  594. assertEquals(MultipleFilesTestProto.getDescriptor(),
  595. MessageWithNoOuter.getDescriptor().getFile());
  596. Descriptors.FieldDescriptor field =
  597. MessageWithNoOuter.getDescriptor().findFieldByName("foreign_enum");
  598. assertEquals(EnumWithNoOuter.BAR.getValueDescriptor(),
  599. message.getField(field));
  600. assertEquals(MultipleFilesTestProto.getDescriptor(),
  601. ServiceWithNoOuter.getDescriptor().getFile());
  602. assertFalse(
  603. TestAllExtensions.getDefaultInstance().hasExtension(
  604. MultipleFilesTestProto.extensionWithOuter));
  605. }
  606. public void testOptionalFieldWithRequiredSubfieldsOptimizedForSize()
  607. throws Exception {
  608. TestOptionalOptimizedForSize message =
  609. TestOptionalOptimizedForSize.getDefaultInstance();
  610. assertTrue(message.isInitialized());
  611. message = TestOptionalOptimizedForSize.newBuilder().setO(
  612. TestRequiredOptimizedForSize.newBuilder().buildPartial()
  613. ).buildPartial();
  614. assertFalse(message.isInitialized());
  615. message = TestOptionalOptimizedForSize.newBuilder().setO(
  616. TestRequiredOptimizedForSize.newBuilder().setX(5).buildPartial()
  617. ).buildPartial();
  618. assertTrue(message.isInitialized());
  619. }
  620. public void testUninitializedExtensionInOptimizedForSize()
  621. throws Exception {
  622. TestOptimizedForSize.Builder builder = TestOptimizedForSize.newBuilder();
  623. builder.setExtension(TestOptimizedForSize.testExtension2,
  624. TestRequiredOptimizedForSize.newBuilder().buildPartial());
  625. assertFalse(builder.isInitialized());
  626. assertFalse(builder.buildPartial().isInitialized());
  627. builder = TestOptimizedForSize.newBuilder();
  628. builder.setExtension(TestOptimizedForSize.testExtension2,
  629. TestRequiredOptimizedForSize.newBuilder().setX(10).buildPartial());
  630. assertTrue(builder.isInitialized());
  631. assertTrue(builder.buildPartial().isInitialized());
  632. }
  633. public void testToBuilder() throws Exception {
  634. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  635. TestUtil.setAllFields(builder);
  636. TestAllTypes message = builder.build();
  637. TestUtil.assertAllFieldsSet(message);
  638. TestUtil.assertAllFieldsSet(message.toBuilder().build());
  639. }
  640. public void testFieldConstantValues() throws Exception {
  641. assertEquals(TestAllTypes.NestedMessage.BB_FIELD_NUMBER, 1);
  642. assertEquals(TestAllTypes.OPTIONAL_INT32_FIELD_NUMBER, 1);
  643. assertEquals(TestAllTypes.OPTIONALGROUP_FIELD_NUMBER, 16);
  644. assertEquals(TestAllTypes.OPTIONAL_NESTED_MESSAGE_FIELD_NUMBER, 18);
  645. assertEquals(TestAllTypes.OPTIONAL_NESTED_ENUM_FIELD_NUMBER, 21);
  646. assertEquals(TestAllTypes.REPEATED_INT32_FIELD_NUMBER, 31);
  647. assertEquals(TestAllTypes.REPEATEDGROUP_FIELD_NUMBER, 46);
  648. assertEquals(TestAllTypes.REPEATED_NESTED_MESSAGE_FIELD_NUMBER, 48);
  649. assertEquals(TestAllTypes.REPEATED_NESTED_ENUM_FIELD_NUMBER, 51);
  650. }
  651. public void testExtensionConstantValues() throws Exception {
  652. assertEquals(UnittestProto.TestRequired.SINGLE_FIELD_NUMBER, 1000);
  653. assertEquals(UnittestProto.TestRequired.MULTI_FIELD_NUMBER, 1001);
  654. assertEquals(UnittestProto.OPTIONAL_INT32_EXTENSION_FIELD_NUMBER, 1);
  655. assertEquals(UnittestProto.OPTIONALGROUP_EXTENSION_FIELD_NUMBER, 16);
  656. assertEquals(
  657. UnittestProto.OPTIONAL_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 18);
  658. assertEquals(UnittestProto.OPTIONAL_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 21);
  659. assertEquals(UnittestProto.REPEATED_INT32_EXTENSION_FIELD_NUMBER, 31);
  660. assertEquals(UnittestProto.REPEATEDGROUP_EXTENSION_FIELD_NUMBER, 46);
  661. assertEquals(
  662. UnittestProto.REPEATED_NESTED_MESSAGE_EXTENSION_FIELD_NUMBER, 48);
  663. assertEquals(UnittestProto.REPEATED_NESTED_ENUM_EXTENSION_FIELD_NUMBER, 51);
  664. }
  665. public void testRecursiveMessageDefaultInstance() throws Exception {
  666. UnittestProto.TestRecursiveMessage message =
  667. UnittestProto.TestRecursiveMessage.getDefaultInstance();
  668. assertTrue(message != null);
  669. assertTrue(message.getA() != null);
  670. assertTrue(message.getA() == message);
  671. }
  672. public void testSerialize() throws Exception {
  673. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  674. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  675. TestUtil.setAllFields(builder);
  676. TestAllTypes expected = builder.build();
  677. ObjectOutputStream out = new ObjectOutputStream(baos);
  678. try {
  679. out.writeObject(expected);
  680. } finally {
  681. out.close();
  682. }
  683. ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
  684. ObjectInputStream in = new ObjectInputStream(bais);
  685. TestAllTypes actual = (TestAllTypes) in.readObject();
  686. assertEquals(expected, actual);
  687. }
  688. public void testSerializePartial() throws Exception {
  689. ByteArrayOutputStream baos = new ByteArrayOutputStream();
  690. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  691. TestAllTypes expected = builder.buildPartial();
  692. ObjectOutputStream out = new ObjectOutputStream(baos);
  693. try {
  694. out.writeObject(expected);
  695. } finally {
  696. out.close();
  697. }
  698. ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
  699. ObjectInputStream in = new ObjectInputStream(bais);
  700. TestAllTypes actual = (TestAllTypes) in.readObject();
  701. assertEquals(expected, actual);
  702. }
  703. public void testEnumValues() {
  704. assertEquals(
  705. TestAllTypes.NestedEnum.BAR.getNumber(),
  706. TestAllTypes.NestedEnum.BAR_VALUE);
  707. assertEquals(
  708. TestAllTypes.NestedEnum.BAZ.getNumber(),
  709. TestAllTypes.NestedEnum.BAZ_VALUE);
  710. assertEquals(
  711. TestAllTypes.NestedEnum.FOO.getNumber(),
  712. TestAllTypes.NestedEnum.FOO_VALUE);
  713. }
  714. public void testNonNestedExtensionInitialization() {
  715. assertTrue(NonNestedExtension.nonNestedExtension
  716. .getMessageDefaultInstance() instanceof MyNonNestedExtension);
  717. assertEquals("nonNestedExtension",
  718. NonNestedExtension.nonNestedExtension.getDescriptor().getName());
  719. }
  720. public void testNestedExtensionInitialization() {
  721. assertTrue(MyNestedExtension.recursiveExtension.getMessageDefaultInstance()
  722. instanceof MessageToBeExtended);
  723. assertEquals("recursiveExtension",
  724. MyNestedExtension.recursiveExtension.getDescriptor().getName());
  725. }
  726. public void testNonNestedExtensionLiteInitialization() {
  727. assertTrue(NonNestedExtensionLite.nonNestedExtensionLite
  728. .getMessageDefaultInstance() instanceof MyNonNestedExtensionLite);
  729. }
  730. public void testNestedExtensionLiteInitialization() {
  731. assertTrue(MyNestedExtensionLite.recursiveExtensionLite
  732. .getMessageDefaultInstance() instanceof MessageLiteToBeExtended);
  733. }
  734. public void testInvalidations() throws Exception {
  735. GeneratedMessage.enableAlwaysUseFieldBuildersForTesting();
  736. TestAllTypes.NestedMessage nestedMessage1 =
  737. TestAllTypes.NestedMessage.newBuilder().build();
  738. TestAllTypes.NestedMessage nestedMessage2 =
  739. TestAllTypes.NestedMessage.newBuilder().build();
  740. // Set all three flavors (enum, primitive, message and singular/repeated)
  741. // and verify no invalidations fired
  742. TestUtil.MockBuilderParent mockParent = new TestUtil.MockBuilderParent();
  743. TestAllTypes.Builder builder = (TestAllTypes.Builder)
  744. ((GeneratedMessage) TestAllTypes.getDefaultInstance()).
  745. newBuilderForType(mockParent);
  746. builder.setOptionalInt32(1);
  747. builder.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAR);
  748. builder.setOptionalNestedMessage(nestedMessage1);
  749. builder.addRepeatedInt32(1);
  750. builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAR);
  751. builder.addRepeatedNestedMessage(nestedMessage1);
  752. assertEquals(0, mockParent.getInvalidationCount());
  753. // Now tell it we want changes and make sure it's only fired once
  754. // And do this for each flavor
  755. // primitive single
  756. builder.buildPartial();
  757. builder.setOptionalInt32(2);
  758. builder.setOptionalInt32(3);
  759. assertEquals(1, mockParent.getInvalidationCount());
  760. // enum single
  761. builder.buildPartial();
  762. builder.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAZ);
  763. builder.setOptionalNestedEnum(TestAllTypes.NestedEnum.BAR);
  764. assertEquals(2, mockParent.getInvalidationCount());
  765. // message single
  766. builder.buildPartial();
  767. builder.setOptionalNestedMessage(nestedMessage2);
  768. builder.setOptionalNestedMessage(nestedMessage1);
  769. assertEquals(3, mockParent.getInvalidationCount());
  770. // primitive repated
  771. builder.buildPartial();
  772. builder.addRepeatedInt32(2);
  773. builder.addRepeatedInt32(3);
  774. assertEquals(4, mockParent.getInvalidationCount());
  775. // enum repeated
  776. builder.buildPartial();
  777. builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ);
  778. builder.addRepeatedNestedEnum(TestAllTypes.NestedEnum.BAZ);
  779. assertEquals(5, mockParent.getInvalidationCount());
  780. // message repeated
  781. builder.buildPartial();
  782. builder.addRepeatedNestedMessage(nestedMessage2);
  783. builder.addRepeatedNestedMessage(nestedMessage1);
  784. assertEquals(6, mockParent.getInvalidationCount());
  785. }
  786. public void testInvalidations_Extensions() throws Exception {
  787. TestUtil.MockBuilderParent mockParent = new TestUtil.MockBuilderParent();
  788. TestAllExtensions.Builder builder = (TestAllExtensions.Builder)
  789. ((GeneratedMessage) TestAllExtensions.getDefaultInstance()).
  790. newBuilderForType(mockParent);
  791. builder.addExtension(UnittestProto.repeatedInt32Extension, 1);
  792. builder.setExtension(UnittestProto.repeatedInt32Extension, 0, 2);
  793. builder.clearExtension(UnittestProto.repeatedInt32Extension);
  794. assertEquals(0, mockParent.getInvalidationCount());
  795. // Now tell it we want changes and make sure it's only fired once
  796. builder.buildPartial();
  797. builder.addExtension(UnittestProto.repeatedInt32Extension, 2);
  798. builder.addExtension(UnittestProto.repeatedInt32Extension, 3);
  799. assertEquals(1, mockParent.getInvalidationCount());
  800. builder.buildPartial();
  801. builder.setExtension(UnittestProto.repeatedInt32Extension, 0, 4);
  802. builder.setExtension(UnittestProto.repeatedInt32Extension, 1, 5);
  803. assertEquals(2, mockParent.getInvalidationCount());
  804. builder.buildPartial();
  805. builder.clearExtension(UnittestProto.repeatedInt32Extension);
  806. builder.clearExtension(UnittestProto.repeatedInt32Extension);
  807. assertEquals(3, mockParent.getInvalidationCount());
  808. }
  809. public void testBaseMessageOrBuilder() {
  810. // Mostly just makes sure the base interface exists and has some methods.
  811. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  812. TestAllTypes message = builder.buildPartial();
  813. TestAllTypesOrBuilder builderAsInterface = (TestAllTypesOrBuilder) builder;
  814. TestAllTypesOrBuilder messageAsInterface = (TestAllTypesOrBuilder) message;
  815. assertEquals(
  816. messageAsInterface.getDefaultBool(),
  817. messageAsInterface.getDefaultBool());
  818. assertEquals(
  819. messageAsInterface.getOptionalDouble(),
  820. messageAsInterface.getOptionalDouble());
  821. }
  822. public void testMessageOrBuilderGetters() {
  823. TestAllTypes.Builder builder = TestAllTypes.newBuilder();
  824. // single fields
  825. assertSame(ForeignMessage.getDefaultInstance(),
  826. builder.getOptionalForeignMessageOrBuilder());
  827. ForeignMessage.Builder subBuilder =
  828. builder.getOptionalForeignMessageBuilder();
  829. assertSame(subBuilder, builder.getOptionalForeignMessageOrBuilder());
  830. // repeated fields
  831. ForeignMessage m0 = ForeignMessage.newBuilder().buildPartial();
  832. ForeignMessage m1 = ForeignMessage.newBuilder().buildPartial();
  833. ForeignMessage m2 = ForeignMessage.newBuilder().buildPartial();
  834. builder.addRepeatedForeignMessage(m0);
  835. builder.addRepeatedForeignMessage(m1);
  836. builder.addRepeatedForeignMessage(m2);
  837. assertSame(m0, builder.getRepeatedForeignMessageOrBuilder(0));
  838. assertSame(m1, builder.getRepeatedForeignMessageOrBuilder(1));
  839. assertSame(m2, builder.getRepeatedForeignMessageOrBuilder(2));
  840. ForeignMessage.Builder b0 = builder.getRepeatedForeignMessageBuilder(0);
  841. ForeignMessage.Builder b1 = builder.getRepeatedForeignMessageBuilder(1);
  842. assertSame(b0, builder.getRepeatedForeignMessageOrBuilder(0));
  843. assertSame(b1, builder.getRepeatedForeignMessageOrBuilder(1));
  844. assertSame(m2, builder.getRepeatedForeignMessageOrBuilder(2));
  845. List<? extends ForeignMessageOrBuilder> messageOrBuilderList =
  846. builder.getRepeatedForeignMessageOrBuilderList();
  847. assertSame(b0, messageOrBuilderList.get(0));
  848. assertSame(b1, messageOrBuilderList.get(1));
  849. assertSame(m2, messageOrBuilderList.get(2));
  850. }
  851. }