| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // https://developers.google.com/protocol-buffers/ |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package com.google.protobuf.util; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| import static com.google.common.truth.Truth.assertWithMessage; |
| |
| import com.google.common.collect.ImmutableSet; |
| import com.google.gson.JsonSyntaxException; |
| import com.google.protobuf.Any; |
| import com.google.protobuf.BoolValue; |
| import com.google.protobuf.ByteString; |
| import com.google.protobuf.BytesValue; |
| import com.google.protobuf.Descriptors.Descriptor; |
| import com.google.protobuf.Descriptors.FieldDescriptor; |
| import com.google.protobuf.DoubleValue; |
| import com.google.protobuf.FloatValue; |
| import com.google.protobuf.Int32Value; |
| import com.google.protobuf.Int64Value; |
| import com.google.protobuf.InvalidProtocolBufferException; |
| import com.google.protobuf.ListValue; |
| import com.google.protobuf.Message; |
| import com.google.protobuf.NullValue; |
| import com.google.protobuf.StringValue; |
| import com.google.protobuf.Struct; |
| import com.google.protobuf.UInt32Value; |
| import com.google.protobuf.UInt64Value; |
| import com.google.protobuf.Value; |
| import com.google.protobuf.util.JsonFormat.TypeRegistry; |
| import com.google.protobuf.util.proto.JsonTestProto.TestAllTypes; |
| import com.google.protobuf.util.proto.JsonTestProto.TestAllTypes.AliasedEnum; |
| import com.google.protobuf.util.proto.JsonTestProto.TestAllTypes.NestedEnum; |
| import com.google.protobuf.util.proto.JsonTestProto.TestAllTypes.NestedMessage; |
| import com.google.protobuf.util.proto.JsonTestProto.TestAny; |
| import com.google.protobuf.util.proto.JsonTestProto.TestCustomJsonName; |
| import com.google.protobuf.util.proto.JsonTestProto.TestDuration; |
| import com.google.protobuf.util.proto.JsonTestProto.TestFieldMask; |
| import com.google.protobuf.util.proto.JsonTestProto.TestMap; |
| import com.google.protobuf.util.proto.JsonTestProto.TestOneof; |
| import com.google.protobuf.util.proto.JsonTestProto.TestRecursive; |
| import com.google.protobuf.util.proto.JsonTestProto.TestStruct; |
| import com.google.protobuf.util.proto.JsonTestProto.TestTimestamp; |
| import com.google.protobuf.util.proto.JsonTestProto.TestWrappers; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.Reader; |
| import java.io.StringReader; |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.util.Collections; |
| import java.util.HashSet; |
| import java.util.Locale; |
| import java.util.Set; |
| import org.junit.AfterClass; |
| import org.junit.BeforeClass; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| import org.junit.runners.JUnit4; |
| |
| @RunWith(JUnit4.class) |
| public class JsonFormatTest { |
| |
| private static Locale originalLocale; |
| |
| @BeforeClass |
| public static void setLocale() { |
| originalLocale = Locale.getDefault(); |
| // Test that locale does not affect JsonFormat. |
| Locale.setDefault(Locale.forLanguageTag("hi-IN")); |
| } |
| |
| @AfterClass |
| public static void resetLocale() { |
| Locale.setDefault(originalLocale); |
| } |
| |
| private void setAllFields(TestAllTypes.Builder builder) { |
| builder.setOptionalInt32(1234); |
| builder.setOptionalInt64(1234567890123456789L); |
| builder.setOptionalUint32(5678); |
| builder.setOptionalUint64(2345678901234567890L); |
| builder.setOptionalSint32(9012); |
| builder.setOptionalSint64(3456789012345678901L); |
| builder.setOptionalFixed32(3456); |
| builder.setOptionalFixed64(4567890123456789012L); |
| builder.setOptionalSfixed32(7890); |
| builder.setOptionalSfixed64(5678901234567890123L); |
| builder.setOptionalFloat(1.5f); |
| builder.setOptionalDouble(1.25); |
| builder.setOptionalBool(true); |
| builder.setOptionalString("Hello world!"); |
| builder.setOptionalBytes(ByteString.copyFrom(new byte[] {0, 1, 2})); |
| builder.setOptionalNestedEnum(NestedEnum.BAR); |
| builder.getOptionalNestedMessageBuilder().setValue(100); |
| |
| builder.addRepeatedInt32(1234); |
| builder.addRepeatedInt64(1234567890123456789L); |
| builder.addRepeatedUint32(5678); |
| builder.addRepeatedUint64(2345678901234567890L); |
| builder.addRepeatedSint32(9012); |
| builder.addRepeatedSint64(3456789012345678901L); |
| builder.addRepeatedFixed32(3456); |
| builder.addRepeatedFixed64(4567890123456789012L); |
| builder.addRepeatedSfixed32(7890); |
| builder.addRepeatedSfixed64(5678901234567890123L); |
| builder.addRepeatedFloat(1.5f); |
| builder.addRepeatedDouble(1.25); |
| builder.addRepeatedBool(true); |
| builder.addRepeatedString("Hello world!"); |
| builder.addRepeatedBytes(ByteString.copyFrom(new byte[] {0, 1, 2})); |
| builder.addRepeatedNestedEnum(NestedEnum.BAR); |
| builder.addRepeatedNestedMessageBuilder().setValue(100); |
| |
| builder.addRepeatedInt32(234); |
| builder.addRepeatedInt64(234567890123456789L); |
| builder.addRepeatedUint32(678); |
| builder.addRepeatedUint64(345678901234567890L); |
| builder.addRepeatedSint32(012); |
| builder.addRepeatedSint64(456789012345678901L); |
| builder.addRepeatedFixed32(456); |
| builder.addRepeatedFixed64(567890123456789012L); |
| builder.addRepeatedSfixed32(890); |
| builder.addRepeatedSfixed64(678901234567890123L); |
| builder.addRepeatedFloat(11.5f); |
| builder.addRepeatedDouble(11.25); |
| builder.addRepeatedBool(true); |
| builder.addRepeatedString("ello world!"); |
| builder.addRepeatedBytes(ByteString.copyFrom(new byte[] {1, 2})); |
| builder.addRepeatedNestedEnum(NestedEnum.BAZ); |
| builder.addRepeatedNestedMessageBuilder().setValue(200); |
| } |
| |
| private void assertRoundTripEquals(Message message) throws Exception { |
| assertRoundTripEquals(message, TypeRegistry.getEmptyTypeRegistry()); |
| } |
| |
| private void assertRoundTripEquals(Message message, TypeRegistry registry) throws Exception { |
| JsonFormat.Printer printer = JsonFormat.printer().usingTypeRegistry(registry); |
| JsonFormat.Parser parser = JsonFormat.parser().usingTypeRegistry(registry); |
| Message.Builder builder = message.newBuilderForType(); |
| parser.merge(printer.print(message), builder); |
| Message parsedMessage = builder.build(); |
| assertThat(parsedMessage.toString()).isEqualTo(message.toString()); |
| } |
| |
| private void assertRoundTripEquals(Message message, com.google.protobuf.TypeRegistry registry) |
| throws Exception { |
| JsonFormat.Printer printer = JsonFormat.printer().usingTypeRegistry(registry); |
| JsonFormat.Parser parser = JsonFormat.parser().usingTypeRegistry(registry); |
| Message.Builder builder = message.newBuilderForType(); |
| parser.merge(printer.print(message), builder); |
| Message parsedMessage = builder.build(); |
| assertThat(parsedMessage.toString()).isEqualTo(message.toString()); |
| } |
| |
| private String toJsonString(Message message) throws IOException { |
| return JsonFormat.printer().print(message); |
| } |
| private String toCompactJsonString(Message message) throws IOException { |
| return JsonFormat.printer().omittingInsignificantWhitespace().print(message); |
| } |
| private String toSortedJsonString(Message message) throws IOException { |
| return JsonFormat.printer().sortingMapKeys().print(message); |
| } |
| |
| private void mergeFromJson(String json, Message.Builder builder) throws IOException { |
| JsonFormat.parser().merge(json, builder); |
| } |
| |
| private void mergeFromJsonIgnoringUnknownFields(String json, Message.Builder builder) |
| throws IOException { |
| JsonFormat.parser().ignoringUnknownFields().merge(json, builder); |
| } |
| |
| @Test |
| public void testAllFields() throws Exception { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| setAllFields(builder); |
| TestAllTypes message = builder.build(); |
| |
| assertThat(toJsonString(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"optionalInt32\": 1234,\n" |
| + " \"optionalInt64\": \"1234567890123456789\",\n" |
| + " \"optionalUint32\": 5678,\n" |
| + " \"optionalUint64\": \"2345678901234567890\",\n" |
| + " \"optionalSint32\": 9012,\n" |
| + " \"optionalSint64\": \"3456789012345678901\",\n" |
| + " \"optionalFixed32\": 3456,\n" |
| + " \"optionalFixed64\": \"4567890123456789012\",\n" |
| + " \"optionalSfixed32\": 7890,\n" |
| + " \"optionalSfixed64\": \"5678901234567890123\",\n" |
| + " \"optionalFloat\": 1.5,\n" |
| + " \"optionalDouble\": 1.25,\n" |
| + " \"optionalBool\": true,\n" |
| + " \"optionalString\": \"Hello world!\",\n" |
| + " \"optionalBytes\": \"AAEC\",\n" |
| + " \"optionalNestedMessage\": {\n" |
| + " \"value\": 100\n" |
| + " },\n" |
| + " \"optionalNestedEnum\": \"BAR\",\n" |
| + " \"repeatedInt32\": [1234, 234],\n" |
| + " \"repeatedInt64\": [\"1234567890123456789\", \"234567890123456789\"],\n" |
| + " \"repeatedUint32\": [5678, 678],\n" |
| + " \"repeatedUint64\": [\"2345678901234567890\", \"345678901234567890\"],\n" |
| + " \"repeatedSint32\": [9012, 10],\n" |
| + " \"repeatedSint64\": [\"3456789012345678901\", \"456789012345678901\"],\n" |
| + " \"repeatedFixed32\": [3456, 456],\n" |
| + " \"repeatedFixed64\": [\"4567890123456789012\", \"567890123456789012\"],\n" |
| + " \"repeatedSfixed32\": [7890, 890],\n" |
| + " \"repeatedSfixed64\": [\"5678901234567890123\", \"678901234567890123\"],\n" |
| + " \"repeatedFloat\": [1.5, 11.5],\n" |
| + " \"repeatedDouble\": [1.25, 11.25],\n" |
| + " \"repeatedBool\": [true, true],\n" |
| + " \"repeatedString\": [\"Hello world!\", \"ello world!\"],\n" |
| + " \"repeatedBytes\": [\"AAEC\", \"AQI=\"],\n" |
| + " \"repeatedNestedMessage\": [{\n" |
| + " \"value\": 100\n" |
| + " }, {\n" |
| + " \"value\": 200\n" |
| + " }],\n" |
| + " \"repeatedNestedEnum\": [\"BAR\", \"BAZ\"]\n" |
| + "}"); |
| |
| assertRoundTripEquals(message); |
| } |
| |
| @Test |
| public void testUnknownEnumValues() throws Exception { |
| TestAllTypes message = |
| TestAllTypes.newBuilder() |
| .setOptionalNestedEnumValue(12345) |
| .addRepeatedNestedEnumValue(12345) |
| .addRepeatedNestedEnumValue(0) |
| .build(); |
| assertThat(toJsonString(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"optionalNestedEnum\": 12345,\n" |
| + " \"repeatedNestedEnum\": [12345, \"FOO\"]\n" |
| + "}"); |
| assertRoundTripEquals(message); |
| |
| TestMap.Builder mapBuilder = TestMap.newBuilder(); |
| mapBuilder.putInt32ToEnumMapValue(1, 0); |
| mapBuilder.putInt32ToEnumMapValue(2, 12345); |
| TestMap mapMessage = mapBuilder.build(); |
| assertThat(toJsonString(mapMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"int32ToEnumMap\": {\n" |
| + " \"1\": \"FOO\",\n" |
| + " \"2\": 12345\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(mapMessage); |
| } |
| |
| @Test |
| public void testSpecialFloatValues() throws Exception { |
| TestAllTypes message = |
| TestAllTypes.newBuilder() |
| .addRepeatedFloat(Float.NaN) |
| .addRepeatedFloat(Float.POSITIVE_INFINITY) |
| .addRepeatedFloat(Float.NEGATIVE_INFINITY) |
| .addRepeatedDouble(Double.NaN) |
| .addRepeatedDouble(Double.POSITIVE_INFINITY) |
| .addRepeatedDouble(Double.NEGATIVE_INFINITY) |
| .build(); |
| assertThat(toJsonString(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"repeatedFloat\": [\"NaN\", \"Infinity\", \"-Infinity\"],\n" |
| + " \"repeatedDouble\": [\"NaN\", \"Infinity\", \"-Infinity\"]\n" |
| + "}"); |
| |
| assertRoundTripEquals(message); |
| } |
| |
| @Test |
| public void testParserAcceptStringForNumericField() throws Exception { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| mergeFromJson( |
| "{\n" |
| + " \"optionalInt32\": \"1234\",\n" |
| + " \"optionalUint32\": \"5678\",\n" |
| + " \"optionalSint32\": \"9012\",\n" |
| + " \"optionalFixed32\": \"3456\",\n" |
| + " \"optionalSfixed32\": \"7890\",\n" |
| + " \"optionalFloat\": \"1.5\",\n" |
| + " \"optionalDouble\": \"1.25\",\n" |
| + " \"optionalBool\": \"true\"\n" |
| + "}", |
| builder); |
| TestAllTypes message = builder.build(); |
| assertThat(message.getOptionalInt32()).isEqualTo(1234); |
| assertThat(message.getOptionalUint32()).isEqualTo(5678); |
| assertThat(message.getOptionalSint32()).isEqualTo(9012); |
| assertThat(message.getOptionalFixed32()).isEqualTo(3456); |
| assertThat(message.getOptionalSfixed32()).isEqualTo(7890); |
| assertThat(message.getOptionalFloat()).isEqualTo(1.5f); |
| assertThat(message.getOptionalDouble()).isEqualTo(1.25); |
| assertThat(message.getOptionalBool()).isTrue(); |
| } |
| |
| @Test |
| public void testParserAcceptFloatingPointValueForIntegerField() throws Exception { |
| // Test that numeric values like "1.000", "1e5" will also be accepted. |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| mergeFromJson( |
| "{\n" |
| + " \"repeatedInt32\": [1.000, 1e5, \"1.000\", \"1e5\"],\n" |
| + " \"repeatedUint32\": [1.000, 1e5, \"1.000\", \"1e5\"],\n" |
| + " \"repeatedInt64\": [1.000, 1e5, \"1.000\", \"1e5\"],\n" |
| + " \"repeatedUint64\": [1.000, 1e5, \"1.000\", \"1e5\"]\n" |
| + "}", |
| builder); |
| int[] expectedValues = new int[] {1, 100000, 1, 100000}; |
| assertThat(builder.getRepeatedInt32Count()).isEqualTo(4); |
| assertThat(builder.getRepeatedUint32Count()).isEqualTo(4); |
| assertThat(builder.getRepeatedInt64Count()).isEqualTo(4); |
| assertThat(builder.getRepeatedUint64Count()).isEqualTo(4); |
| for (int i = 0; i < 4; ++i) { |
| assertThat(builder.getRepeatedInt32(i)).isEqualTo(expectedValues[i]); |
| assertThat(builder.getRepeatedUint32(i)).isEqualTo(expectedValues[i]); |
| assertThat(builder.getRepeatedInt64(i)).isEqualTo(expectedValues[i]); |
| assertThat(builder.getRepeatedUint64(i)).isEqualTo(expectedValues[i]); |
| } |
| } |
| |
| @Test |
| public void testRejectTooLargeFloat() throws IOException { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| double tooLarge = 2.0 * Float.MAX_VALUE; |
| try { |
| mergeFromJson("{\"" + "optionalFloat" + "\":" + tooLarge + "}", builder); |
| assertWithMessage("InvalidProtocolBufferException expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasMessageThat().isEqualTo("Out of range float value: " + tooLarge); |
| } |
| } |
| |
| @Test |
| public void testRejectMalformedFloat() throws IOException { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| try { |
| mergeFromJson("{\"optionalFloat\":3.5aa}", builder); |
| assertWithMessage("InvalidProtocolBufferException expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasCauseThat().isNotNull(); |
| } |
| } |
| |
| @Test |
| public void testRejectFractionalInt64() throws IOException { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| try { |
| mergeFromJson("{\"" + "optionalInt64" + "\":" + "1.5" + "}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasMessageThat().isEqualTo("Not an int64 value: 1.5"); |
| assertThat(expected).hasCauseThat().isNotNull(); |
| } |
| } |
| |
| @Test |
| public void testRejectFractionalInt32() throws IOException { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| try { |
| mergeFromJson("{\"" + "optionalInt32" + "\":" + "1.5" + "}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasMessageThat().isEqualTo("Not an int32 value: 1.5"); |
| assertThat(expected).hasCauseThat().isNotNull(); |
| } |
| } |
| |
| @Test |
| public void testRejectFractionalUnsignedInt32() throws IOException { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| try { |
| mergeFromJson("{\"" + "optionalUint32" + "\":" + "1.5" + "}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasMessageThat().isEqualTo("Not an uint32 value: 1.5"); |
| assertThat(expected).hasCauseThat().isNotNull(); |
| } |
| } |
| |
| @Test |
| public void testRejectFractionalUnsignedInt64() throws IOException { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| try { |
| mergeFromJson("{\"" + "optionalUint64" + "\":" + "1.5" + "}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasMessageThat().isEqualTo("Not an uint64 value: 1.5"); |
| assertThat(expected).hasCauseThat().isNotNull(); |
| } |
| } |
| |
| private void assertRejects(String name, String value) throws IOException { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| try { |
| // Numeric form is rejected. |
| mergeFromJson("{\"" + name + "\":" + value + "}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasMessageThat().contains(value); |
| } |
| try { |
| // String form is also rejected. |
| mergeFromJson("{\"" + name + "\":\"" + value + "\"}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasMessageThat().contains(value); |
| } |
| } |
| |
| private void assertAccepts(String name, String value) throws IOException { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| // Both numeric form and string form are accepted. |
| mergeFromJson("{\"" + name + "\":" + value + "}", builder); |
| builder.clear(); |
| mergeFromJson("{\"" + name + "\":\"" + value + "\"}", builder); |
| } |
| |
| @Test |
| public void testParserRejectOutOfRangeNumericValues() throws Exception { |
| assertAccepts("optionalInt32", String.valueOf(Integer.MAX_VALUE)); |
| assertAccepts("optionalInt32", String.valueOf(Integer.MIN_VALUE)); |
| assertRejects("optionalInt32", String.valueOf(Integer.MAX_VALUE + 1L)); |
| assertRejects("optionalInt32", String.valueOf(Integer.MIN_VALUE - 1L)); |
| |
| assertAccepts("optionalUint32", String.valueOf(Integer.MAX_VALUE + 1L)); |
| assertRejects("optionalUint32", "123456789012345"); |
| assertRejects("optionalUint32", "-1"); |
| |
| BigInteger one = BigInteger.ONE; |
| BigInteger maxLong = new BigInteger(String.valueOf(Long.MAX_VALUE)); |
| BigInteger minLong = new BigInteger(String.valueOf(Long.MIN_VALUE)); |
| assertAccepts("optionalInt64", maxLong.toString()); |
| assertAccepts("optionalInt64", minLong.toString()); |
| assertRejects("optionalInt64", maxLong.add(one).toString()); |
| assertRejects("optionalInt64", minLong.subtract(one).toString()); |
| |
| assertAccepts("optionalUint64", maxLong.add(one).toString()); |
| assertRejects("optionalUint64", "1234567890123456789012345"); |
| assertRejects("optionalUint64", "-1"); |
| |
| assertAccepts("optionalBool", "true"); |
| assertRejects("optionalBool", "1"); |
| assertRejects("optionalBool", "0"); |
| |
| assertAccepts("optionalFloat", String.valueOf(Float.MAX_VALUE)); |
| assertAccepts("optionalFloat", String.valueOf(-Float.MAX_VALUE)); |
| assertRejects("optionalFloat", String.valueOf(Double.MAX_VALUE)); |
| assertRejects("optionalFloat", String.valueOf(-Double.MAX_VALUE)); |
| |
| BigDecimal moreThanOne = new BigDecimal("1.000001"); |
| BigDecimal maxDouble = new BigDecimal(Double.MAX_VALUE); |
| BigDecimal minDouble = new BigDecimal(-Double.MAX_VALUE); |
| assertAccepts("optionalDouble", maxDouble.toString()); |
| assertAccepts("optionalDouble", minDouble.toString()); |
| assertRejects("optionalDouble", maxDouble.multiply(moreThanOne).toString()); |
| assertRejects("optionalDouble", minDouble.multiply(moreThanOne).toString()); |
| } |
| |
| @Test |
| public void testParserAcceptNull() throws Exception { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| mergeFromJson( |
| "{\n" |
| + " \"optionalInt32\": null,\n" |
| + " \"optionalInt64\": null,\n" |
| + " \"optionalUint32\": null,\n" |
| + " \"optionalUint64\": null,\n" |
| + " \"optionalSint32\": null,\n" |
| + " \"optionalSint64\": null,\n" |
| + " \"optionalFixed32\": null,\n" |
| + " \"optionalFixed64\": null,\n" |
| + " \"optionalSfixed32\": null,\n" |
| + " \"optionalSfixed64\": null,\n" |
| + " \"optionalFloat\": null,\n" |
| + " \"optionalDouble\": null,\n" |
| + " \"optionalBool\": null,\n" |
| + " \"optionalString\": null,\n" |
| + " \"optionalBytes\": null,\n" |
| + " \"optionalNestedMessage\": null,\n" |
| + " \"optionalNestedEnum\": null,\n" |
| + " \"repeatedInt32\": null,\n" |
| + " \"repeatedInt64\": null,\n" |
| + " \"repeatedUint32\": null,\n" |
| + " \"repeatedUint64\": null,\n" |
| + " \"repeatedSint32\": null,\n" |
| + " \"repeatedSint64\": null,\n" |
| + " \"repeatedFixed32\": null,\n" |
| + " \"repeatedFixed64\": null,\n" |
| + " \"repeatedSfixed32\": null,\n" |
| + " \"repeatedSfixed64\": null,\n" |
| + " \"repeatedFloat\": null,\n" |
| + " \"repeatedDouble\": null,\n" |
| + " \"repeatedBool\": null,\n" |
| + " \"repeatedString\": null,\n" |
| + " \"repeatedBytes\": null,\n" |
| + " \"repeatedNestedMessage\": null,\n" |
| + " \"repeatedNestedEnum\": null\n" |
| + "}", |
| builder); |
| TestAllTypes message = builder.build(); |
| assertThat(message).isEqualTo(TestAllTypes.getDefaultInstance()); |
| |
| // Repeated field elements cannot be null. |
| try { |
| builder = TestAllTypes.newBuilder(); |
| mergeFromJson("{\n" + " \"repeatedInt32\": [null, null],\n" + "}", builder); |
| assertWithMessage("expected exception").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| } |
| |
| try { |
| builder = TestAllTypes.newBuilder(); |
| mergeFromJson("{\n" + " \"repeatedNestedMessage\": [null, null],\n" + "}", builder); |
| assertWithMessage("expected exception").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| } |
| } |
| |
| @Test |
| public void testNullInOneof() throws Exception { |
| TestOneof.Builder builder = TestOneof.newBuilder(); |
| mergeFromJson("{\n" + " \"oneofNullValue\": null \n" + "}", builder); |
| TestOneof message = builder.build(); |
| assertThat(message.getOneofFieldCase()).isEqualTo(TestOneof.OneofFieldCase.ONEOF_NULL_VALUE); |
| assertThat(message.getOneofNullValue()).isEqualTo(NullValue.NULL_VALUE); |
| } |
| |
| @Test |
| public void testNullFirstInDuplicateOneof() throws Exception { |
| TestOneof.Builder builder = TestOneof.newBuilder(); |
| mergeFromJson("{\"oneofNestedMessage\": null, \"oneofInt32\": 1}", builder); |
| TestOneof message = builder.build(); |
| assertThat(message.getOneofInt32()).isEqualTo(1); |
| } |
| |
| @Test |
| public void testNullLastInDuplicateOneof() throws Exception { |
| TestOneof.Builder builder = TestOneof.newBuilder(); |
| mergeFromJson("{\"oneofInt32\": 1, \"oneofNestedMessage\": null}", builder); |
| TestOneof message = builder.build(); |
| assertThat(message.getOneofInt32()).isEqualTo(1); |
| } |
| |
| @Test |
| public void testParserRejectDuplicatedFields() throws Exception { |
| // TODO(xiaofeng): The parser we are currently using (GSON) will accept and keep the last |
| // one if multiple entries have the same name. This is not the desired behavior but it can |
| // only be fixed by using our own parser. Here we only test the cases where the names are |
| // different but still referring to the same field. |
| |
| // Duplicated optional fields. |
| try { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| mergeFromJson( |
| "{\n" |
| + " \"optionalNestedMessage\": {},\n" |
| + " \"optional_nested_message\": {}\n" |
| + "}", |
| builder); |
| assertWithMessage("expected exception").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| } |
| |
| // Duplicated repeated fields. |
| try { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| mergeFromJson( |
| "{\n" |
| + " \"repeatedInt32\": [1, 2],\n" |
| + " \"repeated_int32\": [5, 6]\n" |
| + "}", |
| builder); |
| assertWithMessage("expected exception").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| } |
| |
| // Duplicated oneof fields, same name. |
| try { |
| TestOneof.Builder builder = TestOneof.newBuilder(); |
| mergeFromJson("{\n" + " \"oneofInt32\": 1,\n" + " \"oneof_int32\": 2\n" + "}", builder); |
| assertWithMessage("expected exception").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| } |
| |
| // Duplicated oneof fields, different name. |
| try { |
| TestOneof.Builder builder = TestOneof.newBuilder(); |
| mergeFromJson( |
| "{\n" + " \"oneofInt32\": 1,\n" + " \"oneofNullValue\": null\n" + "}", builder); |
| assertWithMessage("expected exception").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| } |
| } |
| |
| @Test |
| public void testMapFields() throws Exception { |
| TestMap.Builder builder = TestMap.newBuilder(); |
| builder.putInt32ToInt32Map(1, 10); |
| builder.putInt64ToInt32Map(1234567890123456789L, 10); |
| builder.putUint32ToInt32Map(2, 20); |
| builder.putUint64ToInt32Map(2234567890123456789L, 20); |
| builder.putSint32ToInt32Map(3, 30); |
| builder.putSint64ToInt32Map(3234567890123456789L, 30); |
| builder.putFixed32ToInt32Map(4, 40); |
| builder.putFixed64ToInt32Map(4234567890123456789L, 40); |
| builder.putSfixed32ToInt32Map(5, 50); |
| builder.putSfixed64ToInt32Map(5234567890123456789L, 50); |
| builder.putBoolToInt32Map(false, 6); |
| builder.putStringToInt32Map("Hello", 10); |
| |
| builder.putInt32ToInt64Map(1, 1234567890123456789L); |
| builder.putInt32ToUint32Map(2, 20); |
| builder.putInt32ToUint64Map(2, 2234567890123456789L); |
| builder.putInt32ToSint32Map(3, 30); |
| builder.putInt32ToSint64Map(3, 3234567890123456789L); |
| builder.putInt32ToFixed32Map(4, 40); |
| builder.putInt32ToFixed64Map(4, 4234567890123456789L); |
| builder.putInt32ToSfixed32Map(5, 50); |
| builder.putInt32ToSfixed64Map(5, 5234567890123456789L); |
| builder.putInt32ToFloatMap(6, 1.5f); |
| builder.putInt32ToDoubleMap(6, 1.25); |
| builder.putInt32ToBoolMap(7, false); |
| builder.putInt32ToStringMap(7, "World"); |
| builder.putInt32ToBytesMap(8, ByteString.copyFrom(new byte[] {1, 2, 3})); |
| builder.putInt32ToMessageMap(8, NestedMessage.newBuilder().setValue(1234).build()); |
| builder.putInt32ToEnumMap(9, NestedEnum.BAR); |
| TestMap message = builder.build(); |
| |
| assertThat(toJsonString(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"int32ToInt32Map\": {\n" |
| + " \"1\": 10\n" |
| + " },\n" |
| + " \"int64ToInt32Map\": {\n" |
| + " \"1234567890123456789\": 10\n" |
| + " },\n" |
| + " \"uint32ToInt32Map\": {\n" |
| + " \"2\": 20\n" |
| + " },\n" |
| + " \"uint64ToInt32Map\": {\n" |
| + " \"2234567890123456789\": 20\n" |
| + " },\n" |
| + " \"sint32ToInt32Map\": {\n" |
| + " \"3\": 30\n" |
| + " },\n" |
| + " \"sint64ToInt32Map\": {\n" |
| + " \"3234567890123456789\": 30\n" |
| + " },\n" |
| + " \"fixed32ToInt32Map\": {\n" |
| + " \"4\": 40\n" |
| + " },\n" |
| + " \"fixed64ToInt32Map\": {\n" |
| + " \"4234567890123456789\": 40\n" |
| + " },\n" |
| + " \"sfixed32ToInt32Map\": {\n" |
| + " \"5\": 50\n" |
| + " },\n" |
| + " \"sfixed64ToInt32Map\": {\n" |
| + " \"5234567890123456789\": 50\n" |
| + " },\n" |
| + " \"boolToInt32Map\": {\n" |
| + " \"false\": 6\n" |
| + " },\n" |
| + " \"stringToInt32Map\": {\n" |
| + " \"Hello\": 10\n" |
| + " },\n" |
| + " \"int32ToInt64Map\": {\n" |
| + " \"1\": \"1234567890123456789\"\n" |
| + " },\n" |
| + " \"int32ToUint32Map\": {\n" |
| + " \"2\": 20\n" |
| + " },\n" |
| + " \"int32ToUint64Map\": {\n" |
| + " \"2\": \"2234567890123456789\"\n" |
| + " },\n" |
| + " \"int32ToSint32Map\": {\n" |
| + " \"3\": 30\n" |
| + " },\n" |
| + " \"int32ToSint64Map\": {\n" |
| + " \"3\": \"3234567890123456789\"\n" |
| + " },\n" |
| + " \"int32ToFixed32Map\": {\n" |
| + " \"4\": 40\n" |
| + " },\n" |
| + " \"int32ToFixed64Map\": {\n" |
| + " \"4\": \"4234567890123456789\"\n" |
| + " },\n" |
| + " \"int32ToSfixed32Map\": {\n" |
| + " \"5\": 50\n" |
| + " },\n" |
| + " \"int32ToSfixed64Map\": {\n" |
| + " \"5\": \"5234567890123456789\"\n" |
| + " },\n" |
| + " \"int32ToFloatMap\": {\n" |
| + " \"6\": 1.5\n" |
| + " },\n" |
| + " \"int32ToDoubleMap\": {\n" |
| + " \"6\": 1.25\n" |
| + " },\n" |
| + " \"int32ToBoolMap\": {\n" |
| + " \"7\": false\n" |
| + " },\n" |
| + " \"int32ToStringMap\": {\n" |
| + " \"7\": \"World\"\n" |
| + " },\n" |
| + " \"int32ToBytesMap\": {\n" |
| + " \"8\": \"AQID\"\n" |
| + " },\n" |
| + " \"int32ToMessageMap\": {\n" |
| + " \"8\": {\n" |
| + " \"value\": 1234\n" |
| + " }\n" |
| + " },\n" |
| + " \"int32ToEnumMap\": {\n" |
| + " \"9\": \"BAR\"\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(message); |
| |
| // Test multiple entries. |
| builder = TestMap.newBuilder(); |
| builder.putInt32ToInt32Map(1, 2); |
| builder.putInt32ToInt32Map(3, 4); |
| message = builder.build(); |
| |
| assertThat(toJsonString(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"int32ToInt32Map\": {\n" |
| + " \"1\": 2,\n" |
| + " \"3\": 4\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(message); |
| } |
| |
| @Test |
| public void testMapNullValueIsRejected() throws Exception { |
| try { |
| TestMap.Builder builder = TestMap.newBuilder(); |
| mergeFromJson( |
| "{\n" |
| + " \"int32ToInt32Map\": {null: 1},\n" |
| + " \"int32ToMessageMap\": {null: 2}\n" |
| + "}", |
| builder); |
| assertWithMessage("expected exception").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| } |
| |
| try { |
| TestMap.Builder builder = TestMap.newBuilder(); |
| mergeFromJson( |
| "{\n" |
| + " \"int32ToInt32Map\": {\"1\": null},\n" |
| + " \"int32ToMessageMap\": {\"2\": null}\n" |
| + "}", |
| builder); |
| assertWithMessage("expected exception").fail(); |
| |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| } |
| } |
| |
| @Test |
| public void testMapEnumNullValueIsIgnored() throws Exception { |
| TestMap.Builder builder = TestMap.newBuilder(); |
| mergeFromJsonIgnoringUnknownFields( |
| "{\n" + " \"int32ToEnumMap\": {\"1\": null}\n" + "}", builder); |
| TestMap map = builder.build(); |
| assertThat(map.getInt32ToEnumMapMap()).isEmpty(); |
| } |
| |
| @Test |
| // https://github.com/protocolbuffers/protobuf/issues/7456 |
| public void testArrayTypeMismatch() throws IOException { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| try { |
| mergeFromJson( |
| "{\n" |
| + " \"repeated_int32\": 5\n" |
| + "}", |
| builder); |
| assertWithMessage("should have thrown exception for incorrect type").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasMessageThat() |
| .isEqualTo("Expected an array for repeated_int32 but found 5"); |
| } |
| } |
| |
| @Test |
| public void testParserAcceptNonQuotedObjectKey() throws Exception { |
| TestMap.Builder builder = TestMap.newBuilder(); |
| mergeFromJson( |
| "{\n" + " int32ToInt32Map: {1: 2},\n" + " stringToInt32Map: {hello: 3}\n" + "}", builder); |
| TestMap message = builder.build(); |
| assertThat(message.getInt32ToInt32MapMap().get(1).intValue()).isEqualTo(2); |
| assertThat(message.getStringToInt32MapMap().get("hello").intValue()).isEqualTo(3); |
| } |
| |
| @Test |
| public void testWrappers() throws Exception { |
| TestWrappers.Builder builder = TestWrappers.newBuilder(); |
| builder.getBoolValueBuilder().setValue(false); |
| builder.getInt32ValueBuilder().setValue(0); |
| builder.getInt64ValueBuilder().setValue(0); |
| builder.getUint32ValueBuilder().setValue(0); |
| builder.getUint64ValueBuilder().setValue(0); |
| builder.getFloatValueBuilder().setValue(0.0f); |
| builder.getDoubleValueBuilder().setValue(0.0); |
| builder.getStringValueBuilder().setValue(""); |
| builder.getBytesValueBuilder().setValue(ByteString.EMPTY); |
| TestWrappers message = builder.build(); |
| |
| assertThat(toJsonString(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"int32Value\": 0,\n" |
| + " \"uint32Value\": 0,\n" |
| + " \"int64Value\": \"0\",\n" |
| + " \"uint64Value\": \"0\",\n" |
| + " \"floatValue\": 0.0,\n" |
| + " \"doubleValue\": 0.0,\n" |
| + " \"boolValue\": false,\n" |
| + " \"stringValue\": \"\",\n" |
| + " \"bytesValue\": \"\"\n" |
| + "}"); |
| assertRoundTripEquals(message); |
| |
| builder = TestWrappers.newBuilder(); |
| builder.getBoolValueBuilder().setValue(true); |
| builder.getInt32ValueBuilder().setValue(1); |
| builder.getInt64ValueBuilder().setValue(2); |
| builder.getUint32ValueBuilder().setValue(3); |
| builder.getUint64ValueBuilder().setValue(4); |
| builder.getFloatValueBuilder().setValue(5.0f); |
| builder.getDoubleValueBuilder().setValue(6.0); |
| builder.getStringValueBuilder().setValue("7"); |
| builder.getBytesValueBuilder().setValue(ByteString.copyFrom(new byte[] {8})); |
| message = builder.build(); |
| |
| assertThat(toJsonString(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"int32Value\": 1,\n" |
| + " \"uint32Value\": 3,\n" |
| + " \"int64Value\": \"2\",\n" |
| + " \"uint64Value\": \"4\",\n" |
| + " \"floatValue\": 5.0,\n" |
| + " \"doubleValue\": 6.0,\n" |
| + " \"boolValue\": true,\n" |
| + " \"stringValue\": \"7\",\n" |
| + " \"bytesValue\": \"CA==\"\n" |
| + "}"); |
| assertRoundTripEquals(message); |
| } |
| |
| @Test |
| public void testTimestamp() throws Exception { |
| TestTimestamp message = |
| TestTimestamp.newBuilder() |
| .setTimestampValue(Timestamps.parse("1970-01-01T00:00:00Z")) |
| .build(); |
| |
| assertThat(toJsonString(message)) |
| .isEqualTo("{\n" + " \"timestampValue\": \"1970-01-01T00:00:00Z\"\n" + "}"); |
| assertRoundTripEquals(message); |
| } |
| |
| @Test |
| public void testTimestampMergeError() throws Exception { |
| final String incorrectTimestampString = "{\"seconds\":1800,\"nanos\":0}"; |
| try { |
| TestTimestamp.Builder builder = TestTimestamp.newBuilder(); |
| mergeFromJson(String.format("{\"timestamp_value\": %s}", incorrectTimestampString), builder); |
| assertWithMessage("expected exception").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| assertThat(e) |
| .hasMessageThat() |
| .isEqualTo("Failed to parse timestamp: " + incorrectTimestampString); |
| assertThat(e).hasCauseThat().isNotNull(); |
| } |
| } |
| |
| @Test |
| public void testDuration() throws Exception { |
| TestDuration message = |
| TestDuration.newBuilder().setDurationValue(Durations.parse("12345s")).build(); |
| |
| assertThat(toJsonString(message)).isEqualTo("{\n" + " \"durationValue\": \"12345s\"\n" + "}"); |
| assertRoundTripEquals(message); |
| } |
| |
| @Test |
| public void testDurationMergeError() throws Exception { |
| final String incorrectDurationString = "{\"seconds\":10,\"nanos\":500}"; |
| try { |
| TestDuration.Builder builder = TestDuration.newBuilder(); |
| mergeFromJson(String.format("{\"duration_value\": %s}", incorrectDurationString), builder); |
| assertWithMessage("expected exception").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Exception expected. |
| assertThat(e) |
| .hasMessageThat() |
| .isEqualTo("Failed to parse duration: " + incorrectDurationString); |
| assertThat(e).hasCauseThat().isNotNull(); |
| } |
| } |
| |
| @Test |
| public void testFieldMask() throws Exception { |
| TestFieldMask message = |
| TestFieldMask.newBuilder() |
| .setFieldMaskValue(FieldMaskUtil.fromString("foo.bar,baz,foo_bar.baz")) |
| .build(); |
| |
| assertThat(toJsonString(message)) |
| .isEqualTo("{\n" + " \"fieldMaskValue\": \"foo.bar,baz,fooBar.baz\"\n" + "}"); |
| assertRoundTripEquals(message); |
| } |
| |
| @Test |
| public void testStruct() throws Exception { |
| // Build a struct with all possible values. |
| TestStruct.Builder builder = TestStruct.newBuilder(); |
| Struct.Builder structBuilder = builder.getStructValueBuilder(); |
| structBuilder.putFields("null_value", Value.newBuilder().setNullValueValue(0).build()); |
| structBuilder.putFields("number_value", Value.newBuilder().setNumberValue(1.25).build()); |
| structBuilder.putFields("string_value", Value.newBuilder().setStringValue("hello").build()); |
| Struct.Builder subStructBuilder = Struct.newBuilder(); |
| subStructBuilder.putFields("number_value", Value.newBuilder().setNumberValue(1234).build()); |
| structBuilder.putFields( |
| "struct_value", Value.newBuilder().setStructValue(subStructBuilder.build()).build()); |
| ListValue.Builder listBuilder = ListValue.newBuilder(); |
| listBuilder.addValues(Value.newBuilder().setNumberValue(1.125).build()); |
| listBuilder.addValues(Value.newBuilder().setNullValueValue(0).build()); |
| structBuilder.putFields( |
| "list_value", Value.newBuilder().setListValue(listBuilder.build()).build()); |
| TestStruct message = builder.build(); |
| |
| assertThat(toJsonString(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"structValue\": {\n" |
| + " \"null_value\": null,\n" |
| + " \"number_value\": 1.25,\n" |
| + " \"string_value\": \"hello\",\n" |
| + " \"struct_value\": {\n" |
| + " \"number_value\": 1234.0\n" |
| + " },\n" |
| + " \"list_value\": [1.125, null]\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(message); |
| |
| builder = TestStruct.newBuilder(); |
| builder.setValue(Value.newBuilder().setNullValueValue(0).build()); |
| message = builder.build(); |
| assertThat(toJsonString(message)).isEqualTo("{\n" + " \"value\": null\n" + "}"); |
| assertRoundTripEquals(message); |
| |
| builder = TestStruct.newBuilder(); |
| listBuilder = builder.getListValueBuilder(); |
| listBuilder.addValues(Value.newBuilder().setNumberValue(31831.125).build()); |
| listBuilder.addValues(Value.newBuilder().setNullValueValue(0).build()); |
| message = builder.build(); |
| assertThat(toJsonString(message)) |
| .isEqualTo("{\n" + " \"listValue\": [31831.125, null]\n" + "}"); |
| assertRoundTripEquals(message); |
| } |
| |
| |
| @Test |
| public void testAnyFieldsWithCustomAddedTypeRegistry() throws Exception { |
| TestAllTypes content = TestAllTypes.newBuilder().setOptionalInt32(1234).build(); |
| TestAny message = TestAny.newBuilder().setAnyValue(Any.pack(content)).build(); |
| |
| com.google.protobuf.TypeRegistry registry = |
| com.google.protobuf.TypeRegistry.newBuilder().add(content.getDescriptorForType()).build(); |
| JsonFormat.Printer printer = JsonFormat.printer().usingTypeRegistry(registry); |
| |
| assertThat(printer.print(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"anyValue\": {\n" |
| + " \"@type\": \"type.googleapis.com/json_test.TestAllTypes\",\n" |
| + " \"optionalInt32\": 1234\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(message, registry); |
| |
| TestAny messageWithDefaultAnyValue = |
| TestAny.newBuilder().setAnyValue(Any.getDefaultInstance()).build(); |
| assertThat(printer.print(messageWithDefaultAnyValue)) |
| .isEqualTo("{\n" + " \"anyValue\": {}\n" + "}"); |
| assertRoundTripEquals(messageWithDefaultAnyValue, registry); |
| |
| // Well-known types have a special formatting when embedded in Any. |
| // |
| // 1. Any in Any. |
| Any anyMessage = Any.pack(Any.pack(content)); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Any\",\n" |
| + " \"value\": {\n" |
| + " \"@type\": \"type.googleapis.com/json_test.TestAllTypes\",\n" |
| + " \"optionalInt32\": 1234\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| } |
| |
| @Test |
| public void testAnyFields() throws Exception { |
| TestAllTypes content = TestAllTypes.newBuilder().setOptionalInt32(1234).build(); |
| TestAny message = TestAny.newBuilder().setAnyValue(Any.pack(content)).build(); |
| |
| // A TypeRegistry must be provided in order to convert Any types. |
| try { |
| toJsonString(message); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasMessageThat().isEqualTo( |
| "Cannot find type for url: type.googleapis.com/json_test.TestAllTypes"); |
| } |
| |
| JsonFormat.TypeRegistry registry = |
| JsonFormat.TypeRegistry.newBuilder().add(TestAllTypes.getDescriptor()).build(); |
| JsonFormat.Printer printer = JsonFormat.printer().usingTypeRegistry(registry); |
| |
| assertThat(printer.print(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"anyValue\": {\n" |
| + " \"@type\": \"type.googleapis.com/json_test.TestAllTypes\",\n" |
| + " \"optionalInt32\": 1234\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(message, registry); |
| |
| TestAny messageWithDefaultAnyValue = |
| TestAny.newBuilder().setAnyValue(Any.getDefaultInstance()).build(); |
| assertThat(printer.print(messageWithDefaultAnyValue)) |
| .isEqualTo("{\n" + " \"anyValue\": {}\n" + "}"); |
| assertRoundTripEquals(messageWithDefaultAnyValue, registry); |
| |
| // Well-known types have a special formatting when embedded in Any. |
| // |
| // 1. Any in Any. |
| Any anyMessage = Any.pack(Any.pack(content)); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Any\",\n" |
| + " \"value\": {\n" |
| + " \"@type\": \"type.googleapis.com/json_test.TestAllTypes\",\n" |
| + " \"optionalInt32\": 1234\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| |
| // 2. Wrappers in Any. |
| anyMessage = Any.pack(Int32Value.of(12345)); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Int32Value\",\n" |
| + " \"value\": 12345\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| anyMessage = Any.pack(UInt32Value.of(12345)); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.UInt32Value\",\n" |
| + " \"value\": 12345\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| anyMessage = Any.pack(Int64Value.of(12345)); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Int64Value\",\n" |
| + " \"value\": \"12345\"\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| anyMessage = Any.pack(UInt64Value.of(12345)); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.UInt64Value\",\n" |
| + " \"value\": \"12345\"\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| anyMessage = Any.pack(FloatValue.of(12345)); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.FloatValue\",\n" |
| + " \"value\": 12345.0\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| anyMessage = Any.pack(DoubleValue.of(12345)); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.DoubleValue\",\n" |
| + " \"value\": 12345.0\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| anyMessage = Any.pack(BoolValue.of(true)); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.BoolValue\",\n" |
| + " \"value\": true\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| anyMessage = Any.pack(StringValue.of("Hello")); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.StringValue\",\n" |
| + " \"value\": \"Hello\"\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| anyMessage = Any.pack(BytesValue.of(ByteString.copyFrom(new byte[] {1, 2}))); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.BytesValue\",\n" |
| + " \"value\": \"AQI=\"\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| |
| // 3. Timestamp in Any. |
| anyMessage = Any.pack(Timestamps.parse("1969-12-31T23:59:59Z")); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Timestamp\",\n" |
| + " \"value\": \"1969-12-31T23:59:59Z\"\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| |
| // 4. Duration in Any |
| anyMessage = Any.pack(Durations.parse("12345.10s")); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n" |
| + " \"value\": \"12345.100s\"\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| |
| // 5. FieldMask in Any |
| anyMessage = Any.pack(FieldMaskUtil.fromString("foo.bar,baz")); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.FieldMask\",\n" |
| + " \"value\": \"foo.bar,baz\"\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| |
| // 6. Struct in Any |
| Struct.Builder structBuilder = Struct.newBuilder(); |
| structBuilder.putFields("number", Value.newBuilder().setNumberValue(1.125).build()); |
| anyMessage = Any.pack(structBuilder.build()); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Struct\",\n" |
| + " \"value\": {\n" |
| + " \"number\": 1.125\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| |
| // 7. Value (number type) in Any |
| Value.Builder valueBuilder = Value.newBuilder(); |
| valueBuilder.setNumberValue(1); |
| anyMessage = Any.pack(valueBuilder.build()); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Value\",\n" |
| + " \"value\": 1.0\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| |
| // 8. Value (null type) in Any |
| anyMessage = Any.pack(Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build()); |
| assertThat(printer.print(anyMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Value\",\n" |
| + " \"value\": null\n" |
| + "}"); |
| assertRoundTripEquals(anyMessage, registry); |
| } |
| |
| @Test |
| public void testAnyInMaps() throws Exception { |
| JsonFormat.TypeRegistry registry = |
| JsonFormat.TypeRegistry.newBuilder().add(TestAllTypes.getDescriptor()).build(); |
| JsonFormat.Printer printer = JsonFormat.printer().usingTypeRegistry(registry); |
| |
| TestAny.Builder testAny = TestAny.newBuilder(); |
| testAny.putAnyMap("int32_wrapper", Any.pack(Int32Value.of(123))); |
| testAny.putAnyMap("int64_wrapper", Any.pack(Int64Value.of(456))); |
| testAny.putAnyMap("timestamp", Any.pack(Timestamps.parse("1969-12-31T23:59:59Z"))); |
| testAny.putAnyMap("duration", Any.pack(Durations.parse("12345.1s"))); |
| testAny.putAnyMap("field_mask", Any.pack(FieldMaskUtil.fromString("foo.bar,baz"))); |
| Value numberValue = Value.newBuilder().setNumberValue(1.125).build(); |
| Struct.Builder struct = Struct.newBuilder(); |
| struct.putFields("number", numberValue); |
| testAny.putAnyMap("struct", Any.pack(struct.build())); |
| Value nullValue = Value.newBuilder().setNullValue(NullValue.NULL_VALUE).build(); |
| testAny.putAnyMap( |
| "list_value", |
| Any.pack(ListValue.newBuilder().addValues(numberValue).addValues(nullValue).build())); |
| testAny.putAnyMap("number_value", Any.pack(numberValue)); |
| testAny.putAnyMap("any_value_number", Any.pack(Any.pack(numberValue))); |
| testAny.putAnyMap("any_value_default", Any.pack(Any.getDefaultInstance())); |
| testAny.putAnyMap("default", Any.getDefaultInstance()); |
| |
| assertThat(printer.print(testAny.build())) |
| .isEqualTo( |
| "{\n" |
| + " \"anyMap\": {\n" |
| + " \"int32_wrapper\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Int32Value\",\n" |
| + " \"value\": 123\n" |
| + " },\n" |
| + " \"int64_wrapper\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Int64Value\",\n" |
| + " \"value\": \"456\"\n" |
| + " },\n" |
| + " \"timestamp\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Timestamp\",\n" |
| + " \"value\": \"1969-12-31T23:59:59Z\"\n" |
| + " },\n" |
| + " \"duration\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n" |
| + " \"value\": \"12345.100s\"\n" |
| + " },\n" |
| + " \"field_mask\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.FieldMask\",\n" |
| + " \"value\": \"foo.bar,baz\"\n" |
| + " },\n" |
| + " \"struct\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Struct\",\n" |
| + " \"value\": {\n" |
| + " \"number\": 1.125\n" |
| + " }\n" |
| + " },\n" |
| + " \"list_value\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.ListValue\",\n" |
| + " \"value\": [1.125, null]\n" |
| + " },\n" |
| + " \"number_value\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Value\",\n" |
| + " \"value\": 1.125\n" |
| + " },\n" |
| + " \"any_value_number\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Any\",\n" |
| + " \"value\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Value\",\n" |
| + " \"value\": 1.125\n" |
| + " }\n" |
| + " },\n" |
| + " \"any_value_default\": {\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.Any\",\n" |
| + " \"value\": {}\n" |
| + " },\n" |
| + " \"default\": {}\n" |
| + " }\n" |
| + "}"); |
| assertRoundTripEquals(testAny.build(), registry); |
| } |
| |
| @Test |
| public void testParserMissingTypeUrl() throws Exception { |
| try { |
| Any.Builder builder = Any.newBuilder(); |
| mergeFromJson("{\n" + " \"optionalInt32\": 1234\n" + "}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (IOException e) { |
| // Expected. |
| } |
| } |
| |
| @Test |
| public void testParserUnexpectedTypeUrl() throws Exception { |
| try { |
| Any.Builder builder = Any.newBuilder(); |
| mergeFromJson( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/json_test.UnexpectedTypes\",\n" |
| + " \"optionalInt32\": 12345\n" |
| + "}", |
| builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (IOException e) { |
| // Expected. |
| } |
| } |
| |
| @Test |
| public void testParserRejectTrailingComma() throws Exception { |
| try { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| mergeFromJson("{\n" + " \"optionalInt32\": 12345,\n" + "}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (IOException e) { |
| // Expected. |
| } |
| |
| try { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| mergeFromJson( |
| "{\n" |
| + " \"repeatedInt32\": [12345,]\n" |
| + "}", builder); |
| assertWithMessage("IOException expected.").fail(); |
| } catch (IOException e) { |
| // Expected. |
| } |
| } |
| |
| @Test |
| public void testParserRejectInvalidBase64() throws Exception { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| try { |
| mergeFromJson("{\"" + "optionalBytes" + "\":" + "!@#$" + "}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException expected) { |
| assertThat(expected).hasCauseThat().isNotNull(); |
| } |
| } |
| |
| @Test |
| public void testParserAcceptBase64Variants() throws Exception { |
| assertAccepts("optionalBytes", "AQI"); // No padding |
| assertAccepts("optionalBytes", "-_w"); // base64Url, no padding |
| } |
| |
| @Test |
| public void testParserRejectInvalidEnumValue() throws Exception { |
| try { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| mergeFromJson("{\n" + " \"optionalNestedEnum\": \"XXX\"\n" + "}", builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Expected. |
| } |
| } |
| |
| @Test |
| public void testParserUnknownFields() throws Exception { |
| try { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| String json = "{\n" + " \"unknownField\": \"XXX\"\n" + "}"; |
| JsonFormat.parser().merge(json, builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Expected. |
| } |
| } |
| |
| @Test |
| public void testParserIgnoringUnknownFields() throws Exception { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| String json = "{\n" + " \"unknownField\": \"XXX\"\n" + "}"; |
| JsonFormat.parser().ignoringUnknownFields().merge(json, builder); |
| } |
| |
| @Test |
| public void testParserIgnoringUnknownEnums() throws Exception { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| String json = "{\n" + " \"optionalNestedEnum\": \"XXX\"\n" + "}"; |
| JsonFormat.parser().ignoringUnknownFields().merge(json, builder); |
| assertThat(builder.getOptionalNestedEnumValue()).isEqualTo(0); |
| } |
| |
| @Test |
| public void testParserSupportAliasEnums() throws Exception { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| String json = "{\n" + " \"optionalAliasedEnum\": \"QUX\"\n" + "}"; |
| JsonFormat.parser().merge(json, builder); |
| assertThat(builder.getOptionalAliasedEnum()).isEqualTo(AliasedEnum.ALIAS_BAZ); |
| |
| builder = TestAllTypes.newBuilder(); |
| json = "{\n" + " \"optionalAliasedEnum\": \"qux\"\n" + "}"; |
| JsonFormat.parser().merge(json, builder); |
| assertThat(builder.getOptionalAliasedEnum()).isEqualTo(AliasedEnum.ALIAS_BAZ); |
| |
| builder = TestAllTypes.newBuilder(); |
| json = "{\n" + " \"optionalAliasedEnum\": \"bAz\"\n" + "}"; |
| JsonFormat.parser().merge(json, builder); |
| assertThat(builder.getOptionalAliasedEnum()).isEqualTo(AliasedEnum.ALIAS_BAZ); |
| } |
| |
| @Test |
| public void testUnknownEnumMap() throws Exception { |
| TestMap.Builder builder = TestMap.newBuilder(); |
| JsonFormat.parser() |
| .ignoringUnknownFields() |
| .merge("{\n" + " \"int32ToEnumMap\": {1: XXX, 2: FOO}" + "}", builder); |
| |
| assertThat(builder.getInt32ToEnumMapMap()).containsEntry(2, NestedEnum.FOO); |
| assertThat(builder.getInt32ToEnumMapMap()).hasSize(1); |
| } |
| |
| @Test |
| public void testRepeatedUnknownEnum() throws Exception { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| JsonFormat.parser() |
| .ignoringUnknownFields() |
| .merge("{\n" + " \"repeatedNestedEnum\": [XXX, FOO, BAR, BAZ]" + "}", builder); |
| |
| assertThat(builder.getRepeatedNestedEnum(0)).isEqualTo(NestedEnum.FOO); |
| assertThat(builder.getRepeatedNestedEnum(1)).isEqualTo(NestedEnum.BAR); |
| assertThat(builder.getRepeatedNestedEnum(2)).isEqualTo(NestedEnum.BAZ); |
| assertThat(builder.getRepeatedNestedEnumList()).hasSize(3); |
| } |
| |
| @Test |
| public void testParserIntegerEnumValue() throws Exception { |
| TestAllTypes.Builder actualBuilder = TestAllTypes.newBuilder(); |
| mergeFromJson("{\n" + " \"optionalNestedEnum\": 2\n" + "}", actualBuilder); |
| |
| TestAllTypes expected = TestAllTypes.newBuilder().setOptionalNestedEnum(NestedEnum.BAZ).build(); |
| assertThat(actualBuilder.build()).isEqualTo(expected); |
| } |
| |
| @Test |
| public void testCustomJsonName() throws Exception { |
| TestCustomJsonName message = TestCustomJsonName.newBuilder().setValue(12345).build(); |
| assertThat(JsonFormat.printer().print(message)) |
| .isEqualTo("{\n" + " \"@value\": 12345\n" + "}"); |
| assertRoundTripEquals(message); |
| } |
| |
| // Regression test for b/73832901. Make sure html tags are escaped. |
| @Test |
| public void testHtmlEscape() throws Exception { |
| TestAllTypes message = TestAllTypes.newBuilder().setOptionalString("</script>").build(); |
| assertThat(toJsonString(message)) |
| .isEqualTo("{\n \"optionalString\": \"\\u003c/script\\u003e\"\n}"); |
| |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| JsonFormat.parser().merge(toJsonString(message), builder); |
| assertThat(builder.getOptionalString()).isEqualTo(message.getOptionalString()); |
| } |
| |
| @Test |
| public void testIncludingDefaultValueFields() throws Exception { |
| TestAllTypes message = TestAllTypes.getDefaultInstance(); |
| assertThat(JsonFormat.printer().print(message)).isEqualTo("{\n}"); |
| assertThat(JsonFormat.printer().includingDefaultValueFields().print(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"optionalInt32\": 0,\n" |
| + " \"optionalInt64\": \"0\",\n" |
| + " \"optionalUint32\": 0,\n" |
| + " \"optionalUint64\": \"0\",\n" |
| + " \"optionalSint32\": 0,\n" |
| + " \"optionalSint64\": \"0\",\n" |
| + " \"optionalFixed32\": 0,\n" |
| + " \"optionalFixed64\": \"0\",\n" |
| + " \"optionalSfixed32\": 0,\n" |
| + " \"optionalSfixed64\": \"0\",\n" |
| + " \"optionalFloat\": 0.0,\n" |
| + " \"optionalDouble\": 0.0,\n" |
| + " \"optionalBool\": false,\n" |
| + " \"optionalString\": \"\",\n" |
| + " \"optionalBytes\": \"\",\n" |
| + " \"optionalNestedEnum\": \"FOO\",\n" |
| + " \"repeatedInt32\": [],\n" |
| + " \"repeatedInt64\": [],\n" |
| + " \"repeatedUint32\": [],\n" |
| + " \"repeatedUint64\": [],\n" |
| + " \"repeatedSint32\": [],\n" |
| + " \"repeatedSint64\": [],\n" |
| + " \"repeatedFixed32\": [],\n" |
| + " \"repeatedFixed64\": [],\n" |
| + " \"repeatedSfixed32\": [],\n" |
| + " \"repeatedSfixed64\": [],\n" |
| + " \"repeatedFloat\": [],\n" |
| + " \"repeatedDouble\": [],\n" |
| + " \"repeatedBool\": [],\n" |
| + " \"repeatedString\": [],\n" |
| + " \"repeatedBytes\": [],\n" |
| + " \"repeatedNestedMessage\": [],\n" |
| + " \"repeatedNestedEnum\": [],\n" |
| + " \"optionalAliasedEnum\": \"ALIAS_FOO\"\n" |
| + "}"); |
| |
| Set<FieldDescriptor> fixedFields = new HashSet<>(); |
| for (FieldDescriptor fieldDesc : TestAllTypes.getDescriptor().getFields()) { |
| if (fieldDesc.getName().contains("_fixed")) { |
| fixedFields.add(fieldDesc); |
| } |
| } |
| |
| assertThat(JsonFormat.printer().includingDefaultValueFields(fixedFields).print(message)) |
| .isEqualTo( |
| "{\n" |
| + " \"optionalFixed32\": 0,\n" |
| + " \"optionalFixed64\": \"0\",\n" |
| + " \"repeatedFixed32\": [],\n" |
| + " \"repeatedFixed64\": []\n" |
| + "}"); |
| |
| TestAllTypes messageNonDefaults = |
| message.toBuilder().setOptionalInt64(1234).setOptionalFixed32(3232).build(); |
| assertThat( |
| JsonFormat.printer().includingDefaultValueFields(fixedFields).print(messageNonDefaults)) |
| .isEqualTo( |
| "{\n" |
| + " \"optionalInt64\": \"1234\",\n" |
| + " \"optionalFixed32\": 3232,\n" |
| + " \"optionalFixed64\": \"0\",\n" |
| + " \"repeatedFixed32\": [],\n" |
| + " \"repeatedFixed64\": []\n" |
| + "}"); |
| |
| try { |
| JsonFormat.printer().includingDefaultValueFields().includingDefaultValueFields(); |
| assertWithMessage("IllegalStateException is expected.").fail(); |
| } catch (IllegalStateException e) { |
| // Expected. |
| assertWithMessage("Exception message should mention includingDefaultValueFields.") |
| .that(e.getMessage().contains("includingDefaultValueFields")) |
| .isTrue(); |
| } |
| |
| try { |
| JsonFormat.printer().includingDefaultValueFields().includingDefaultValueFields(fixedFields); |
| assertWithMessage("IllegalStateException is expected.").fail(); |
| } catch (IllegalStateException e) { |
| // Expected. |
| assertWithMessage("Exception message should mention includingDefaultValueFields.") |
| .that(e.getMessage().contains("includingDefaultValueFields")) |
| .isTrue(); |
| } |
| |
| try { |
| JsonFormat.printer().includingDefaultValueFields(fixedFields).includingDefaultValueFields(); |
| assertWithMessage("IllegalStateException is expected.").fail(); |
| } catch (IllegalStateException e) { |
| // Expected. |
| assertWithMessage("Exception message should mention includingDefaultValueFields.") |
| .that(e.getMessage().contains("includingDefaultValueFields")) |
| .isTrue(); |
| } |
| |
| try { |
| JsonFormat.printer() |
| .includingDefaultValueFields(fixedFields) |
| .includingDefaultValueFields(fixedFields); |
| assertWithMessage("IllegalStateException is expected.").fail(); |
| } catch (IllegalStateException e) { |
| // Expected. |
| assertWithMessage("Exception message should mention includingDefaultValueFields.") |
| .that(e.getMessage().contains("includingDefaultValueFields")) |
| .isTrue(); |
| } |
| |
| Set<FieldDescriptor> intFields = new HashSet<>(); |
| for (FieldDescriptor fieldDesc : TestAllTypes.getDescriptor().getFields()) { |
| if (fieldDesc.getName().contains("_int")) { |
| intFields.add(fieldDesc); |
| } |
| } |
| |
| try { |
| JsonFormat.printer() |
| .includingDefaultValueFields(intFields) |
| .includingDefaultValueFields(fixedFields); |
| assertWithMessage("IllegalStateException is expected.").fail(); |
| } catch (IllegalStateException e) { |
| // Expected. |
| assertWithMessage("Exception message should mention includingDefaultValueFields.") |
| .that(e.getMessage().contains("includingDefaultValueFields")) |
| .isTrue(); |
| } |
| |
| try { |
| JsonFormat.printer().includingDefaultValueFields(null); |
| assertWithMessage("IllegalArgumentException is expected.").fail(); |
| } catch (IllegalArgumentException e) { |
| // Expected. |
| assertWithMessage("Exception message should mention includingDefaultValueFields.") |
| .that(e.getMessage().contains("includingDefaultValueFields")) |
| .isTrue(); |
| } |
| |
| try { |
| JsonFormat.printer().includingDefaultValueFields(Collections.<FieldDescriptor>emptySet()); |
| assertWithMessage("IllegalArgumentException is expected.").fail(); |
| } catch (IllegalArgumentException e) { |
| // Expected. |
| assertWithMessage("Exception message should mention includingDefaultValueFields.") |
| .that(e.getMessage().contains("includingDefaultValueFields")) |
| .isTrue(); |
| } |
| |
| TestMap mapMessage = TestMap.getDefaultInstance(); |
| assertThat(JsonFormat.printer().print(mapMessage)).isEqualTo("{\n}"); |
| assertThat(JsonFormat.printer().includingDefaultValueFields().print(mapMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"int32ToInt32Map\": {\n" |
| + " },\n" |
| + " \"int64ToInt32Map\": {\n" |
| + " },\n" |
| + " \"uint32ToInt32Map\": {\n" |
| + " },\n" |
| + " \"uint64ToInt32Map\": {\n" |
| + " },\n" |
| + " \"sint32ToInt32Map\": {\n" |
| + " },\n" |
| + " \"sint64ToInt32Map\": {\n" |
| + " },\n" |
| + " \"fixed32ToInt32Map\": {\n" |
| + " },\n" |
| + " \"fixed64ToInt32Map\": {\n" |
| + " },\n" |
| + " \"sfixed32ToInt32Map\": {\n" |
| + " },\n" |
| + " \"sfixed64ToInt32Map\": {\n" |
| + " },\n" |
| + " \"boolToInt32Map\": {\n" |
| + " },\n" |
| + " \"stringToInt32Map\": {\n" |
| + " },\n" |
| + " \"int32ToInt64Map\": {\n" |
| + " },\n" |
| + " \"int32ToUint32Map\": {\n" |
| + " },\n" |
| + " \"int32ToUint64Map\": {\n" |
| + " },\n" |
| + " \"int32ToSint32Map\": {\n" |
| + " },\n" |
| + " \"int32ToSint64Map\": {\n" |
| + " },\n" |
| + " \"int32ToFixed32Map\": {\n" |
| + " },\n" |
| + " \"int32ToFixed64Map\": {\n" |
| + " },\n" |
| + " \"int32ToSfixed32Map\": {\n" |
| + " },\n" |
| + " \"int32ToSfixed64Map\": {\n" |
| + " },\n" |
| + " \"int32ToFloatMap\": {\n" |
| + " },\n" |
| + " \"int32ToDoubleMap\": {\n" |
| + " },\n" |
| + " \"int32ToBoolMap\": {\n" |
| + " },\n" |
| + " \"int32ToStringMap\": {\n" |
| + " },\n" |
| + " \"int32ToBytesMap\": {\n" |
| + " },\n" |
| + " \"int32ToMessageMap\": {\n" |
| + " },\n" |
| + " \"int32ToEnumMap\": {\n" |
| + " }\n" |
| + "}"); |
| |
| TestOneof oneofMessage = TestOneof.getDefaultInstance(); |
| assertThat(JsonFormat.printer().print(oneofMessage)).isEqualTo("{\n}"); |
| assertThat(JsonFormat.printer().includingDefaultValueFields().print(oneofMessage)) |
| .isEqualTo("{\n}"); |
| |
| oneofMessage = TestOneof.newBuilder().setOneofInt32(42).build(); |
| assertThat(JsonFormat.printer().print(oneofMessage)).isEqualTo("{\n \"oneofInt32\": 42\n}"); |
| assertThat(JsonFormat.printer().includingDefaultValueFields().print(oneofMessage)) |
| .isEqualTo("{\n \"oneofInt32\": 42\n}"); |
| |
| TestOneof.Builder oneofBuilder = TestOneof.newBuilder(); |
| mergeFromJson("{\n" + " \"oneofNullValue\": null \n" + "}", oneofBuilder); |
| oneofMessage = oneofBuilder.build(); |
| assertThat(JsonFormat.printer().print(oneofMessage)) |
| .isEqualTo("{\n \"oneofNullValue\": null\n}"); |
| assertThat(JsonFormat.printer().includingDefaultValueFields().print(oneofMessage)) |
| .isEqualTo("{\n \"oneofNullValue\": null\n}"); |
| } |
| |
| @Test |
| public void testPreservingProtoFieldNames() throws Exception { |
| TestAllTypes message = TestAllTypes.newBuilder().setOptionalInt32(12345).build(); |
| assertThat(JsonFormat.printer().print(message)) |
| .isEqualTo("{\n" + " \"optionalInt32\": 12345\n" + "}"); |
| assertThat(JsonFormat.printer().preservingProtoFieldNames().print(message)) |
| .isEqualTo("{\n" + " \"optional_int32\": 12345\n" + "}"); |
| |
| // The json_name field option is ignored when configured to use original proto field names. |
| TestCustomJsonName messageWithCustomJsonName = |
| TestCustomJsonName.newBuilder().setValue(12345).build(); |
| assertThat(JsonFormat.printer().preservingProtoFieldNames().print(messageWithCustomJsonName)) |
| .isEqualTo("{\n" + " \"value\": 12345\n" + "}"); |
| |
| // Parsers accept both original proto field names and lowerCamelCase names. |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| JsonFormat.parser().merge("{\"optionalInt32\": 12345}", builder); |
| assertThat(builder.getOptionalInt32()).isEqualTo(12345); |
| builder.clear(); |
| JsonFormat.parser().merge("{\"optional_int32\": 54321}", builder); |
| assertThat(builder.getOptionalInt32()).isEqualTo(54321); |
| } |
| |
| @Test |
| public void testPrintingEnumsAsInts() throws Exception { |
| TestAllTypes message = TestAllTypes.newBuilder().setOptionalNestedEnum(NestedEnum.BAR).build(); |
| assertThat(JsonFormat.printer().printingEnumsAsInts().print(message)) |
| .isEqualTo("{\n" + " \"optionalNestedEnum\": 1\n" + "}"); |
| } |
| |
| @Test |
| public void testOmittingInsignificantWhiteSpace() throws Exception { |
| TestAllTypes message = TestAllTypes.newBuilder().setOptionalInt32(12345).build(); |
| assertThat(JsonFormat.printer().omittingInsignificantWhitespace().print(message)) |
| .isEqualTo("{" + "\"optionalInt32\":12345" + "}"); |
| TestAllTypes message1 = TestAllTypes.getDefaultInstance(); |
| assertThat(JsonFormat.printer().omittingInsignificantWhitespace().print(message1)) |
| .isEqualTo("{}"); |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| setAllFields(builder); |
| TestAllTypes message2 = builder.build(); |
| assertThat(toCompactJsonString(message2)) |
| .isEqualTo( |
| "{" |
| + "\"optionalInt32\":1234," |
| + "\"optionalInt64\":\"1234567890123456789\"," |
| + "\"optionalUint32\":5678," |
| + "\"optionalUint64\":\"2345678901234567890\"," |
| + "\"optionalSint32\":9012," |
| + "\"optionalSint64\":\"3456789012345678901\"," |
| + "\"optionalFixed32\":3456," |
| + "\"optionalFixed64\":\"4567890123456789012\"," |
| + "\"optionalSfixed32\":7890," |
| + "\"optionalSfixed64\":\"5678901234567890123\"," |
| + "\"optionalFloat\":1.5," |
| + "\"optionalDouble\":1.25," |
| + "\"optionalBool\":true," |
| + "\"optionalString\":\"Hello world!\"," |
| + "\"optionalBytes\":\"AAEC\"," |
| + "\"optionalNestedMessage\":{" |
| + "\"value\":100" |
| + "}," |
| + "\"optionalNestedEnum\":\"BAR\"," |
| + "\"repeatedInt32\":[1234,234]," |
| + "\"repeatedInt64\":[\"1234567890123456789\",\"234567890123456789\"]," |
| + "\"repeatedUint32\":[5678,678]," |
| + "\"repeatedUint64\":[\"2345678901234567890\",\"345678901234567890\"]," |
| + "\"repeatedSint32\":[9012,10]," |
| + "\"repeatedSint64\":[\"3456789012345678901\",\"456789012345678901\"]," |
| + "\"repeatedFixed32\":[3456,456]," |
| + "\"repeatedFixed64\":[\"4567890123456789012\",\"567890123456789012\"]," |
| + "\"repeatedSfixed32\":[7890,890]," |
| + "\"repeatedSfixed64\":[\"5678901234567890123\",\"678901234567890123\"]," |
| + "\"repeatedFloat\":[1.5,11.5]," |
| + "\"repeatedDouble\":[1.25,11.25]," |
| + "\"repeatedBool\":[true,true]," |
| + "\"repeatedString\":[\"Hello world!\",\"ello world!\"]," |
| + "\"repeatedBytes\":[\"AAEC\",\"AQI=\"]," |
| + "\"repeatedNestedMessage\":[{" |
| + "\"value\":100" |
| + "},{" |
| + "\"value\":200" |
| + "}]," |
| + "\"repeatedNestedEnum\":[\"BAR\",\"BAZ\"]" |
| + "}"); |
| } |
| |
| // Regression test for b/29892357 |
| @Test |
| public void testEmptyWrapperTypesInAny() throws Exception { |
| JsonFormat.TypeRegistry registry = |
| JsonFormat.TypeRegistry.newBuilder().add(TestAllTypes.getDescriptor()).build(); |
| JsonFormat.Parser parser = JsonFormat.parser().usingTypeRegistry(registry); |
| |
| Any.Builder builder = Any.newBuilder(); |
| parser.merge( |
| "{\n" |
| + " \"@type\": \"type.googleapis.com/google.protobuf.BoolValue\",\n" |
| + " \"value\": false\n" |
| + "}\n", |
| builder); |
| Any any = builder.build(); |
| assertThat(any.getValue().size()).isEqualTo(0); |
| } |
| |
| @Test |
| public void testRecursionLimit() throws Exception { |
| String input = |
| "{\n" |
| + " \"nested\": {\n" |
| + " \"nested\": {\n" |
| + " \"nested\": {\n" |
| + " \"nested\": {\n" |
| + " \"value\": 1234\n" |
| + " }\n" |
| + " }\n" |
| + " }\n" |
| + " }\n" |
| + "}\n"; |
| |
| JsonFormat.Parser parser = JsonFormat.parser(); |
| TestRecursive.Builder builder = TestRecursive.newBuilder(); |
| parser.merge(input, builder); |
| TestRecursive message = builder.build(); |
| assertThat(message.getNested().getNested().getNested().getNested().getValue()).isEqualTo(1234); |
| |
| parser = JsonFormat.parser().usingRecursionLimit(3); |
| builder = TestRecursive.newBuilder(); |
| try { |
| parser.merge(input, builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| // Expected. |
| } |
| } |
| |
| // Test that we are not leaking out JSON exceptions. |
| @Test |
| public void testJsonException_forwardsIOException() throws Exception { |
| InputStream throwingInputStream = |
| new InputStream() { |
| @Override |
| public int read() throws IOException { |
| throw new IOException("12345"); |
| } |
| }; |
| InputStreamReader throwingReader = new InputStreamReader(throwingInputStream); |
| // When the underlying reader throws IOException, JsonFormat should forward |
| // through this IOException. |
| try { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| JsonFormat.parser().merge(throwingReader, builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (IOException e) { |
| assertThat(e).hasMessageThat().isEqualTo("12345"); |
| } |
| } |
| |
| @Test |
| public void testJsonException_forwardsJsonException() throws Exception { |
| Reader invalidJsonReader = new StringReader("{ xxx - yyy }"); |
| // When the JSON parser throws parser exceptions, JsonFormat should turn |
| // that into InvalidProtocolBufferException. |
| try { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| JsonFormat.parser().merge(invalidJsonReader, builder); |
| assertWithMessage("Exception is expected.").fail(); |
| } catch (InvalidProtocolBufferException e) { |
| assertThat(e.getCause()).isInstanceOf(JsonSyntaxException.class); |
| } |
| } |
| |
| // Test that an error is thrown if a nested JsonObject is parsed as a primitive field. |
| @Test |
| public void testJsonObjectForPrimitiveField() throws Exception { |
| TestAllTypes.Builder builder = TestAllTypes.newBuilder(); |
| try { |
| mergeFromJson( |
| "{\n" |
| + " \"optionalString\": {\n" |
| + " \"invalidNestedString\": \"Hello world\"\n" |
| + " }\n" |
| + "}\n", |
| builder); |
| } catch (InvalidProtocolBufferException e) { |
| // Expected. |
| } |
| } |
| |
| @Test |
| public void testSortedMapKeys() throws Exception { |
| TestMap.Builder mapBuilder = TestMap.newBuilder(); |
| mapBuilder.putStringToInt32Map("\ud834\udd20", 3); // utf-8 F0 9D 84 A0 |
| mapBuilder.putStringToInt32Map("foo", 99); |
| mapBuilder.putStringToInt32Map("xxx", 123); |
| mapBuilder.putStringToInt32Map("\u20ac", 1); // utf-8 E2 82 AC |
| mapBuilder.putStringToInt32Map("abc", 20); |
| mapBuilder.putStringToInt32Map("19", 19); |
| mapBuilder.putStringToInt32Map("8", 8); |
| mapBuilder.putStringToInt32Map("\ufb00", 2); // utf-8 EF AC 80 |
| mapBuilder.putInt32ToInt32Map(3, 3); |
| mapBuilder.putInt32ToInt32Map(10, 10); |
| mapBuilder.putInt32ToInt32Map(5, 5); |
| mapBuilder.putInt32ToInt32Map(4, 4); |
| mapBuilder.putInt32ToInt32Map(1, 1); |
| mapBuilder.putInt32ToInt32Map(2, 2); |
| mapBuilder.putInt32ToInt32Map(-3, -3); |
| TestMap mapMessage = mapBuilder.build(); |
| assertThat(toSortedJsonString(mapMessage)) |
| .isEqualTo( |
| "{\n" |
| + " \"int32ToInt32Map\": {\n" |
| + " \"-3\": -3,\n" |
| + " \"1\": 1,\n" |
| + " \"2\": 2,\n" |
| + " \"3\": 3,\n" |
| + " \"4\": 4,\n" |
| + " \"5\": 5,\n" |
| + " \"10\": 10\n" |
| + " },\n" |
| + " \"stringToInt32Map\": {\n" |
| + " \"19\": 19,\n" |
| + " \"8\": 8,\n" |
| + " \"abc\": 20,\n" |
| + " \"foo\": 99,\n" |
| + " \"xxx\": 123,\n" |
| + " \"\u20ac\": 1,\n" |
| + " \"\ufb00\": 2,\n" |
| + " \"\ud834\udd20\": 3\n" |
| + " }\n" |
| + "}"); |
| |
| TestMap emptyMap = TestMap.getDefaultInstance(); |
| assertThat(toSortedJsonString(emptyMap)).isEqualTo("{\n}"); |
| } |
| |
| @Test |
| public void testPrintingEnumsAsIntsChainedAfterIncludingDefaultValueFields() throws Exception { |
| TestAllTypes message = TestAllTypes.newBuilder().setOptionalBool(false).build(); |
| |
| assertThat( |
| JsonFormat.printer() |
| .includingDefaultValueFields( |
| ImmutableSet.of( |
| message.getDescriptorForType().findFieldByName("optional_bool"))) |
| .printingEnumsAsInts() |
| .print(message)) |
| .isEqualTo("{\n" + " \"optionalBool\": false\n" + "}"); |
| } |
| |
| @Test |
| public void testPreservesFloatingPointNegative0() throws Exception { |
| TestAllTypes message = |
| TestAllTypes.newBuilder().setOptionalFloat(-0.0f).setOptionalDouble(-0.0).build(); |
| assertThat(JsonFormat.printer().print(message)) |
| .isEqualTo("{\n \"optionalFloat\": -0.0,\n \"optionalDouble\": -0.0\n}"); |
| } |
| } |
