← Back to branch summary

~ubuntu-branches/debian/stretch/protobuf/stretch

« back to all changes in this revision

Viewing changes to java/src/test/java/com/google/protobuf/TextFormatTest.java

  • Committer: Package Import Robot
  • Author(s): Robert S. Edmonds
  • Date: 2014-09-11 22:50:10 UTC
  • mfrom: (10.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20140911225010-wt4yo9dpc1fzuq5g
Tags: 2.6.0-3
Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
java/src/test/java/com/google/protobuf/TextFormatTest.java
31
31
package com.google.protobuf;
32
32
 
33
33
import com.google.protobuf.Descriptors.FieldDescriptor;
 
34
import com.google.protobuf.TextFormat.Parser.SingularOverwritePolicy;
34
35
import protobuf_unittest.UnittestMset.TestMessageSet;
35
36
import protobuf_unittest.UnittestMset.TestMessageSetExtension1;
36
37
import protobuf_unittest.UnittestMset.TestMessageSetExtension2;
39
40
import protobuf_unittest.UnittestProto.TestAllTypes;
40
41
import protobuf_unittest.UnittestProto.TestAllTypes.NestedMessage;
41
42
import protobuf_unittest.UnittestProto.TestEmptyMessage;
 
43
import protobuf_unittest.UnittestProto.TestOneof2;
42
44
 
43
45
import junit.framework.TestCase;
44
46
 
64
66
          + "and \\t tabs and \\001 slashes \\\\";
65
67
 
66
68
  private static String allFieldsSetText = TestUtil.readTextFromFile(
67
 
    "text_format_unittest_data.txt");
 
69
    "text_format_unittest_data_oneof_implemented.txt");
68
70
  private static String allExtensionsSetText = TestUtil.readTextFromFile(
69
71
    "text_format_unittest_extensions_data.txt");
70
72
 
109
111
    "  str: \"foo\"\n" +
110
112
    "}\n";
111
113
 
 
114
  private String messageSetTextWithRepeatedExtension =
 
115
      "[protobuf_unittest.TestMessageSetExtension1] {\n" +
 
116
      "  i: 123\n" +
 
117
      "}\n" +
 
118
      "[protobuf_unittest.TestMessageSetExtension1] {\n" +
 
119
      "  i: 456\n" +
 
120
      "}\n";
 
121
 
 
122
  private final TextFormat.Parser parserWithOverwriteForbidden =
 
123
      TextFormat.Parser.newBuilder()
 
124
          .setSingularOverwritePolicy(
 
125
              SingularOverwritePolicy.FORBID_SINGULAR_OVERWRITES)
 
126
          .build();
 
127
 
 
128
  private final TextFormat.Parser defaultParser =
 
129
      TextFormat.Parser.newBuilder().build();
 
130
 
112
131
  /** Print TestAllTypes and compare with golden file. */
113
132
  public void testPrintMessage() throws Exception {
114
133
    String javaText = TextFormat.printToString(TestUtil.getAllSet());
250
269
 
251
270
      .addRepeatedInt32 (1  << 31)
252
271
      .addRepeatedUint32(1  << 31)
253
 
      .addRepeatedInt64 (1l << 63)
254
 
      .addRepeatedUint64(1l << 63)
 
272
      .addRepeatedInt64 (1L << 63)
 
273
      .addRepeatedUint64(1L << 63)
255
274
 
256
275
      // Floats of various precisions and exponents.
257
276
      .addRepeatedDouble(123)
371
390
      TestMessageSetExtension2.messageSetExtension));
372
391
    assertEquals("foo", messageSet.getExtension(
373
392
      TestMessageSetExtension2.messageSetExtension).getStr());
 
393
 
 
394
    builder = TestMessageSet.newBuilder();
 
395
    TextFormat.merge(messageSetTextWithRepeatedExtension, extensionRegistry,
 
396
        builder);
 
397
    messageSet = builder.build();
 
398
    assertEquals(456, messageSet.getExtension(
 
399
      TestMessageSetExtension1.messageSetExtension).getI());
 
