← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/protobuf/oneiric

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Iustin Pop
  • Date: 2008-08-03 11:01:44 UTC
  • Revision ID: james.westby@ubuntu.com-20080803110144-uyiw41bf1m2oe17t
Tags: upstream-2.0.0~b
Import upstream version 2.0.0~b

Show diffs side-by-side

added added

removed removed

Lines of Context:
java/src/test/java/com/google/protobuf/WireFormatTest.java
 
1
// Protocol Buffers - Google's data interchange format
 
2
// Copyright 2008 Google Inc.
 
3
// http://code.google.com/p/protobuf/
 
4
//
 
5
// Licensed under the Apache License, Version 2.0 (the "License");
 
6
// you may not use this file except in compliance with the License.
 
7
// You may obtain a copy of the License at
 
8
//
 
9
//      http://www.apache.org/licenses/LICENSE-2.0
 
10
//
 
11
// Unless required by applicable law or agreed to in writing, software
 
12
// distributed under the License is distributed on an "AS IS" BASIS,
 
13
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
14
// See the License for the specific language governing permissions and
 
15
// limitations under the License.
 
16
 
 
17
package com.google.protobuf;
 
18
 
 
19
import junit.framework.TestCase;
 
20
import protobuf_unittest.UnittestProto;
 
21
import protobuf_unittest.UnittestProto.TestAllTypes;
 
22
import protobuf_unittest.UnittestProto.TestAllExtensions;
 
23
import protobuf_unittest.UnittestProto.TestFieldOrderings;
 
24
import protobuf_unittest.UnittestMset.TestMessageSet;
 
25
import protobuf_unittest.UnittestMset.RawMessageSet;
 
26
import protobuf_unittest.UnittestMset.TestMessageSetExtension1;
 
27
import protobuf_unittest.UnittestMset.TestMessageSetExtension2;
 
28
 
 
29
/**
 
30
 * Tests related to parsing and serialization.
 
31
 *
 
32
 * @author kenton@google.com (Kenton Varda)
 
33
 */
 
34
public class WireFormatTest extends TestCase {
 
35
  public void testSerialization() throws Exception {
 
36
    TestAllTypes message = TestUtil.getAllSet();
 
37
 
 
38
    ByteString rawBytes = message.toByteString();
 
39
    assertEquals(rawBytes.size(), message.getSerializedSize());
 
40
 
 
41
    TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes);
 
42
 
 
43
    TestUtil.assertAllFieldsSet(message2);
 
44
  }
 
45
 
 
46
  public void testSerializeExtensions() throws Exception {
 
47
    // TestAllTypes and TestAllExtensions should have compatible wire formats,
 
48
    // so if we serealize a TestAllExtensions then parse it as TestAllTypes
 
49
    // it should work.
 
50
 
 
51
    TestAllExtensions message = TestUtil.getAllExtensionsSet();
 
52
    ByteString rawBytes = message.toByteString();
 
53
    assertEquals(rawBytes.size(), message.getSerializedSize());
 
54
 
 
55
    TestAllTypes message2 = TestAllTypes.parseFrom(rawBytes);
 
56
 
 
57
    TestUtil.assertAllFieldsSet(message2);
 
58
  }
 
59
 
 
60
  public void testParseExtensions() throws Exception {
 
61
    // TestAllTypes and TestAllExtensions should have compatible wire formats,
 
62
    // so if we serealize a TestAllTypes then parse it as TestAllExtensions
 
63
    // it should work.
 
64
 
 
65
    TestAllTypes message = TestUtil.getAllSet();
 
66
    ByteString rawBytes = message.toByteString();
 
67
 
 
68
    ExtensionRegistry registry = ExtensionRegistry.newInstance();
 
69
    TestUtil.registerAllExtensions(registry);
 
70
    registry = registry.getUnmodifiable();
 
71
 
 
72
    TestAllExtensions message2 =
 
73
      TestAllExtensions.parseFrom(rawBytes, registry);
 
74
 
 
75
    TestUtil.assertAllExtensionsSet(message2);
 
76
  }
 
