OLD | NEW |
1 #!/usr/bin/env dart | 1 #!/usr/bin/env dart |
2 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | 2 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
3 // for details. All rights reserved. Use of this source code is governed by a | 3 // for details. All rights reserved. Use of this source code is governed by a |
4 // BSD-style license that can be found in the LICENSE file. | 4 // BSD-style license that can be found in the LICENSE file. |
5 | 5 |
6 library message_test; | 6 library message_test; |
7 | 7 |
8 import 'package:test/test.dart'; | 8 import 'package:test/test.dart'; |
9 | 9 |
10 import 'test_util.dart'; | 10 import 'test_util.dart'; |
11 | 11 |
12 import '../out/protos/descriptor_2_5_opensource.pb.dart' | 12 import '../out/protos/descriptor_2_5_opensource.pb.dart' show DescriptorProto; |
13 show DescriptorProto; | |
14 import '../out/protos/google/protobuf/unittest.pb.dart'; | 13 import '../out/protos/google/protobuf/unittest.pb.dart'; |
15 | 14 |
16 void main() { | 15 void main() { |
17 TestRequired TEST_REQUIRED_UNINITIALIZED = new TestRequired(); | 16 TestRequired TEST_REQUIRED_UNINITIALIZED = new TestRequired(); |
18 | 17 |
19 TestRequired TEST_REQUIRED_INITIALIZED = new TestRequired() | 18 TestRequired TEST_REQUIRED_INITIALIZED = new TestRequired() |
20 ..a = 1 | 19 ..a = 1 |
21 ..b = 2 | 20 ..b = 2 |
22 ..c = 3; | 21 ..c = 3; |
23 | 22 |
24 test('testMergeFrom', () { | 23 test('testMergeFrom', () { |
25 TestAllTypes mergeSource = new TestAllTypes() | 24 TestAllTypes mergeSource = new TestAllTypes() |
26 ..optionalInt32 = 1 | 25 ..optionalInt32 = 1 |
27 ..optionalString = 'foo' | 26 ..optionalString = 'foo' |
28 ..optionalForeignMessage = new ForeignMessage() | 27 ..optionalForeignMessage = new ForeignMessage() |
29 ..repeatedString.add('bar'); | 28 ..repeatedString.add('bar'); |
30 | 29 |
31 TestAllTypes mergeDest = new TestAllTypes() | 30 TestAllTypes mergeDest = new TestAllTypes() |
32 ..optionalInt64 = make64(2) | 31 ..optionalInt64 = make64(2) |
33 ..optionalString = 'baz' | 32 ..optionalString = 'baz' |
34 ..optionalForeignMessage = new ForeignMessage() | 33 ..optionalForeignMessage = new ForeignMessage() |
35 ..optionalForeignMessage = (new ForeignMessage()..c = 3) | 34 ..optionalForeignMessage = (new ForeignMessage()..c = 3) |
36 ..repeatedString.add('qux'); | 35 ..repeatedString.add('qux'); |
37 | 36 |
38 String mergeResultExpected = ''' | 37 String mergeResultExpected = ''' |
39 optionalInt32: 1 | 38 optionalInt32: 1 |
40 optionalInt64: 2 | 39 optionalInt64: 2 |
41 optionalString: baz | 40 optionalString: baz |
42 optionalForeignMessage: { | 41 optionalForeignMessage: { |
43 c: 3 | 42 c: 3 |
44 } | 43 } |
45 repeatedString: bar | 44 repeatedString: bar |
46 repeatedString: qux | 45 repeatedString: qux |
47 '''; | 46 '''; |
48 | 47 |
49 TestAllTypes result = new TestAllTypes() | 48 TestAllTypes result = new TestAllTypes() |
50 ..mergeFromMessage(mergeSource) | 49 ..mergeFromMessage(mergeSource) |
51 ..mergeFromMessage(mergeDest); | 50 ..mergeFromMessage(mergeDest); |
52 | 51 |
53 expect(result.toString(), mergeResultExpected); | 52 expect(result.toString(), mergeResultExpected); |
54 }); | 53 }); |
55 | 54 |
56 test('testRequired', () { | 55 test('testRequired', () { |
57 TestRequired message = new TestRequired(); | 56 TestRequired message = new TestRequired(); |
58 | 57 |
59 expect(message.isInitialized(), isFalse, reason: 'no required fields set'); | 58 expect(message.isInitialized(), isFalse, reason: 'no required fields set'); |
60 message.a = 1; | 59 message.a = 1; |
61 expect(message.isInitialized(), isFalse, | 60 expect(message.isInitialized(), isFalse, |
62 reason: 'single required field set'); | 61 reason: 'single required field set'); |
63 message.b = 1; | 62 message.b = 1; |
64 expect(message.isInitialized(), isFalse, | 63 expect(message.isInitialized(), isFalse, |
65 reason: 'all but one required field set'); | 64 reason: 'all but one required field set'); |
66 message.c = 1; | 65 message.c = 1; |
67 expect(message.isInitialized(), isTrue, reason: 'required fields set'); | 66 expect(message.isInitialized(), isTrue, reason: 'required fields set'); |
68 }); | 67 }); |
69 | 68 |
70 test('testRequiredForeign', () { | 69 test('testRequiredForeign', () { |
71 TestRequiredForeign message = new TestRequiredForeign(); | 70 TestRequiredForeign message = new TestRequiredForeign(); |
72 expect(message.isInitialized(), isTrue, | 71 expect(message.isInitialized(), isTrue, |
73 reason: 'TestRequiredForeign without children should be initialized'); | 72 reason: 'TestRequiredForeign without children should be initialized'); |
74 | 73 |
75 message.optionalMessage = TEST_REQUIRED_UNINITIALIZED; | 74 message.optionalMessage = TEST_REQUIRED_UNINITIALIZED; |
76 expect(message.isInitialized(), isFalse, reason: | 75 expect(message.isInitialized(), isFalse, |
77 'TestRequiredForeign with optional TEST_REQUIRED_UNINITIALIZED ' | 76 reason: 'TestRequiredForeign with optional TEST_REQUIRED_UNINITIALIZED ' |
78 'should not be initialized'); | 77 'should not be initialized'); |
79 | 78 |
80 message.optionalMessage = TEST_REQUIRED_INITIALIZED; | 79 message.optionalMessage = TEST_REQUIRED_INITIALIZED; |
81 expect(message.isInitialized(), isTrue, | 80 expect(message.isInitialized(), isTrue, |
82 reason: 'TestRequiredForeign with optional TEST_REQUIRED_INITIALIZED ' | 81 reason: 'TestRequiredForeign with optional TEST_REQUIRED_INITIALIZED ' |
83 'should be initialized'); | 82 'should be initialized'); |
84 | 83 |
85 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); | 84 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); |
86 expect(message.isInitialized(), isFalse, reason: | 85 expect(message.isInitialized(), isFalse, |
87 'TestRequiredForeign with repeating TEST_REQUIRED_UNINITIALIZED ' | 86 reason: |
88 'should not be initialized'); | 87 'TestRequiredForeign with repeating TEST_REQUIRED_UNINITIALIZED ' |
| 88 'should not be initialized'); |
89 | 89 |
90 message.repeatedMessage[0] = TEST_REQUIRED_INITIALIZED; | 90 message.repeatedMessage[0] = TEST_REQUIRED_INITIALIZED; |
91 expect(message.isInitialized(), isTrue, | 91 expect(message.isInitialized(), isTrue, |
92 reason: 'TestRequiredForeign with repeating TEST_REQUIRED_INITIALIZED ' | 92 reason: 'TestRequiredForeign with repeating TEST_REQUIRED_INITIALIZED ' |
93 'should be initialized'); | 93 'should be initialized'); |
94 }); | 94 }); |
95 | 95 |
96 test('testRequiredExtension', () { | 96 test('testRequiredExtension', () { |
97 TestAllExtensions message = new TestAllExtensions(); | 97 TestAllExtensions message = new TestAllExtensions(); |
98 expect(message.isInitialized(), isTrue); | 98 expect(message.isInitialized(), isTrue); |
99 | 99 |
100 message.setExtension(TestRequired.single, TEST_REQUIRED_UNINITIALIZED); | 100 message.setExtension(TestRequired.single, TEST_REQUIRED_UNINITIALIZED); |
101 expect(message.isInitialized(), isFalse); | 101 expect(message.isInitialized(), isFalse); |
102 | 102 |
103 message.setExtension(TestRequired.single, TEST_REQUIRED_INITIALIZED); | 103 message.setExtension(TestRequired.single, TEST_REQUIRED_INITIALIZED); |
(...skipping 26 matching lines...) Expand all Loading... |
130 TestRequiredForeign message = new TestRequiredForeign(); | 130 TestRequiredForeign message = new TestRequiredForeign(); |
131 message.optionalMessage = TEST_REQUIRED_UNINITIALIZED; | 131 message.optionalMessage = TEST_REQUIRED_UNINITIALIZED; |
132 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); | 132 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); |
133 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); | 133 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); |
134 message.check(); | 134 message.check(); |
135 fail('Should have thrown an exception.'); | 135 fail('Should have thrown an exception.'); |
136 } on StateError catch (e) { | 136 } on StateError catch (e) { |
137 // NOTE: error message differs from Java in that | 137 // NOTE: error message differs from Java in that |
138 // fields are referenced using Dart fieldnames r.t. | 138 // fields are referenced using Dart fieldnames r.t. |
139 // proto field names. | 139 // proto field names. |
140 expect(e.message, | 140 expect( |
141 'Message missing required fields: ' | 141 e.message, |
142 'optionalMessage.a, ' | 142 'Message missing required fields: ' |
143 'optionalMessage.b, ' | 143 'optionalMessage.a, ' |
144 'optionalMessage.c, ' | 144 'optionalMessage.b, ' |
145 'repeatedMessage[0].a, ' | 145 'optionalMessage.c, ' |
146 'repeatedMessage[0].b, ' | 146 'repeatedMessage[0].a, ' |
147 'repeatedMessage[0].c, ' | 147 'repeatedMessage[0].b, ' |
148 'repeatedMessage[1].a, ' | 148 'repeatedMessage[0].c, ' |
149 'repeatedMessage[1].b, ' | 149 'repeatedMessage[1].a, ' |
150 'repeatedMessage[1].c'); | 150 'repeatedMessage[1].b, ' |
| 151 'repeatedMessage[1].c'); |
151 } | 152 } |
152 }); | 153 }); |
153 | 154 |
154 test('testBuildNestedPartial', () { | 155 test('testBuildNestedPartial', () { |
155 // We're mostly testing that no exception is thrown. | 156 // We're mostly testing that no exception is thrown. |
156 TestRequiredForeign message = new TestRequiredForeign(); | 157 TestRequiredForeign message = new TestRequiredForeign(); |
157 message.optionalMessage = TEST_REQUIRED_UNINITIALIZED; | 158 message.optionalMessage = TEST_REQUIRED_UNINITIALIZED; |
158 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); | 159 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); |
159 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); | 160 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); |
160 expect(message.isInitialized(), isFalse); | 161 expect(message.isInitialized(), isFalse); |
(...skipping 15 matching lines...) Expand all Loading... |
176 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); | 177 message.repeatedMessage.add(TEST_REQUIRED_UNINITIALIZED); |
177 List<int> buffer = message.writeToBuffer(); | 178 List<int> buffer = message.writeToBuffer(); |
178 | 179 |
179 try { | 180 try { |
180 (new TestRequiredForeign.fromBuffer(buffer)).check(); | 181 (new TestRequiredForeign.fromBuffer(buffer)).check(); |
181 fail('Should have thrown an exception.'); | 182 fail('Should have thrown an exception.'); |
182 } on StateError catch (e) { | 183 } on StateError catch (e) { |
183 // NOTE: error message differs from Java in that | 184 // NOTE: error message differs from Java in that |
184 // fields are referenced using Dart fieldnames r.t. | 185 // fields are referenced using Dart fieldnames r.t. |
185 // proto field names. | 186 // proto field names. |
186 expect(e.message, | 187 expect( |
| 188 e.message, |
187 'Message missing required fields: ' | 189 'Message missing required fields: ' |
188 'optionalMessage.a, ' | 190 'optionalMessage.a, ' |
189 'optionalMessage.b, ' | 191 'optionalMessage.b, ' |
190 'optionalMessage.c, ' | 192 'optionalMessage.c, ' |
191 'repeatedMessage[0].a, ' | 193 'repeatedMessage[0].a, ' |
192 'repeatedMessage[0].b, ' | 194 'repeatedMessage[0].b, ' |
193 'repeatedMessage[0].c, ' | 195 'repeatedMessage[0].c, ' |
194 'repeatedMessage[1].a, ' | 196 'repeatedMessage[1].a, ' |
195 'repeatedMessage[1].b, ' | 197 'repeatedMessage[1].b, ' |
196 'repeatedMessage[1].c'); | 198 'repeatedMessage[1].c'); |
197 } | 199 } |
198 }); | 200 }); |
199 | 201 |
200 test('testClearField', () { | 202 test('testClearField', () { |
201 int fieldNo; | 203 int fieldNo; |
202 TestAllTypes message = new TestAllTypes(); | 204 TestAllTypes message = new TestAllTypes(); |
203 | 205 |
204 // Singular field with no default. | 206 // Singular field with no default. |
205 fieldNo = 1; | 207 fieldNo = 1; |
206 expect(message.hasField(fieldNo), isFalse); | 208 expect(message.hasField(fieldNo), isFalse); |
207 expect(message.getField(fieldNo), 0); | 209 expect(message.getField(fieldNo), 0); |
208 message.clearField(fieldNo); | 210 message.clearField(fieldNo); |
209 expect(message.hasField(fieldNo), isFalse); | 211 expect(message.hasField(fieldNo), isFalse); |
210 message.setField(fieldNo, 0); | 212 message.setField(fieldNo, 0); |
211 expect(message.getField(fieldNo), 0); | 213 expect(message.getField(fieldNo), 0); |
212 expect(message.hasField(fieldNo), isTrue); | 214 expect(message.hasField(fieldNo), isTrue); |
213 message.clearField(fieldNo); | 215 message.clearField(fieldNo); |
214 expect(message.hasField(fieldNo), isFalse); | 216 expect(message.hasField(fieldNo), isFalse); |
215 | 217 |
216 // Repeated field. | 218 // Repeated field. |
217 fieldNo = 31; | 219 fieldNo = 31; |
218 expect(message.hasField(fieldNo), isFalse); | 220 expect(message.hasField(fieldNo), isFalse); |
219 message.getField(fieldNo).add(1); | 221 message.getField(fieldNo).add(1); |
220 expect(message.hasField(fieldNo), isTrue); | 222 expect(message.hasField(fieldNo), isTrue); |
221 | 223 |
222 // Singular field with default. | 224 // Singular field with default. |
223 fieldNo = 61; | 225 fieldNo = 61; |
224 expect(message.hasField(fieldNo), isFalse); | 226 expect(message.hasField(fieldNo), isFalse); |
225 expect(message.getField(fieldNo), 41); | 227 expect(message.getField(fieldNo), 41); |
226 message.clearField(fieldNo); | 228 message.clearField(fieldNo); |
227 message.setField(fieldNo, 41); | 229 message.setField(fieldNo, 41); |
228 expect(message.hasField(fieldNo), isTrue); | 230 expect(message.hasField(fieldNo), isTrue); |
229 message.setField(fieldNo, 42); | 231 message.setField(fieldNo, 42); |
230 expect(message.hasField(fieldNo), isTrue); | 232 expect(message.hasField(fieldNo), isTrue); |
231 expect(message.getField(fieldNo), 42); | 233 expect(message.getField(fieldNo), 42); |
232 message.clearField(fieldNo); | 234 message.clearField(fieldNo); |
233 expect(message.hasField(fieldNo), isFalse); | 235 expect(message.hasField(fieldNo), isFalse); |
234 expect(message.getField(fieldNo), 41); | 236 expect(message.getField(fieldNo), 41); |
235 }); | 237 }); |
236 | 238 |
237 test('JSON constants share structure', () { | 239 test('JSON constants share structure', () { |
238 const nestedTypeTag = 3; | 240 const nestedTypeTag = 3; |
239 expect(TestAllTypes$json['$nestedTypeTag'][0], | 241 List fields = TestAllTypes$json['$nestedTypeTag']; |
240 same(TestAllTypes_NestedMessage$json)); | 242 expect(fields[0], same(TestAllTypes_NestedMessage$json)); |
241 | 243 |
242 const enumTypeTag = 4; | 244 const enumTypeTag = 4; |
243 expect(TestAllTypes$json['$enumTypeTag'][0], | 245 fields = TestAllTypes$json['$enumTypeTag']; |
244 same(TestAllTypes_NestedEnum$json)); | 246 expect(fields[0], same(TestAllTypes_NestedEnum$json)); |
245 }); | 247 }); |
246 | 248 |
247 test('Can read JSON constant into DescriptorProto', () { | 249 test('Can read JSON constant into DescriptorProto', () { |
248 var d = new DescriptorProto()..mergeFromJsonMap(TestAllTypes$json); | 250 var d = new DescriptorProto()..mergeFromJsonMap(TestAllTypes$json); |
249 expect(d.name, "TestAllTypes"); | 251 expect(d.name, "TestAllTypes"); |
250 expect(d.field[0].name, "optional_int32"); | 252 expect(d.field[0].name, "optional_int32"); |
251 expect(d.nestedType[0].name, "NestedMessage"); | 253 expect(d.nestedType[0].name, "NestedMessage"); |
252 }); | 254 }); |
253 } | 255 } |
OLD | NEW |