400
  }
 
401
 
 
402
  public void testParseMessageSetWithOverwriteForbidden() throws Exception {
 
403
    ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance();
 
404
    extensionRegistry.add(TestMessageSetExtension1.messageSetExtension);
 
405
    extensionRegistry.add(TestMessageSetExtension2.messageSetExtension);
 
406
 
 
407
    TestMessageSet.Builder builder = TestMessageSet.newBuilder();
 
408
    parserWithOverwriteForbidden.merge(
 
409
        messageSetText, extensionRegistry, builder);
 
410
    TestMessageSet messageSet = builder.build();
 
411
    assertEquals(123, messageSet.getExtension(
 
412
        TestMessageSetExtension1.messageSetExtension).getI());
 
413
    assertEquals("foo", messageSet.getExtension(
 
414
      TestMessageSetExtension2.messageSetExtension).getStr());
 
415
 
 
416
    builder = TestMessageSet.newBuilder();
 
417
    try {
 
418
      parserWithOverwriteForbidden.merge(
 
419
          messageSetTextWithRepeatedExtension, extensionRegistry, builder);
 
420
      fail("expected parse exception");
 
421
    } catch (TextFormat.ParseException e) {
 
422
      assertEquals("6:1: Non-repeated field "
 
423
          + "\"protobuf_unittest.TestMessageSetExtension1.message_set_extension\""
 
424
          + " cannot be overwritten.",
 
425
          e.getMessage());
 
426
    }
374
427
  }
375
428
 
376
429
  public void testParseNumericEnum() throws Exception {
407
460
    }
408
461
  }
409
462
 
 
463
  private void assertParseErrorWithOverwriteForbidden(String error,
 
464
      String text) {
 
465
    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 
466
    try {
 
467
      parserWithOverwriteForbidden.merge(
 
468
          text, TestUtil.getExtensionRegistry(), builder);
 
469
      fail("Expected parse exception.");
 
470
    } catch (TextFormat.ParseException e) {
 
471
      assertEquals(error, e.getMessage());
 
472
    }
 
473
  }
 
474
 
 
475
  private TestAllTypes assertParseSuccessWithOverwriteForbidden(
 
476
      String text) throws TextFormat.ParseException {
 
477
    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 
478
    parserWithOverwriteForbidden.merge(
 
479
        text, TestUtil.getExtensionRegistry(), builder);
 
480
    return builder.build();
 
481
  }
 
482
 
410
483
  public void testParseErrors() throws Exception {
411
484
    assertParseError(
412
485
      "1:16: Expected \":\".",
413
486
      "optional_int32 123");
414
487
    assertParseError(
415
 
      "1:23: Expected identifier.",
 
488
      "1:23: Expected identifier. Found '?'",
416
489
      "optional_nested_enum: ?");
417
490
    assertParseError(
418
491
      "1:18: Couldn't parse integer: Number must be positive: -1",
469
542
 
470
543
    // Delimiters must match.
471
544
    assertParseError(
472
 
      "1:22: Expected identifier.",
 
545
      "1:22: Expected identifier. Found '}'",
473
546
      "OptionalGroup < a: 1 }");
474
547
    assertParseError(
475
 
      "1:22: Expected identifier.",
 
548
      "1:22: Expected identifier. Found '>'",
476
549
      "OptionalGroup { a: 1 >");
477
550
  }
478
551
 
762
835
        TextFormat.shortDebugString(makeUnknownFieldSet()));
763
836
  }
764
837
 