77
 
 
78
  public void testExtensionsSerializedSize() throws Exception {
 
79
    assertEquals(TestUtil.getAllSet().getSerializedSize(),
 
80
                 TestUtil.getAllExtensionsSet().getSerializedSize());
 
81
  }
 
82
 
 
83
  private void assertFieldsInOrder(ByteString data) throws Exception {
 
84
    CodedInputStream input = data.newCodedInput();
 
85
    int previousTag = 0;
 
86
 
 
87
    while (true) {
 
88
      int tag = input.readTag();
 
89
      if (tag == 0) {
 
90
        break;
 
91
      }
 
92
 
 
93
      assertTrue(tag > previousTag);
 
94
      input.skipField(tag);
 
95
    }
 
96
  }
 
97
 
 
98
  public void testInterleavedFieldsAndExtensions() throws Exception {
 
99
    // Tests that fields are written in order even when extension ranges
 
100
    // are interleaved with field numbers.
 
101
    ByteString data =
 
102
      TestFieldOrderings.newBuilder()
 
103
        .setMyInt(1)
 
104
        .setMyString("foo")
 
105
        .setMyFloat(1.0F)
 
106
        .setExtension(UnittestProto.myExtensionInt, 23)
 
107
        .setExtension(UnittestProto.myExtensionString, "bar")
 
108
        .build().toByteString();
 
109
    assertFieldsInOrder(data);
 
110
 
 
111
    Descriptors.Descriptor descriptor = TestFieldOrderings.getDescriptor();
 
112
    ByteString dynamic_data =
 
113
      DynamicMessage.newBuilder(TestFieldOrderings.getDescriptor())
 
114
        .setField(descriptor.findFieldByName("my_int"), 1L)
 
115
        .setField(descriptor.findFieldByName("my_string"), "foo")
 
116
        .setField(descriptor.findFieldByName("my_float"), 1.0F)
 
117
        .setField(UnittestProto.myExtensionInt.getDescriptor(), 23)
 
118
        .setField(UnittestProto.myExtensionString.getDescriptor(), "bar")
 
119
        .build().toByteString();
 
120
    assertFieldsInOrder(dynamic_data);
 
121
  }
 
122
 
 
123
  private static final int UNKNOWN_TYPE_ID = 1550055;
 
124
  private static final int TYPE_ID_1 =
 
125
    TestMessageSetExtension1.getDescriptor().getExtensions().get(0).getNumber();
 
126
  private static final int TYPE_ID_2 =
 
127
    TestMessageSetExtension2.getDescriptor().getExtensions().get(0).getNumber();
 
128
 
 
129
  public void testSerializeMessageSet() throws Exception {
 
130
    // Set up a TestMessageSet with two known messages and an unknown one.
 
131
    TestMessageSet messageSet =
 
132
      TestMessageSet.newBuilder()
 
133
        .setExtension(
 
134
          TestMessageSetExtension1.messageSetExtension,
 
135
          TestMessageSetExtension1.newBuilder().setI(123).build())
 
136
        .setExtension(
 
137
          TestMessageSetExtension2.messageSetExtension,
 
138
          TestMessageSetExtension2.newBuilder().setStr("foo").build())
 
139
        .setUnknownFields(
 
140
          UnknownFieldSet.newBuilder()
 
141
            .addField(UNKNOWN_TYPE_ID,
 
142
              UnknownFieldSet.Field.newBuilder()
 
143
                .addLengthDelimited(ByteString.copyFromUtf8("bar"))
 
144
                .build())
 
145
            .build())
 
146
        .build();
 
147
 
 
148
    ByteString data = messageSet.toByteString();
 
149
 
 
150
    // Parse back using RawMessageSet and check the contents.
 
151
    RawMessageSet raw = RawMessageSet.parseFrom(data);
 
152
 
 
153
    assertTrue(raw.getUnknownFields().asMap().isEmpty());
 
154
 
 
155
    assertEquals(3, raw.getItemCount());
 
156
    assertEquals(TYPE_ID_1, raw.getItem(0).getTypeId());
 
157
    assertEquals(TYPE_ID_2, raw.getItem(1).getTypeId());
 
158
    assertEquals(UNKNOWN_TYPE_ID, raw.getItem(2).getTypeId());
 
159
 
 
160
    TestMessageSetExtension1 message1 =
 
161
      TestMessageSetExtension1.parseFrom(
 
162
        raw.getItem(0).getMessage().toByteArray());
 
163
    assertEquals(123, message1.getI());
 
164
 
 
165
    TestMessageSetExtension2 message2 =
 
166
      TestMessageSetExtension2.parseFrom(
 
167
        raw.getItem(1).getMessage().toByteArray());
 
168
    assertEquals("foo", message2.getStr());
 
169
 
 
170
    assertEquals("bar", raw.getItem(2).getMessage().toStringUtf8());
 
171
  }
 
