PageRenderTime 303ms CodeModel.GetById 31ms RepoModel.GetById 1ms app.codeStats 0ms

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

http://github.com/tomahawk-player/tomahawk
Java | 1278 lines | 1021 code | 127 blank | 130 comment | 0 complexity | e96d58a1d50e576fb4df7cb2ff66b36a MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause, GPL-3.0, GPL-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. // Protocol Buffers - Google's data interchange format
    2. 

  2. // Copyright 2008 Google Inc.  All rights reserved.
    3. 

  3. // http://code.google.com/p/protobuf/
    4. 

  4. //
    5. 

  5. // Redistribution and use in source and binary forms, with or without
    6. 

  6. // modification, are permitted provided that the following conditions are
    7. 

  7. // met:
    8. 

  8. //
    9. 

  9. //     * Redistributions of source code must retain the above copyright
    10. 

  10. // notice, this list of conditions and the following disclaimer.
    11. 

  11. //     * Redistributions in binary form must reproduce the above
    12. 

  12. // copyright notice, this list of conditions and the following disclaimer
    13. 

  13. // in the documentation and/or other materials provided with the
    14. 

  14. // distribution.
    15. 

  15. //     * Neither the name of Google Inc. nor the names of its
    16. 

  16. // contributors may be used to endorse or promote products derived from
    17. 

  17. // this software without specific prior written permission.
    18. 

  18. //
    19. 

  19. // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    20. 

  20. // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    21. 

  21. // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    22. 

  22. // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    23. 

  23. // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    24. 

  24. // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    25. 

  25. // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    26. 

  26. // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    27. 

  27. // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    28. 

  28. // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    29. 

  29. // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    30. 

  30. 

  31. package com.google.protobuf;
    32. 

  32. 

  33. import protobuf_unittest.UnittestProto;
    34. 

  34. import com.google.protobuf.UnittestLite;
    35. 

  35. 

  36. // The static imports are to avoid 100+ char lines.  The following is roughly equivalent to
    37. 

  37. // import static protobuf_unittest.UnittestProto.*;
    38. 

  38. import static protobuf_unittest.UnittestProto.defaultInt32Extension;
    39. 

  39. import static protobuf_unittest.UnittestProto.defaultInt64Extension;
    40. 

  40. import static protobuf_unittest.UnittestProto.defaultUint32Extension;
    41. 

  41. import static protobuf_unittest.UnittestProto.defaultUint64Extension;
    42. 

  42. import static protobuf_unittest.UnittestProto.defaultSint32Extension;
    43. 

  43. import static protobuf_unittest.UnittestProto.defaultSint64Extension;
    44. 

  44. import static protobuf_unittest.UnittestProto.defaultFixed32Extension;
    45. 

  45. import static protobuf_unittest.UnittestProto.defaultFixed64Extension;
    46. 

  46. import static protobuf_unittest.UnittestProto.defaultSfixed32Extension;
    47. 

  47. import static protobuf_unittest.UnittestProto.defaultSfixed64Extension;
    48. 

  48. import static protobuf_unittest.UnittestProto.defaultFloatExtension;
    49. 

  49. import static protobuf_unittest.UnittestProto.defaultDoubleExtension;
    50. 

  50. import static protobuf_unittest.UnittestProto.defaultBoolExtension;
    51. 

  51. import static protobuf_unittest.UnittestProto.defaultStringExtension;
    52. 

  52. import static protobuf_unittest.UnittestProto.defaultBytesExtension;
    53. 

  53. import static protobuf_unittest.UnittestProto.defaultNestedEnumExtension;
    54. 

  54. import static protobuf_unittest.UnittestProto.defaultForeignEnumExtension;
    55. 

  55. import static protobuf_unittest.UnittestProto.defaultImportEnumExtension;
    56. 

  56. import static protobuf_unittest.UnittestProto.defaultStringPieceExtension;
    57. 

  57. import static protobuf_unittest.UnittestProto.defaultCordExtension;
    58. 

  58. 

  59. import static protobuf_unittest.UnittestProto.optionalInt32Extension;
    60. 

  60. import static protobuf_unittest.UnittestProto.optionalInt64Extension;
    61. 

  61. import static protobuf_unittest.UnittestProto.optionalUint32Extension;
    62. 

  62. import static protobuf_unittest.UnittestProto.optionalUint64Extension;
    63. 

  63. import static protobuf_unittest.UnittestProto.optionalSint32Extension;
    64. 

  64. import static protobuf_unittest.UnittestProto.optionalSint64Extension;
    65. 

  65. import static protobuf_unittest.UnittestProto.optionalFixed32Extension;
    66. 

  66. import static protobuf_unittest.UnittestProto.optionalFixed64Extension;
    67. 

  67. import static protobuf_unittest.UnittestProto.optionalSfixed32Extension;
    68. 

  68. import static protobuf_unittest.UnittestProto.optionalSfixed64Extension;
    69. 

  69. import static protobuf_unittest.UnittestProto.optionalFloatExtension;
    70. 

  70. import static protobuf_unittest.UnittestProto.optionalDoubleExtension;
    71. 

  71. import static protobuf_unittest.UnittestProto.optionalBoolExtension;
    72. 

  72. import static protobuf_unittest.UnittestProto.optionalStringExtension;
    73. 

  73. import static protobuf_unittest.UnittestProto.optionalBytesExtension;
    74. 

  74. import static protobuf_unittest.UnittestProto.optionalGroupExtension;
    75. 

  75. import static protobuf_unittest.UnittestProto.optionalNestedMessageExtension;
    76. 

  76. import static protobuf_unittest.UnittestProto.optionalForeignMessageExtension;
    77. 

  77. import static protobuf_unittest.UnittestProto.optionalImportMessageExtension;
    78. 

  78. import static protobuf_unittest.UnittestProto.optionalNestedEnumExtension;
    79. 

  79. import static protobuf_unittest.UnittestProto.optionalForeignEnumExtension;
    80. 

  80. import static protobuf_unittest.UnittestProto.optionalImportEnumExtension;
    81. 

  81. import static protobuf_unittest.UnittestProto.optionalStringPieceExtension;
    82. 

  82. import static protobuf_unittest.UnittestProto.optionalCordExtension;
    83. 

  83. 

  84. import static protobuf_unittest.UnittestProto.repeatedInt32Extension;
    85. 

  85. import static protobuf_unittest.UnittestProto.repeatedInt64Extension;
    86. 

  86. import static protobuf_unittest.UnittestProto.repeatedUint32Extension;
    87. 

  87. import static protobuf_unittest.UnittestProto.repeatedUint64Extension;
    88. 

  88. import static protobuf_unittest.UnittestProto.repeatedSint32Extension;
    89. 

  89. import static protobuf_unittest.UnittestProto.repeatedSint64Extension;
    90. 

  90. import static protobuf_unittest.UnittestProto.repeatedFixed32Extension;
    91. 

  91. import static protobuf_unittest.UnittestProto.repeatedFixed64Extension;
    92. 

  92. import static protobuf_unittest.UnittestProto.repeatedSfixed32Extension;
    93. 

  93. import static protobuf_unittest.UnittestProto.repeatedSfixed64Extension;
    94. 

  94. import static protobuf_unittest.UnittestProto.repeatedFloatExtension;
    95. 

  95. import static protobuf_unittest.UnittestProto.repeatedDoubleExtension;
    96. 

  96. import static protobuf_unittest.UnittestProto.repeatedBoolExtension;
    97. 

  97. import static protobuf_unittest.UnittestProto.repeatedStringExtension;
    98. 

  98. import static protobuf_unittest.UnittestProto.repeatedBytesExtension;
    99. 

  99. import static protobuf_unittest.UnittestProto.repeatedGroupExtension;
    100. 

  100. import static protobuf_unittest.UnittestProto.repeatedNestedMessageExtension;
    101. 

  101. import static protobuf_unittest.UnittestProto.repeatedForeignMessageExtension;
    102. 

  102. import static protobuf_unittest.UnittestProto.repeatedImportMessageExtension;
    103. 

  103. import static protobuf_unittest.UnittestProto.repeatedNestedEnumExtension;
    104. 

  104. import static protobuf_unittest.UnittestProto.repeatedForeignEnumExtension;
    105. 

  105. import static protobuf_unittest.UnittestProto.repeatedImportEnumExtension;
    106. 

  106. import static protobuf_unittest.UnittestProto.repeatedStringPieceExtension;
    107. 

  107. import static protobuf_unittest.UnittestProto.repeatedCordExtension;
    108. 

  108. 

  109. import static protobuf_unittest.UnittestProto.OptionalGroup_extension;
    110. 

  110. import static protobuf_unittest.UnittestProto.RepeatedGroup_extension;
    111. 

  111. 

  112. import static protobuf_unittest.UnittestProto.packedInt32Extension;
    113. 

  113. import static protobuf_unittest.UnittestProto.packedInt64Extension;
    114. 

  114. import static protobuf_unittest.UnittestProto.packedUint32Extension;
    115. 

  115. import static protobuf_unittest.UnittestProto.packedUint64Extension;
    116. 

  116. import static protobuf_unittest.UnittestProto.packedSint32Extension;
    117. 

  117. import static protobuf_unittest.UnittestProto.packedSint64Extension;
    118. 

  118. import static protobuf_unittest.UnittestProto.packedFixed32Extension;
    119. 

  119. import static protobuf_unittest.UnittestProto.packedFixed64Extension;
    120. 

  120. import static protobuf_unittest.UnittestProto.packedSfixed32Extension;
    121. 

  121. import static protobuf_unittest.UnittestProto.packedSfixed64Extension;
    122. 

  122. import static protobuf_unittest.UnittestProto.packedFloatExtension;
    123. 

  123. import static protobuf_unittest.UnittestProto.packedDoubleExtension;
    124. 

  124. import static protobuf_unittest.UnittestProto.packedBoolExtension;
    125. 

  125. import static protobuf_unittest.UnittestProto.packedEnumExtension;
    126. 

  126. 

  127. import static com.google.protobuf.UnittestLite.defaultInt32ExtensionLite;
    128. 

  128. import static com.google.protobuf.UnittestLite.defaultInt64ExtensionLite;
    129. 

  129. import static com.google.protobuf.UnittestLite.defaultUint32ExtensionLite;
    130. 

  130. import static com.google.protobuf.UnittestLite.defaultUint64ExtensionLite;
    131. 

  131. import static com.google.protobuf.UnittestLite.defaultSint32ExtensionLite;
    132. 

  132. import static com.google.protobuf.UnittestLite.defaultSint64ExtensionLite;
    133. 

  133. import static com.google.protobuf.UnittestLite.defaultFixed32ExtensionLite;
    134. 

  134. import static com.google.protobuf.UnittestLite.defaultFixed64ExtensionLite;
    135. 

  135. import static com.google.protobuf.UnittestLite.defaultSfixed32ExtensionLite;
    136. 

  136. import static com.google.protobuf.UnittestLite.defaultSfixed64ExtensionLite;
    137. 

  137. import static com.google.protobuf.UnittestLite.defaultFloatExtensionLite;
    138. 

  138. import static com.google.protobuf.UnittestLite.defaultDoubleExtensionLite;
    139. 

  139. import static com.google.protobuf.UnittestLite.defaultBoolExtensionLite;
    140. 

  140. import static com.google.protobuf.UnittestLite.defaultStringExtensionLite;
    141. 

  141. import static com.google.protobuf.UnittestLite.defaultBytesExtensionLite;
    142. 

  142. import static com.google.protobuf.UnittestLite.defaultNestedEnumExtensionLite;
    143. 

  143. import static com.google.protobuf.UnittestLite.defaultForeignEnumExtensionLite;
    144. 

  144. import static com.google.protobuf.UnittestLite.defaultImportEnumExtensionLite;
    145. 

  145. import static com.google.protobuf.UnittestLite.defaultStringPieceExtensionLite;
    146. 

  146. import static com.google.protobuf.UnittestLite.defaultCordExtensionLite;
    147. 

  147. 

  148. import static com.google.protobuf.UnittestLite.optionalInt32ExtensionLite;
    149. 

  149. import static com.google.protobuf.UnittestLite.optionalInt64ExtensionLite;
    150. 

  150. import static com.google.protobuf.UnittestLite.optionalUint32ExtensionLite;
    151. 

  151. import static com.google.protobuf.UnittestLite.optionalUint64ExtensionLite;
    152. 

  152. import static com.google.protobuf.UnittestLite.optionalSint32ExtensionLite;
    153. 

  153. import static com.google.protobuf.UnittestLite.optionalSint64ExtensionLite;
    154. 

  154. import static com.google.protobuf.UnittestLite.optionalFixed32ExtensionLite;
    155. 

  155. import static com.google.protobuf.UnittestLite.optionalFixed64ExtensionLite;
    156. 

  156. import static com.google.protobuf.UnittestLite.optionalSfixed32ExtensionLite;
    157. 

  157. import static com.google.protobuf.UnittestLite.optionalSfixed64ExtensionLite;
    158. 

  158. import static com.google.protobuf.UnittestLite.optionalFloatExtensionLite;
    159. 

  159. import static com.google.protobuf.UnittestLite.optionalDoubleExtensionLite;
    160. 

  160. import static com.google.protobuf.UnittestLite.optionalBoolExtensionLite;
    161. 

  161. import static com.google.protobuf.UnittestLite.optionalStringExtensionLite;
    162. 

  162. import static com.google.protobuf.UnittestLite.optionalBytesExtensionLite;
    163. 

  163. import static com.google.protobuf.UnittestLite.optionalGroupExtensionLite;
    164. 

  164. import static com.google.protobuf.UnittestLite.optionalNestedMessageExtensionLite;
    165. 

  165. import static com.google.protobuf.UnittestLite.optionalForeignMessageExtensionLite;
    166. 

  166. import static com.google.protobuf.UnittestLite.optionalImportMessageExtensionLite;
    167. 

  167. import static com.google.protobuf.UnittestLite.optionalNestedEnumExtensionLite;
    168. 

  168. import static com.google.protobuf.UnittestLite.optionalForeignEnumExtensionLite;
    169. 

  169. import static com.google.protobuf.UnittestLite.optionalImportEnumExtensionLite;
    170. 

  170. import static com.google.protobuf.UnittestLite.optionalStringPieceExtensionLite;
    171. 

  171. import static com.google.protobuf.UnittestLite.optionalCordExtensionLite;
    172. 

  172. 

  173. import static com.google.protobuf.UnittestLite.repeatedInt32ExtensionLite;
    174. 

  174. import static com.google.protobuf.UnittestLite.repeatedInt64ExtensionLite;
    175. 

  175. import static com.google.protobuf.UnittestLite.repeatedUint32ExtensionLite;
    176. 

  176. import static com.google.protobuf.UnittestLite.repeatedUint64ExtensionLite;
    177. 

  177. import static com.google.protobuf.UnittestLite.repeatedSint32ExtensionLite;
    178. 

  178. import static com.google.protobuf.UnittestLite.repeatedSint64ExtensionLite;
    179. 

  179. import static com.google.protobuf.UnittestLite.repeatedFixed32ExtensionLite;
    180. 

  180. import static com.google.protobuf.UnittestLite.repeatedFixed64ExtensionLite;
    181. 

  181. import static com.google.protobuf.UnittestLite.repeatedSfixed32ExtensionLite;
    182. 

  182. import static com.google.protobuf.UnittestLite.repeatedSfixed64ExtensionLite;
    183. 

  183. import static com.google.protobuf.UnittestLite.repeatedFloatExtensionLite;
    184. 

  184. import static com.google.protobuf.UnittestLite.repeatedDoubleExtensionLite;
    185. 

  185. import static com.google.protobuf.UnittestLite.repeatedBoolExtensionLite;
    186. 

  186. import static com.google.protobuf.UnittestLite.repeatedStringExtensionLite;
    187. 

  187. import static com.google.protobuf.UnittestLite.repeatedBytesExtensionLite;
    188. 

  188. import static com.google.protobuf.UnittestLite.repeatedGroupExtensionLite;
    189. 

  189. import static com.google.protobuf.UnittestLite.repeatedNestedMessageExtensionLite;
    190. 

  190. import static com.google.protobuf.UnittestLite.repeatedForeignMessageExtensionLite;
    191. 

  191. import static com.google.protobuf.UnittestLite.repeatedImportMessageExtensionLite;
    192. 

  192. import static com.google.protobuf.UnittestLite.repeatedNestedEnumExtensionLite;
    193. 

  193. import static com.google.protobuf.UnittestLite.repeatedForeignEnumExtensionLite;
    194. 

  194. import static com.google.protobuf.UnittestLite.repeatedImportEnumExtensionLite;
    195. 

  195. import static com.google.protobuf.UnittestLite.repeatedStringPieceExtensionLite;
    196. 

  196. import static com.google.protobuf.UnittestLite.repeatedCordExtensionLite;
    197. 

  197. 

  198. import static com.google.protobuf.UnittestLite.OptionalGroup_extension_lite;
    199. 

  199. import static com.google.protobuf.UnittestLite.RepeatedGroup_extension_lite;
    200. 

  200. 

  201. import static com.google.protobuf.UnittestLite.packedInt32ExtensionLite;
    202. 

  202. import static com.google.protobuf.UnittestLite.packedInt64ExtensionLite;
    203. 

  203. import static com.google.protobuf.UnittestLite.packedUint32ExtensionLite;
    204. 

  204. import static com.google.protobuf.UnittestLite.packedUint64ExtensionLite;
    205. 

  205. import static com.google.protobuf.UnittestLite.packedSint32ExtensionLite;
    206. 

  206. import static com.google.protobuf.UnittestLite.packedSint64ExtensionLite;
    207. 

  207. import static com.google.protobuf.UnittestLite.packedFixed32ExtensionLite;
    208. 

  208. import static com.google.protobuf.UnittestLite.packedFixed64ExtensionLite;
    209. 

  209. import static com.google.protobuf.UnittestLite.packedSfixed32ExtensionLite;
    210. 

  210. import static com.google.protobuf.UnittestLite.packedSfixed64ExtensionLite;
    211. 

  211. import static com.google.protobuf.UnittestLite.packedFloatExtensionLite;
    212. 

  212. import static com.google.protobuf.UnittestLite.packedDoubleExtensionLite;
    213. 

  213. import static com.google.protobuf.UnittestLite.packedBoolExtensionLite;
    214. 

  214. import static com.google.protobuf.UnittestLite.packedEnumExtensionLite;
    215. 

  215. 

  216. import protobuf_unittest.UnittestProto.TestAllExtensions;
    217. 

  217. import protobuf_unittest.UnittestProto.TestAllExtensionsOrBuilder;
    218. 

  218. import protobuf_unittest.UnittestProto.TestAllTypes;
    219. 

  219. import protobuf_unittest.UnittestProto.TestAllTypesOrBuilder;
    220. 

  220. import protobuf_unittest.UnittestProto.TestPackedExtensions;
    221. 

  221. import protobuf_unittest.UnittestProto.TestPackedTypes;
    222. 

  222. import protobuf_unittest.UnittestProto.TestUnpackedTypes;
    223. 

  223. import protobuf_unittest.UnittestProto.ForeignMessage;
    224. 

  224. import protobuf_unittest.UnittestProto.ForeignEnum;
    225. 

  225. import com.google.protobuf.test.UnittestImport.ImportMessage;
    226. 

  226. import com.google.protobuf.test.UnittestImport.ImportEnum;
    227. 

  227. 

  228. import com.google.protobuf.UnittestLite.TestAllTypesLite;
    229. 

  229. import com.google.protobuf.UnittestLite.TestAllExtensionsLite;
    230. 

  230. import com.google.protobuf.UnittestLite.TestAllExtensionsLiteOrBuilder;
    231. 

  231. import com.google.protobuf.UnittestLite.TestPackedExtensionsLite;
    232. 

  232. import com.google.protobuf.UnittestLite.ForeignMessageLite;
    233. 

  233. import com.google.protobuf.UnittestLite.ForeignEnumLite;
    234. 

  234. import com.google.protobuf.UnittestImportLite.ImportMessageLite;
    235. 

  235. import com.google.protobuf.UnittestImportLite.ImportEnumLite;
    236. 

  236. 

  237. import junit.framework.Assert;
    238. 

  238. 

  239. import java.io.File;
    240. 

  240. import java.io.IOException;
    241. 

  241. import java.io.RandomAccessFile;
    242. 

  242. 

  243. /**
    244. 

  244.  * Contains methods for setting all fields of {@code TestAllTypes} to
    245. 

  245.  * some vaules as well as checking that all the fields are set to those values.
    246. 

  246.  * These are useful for testing various protocol message features, e.g.
    247. 

  247.  * set all fields of a message, serialize it, parse it, and check that all
    248. 

  248.  * fields are set.
    249. 

  249.  *
    250. 

  250.  * <p>This code is not to be used outside of {@code com.google.protobuf} and
    251. 

  251.  * subpackages.
    252. 

  252.  *
    253. 

  253.  * @author kenton@google.com Kenton Varda
    254. 

  254.  */
    255. 

  255. public final class TestUtil {
    256. 

  256.   private TestUtil() {}
    257. 

  257. 

  258.   /** Helper to convert a String to ByteString. */
    259. 

  259.   static ByteString toBytes(String str) {
    260. 

  260.     try {
    261. 

  261.       return ByteString.copyFrom(str.getBytes("UTF-8"));
    262. 

  262.     } catch(java.io.UnsupportedEncodingException e) {
    263. 

  263.       throw new RuntimeException("UTF-8 not supported.", e);
    264. 

  264.     }
    265. 

  265.   }
    266. 

  266. 

  267.   /**
    268. 

  268.    * Get a {@code TestAllTypes} with all fields set as they would be by
    269. 

  269.    * {@link #setAllFields(TestAllTypes.Builder)}.
    270. 

  270.    */
    271. 

  271.   public static TestAllTypes getAllSet() {
    272. 

  272.     TestAllTypes.Builder builder = TestAllTypes.newBuilder();
    273. 

  273.     setAllFields(builder);
    274. 

  274.     return builder.build();
    275. 

  275.   }
    276. 

  276. 

  277.   /**
    278. 

  278.    * Get a {@code TestAllExtensions} with all fields set as they would be by
    279. 

  279.    * {@link #setAllExtensions(TestAllExtensions.Builder)}.
    280. 

  280.    */
    281. 

  281.   public static TestAllExtensions getAllExtensionsSet() {
    282. 

  282.     TestAllExtensions.Builder builder = TestAllExtensions.newBuilder();
    283. 

  283.     setAllExtensions(builder);
    284. 

  284.     return builder.build();
    285. 

  285.   }
    286. 

  286. 

  287.   public static TestAllExtensionsLite getAllLiteExtensionsSet() {
    288. 

  288.     TestAllExtensionsLite.Builder builder = TestAllExtensionsLite.newBuilder();
    289. 

  289.     setAllExtensions(builder);
    290. 

  290.     return builder.build();
    291. 

  291.   }
    292. 

  292. 

  293.   public static TestPackedTypes getPackedSet() {
    294. 

  294.     TestPackedTypes.Builder builder = TestPackedTypes.newBuilder();
    295. 

  295.     setPackedFields(builder);
    296. 

  296.     return builder.build();
    297. 

  297.   }
    298. 

  298. 

  299.   public static TestUnpackedTypes getUnpackedSet() {
    300. 

  300.     TestUnpackedTypes.Builder builder = TestUnpackedTypes.newBuilder();
    301. 

  301.     setUnpackedFields(builder);
    302. 

  302.     return builder.build();
    303. 

  303.   }
    304. 

  304. 

  305.   public static TestPackedExtensions getPackedExtensionsSet() {
    306. 

  306.     TestPackedExtensions.Builder builder = TestPackedExtensions.newBuilder();
    307. 

  307.     setPackedExtensions(builder);
    308. 

  308.     return builder.build();
    309. 

  309.   }
    310. 

  310. 

  311.   public static TestPackedExtensionsLite getLitePackedExtensionsSet() {
    312. 

  312.     TestPackedExtensionsLite.Builder builder =
    313. 

  313.         TestPackedExtensionsLite.newBuilder();
    314. 

  314.     setPackedExtensions(builder);
    315. 

  315.     return builder.build();
    316. 

  316.   }
    317. 

  317. 

  318.   /**
    319. 

  319.    * Set every field of {@code message} to the values expected by
    320. 

  320.    * {@code assertAllFieldsSet()}.
    321. 

  321.    */
    322. 

  322.   public static void setAllFields(TestAllTypes.Builder message) {
    323. 

  323.     message.setOptionalInt32   (101);
    324. 

  324.     message.setOptionalInt64   (102);
    325. 

  325.     message.setOptionalUint32  (103);
    326. 

  326.     message.setOptionalUint64  (104);
    327. 

  327.     message.setOptionalSint32  (105);
    328. 

  328.     message.setOptionalSint64  (106);
    329. 

  329.     message.setOptionalFixed32 (107);
    330. 

  330.     message.setOptionalFixed64 (108);
    331. 

  331.     message.setOptionalSfixed32(109);
    332. 

  332.     message.setOptionalSfixed64(110);
    333. 

  333.     message.setOptionalFloat   (111);
    334. 

  334.     message.setOptionalDouble  (112);
    335. 

  335.     message.setOptionalBool    (true);
    336. 

  336.     message.setOptionalString  ("115");
    337. 

  337.     message.setOptionalBytes   (toBytes("116"));
    338. 

  338. 

  339.     message.setOptionalGroup(
    340. 

  340.       TestAllTypes.OptionalGroup.newBuilder().setA(117).build());
    341. 

  341.     message.setOptionalNestedMessage(
    342. 

  342.       TestAllTypes.NestedMessage.newBuilder().setBb(118).build());
    343. 

  343.     message.setOptionalForeignMessage(
    344. 

  344.       ForeignMessage.newBuilder().setC(119).build());
    345. 

  345.     message.setOptionalImportMessage(
    346. 

  346.       ImportMessage.newBuilder().setD(120).build());
    347. 

  347. 

  348.     message.setOptionalNestedEnum (TestAllTypes.NestedEnum.BAZ);
    349. 

  349.     message.setOptionalForeignEnum(ForeignEnum.FOREIGN_BAZ);
    350. 

  350.     message.setOptionalImportEnum (ImportEnum.IMPORT_BAZ);
    351. 

  351. 

  352.     message.setOptionalStringPiece("124");
    353. 

  353.     message.setOptionalCord("125");
    354. 

  354. 

  355.     // -----------------------------------------------------------------
    356. 

  356. 

  357.     message.addRepeatedInt32   (201);
    358. 

  358.     message.addRepeatedInt64   (202);
    359. 

  359.     message.addRepeatedUint32  (203);
    360. 

  360.     message.addRepeatedUint64  (204);
    361. 

  361.     message.addRepeatedSint32  (205);
    362. 

  362.     message.addRepeatedSint64  (206);
    363. 

  363.     message.addRepeatedFixed32 (207);
    364. 

  364.     message.addRepeatedFixed64 (208);
    365. 

  365.     message.addRepeatedSfixed32(209);
    366. 

  366.     message.addRepeatedSfixed64(210);
    367. 

  367.     message.addRepeatedFloat   (211);
    368. 

  368.     message.addRepeatedDouble  (212);
    369. 

  369.     message.addRepeatedBool    (true);
    370. 

  370.     message.addRepeatedString  ("215");
    371. 

  371.     message.addRepeatedBytes   (toBytes("216"));
    372. 

  372. 

  373.     message.addRepeatedGroup(
    374. 

  374.       TestAllTypes.RepeatedGroup.newBuilder().setA(217).build());
    375. 

  375.     message.addRepeatedNestedMessage(
    376. 

  376.       TestAllTypes.NestedMessage.newBuilder().setBb(218).build());
    377. 

  377.     message.addRepeatedForeignMessage(
    378. 

  378.       ForeignMessage.newBuilder().setC(219).build());
    379. 

  379.     message.addRepeatedImportMessage(
    380. 

  380.       ImportMessage.newBuilder().setD(220).build());
    381. 

  381. 

  382.     message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAR);
    383. 

  383.     message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAR);
    384. 

  384.     message.addRepeatedImportEnum (ImportEnum.IMPORT_BAR);
    385. 

  385. 

  386.     message.addRepeatedStringPiece("224");
    387. 

  387.     message.addRepeatedCord("225");
    388. 

  388. 

  389.     // Add a second one of each field.
    390. 

  390.     message.addRepeatedInt32   (301);
    391. 

  391.     message.addRepeatedInt64   (302);
    392. 

  392.     message.addRepeatedUint32  (303);
    393. 

  393.     message.addRepeatedUint64  (304);
    394. 

  394.     message.addRepeatedSint32  (305);
    395. 

  395.     message.addRepeatedSint64  (306);
    396. 

  396.     message.addRepeatedFixed32 (307);
    397. 

  397.     message.addRepeatedFixed64 (308);
    398. 

  398.     message.addRepeatedSfixed32(309);
    399. 

  399.     message.addRepeatedSfixed64(310);
    400. 

  400.     message.addRepeatedFloat   (311);
    401. 

  401.     message.addRepeatedDouble  (312);
    402. 

  402.     message.addRepeatedBool    (false);
    403. 

  403.     message.addRepeatedString  ("315");
    404. 

  404.     message.addRepeatedBytes   (toBytes("316"));
    405. 

  405. 

  406.     message.addRepeatedGroup(
    407. 

  407.       TestAllTypes.RepeatedGroup.newBuilder().setA(317).build());
    408. 

  408.     message.addRepeatedNestedMessage(
    409. 

  409.       TestAllTypes.NestedMessage.newBuilder().setBb(318).build());
    410. 

  410.     message.addRepeatedForeignMessage(
    411. 

  411.       ForeignMessage.newBuilder().setC(319).build());
    412. 

  412.     message.addRepeatedImportMessage(
    413. 

  413.       ImportMessage.newBuilder().setD(320).build());
    414. 

  414. 

  415.     message.addRepeatedNestedEnum (TestAllTypes.NestedEnum.BAZ);
    416. 

  416.     message.addRepeatedForeignEnum(ForeignEnum.FOREIGN_BAZ);
    417. 

  417.     message.addRepeatedImportEnum (ImportEnum.IMPORT_BAZ);
    418. 

  418. 

  419.     message.addRepeatedStringPiece("324");
    420. 

  420.     message.addRepeatedCord("325");
    421. 

  421. 

  422.     // -----------------------------------------------------------------
    423. 

  423. 

  424.     message.setDefaultInt32   (401);
    425. 

  425.     message.setDefaultInt64   (402);
    426. 

  426.     message.setDefaultUint32  (403);
    427. 

  427.     message.setDefaultUint64  (404);
    428. 

  428.     message.setDefaultSint32  (405);
    429. 

  429.     message.setDefaultSint64  (406);
    430. 

  430.     message.setDefaultFixed32 (407);
    431. 

  431.     message.setDefaultFixed64 (408);
    432. 

  432.     message.setDefaultSfixed32(409);
    433. 

  433.     message.setDefaultSfixed64(410);
    434. 

  434.     message.setDefaultFloat   (411);
    435. 

  435.     message.setDefaultDouble  (412);
    436. 

  436.     message.setDefaultBool    (false);
    437. 

  437.     message.setDefaultString  ("415");
    438. 

  438.     message.setDefaultBytes   (toBytes("416"));
    439. 

  439. 

  440.     message.setDefaultNestedEnum (TestAllTypes.NestedEnum.FOO);
    441. 

  441.     message.setDefaultForeignEnum(ForeignEnum.FOREIGN_FOO);
    442. 

  442.     message.setDefaultImportEnum (ImportEnum.IMPORT_FOO);
    443. 

  443. 

  444.     message.setDefaultStringPiece("424");
    445. 

  445.     message.setDefaultCord("425");
    446. 

  446.   }
    447. 

  447. 

  448.   // -------------------------------------------------------------------
    449. 

  449. 

  450.   /**
    451. 

  451.    * Modify the repeated fields of {@code message} to contain the values
    452. 

  452.    * expected by {@code assertRepeatedFieldsModified()}.
    453. 

  453.    */
    454. 

  454.   public static void modifyRepeatedFields(TestAllTypes.Builder message) {
    455. 

  455.     message.setRepeatedInt32   (1, 501);
    456. 

  456.     message.setRepeatedInt64   (1, 502);
    457. 

  457.     message.setRepeatedUint32  (1, 503);
    458. 

  458.     message.setRepeatedUint64  (1, 504);
    459. 

  459.     message.setRepeatedSint32  (1, 505);
    460. 

  460.     message.setRepeatedSint64  (1, 506);
    461. 

  461.     message.setRepeatedFixed32 (1, 507);
    462. 

  462.     message.setRepeatedFixed64 (1, 508);
    463. 

  463.     message.setRepeatedSfixed32(1, 509);
    464. 

  464.     message.setRepeatedSfixed64(1, 510);
    465. 

  465.     message.setRepeatedFloat   (1, 511);
    466. 

  466.     message.setRepeatedDouble  (1, 512);
    467. 

  467.     message.setRepeatedBool    (1, true);
    468. 

  468.     message.setRepeatedString  (1, "515");
    469. 

  469.     message.setRepeatedBytes   (1, toBytes("516"));
    470. 

  470. 

  471.     message.setRepeatedGroup(1,
    472. 

  472.       TestAllTypes.RepeatedGroup.newBuilder().setA(517).build());
    473. 

  473.     message.setRepeatedNestedMessage(1,
    474. 

  474.       TestAllTypes.NestedMessage.newBuilder().setBb(518).build());
    475. 

  475.     message.setRepeatedForeignMessage(1,
    476. 

  476.       ForeignMessage.newBuilder().setC(519).build());
    477. 

  477.     message.setRepeatedImportMessage(1,
    478. 

  478.       ImportMessage.newBuilder().setD(520).build());
    479. 

  479. 

  480.     message.setRepeatedNestedEnum (1, TestAllTypes.NestedEnum.FOO);
    481. 

  481.     message.setRepeatedForeignEnum(1, ForeignEnum.FOREIGN_FOO);
    482. 

  482.     message.setRepeatedImportEnum (1, ImportEnum.IMPORT_FOO);
    483. 

  483. 

  484.     message.setRepeatedStringPiece(1, "524");
    485. 

  485.     message.setRepeatedCord(1, "525");
    486. 

  486.   }
    487. 

  487. 

  488.   // -------------------------------------------------------------------
    489. 

  489. 

  490.   /**
    491. 

  491.    * Assert (using {@code junit.framework.Assert}} that all fields of
    492. 

  492.    * {@code message} are set to the values assigned by {@code setAllFields}.
    493. 

  493.    */
    494. 

  494.   public static void assertAllFieldsSet(TestAllTypesOrBuilder message) {
    495. 

  495.     Assert.assertTrue(message.hasOptionalInt32   ());
    496. 

  496.     Assert.assertTrue(message.hasOptionalInt64   ());
    497. 

  497.     Assert.assertTrue(message.hasOptionalUint32  ());
    498. 

  498.     Assert.assertTrue(message.hasOptionalUint64  ());
    499. 

  499.     Assert.assertTrue(message.hasOptionalSint32  ());
    500. 

  500.     Assert.assertTrue(message.hasOptionalSint64  ());
    501. 

  501.     Assert.assertTrue(message.hasOptionalFixed32 ());
    502. 

  502.     Assert.assertTrue(message.hasOptionalFixed64 ());
    503. 

  503.     Assert.assertTrue(message.hasOptionalSfixed32());
    504. 

  504.     Assert.assertTrue(message.hasOptionalSfixed64());
    505. 

  505.     Assert.assertTrue(message.hasOptionalFloat   ());
    506. 

  506.     Assert.assertTrue(message.hasOptionalDouble  ());
    507. 

  507.     Assert.assertTrue(message.hasOptionalBool    ());
    508. 

  508.     Assert.assertTrue(message.hasOptionalString  ());
    509. 

  509.     Assert.assertTrue(message.hasOptionalBytes   ());
    510. 

  510. 

  511.     Assert.assertTrue(message.hasOptionalGroup         ());
    512. 

  512.     Assert.assertTrue(message.hasOptionalNestedMessage ());
    513. 

  513.     Assert.assertTrue(message.hasOptionalForeignMessage());
    514. 

  514.     Assert.assertTrue(message.hasOptionalImportMessage ());
    515. 

  515. 

  516.     Assert.assertTrue(message.getOptionalGroup         ().hasA());
    517. 

  517.     Assert.assertTrue(message.getOptionalNestedMessage ().hasBb());
    518. 

  518.     Assert.assertTrue(message.getOptionalForeignMessage().hasC());
    519. 

  519.     Assert.assertTrue(message.getOptionalImportMessage ().hasD());
    520. 

  520. 

  521.     Assert.assertTrue(message.hasOptionalNestedEnum ());
    522. 

  522.     Assert.assertTrue(message.hasOptionalForeignEnum());
    523. 

  523.     Assert.assertTrue(message.hasOptionalImportEnum ());
    524. 

  524. 

  525.     Assert.assertTrue(message.hasOptionalStringPiece());
    526. 

  526.     Assert.assertTrue(message.hasOptionalCord());
    527. 

  527. 

  528.     Assert.assertEquals(101  , message.getOptionalInt32   ());
    529. 

  529.     Assert.assertEquals(102  , message.getOptionalInt64   ());
    530. 

  530.     Assert.assertEquals(103  , message.getOptionalUint32  ());
    531. 

  531.     Assert.assertEquals(104  , message.getOptionalUint64  ());
    532. 

  532.     Assert.assertEquals(105  , message.getOptionalSint32  ());
    533. 

  533.     Assert.assertEquals(106  , message.getOptionalSint64  ());
    534. 

  534.     Assert.assertEquals(107  , message.getOptionalFixed32 ());
    535. 

  535.     Assert.assertEquals(108  , message.getOptionalFixed64 ());
    536. 

  536.     Assert.assertEquals(109  , message.getOptionalSfixed32());
    537. 

  537.     Assert.assertEquals(110  , message.getOptionalSfixed64());
    538. 

  538.     Assert.assertEquals(111  , message.getOptionalFloat   (), 0.0);
    539. 

  539.     Assert.assertEquals(112  , message.getOptionalDouble  (), 0.0);
    540. 

  540.     Assert.assertEquals(true , message.getOptionalBool    ());
    541. 

  541.     Assert.assertEquals("115", message.getOptionalString  ());
    542. 

  542.     Assert.assertEquals(toBytes("116"), message.getOptionalBytes());
    543. 

  543. 

  544.     Assert.assertEquals(117, message.getOptionalGroup         ().getA());
    545. 

  545.     Assert.assertEquals(118, message.getOptionalNestedMessage ().getBb());
    546. 

  546.     Assert.assertEquals(119, message.getOptionalForeignMessage().getC());
    547. 

  547.     Assert.assertEquals(120, message.getOptionalImportMessage ().getD());
    548. 

  548. 

  549.     Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getOptionalNestedEnum());
    550. 

  550.     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getOptionalForeignEnum());
    551. 

  551.     Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getOptionalImportEnum());
    552. 

  552. 

  553.     Assert.assertEquals("124", message.getOptionalStringPiece());
    554. 

  554.     Assert.assertEquals("125", message.getOptionalCord());
    555. 

  555. 

  556.     // -----------------------------------------------------------------
    557. 

  557. 

  558.     Assert.assertEquals(2, message.getRepeatedInt32Count   ());
    559. 

  559.     Assert.assertEquals(2, message.getRepeatedInt64Count   ());
    560. 

  560.     Assert.assertEquals(2, message.getRepeatedUint32Count  ());
    561. 

  561.     Assert.assertEquals(2, message.getRepeatedUint64Count  ());
    562. 

  562.     Assert.assertEquals(2, message.getRepeatedSint32Count  ());
    563. 

  563.     Assert.assertEquals(2, message.getRepeatedSint64Count  ());
    564. 

  564.     Assert.assertEquals(2, message.getRepeatedFixed32Count ());
    565. 

  565.     Assert.assertEquals(2, message.getRepeatedFixed64Count ());
    566. 

  566.     Assert.assertEquals(2, message.getRepeatedSfixed32Count());
    567. 

  567.     Assert.assertEquals(2, message.getRepeatedSfixed64Count());
    568. 

  568.     Assert.assertEquals(2, message.getRepeatedFloatCount   ());
    569. 

  569.     Assert.assertEquals(2, message.getRepeatedDoubleCount  ());
    570. 

  570.     Assert.assertEquals(2, message.getRepeatedBoolCount    ());
    571. 

  571.     Assert.assertEquals(2, message.getRepeatedStringCount  ());
    572. 

  572.     Assert.assertEquals(2, message.getRepeatedBytesCount   ());
    573. 

  573. 

  574.     Assert.assertEquals(2, message.getRepeatedGroupCount         ());
    575. 

  575.     Assert.assertEquals(2, message.getRepeatedNestedMessageCount ());
    576. 

  576.     Assert.assertEquals(2, message.getRepeatedForeignMessageCount());
    577. 

  577.     Assert.assertEquals(2, message.getRepeatedImportMessageCount ());
    578. 

  578.     Assert.assertEquals(2, message.getRepeatedNestedEnumCount    ());
    579. 

  579.     Assert.assertEquals(2, message.getRepeatedForeignEnumCount   ());
    580. 

  580.     Assert.assertEquals(2, message.getRepeatedImportEnumCount    ());
    581. 

  581. 

  582.     Assert.assertEquals(2, message.getRepeatedStringPieceCount());
    583. 

  583.     Assert.assertEquals(2, message.getRepeatedCordCount());
    584. 

  584. 

  585.     Assert.assertEquals(201  , message.getRepeatedInt32   (0));
    586. 

  586.     Assert.assertEquals(202  , message.getRepeatedInt64   (0));
    587. 

  587.     Assert.assertEquals(203  , message.getRepeatedUint32  (0));
    588. 

  588.     Assert.assertEquals(204  , message.getRepeatedUint64  (0));
    589. 

  589.     Assert.assertEquals(205  , message.getRepeatedSint32  (0));
    590. 

  590.     Assert.assertEquals(206  , message.getRepeatedSint64  (0));
    591. 

  591.     Assert.assertEquals(207  , message.getRepeatedFixed32 (0));
    592. 

  592.     Assert.assertEquals(208  , message.getRepeatedFixed64 (0));
    593. 

  593.     Assert.assertEquals(209  , message.getRepeatedSfixed32(0));
    594. 

  594.     Assert.assertEquals(210  , message.getRepeatedSfixed64(0));
    595. 

  595.     Assert.assertEquals(211  , message.getRepeatedFloat   (0), 0.0);
    596. 

  596.     Assert.assertEquals(212  , message.getRepeatedDouble  (0), 0.0);
    597. 

  597.     Assert.assertEquals(true , message.getRepeatedBool    (0));
    598. 

  598.     Assert.assertEquals("215", message.getRepeatedString  (0));
    599. 

  599.     Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0));
    600. 

  600. 

  601.     Assert.assertEquals(217, message.getRepeatedGroup         (0).getA());
    602. 

  602.     Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb());
    603. 

  603.     Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC());
    604. 

  604.     Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD());
    605. 

  605. 

  606.     Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEnum (0));
    607. 

  607.     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(0));
    608. 

  608.     Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0));
    609. 

  609. 

  610.     Assert.assertEquals("224", message.getRepeatedStringPiece(0));
    611. 

  611.     Assert.assertEquals("225", message.getRepeatedCord(0));
    612. 

  612. 

  613.     Assert.assertEquals(301  , message.getRepeatedInt32   (1));
    614. 

  614.     Assert.assertEquals(302  , message.getRepeatedInt64   (1));
    615. 

  615.     Assert.assertEquals(303  , message.getRepeatedUint32  (1));
    616. 

  616.     Assert.assertEquals(304  , message.getRepeatedUint64  (1));
    617. 

  617.     Assert.assertEquals(305  , message.getRepeatedSint32  (1));
    618. 

  618.     Assert.assertEquals(306  , message.getRepeatedSint64  (1));
    619. 

  619.     Assert.assertEquals(307  , message.getRepeatedFixed32 (1));
    620. 

  620.     Assert.assertEquals(308  , message.getRepeatedFixed64 (1));
    621. 

  621.     Assert.assertEquals(309  , message.getRepeatedSfixed32(1));
    622. 

  622.     Assert.assertEquals(310  , message.getRepeatedSfixed64(1));
    623. 

  623.     Assert.assertEquals(311  , message.getRepeatedFloat   (1), 0.0);
    624. 

  624.     Assert.assertEquals(312  , message.getRepeatedDouble  (1), 0.0);
    625. 

  625.     Assert.assertEquals(false, message.getRepeatedBool    (1));
    626. 

  626.     Assert.assertEquals("315", message.getRepeatedString  (1));
    627. 

  627.     Assert.assertEquals(toBytes("316"), message.getRepeatedBytes(1));
    628. 

  628. 

  629.     Assert.assertEquals(317, message.getRepeatedGroup         (1).getA());
    630. 

  630.     Assert.assertEquals(318, message.getRepeatedNestedMessage (1).getBb());
    631. 

  631.     Assert.assertEquals(319, message.getRepeatedForeignMessage(1).getC());
    632. 

  632.     Assert.assertEquals(320, message.getRepeatedImportMessage (1).getD());
    633. 

  633. 

  634.     Assert.assertEquals(TestAllTypes.NestedEnum.BAZ, message.getRepeatedNestedEnum (1));
    635. 

  635.     Assert.assertEquals(ForeignEnum.FOREIGN_BAZ, message.getRepeatedForeignEnum(1));
    636. 

  636.     Assert.assertEquals(ImportEnum.IMPORT_BAZ, message.getRepeatedImportEnum(1));
    637. 

  637. 

  638.     Assert.assertEquals("324", message.getRepeatedStringPiece(1));
    639. 

  639.     Assert.assertEquals("325", message.getRepeatedCord(1));
    640. 

  640. 

  641.     // -----------------------------------------------------------------
    642. 

  642. 

  643.     Assert.assertTrue(message.hasDefaultInt32   ());
    644. 

  644.     Assert.assertTrue(message.hasDefaultInt64   ());
    645. 

  645.     Assert.assertTrue(message.hasDefaultUint32  ());
    646. 

  646.     Assert.assertTrue(message.hasDefaultUint64  ());
    647. 

  647.     Assert.assertTrue(message.hasDefaultSint32  ());
    648. 

  648.     Assert.assertTrue(message.hasDefaultSint64  ());
    649. 

  649.     Assert.assertTrue(message.hasDefaultFixed32 ());
    650. 

  650.     Assert.assertTrue(message.hasDefaultFixed64 ());
    651. 

  651.     Assert.assertTrue(message.hasDefaultSfixed32());
    652. 

  652.     Assert.assertTrue(message.hasDefaultSfixed64());
    653. 

  653.     Assert.assertTrue(message.hasDefaultFloat   ());
    654. 

  654.     Assert.assertTrue(message.hasDefaultDouble  ());
    655. 

  655.     Assert.assertTrue(message.hasDefaultBool    ());
    656. 

  656.     Assert.assertTrue(message.hasDefaultString  ());
    657. 

  657.     Assert.assertTrue(message.hasDefaultBytes   ());
    658. 

  658. 

  659.     Assert.assertTrue(message.hasDefaultNestedEnum ());
    660. 

  660.     Assert.assertTrue(message.hasDefaultForeignEnum());
    661. 

  661.     Assert.assertTrue(message.hasDefaultImportEnum ());
    662. 

  662. 

  663.     Assert.assertTrue(message.hasDefaultStringPiece());
    664. 

  664.     Assert.assertTrue(message.hasDefaultCord());
    665. 

  665. 

  666.     Assert.assertEquals(401  , message.getDefaultInt32   ());
    667. 

  667.     Assert.assertEquals(402  , message.getDefaultInt64   ());
    668. 

  668.     Assert.assertEquals(403  , message.getDefaultUint32  ());
    669. 

  669.     Assert.assertEquals(404  , message.getDefaultUint64  ());
    670. 

  670.     Assert.assertEquals(405  , message.getDefaultSint32  ());
    671. 

  671.     Assert.assertEquals(406  , message.getDefaultSint64  ());
    672. 

  672.     Assert.assertEquals(407  , message.getDefaultFixed32 ());
    673. 

  673.     Assert.assertEquals(408  , message.getDefaultFixed64 ());
    674. 

  674.     Assert.assertEquals(409  , message.getDefaultSfixed32());
    675. 

  675.     Assert.assertEquals(410  , message.getDefaultSfixed64());
    676. 

  676.     Assert.assertEquals(411  , message.getDefaultFloat   (), 0.0);
    677. 

  677.     Assert.assertEquals(412  , message.getDefaultDouble  (), 0.0);
    678. 

  678.     Assert.assertEquals(false, message.getDefaultBool    ());
    679. 

  679.     Assert.assertEquals("415", message.getDefaultString  ());
    680. 

  680.     Assert.assertEquals(toBytes("416"), message.getDefaultBytes());
    681. 

  681. 

  682.     Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getDefaultNestedEnum ());
    683. 

  683.     Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getDefaultForeignEnum());
    684. 

  684.     Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getDefaultImportEnum());
    685. 

  685. 

  686.     Assert.assertEquals("424", message.getDefaultStringPiece());
    687. 

  687.     Assert.assertEquals("425", message.getDefaultCord());
    688. 

  688.   }
    689. 

  689. 

  690.   // -------------------------------------------------------------------
    691. 

  691.   /**
    692. 

  692.    * Assert (using {@code junit.framework.Assert}} that all fields of
    693. 

  693.    * {@code message} are cleared, and that getting the fields returns their
    694. 

  694.    * default values.
    695. 

  695.    */
    696. 

  696.   public static void assertClear(TestAllTypesOrBuilder message) {
    697. 

  697.     // hasBlah() should initially be false for all optional fields.
    698. 

  698.     Assert.assertFalse(message.hasOptionalInt32   ());
    699. 

  699.     Assert.assertFalse(message.hasOptionalInt64   ());
    700. 

  700.     Assert.assertFalse(message.hasOptionalUint32  ());
    701. 

  701.     Assert.assertFalse(message.hasOptionalUint64  ());
    702. 

  702.     Assert.assertFalse(message.hasOptionalSint32  ());
    703. 

  703.     Assert.assertFalse(message.hasOptionalSint64  ());
    704. 

  704.     Assert.assertFalse(message.hasOptionalFixed32 ());
    705. 

  705.     Assert.assertFalse(message.hasOptionalFixed64 ());
    706. 

  706.     Assert.assertFalse(message.hasOptionalSfixed32());
    707. 

  707.     Assert.assertFalse(message.hasOptionalSfixed64());
    708. 

  708.     Assert.assertFalse(message.hasOptionalFloat   ());
    709. 

  709.     Assert.assertFalse(message.hasOptionalDouble  ());
    710. 

  710.     Assert.assertFalse(message.hasOptionalBool    ());
    711. 

  711.     Assert.assertFalse(message.hasOptionalString  ());
    712. 

  712.     Assert.assertFalse(message.hasOptionalBytes   ());
    713. 

  713. 

  714.     Assert.assertFalse(message.hasOptionalGroup         ());
    715. 

  715.     Assert.assertFalse(message.hasOptionalNestedMessage ());
    716. 

  716.     Assert.assertFalse(message.hasOptionalForeignMessage());
    717. 

  717.     Assert.assertFalse(message.hasOptionalImportMessage ());
    718. 

  718. 

  719.     Assert.assertFalse(message.hasOptionalNestedEnum ());
    720. 

  720.     Assert.assertFalse(message.hasOptionalForeignEnum());
    721. 

  721.     Assert.assertFalse(message.hasOptionalImportEnum ());
    722. 

  722. 

  723.     Assert.assertFalse(message.hasOptionalStringPiece());
    724. 

  724.     Assert.assertFalse(message.hasOptionalCord());
    725. 

  725. 

  726.     // Optional fields without defaults are set to zero or something like it.
    727. 

  727.     Assert.assertEquals(0    , message.getOptionalInt32   ());
    728. 

  728.     Assert.assertEquals(0    , message.getOptionalInt64   ());
    729. 

  729.     Assert.assertEquals(0    , message.getOptionalUint32  ());
    730. 

  730.     Assert.assertEquals(0    , message.getOptionalUint64  ());
    731. 

  731.     Assert.assertEquals(0    , message.getOptionalSint32  ());
    732. 

  732.     Assert.assertEquals(0    , message.getOptionalSint64  ());
    733. 

  733.     Assert.assertEquals(0    , message.getOptionalFixed32 ());
    734. 

  734.     Assert.assertEquals(0    , message.getOptionalFixed64 ());
    735. 

  735.     Assert.assertEquals(0    , message.getOptionalSfixed32());
    736. 

  736.     Assert.assertEquals(0    , message.getOptionalSfixed64());
    737. 

  737.     Assert.assertEquals(0    , message.getOptionalFloat   (), 0.0);
    738. 

  738.     Assert.assertEquals(0    , message.getOptionalDouble  (), 0.0);
    739. 

  739.     Assert.assertEquals(false, message.getOptionalBool    ());
    740. 

  740.     Assert.assertEquals(""   , message.getOptionalString  ());
    741. 

  741.     Assert.assertEquals(ByteString.EMPTY, message.getOptionalBytes());
    742. 

  742. 

  743.     // Embedded messages should also be clear.
    744. 

  744.     Assert.assertFalse(message.getOptionalGroup         ().hasA());
    745. 

  745.     Assert.assertFalse(message.getOptionalNestedMessage ().hasBb());
    746. 

  746.     Assert.assertFalse(message.getOptionalForeignMessage().hasC());
    747. 

  747.     Assert.assertFalse(message.getOptionalImportMessage ().hasD());
    748. 

  748. 

  749.     Assert.assertEquals(0, message.getOptionalGroup         ().getA());
    750. 

  750.     Assert.assertEquals(0, message.getOptionalNestedMessage ().getBb());
    751. 

  751.     Assert.assertEquals(0, message.getOptionalForeignMessage().getC());
    752. 

  752.     Assert.assertEquals(0, message.getOptionalImportMessage ().getD());
    753. 

  753. 

  754.     // Enums without defaults are set to the first value in the enum.
    755. 

  755.     Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getOptionalNestedEnum ());
    756. 

  756.     Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getOptionalForeignEnum());
    757. 

  757.     Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getOptionalImportEnum());
    758. 

  758. 

  759.     Assert.assertEquals("", message.getOptionalStringPiece());
    760. 

  760.     Assert.assertEquals("", message.getOptionalCord());
    761. 

  761. 

  762.     // Repeated fields are empty.
    763. 

  763.     Assert.assertEquals(0, message.getRepeatedInt32Count   ());
    764. 

  764.     Assert.assertEquals(0, message.getRepeatedInt64Count   ());
    765. 

  765.     Assert.assertEquals(0, message.getRepeatedUint32Count  ());
    766. 

  766.     Assert.assertEquals(0, message.getRepeatedUint64Count  ());
    767. 

  767.     Assert.assertEquals(0, message.getRepeatedSint32Count  ());
    768. 

  768.     Assert.assertEquals(0, message.getRepeatedSint64Count  ());
    769. 

  769.     Assert.assertEquals(0, message.getRepeatedFixed32Count ());
    770. 

  770.     Assert.assertEquals(0, message.getRepeatedFixed64Count ());
    771. 

  771.     Assert.assertEquals(0, message.getRepeatedSfixed32Count());
    772. 

  772.     Assert.assertEquals(0, message.getRepeatedSfixed64Count());
    773. 

  773.     Assert.assertEquals(0, message.getRepeatedFloatCount   ());
    774. 

  774.     Assert.assertEquals(0, message.getRepeatedDoubleCount  ());
    775. 

  775.     Assert.assertEquals(0, message.getRepeatedBoolCount    ());
    776. 

  776.     Assert.assertEquals(0, message.getRepeatedStringCount  ());
    777. 

  777.     Assert.assertEquals(0, message.getRepeatedBytesCount   ());
    778. 

  778. 

  779.     Assert.assertEquals(0, message.getRepeatedGroupCount         ());
    780. 

  780.     Assert.assertEquals(0, message.getRepeatedNestedMessageCount ());
    781. 

  781.     Assert.assertEquals(0, message.getRepeatedForeignMessageCount());
    782. 

  782.     Assert.assertEquals(0, message.getRepeatedImportMessageCount ());
    783. 

  783.     Assert.assertEquals(0, message.getRepeatedNestedEnumCount    ());
    784. 

  784.     Assert.assertEquals(0, message.getRepeatedForeignEnumCount   ());
    785. 

  785.     Assert.assertEquals(0, message.getRepeatedImportEnumCount    ());
    786. 

  786. 

  787.     Assert.assertEquals(0, message.getRepeatedStringPieceCount());
    788. 

  788.     Assert.assertEquals(0, message.getRepeatedCordCount());
    789. 

  789. 

  790.     // hasBlah() should also be false for all default fields.
    791. 

  791.     Assert.assertFalse(message.hasDefaultInt32   ());
    792. 

  792.     Assert.assertFalse(message.hasDefaultInt64   ());
    793. 

  793.     Assert.assertFalse(message.hasDefaultUint32  ());
    794. 

  794.     Assert.assertFalse(message.hasDefaultUint64  ());
    795. 

  795.     Assert.assertFalse(message.hasDefaultSint32  ());
    796. 

  796.     Assert.assertFalse(message.hasDefaultSint64  ());
    797. 

  797.     Assert.assertFalse(message.hasDefaultFixed32 ());
    798. 

  798.     Assert.assertFalse(message.hasDefaultFixed64 ());
    799. 

  799.     Assert.assertFalse(message.hasDefaultSfixed32());
    800. 

  800.     Assert.assertFalse(message.hasDefaultSfixed64());
    801. 

  801.     Assert.assertFalse(message.hasDefaultFloat   ());
    802. 

  802.     Assert.assertFalse(message.hasDefaultDouble  ());
    803. 

  803.     Assert.assertFalse(message.hasDefaultBool    ());
    804. 

  804.     Assert.assertFalse(message.hasDefaultString  ());
    805. 

  805.     Assert.assertFalse(message.hasDefaultBytes   ());
    806. 

  806. 

  807.     Assert.assertFalse(message.hasDefaultNestedEnum ());
    808. 

  808.     Assert.assertFalse(message.hasDefaultForeignEnum());
    809. 

  809.     Assert.assertFalse(message.hasDefaultImportEnum ());
    810. 

  810. 

  811.     Assert.assertFalse(message.hasDefaultStringPiece());
    812. 

  812.     Assert.assertFalse(message.hasDefaultCord());
    813. 

  813. 

  814.     // Fields with defaults have their default values (duh).
    815. 

  815.     Assert.assertEquals( 41    , message.getDefaultInt32   ());
    816. 

  816.     Assert.assertEquals( 42    , message.getDefaultInt64   ());
    817. 

  817.     Assert.assertEquals( 43    , message.getDefaultUint32  ());
    818. 

  818.     Assert.assertEquals( 44    , message.getDefaultUint64  ());
    819. 

  819.     Assert.assertEquals(-45    , message.getDefaultSint32  ());
    820. 

  820.     Assert.assertEquals( 46    , message.getDefaultSint64  ());
    821. 

  821.     Assert.assertEquals( 47    , message.getDefaultFixed32 ());
    822. 

  822.     Assert.assertEquals( 48    , message.getDefaultFixed64 ());
    823. 

  823.     Assert.assertEquals( 49    , message.getDefaultSfixed32());
    824. 

  824.     Assert.assertEquals(-50    , message.getDefaultSfixed64());
    825. 

  825.     Assert.assertEquals( 51.5  , message.getDefaultFloat   (), 0.0);
    826. 

  826.     Assert.assertEquals( 52e3  , message.getDefaultDouble  (), 0.0);
    827. 

  827.     Assert.assertEquals(true   , message.getDefaultBool    ());
    828. 

  828.     Assert.assertEquals("hello", message.getDefaultString  ());
    829. 

  829.     Assert.assertEquals(toBytes("world"), message.getDefaultBytes());
    830. 

  830. 

  831.     Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getDefaultNestedEnum ());
    832. 

  832.     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getDefaultForeignEnum());
    833. 

  833.     Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getDefaultImportEnum());
    834. 

  834. 

  835.     Assert.assertEquals("abc", message.getDefaultStringPiece());
    836. 

  836.     Assert.assertEquals("123", message.getDefaultCord());
    837. 

  837.   }
    838. 

  838. 

  839.   // -------------------------------------------------------------------
    840. 

  840. 

  841.   /**
    842. 

  842.    * Assert (using {@code junit.framework.Assert}} that all fields of
    843. 

  843.    * {@code message} are set to the values assigned by {@code setAllFields}
    844. 

  844.    * followed by {@code modifyRepeatedFields}.
    845. 

  845.    */
    846. 

  846.   public static void assertRepeatedFieldsModified(
    847. 

  847.       TestAllTypesOrBuilder message) {
    848. 

  848.     // ModifyRepeatedFields only sets the second repeated element of each
    849. 

  849.     // field.  In addition to verifying this, we also verify that the first
    850. 

  850.     // element and size were *not* modified.
    851. 

  851.     Assert.assertEquals(2, message.getRepeatedInt32Count   ());
    852. 

  852.     Assert.assertEquals(2, message.getRepeatedInt64Count   ());
    853. 

  853.     Assert.assertEquals(2, message.getRepeatedUint32Count  ());
    854. 

  854.     Assert.assertEquals(2, message.getRepeatedUint64Count  ());
    855. 

  855.     Assert.assertEquals(2, message.getRepeatedSint32Count  ());
    856. 

  856.     Assert.assertEquals(2, message.getRepeatedSint64Count  ());
    857. 

  857.     Assert.assertEquals(2, message.getRepeatedFixed32Count ());
    858. 

  858.     Assert.assertEquals(2, message.getRepeatedFixed64Count ());
    859. 

  859.     Assert.assertEquals(2, message.getRepeatedSfixed32Count());
    860. 

  860.     Assert.assertEquals(2, message.getRepeatedSfixed64Count());
    861. 

  861.     Assert.assertEquals(2, message.getRepeatedFloatCount   ());
    862. 

  862.     Assert.assertEquals(2, message.getRepeatedDoubleCount  ());
    863. 

  863.     Assert.assertEquals(2, message.getRepeatedBoolCount    ());
    864. 

  864.     Assert.assertEquals(2, message.getRepeatedStringCount  ());
    865. 

  865.     Assert.assertEquals(2, message.getRepeatedBytesCount   ());
    866. 

  866. 

  867.     Assert.assertEquals(2, message.getRepeatedGroupCount         ());
    868. 

  868.     Assert.assertEquals(2, message.getRepeatedNestedMessageCount ());
    869. 

  869.     Assert.assertEquals(2, message.getRepeatedForeignMessageCount());
    870. 

  870.     Assert.assertEquals(2, message.getRepeatedImportMessageCount ());
    871. 

  871.     Assert.assertEquals(2, message.getRepeatedNestedEnumCount    ());
    872. 

  872.     Assert.assertEquals(2, message.getRepeatedForeignEnumCount   ());
    873. 

  873.     Assert.assertEquals(2, message.getRepeatedImportEnumCount    ());
    874. 

  874. 

  875.     Assert.assertEquals(2, message.getRepeatedStringPieceCount());
    876. 

  876.     Assert.assertEquals(2, message.getRepeatedCordCount());
    877. 

  877. 

  878.     Assert.assertEquals(201  , message.getRepeatedInt32   (0));
    879. 

  879.     Assert.assertEquals(202L , message.getRepeatedInt64   (0));
    880. 

  880.     Assert.assertEquals(203  , message.getRepeatedUint32  (0));
    881. 

  881.     Assert.assertEquals(204L , message.getRepeatedUint64  (0));
    882. 

  882.     Assert.assertEquals(205  , message.getRepeatedSint32  (0));
    883. 

  883.     Assert.assertEquals(206L , message.getRepeatedSint64  (0));
    884. 

  884.     Assert.assertEquals(207  , message.getRepeatedFixed32 (0));
    885. 

  885.     Assert.assertEquals(208L , message.getRepeatedFixed64 (0));
    886. 

  886.     Assert.assertEquals(209  , message.getRepeatedSfixed32(0));
    887. 

  887.     Assert.assertEquals(210L , message.getRepeatedSfixed64(0));
    888. 

  888.     Assert.assertEquals(211F , message.getRepeatedFloat   (0));
    889. 

  889.     Assert.assertEquals(212D , message.getRepeatedDouble  (0));
    890. 

  890.     Assert.assertEquals(true , message.getRepeatedBool    (0));
    891. 

  891.     Assert.assertEquals("215", message.getRepeatedString  (0));
    892. 

  892.     Assert.assertEquals(toBytes("216"), message.getRepeatedBytes(0));
    893. 

  893. 

  894.     Assert.assertEquals(217, message.getRepeatedGroup         (0).getA());
    895. 

  895.     Assert.assertEquals(218, message.getRepeatedNestedMessage (0).getBb());
    896. 

  896.     Assert.assertEquals(219, message.getRepeatedForeignMessage(0).getC());
    897. 

  897.     Assert.assertEquals(220, message.getRepeatedImportMessage (0).getD());
    898. 

  898. 

  899.     Assert.assertEquals(TestAllTypes.NestedEnum.BAR, message.getRepeatedNestedEnum (0));
    900. 

  900.     Assert.assertEquals(ForeignEnum.FOREIGN_BAR, message.getRepeatedForeignEnum(0));
    901. 

  901.     Assert.assertEquals(ImportEnum.IMPORT_BAR, message.getRepeatedImportEnum(0));
    902. 

  902. 

  903.     Assert.assertEquals("224", message.getRepeatedStringPiece(0));
    904. 

  904.     Assert.assertEquals("225", message.getRepeatedCord(0));
    905. 

  905. 

  906.     // Actually verify the second (modified) elements now.
    907. 

  907.     Assert.assertEquals(501  , message.getRepeatedInt32   (1));
    908. 

  908.     Assert.assertEquals(502L , message.getRepeatedInt64   (1));
    909. 

  909.     Assert.assertEquals(503  , message.getRepeatedUint32  (1));
    910. 

  910.     Assert.assertEquals(504L , message.getRepeatedUint64  (1));
    911. 

  911.     Assert.assertEquals(505  , message.getRepeatedSint32  (1));
    912. 

  912.     Assert.assertEquals(506L , message.getRepeatedSint64  (1));
    913. 

  913.     Assert.assertEquals(507  , message.getRepeatedFixed32 (1));
    914. 

  914.     Assert.assertEquals(508L , message.getRepeatedFixed64 (1));
    915. 

  915.     Assert.assertEquals(509  , message.getRepeatedSfixed32(1));
    916. 

  916.     Assert.assertEquals(510L , message.getRepeatedSfixed64(1));
    917. 

  917.     Assert.assertEquals(511F , message.getRepeatedFloat   (1));
    918. 

  918.     Assert.assertEquals(512D , message.getRepeatedDouble  (1));
    919. 

  919.     Assert.assertEquals(true , message.getRepeatedBool    (1));
    920. 

  920.     Assert.assertEquals("515", message.getRepeatedString  (1));
    921. 

  921.     Assert.assertEquals(toBytes("516"), message.getRepeatedBytes(1));
    922. 

  922. 

  923.     Assert.assertEquals(517, message.getRepeatedGroup         (1).getA());
    924. 

  924.     Assert.assertEquals(518, message.getRepeatedNestedMessage (1).getBb());
    925. 

  925.     Assert.assertEquals(519, message.getRepeatedForeignMessage(1).getC());
    926. 

  926.     Assert.assertEquals(520, message.getRepeatedImportMessage (1).getD());
    927. 

  927. 

  928.     Assert.assertEquals(TestAllTypes.NestedEnum.FOO, message.getRepeatedNestedEnum (1));
    929. 

  929.     Assert.assertEquals(ForeignEnum.FOREIGN_FOO, message.getRepeatedForeignEnum(1));
    930. 

  930.     Assert.assertEquals(ImportEnum.IMPORT_FOO, message.getRepeatedImportEnum(1));
    931. 

  931. 

  932.     Assert.assertEquals("524", message.getRepeatedStringPiece(1));
    933. 

  933.     Assert.assertEquals("525", message.getRepeatedCord(1));
    934. 

  934.   }
    935. 

  935. 

  936.   /**
    937. 

  937.    * Set every field of {@code message} to a unique value.
    938. 

  938.    */
    939. 

  939.   public static void setPackedFields(TestPackedTypes.Builder message) {
    940. 

  940.     message.addPackedInt32   (601);
    941. 

  941.     message.addPackedInt64   (602);
    942. 

  942.     message.addPackedUint32  (603);
    943. 

  943.     message.addPackedUint64  (604);
    944. 

  944.     message.addPackedSint32  (605);
    945. 

  945.     message.addPackedSint64  (606);
    946. 

  946.     message.addPackedFixed32 (607);
    947. 

  947.     message.addPackedFixed64 (608);
    948. 

  948.     message.addPackedSfixed32(609);
    949. 

  949.     message.addPackedSfixed64(610);
    950. 

  950.     message.addPackedFloat   (611);
    951. 

  951.     message.addPackedDouble  (612);
    952. 

  952.     message.addPackedBool    (true);
    953. 

  953.     message.addPackedEnum    (ForeignEnum.FOREIGN_BAR);
    954. 

  954.     // Add a second one of each field.
    955. 

  955.     message.addPackedInt32   (701);
    956. 

  956.     message.addPackedInt64   (702);
    957. 

  957.     message.addPackedUint32  (703);
    958. 

  958.     message.addPackedUint64  (704);
    959. 

  959.     message.addPacked…
    960.

Large files files are truncated, but you can click here to view the full file