765
 
  public void testPrintToUnicodeString() {
 
838
  public void testPrintToUnicodeString() throws Exception {
766
839
    assertEquals(
767
840
        "optional_string: \"abc\u3042efg\"\n" +
768
841
        "optional_bytes: \"\\343\\201\\202\"\n" +
772
845
            .setOptionalBytes(bytes(0xe3, 0x81, 0x82))
773
846
            .addRepeatedString("\u3093XYZ")
774
847
            .build()));
 
848
 
 
849
    // Double quotes and backslashes should be escaped
 
850
    assertEquals(
 
851
        "optional_string: \"a\\\\bc\\\"ef\\\"g\"\n",
 
852
        TextFormat.printToUnicodeString(TestAllTypes.newBuilder()
 
853
            .setOptionalString("a\\bc\"ef\"g")
 
854
            .build()));
 
855
 
 
856
    // Test escaping roundtrip
 
857
    TestAllTypes message = TestAllTypes.newBuilder()
 
858
        .setOptionalString("a\\bc\\\"ef\"g")
 
859
        .build();
 
860
    TestAllTypes.Builder builder = TestAllTypes.newBuilder();
 
861
    TextFormat.merge(TextFormat.printToUnicodeString(message), builder);
 
862
    assertEquals(message.getOptionalString(), builder.getOptionalString());
 
863
  }
 
864
  
 
865
  public void testPrintToUnicodeStringWithNewlines() {
 
866
    // No newlines at start and end
 
867
    assertEquals("optional_string: \"test newlines\n\nin\nstring\"\n",
 
868
        TextFormat.printToUnicodeString(TestAllTypes.newBuilder()
 
869
            .setOptionalString("test newlines\n\nin\nstring")
 
870
            .build()));
 
871
 
 
872
    // Newlines at start and end
 
873
    assertEquals("optional_string: \"\ntest\nnewlines\n\nin\nstring\n\"\n",
 
874
        TextFormat.printToUnicodeString(TestAllTypes.newBuilder()
 
875
            .setOptionalString("\ntest\nnewlines\n\nin\nstring\n")
 
876
            .build()));
 
877
 
 
878
    // Strings with 0, 1 and 2 newlines.
 
879
    assertEquals("optional_string: \"\"\n",
 
880
        TextFormat.printToUnicodeString(TestAllTypes.newBuilder()
 
881
            .setOptionalString("")
 
882
            .build()));
 
883
    assertEquals("optional_string: \"\n\"\n",
 
884
        TextFormat.printToUnicodeString(TestAllTypes.newBuilder()
 
885
            .setOptionalString("\n")
 
886
            .build()));
 
887
    assertEquals("optional_string: \"\n\n\"\n",
 
888
        TextFormat.printToUnicodeString(TestAllTypes.newBuilder()
 
889
            .setOptionalString("\n\n")
 
890
            .build()));
775
891
  }
776
892
 
777
893
  public void testPrintToUnicodeString_unknown() {
783
899
                .addLengthDelimited(bytes(0xe3, 0x81, 0x82)).build())
784
900
            .build()));
785
901
  }
 
902
 
 
903
  public void testParseNonRepeatedFields() throws Exception {
 
904
    assertParseSuccessWithOverwriteForbidden(
 
905
        "repeated_int32: 1\n" +
 
906
        "repeated_int32: 2\n");
 
907
    assertParseSuccessWithOverwriteForbidden(
 
908
        "RepeatedGroup { a: 1 }\n" +
 
909
        "RepeatedGroup { a: 2 }\n");
 
910
    assertParseSuccessWithOverwriteForbidden(
 
911
        "repeated_nested_message { bb: 1 }\n" +
 
912
        "repeated_nested_message { bb: 2 }\n");
 
913
    assertParseErrorWithOverwriteForbidden(
 
914
        "3:17: Non-repeated field " +
 
915
        "\"protobuf_unittest.TestAllTypes.optional_int32\" " +
 
916
        "cannot be overwritten.",
 
917
        "optional_int32: 1\n" +
 
918
        "optional_bool: true\n" +
 
919
        "optional_int32: 1\n");
 
920
    assertParseErrorWithOverwriteForbidden(
 
921
        "2:17: Non-repeated field " +
 
922
        "\"protobuf_unittest.TestAllTypes.optionalgroup\" " +
 
923
        "cannot be overwritten.",
 
924
        "OptionalGroup { a: 1 }\n" +
 
925
        "OptionalGroup { }\n");
 
926
    assertParseErrorWithOverwriteForbidden(
 
927
        "2:33: Non-repeated field " +
 
928
        "\"protobuf_unittest.TestAllTypes.optional_nested_message\" " +
 
929
        "cannot be overwritten.",
 
930
        "optional_nested_message { }\n" +
 
931
        "optional_nested_message { bb: 3 }\n");
 
932
    assertParseErrorWithOverwriteForbidden(
 
933
        "2:16: Non-repeated field " +
 
934
        "\"protobuf_unittest.TestAllTypes.default_int32\" " +
 
935
        "cannot be overwritten.",
 
936
        "default_int32: 41\n" +  // the default value
 
937
        "default_int32: 41\n");
 
938
    assertParseErrorWithOverwriteForbidden(
 
939
        "2:17: Non-repeated field " +
 
940
        "\"protobuf_unittest.TestAllTypes.default_string\" " +
 
941
        "cannot be overwritten.",
 
942
        "default_string: \"zxcv\"\n" +
 
943
        "default_string: \"asdf\"\n");
 
944
  }
 