172
 
 
173
  public void testParseMessageSet() throws Exception {
 
174
    ExtensionRegistry extensionRegistry = ExtensionRegistry.newInstance();
 
175
    extensionRegistry.add(TestMessageSetExtension1.messageSetExtension);
 
176
    extensionRegistry.add(TestMessageSetExtension2.messageSetExtension);
 
177
 
 
178
    // Set up a RawMessageSet with two known messages and an unknown one.
 
179
    RawMessageSet raw =
 
180
      RawMessageSet.newBuilder()
 
181
        .addItem(
 
182
          RawMessageSet.Item.newBuilder()
 
183
            .setTypeId(TYPE_ID_1)
 
184
            .setMessage(
 
185
              TestMessageSetExtension1.newBuilder()
 
186
                .setI(123)
 
187
                .build().toByteString())
 
188
            .build())
 
189
        .addItem(
 
190
          RawMessageSet.Item.newBuilder()
 
191
            .setTypeId(TYPE_ID_2)
 
192
            .setMessage(
 
193
              TestMessageSetExtension2.newBuilder()
 
194
                .setStr("foo")
 
195
                .build().toByteString())
 
196
            .build())
 
197
        .addItem(
 
198
          RawMessageSet.Item.newBuilder()
 
199
            .setTypeId(UNKNOWN_TYPE_ID)
 
200
            .setMessage(ByteString.copyFromUtf8("bar"))
 
201
            .build())
 
202
        .build();
 
203
 
 
204
    ByteString data = raw.toByteString();
 
205
 
 
206
    // Parse as a TestMessageSet and check the contents.
 
207
    TestMessageSet messageSet =
 
208
      TestMessageSet.parseFrom(data, extensionRegistry);
 
209
 
 
210
    assertEquals(123, messageSet.getExtension(
 
211
      TestMessageSetExtension1.messageSetExtension).getI());
 
212
    assertEquals("foo", messageSet.getExtension(
 
213
      TestMessageSetExtension2.messageSetExtension).getStr());
 
214
 
 
215
    // Check for unknown field with type LENGTH_DELIMITED,
 
216
    //   number UNKNOWN_TYPE_ID, and contents "bar".
 
217
    UnknownFieldSet unknownFields = messageSet.getUnknownFields();
 
218
    assertEquals(1, unknownFields.asMap().size());
 
219
    assertTrue(unknownFields.hasField(UNKNOWN_TYPE_ID));
 
220
 
 
221
    UnknownFieldSet.Field field = unknownFields.getField(UNKNOWN_TYPE_ID);
 
222
    assertEquals(1, field.getLengthDelimitedList().size());
 
223
    assertEquals("bar", field.getLengthDelimitedList().get(0).toStringUtf8());
 
224
  }
 
225
}
 
226