945
 
 
946
  public void testParseShortRepeatedFormOfRepeatedFields() throws Exception {
 
947
    assertParseSuccessWithOverwriteForbidden("repeated_foreign_enum: [FOREIGN_FOO, FOREIGN_BAR]");
 
948
    assertParseSuccessWithOverwriteForbidden("repeated_int32: [ 1, 2 ]\n");
 
949
    assertParseSuccessWithOverwriteForbidden("RepeatedGroup [{ a: 1 },{ a: 2 }]\n");
 
950
    assertParseSuccessWithOverwriteForbidden("repeated_nested_message [{ bb: 1 }, { bb: 2 }]\n");
 
951
  }
 
952
 
 
953
  public void testParseShortRepeatedFormOfNonRepeatedFields() throws Exception {
 
954
    assertParseErrorWithOverwriteForbidden(
 
955
        "1:17: Couldn't parse integer: For input string: \"[\"",
 
956
        "optional_int32: [1]\n");
 
957
  }
 
958
 
 
959
  // =======================================================================
 
960
  // test oneof
 
961
 
 
962
  public void testOneofTextFormat() throws Exception {
 
963
    TestOneof2.Builder builder = TestOneof2.newBuilder();
 
964
    TestUtil.setOneof(builder);
 
965
    TestOneof2 message = builder.build();
 
966
    TestOneof2.Builder dest = TestOneof2.newBuilder();
 
967
    TextFormat.merge(TextFormat.printToUnicodeString(message), dest);
 
968
    TestUtil.assertOneofSet(dest.build());
 
969
  }
 
970
 
 
971
  public void testOneofOverwriteForbidden() throws Exception {
 
972
    String input = "foo_string: \"stringvalue\" foo_int: 123";
 
973
    TestOneof2.Builder builder = TestOneof2.newBuilder();
 
974
    try {
 
975
      parserWithOverwriteForbidden.merge(
 
976
          input, TestUtil.getExtensionRegistry(), builder);
 
977
      fail("Expected parse exception.");
 
978
    } catch (TextFormat.ParseException e) {
 
979
      assertEquals("1:36: Field \"protobuf_unittest.TestOneof2.foo_int\""
 
980
                   + " is specified along with field \"protobuf_unittest.TestOneof2.foo_string\","
 
981
                   + " another member of oneof \"foo\".", e.getMessage());
 
982
    }
 
983
  }
 
984
 
 
985
  public void testOneofOverwriteAllowed() throws Exception {
 
986
    String input = "foo_string: \"stringvalue\" foo_int: 123";
 
987
    TestOneof2.Builder builder = TestOneof2.newBuilder();
 
988
    defaultParser.merge(input, TestUtil.getExtensionRegistry(), builder);
 
989
    // Only the last value sticks.
 
990
    TestOneof2 oneof = builder.build();
 
991
    assertFalse(oneof.hasFooString());
 
992
    assertTrue(oneof.hasFooInt());
 
993
  }
786
994
}