BindingsVersioningTest.java revision 645501c2ab19a559ce82a1d5a29ced159a4c30fb 
1// Copyright 2015 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5package org.chromium.mojo.bindings;
6
7import android.test.suitebuilder.annotation.SmallTest;
8
9import org.chromium.mojo.MojoTestCase;
10import org.chromium.mojo.bindings.test.mojom.test_structs.MultiVersionStruct;
11import org.chromium.mojo.bindings.test.mojom.test_structs.MultiVersionStructV0;
12import org.chromium.mojo.bindings.test.mojom.test_structs.MultiVersionStructV1;
13import org.chromium.mojo.bindings.test.mojom.test_structs.MultiVersionStructV3;
14import org.chromium.mojo.bindings.test.mojom.test_structs.MultiVersionStructV5;
15import org.chromium.mojo.bindings.test.mojom.test_structs.MultiVersionStructV7;
16import org.chromium.mojo.bindings.test.mojom.test_structs.Rect;
17import org.chromium.mojo.system.impl.CoreImpl;
18
19/**
20 * Testing generated classes with the [MinVersion] annotation. Struct in this test are from:
21 * mojo/public/interfaces/bindings/tests/rect.mojom and
22 * mojo/public/interfaces/bindings/tests/test_structs.mojom
23 */
24public class BindingsVersioningTest extends MojoTestCase {
25    private static Rect newRect(int factor) {
26        Rect rect = new Rect();
27        rect.x = factor;
28        rect.y = 2 * factor;
29        rect.width = 10 * factor;
30        rect.height = 20 * factor;
31        return rect;
32    }
33
34    private static MultiVersionStruct newStruct() {
35        MultiVersionStruct struct = new MultiVersionStruct();
36        struct.fInt32 = 123;
37        struct.fRect = newRect(5);
38        struct.fString = "hello";
39        struct.fArray = new byte[] {10, 9, 8};
40        struct.fBool = true;
41        struct.fInt16 = 256;
42        return struct;
43    }
44
45    /**
46     * Testing serializing old struct version to newer one.
47     */
48    @SmallTest
49    public void testOldToNew() {
50        {
51            MultiVersionStructV0 v0 = new MultiVersionStructV0();
52            v0.fInt32 = 123;
53            MultiVersionStruct expected = new MultiVersionStruct();
54            expected.fInt32 = 123;
55
56            MultiVersionStruct output = MultiVersionStruct.deserialize(v0.serialize(null));
57            assertEquals(expected, output);
58            assertEquals(0, v0.getVersion());
59            assertEquals(0, output.getVersion());
60        }
61
62        {
63            MultiVersionStructV1 v1 = new MultiVersionStructV1();
64            v1.fInt32 = 123;
65            v1.fRect = newRect(5);
66            MultiVersionStruct expected = new MultiVersionStruct();
67            expected.fInt32 = 123;
68            expected.fRect = newRect(5);
69
70            MultiVersionStruct output = MultiVersionStruct.deserialize(v1.serialize(null));
71            assertEquals(expected, output);
72            assertEquals(1, v1.getVersion());
73            assertEquals(1, output.getVersion());
74        }
75
76        {
77            MultiVersionStructV3 v3 = new MultiVersionStructV3();
78            v3.fInt32 = 123;
79            v3.fRect = newRect(5);
80            v3.fString = "hello";
81            MultiVersionStruct expected = new MultiVersionStruct();
82            expected.fInt32 = 123;
83            expected.fRect = newRect(5);
84            expected.fString = "hello";
85
86            MultiVersionStruct output = MultiVersionStruct.deserialize(v3.serialize(null));
87            assertEquals(expected, output);
88            assertEquals(3, v3.getVersion());
89            assertEquals(3, output.getVersion());
90        }
91
92        {
93            MultiVersionStructV5 v5 = new MultiVersionStructV5();
94            v5.fInt32 = 123;
95            v5.fRect = newRect(5);
96            v5.fString = "hello";
97            v5.fArray = new byte[] {10, 9, 8};
98            MultiVersionStruct expected = new MultiVersionStruct();
99            expected.fInt32 = 123;
100            expected.fRect = newRect(5);
101            expected.fString = "hello";
102            expected.fArray = new byte[] {10, 9, 8};
103
104            MultiVersionStruct output = MultiVersionStruct.deserialize(v5.serialize(null));
105            assertEquals(expected, output);
106            assertEquals(5, v5.getVersion());
107            assertEquals(5, output.getVersion());
108        }
109
110        {
111            int expectedHandle = 42;
112            MultiVersionStructV7 v7 = new MultiVersionStructV7();
113            v7.fInt32 = 123;
114            v7.fRect = newRect(5);
115            v7.fString = "hello";
116            v7.fArray = new byte[] {10, 9, 8};
117            v7.fMessagePipe = CoreImpl.getInstance()
118                                      .acquireNativeHandle(expectedHandle)
119                                      .toMessagePipeHandle();
120            v7.fBool = true;
121            MultiVersionStruct expected = new MultiVersionStruct();
122            expected.fInt32 = 123;
123            expected.fRect = newRect(5);
124            expected.fString = "hello";
125            expected.fArray = new byte[] {10, 9, 8};
126            expected.fBool = true;
127
128            MultiVersionStruct output = MultiVersionStruct.deserialize(v7.serialize(null));
129
130            // Handles must be tested separately.
131            assertEquals(expectedHandle, output.fMessagePipe.releaseNativeHandle());
132            output.fMessagePipe = expected.fMessagePipe;
133
134            assertEquals(expected, output);
135            assertEquals(7, v7.getVersion());
136            assertEquals(7, output.getVersion());
137        }
138    }
139
140    /**
141     * Testing serializing new struct version to older one.
142     */
143    @SmallTest
144    public void testNewToOld() {
145        MultiVersionStruct struct = newStruct();
146        {
147            MultiVersionStructV0 expected = new MultiVersionStructV0();
148            expected.fInt32 = 123;
149
150            MultiVersionStructV0 output = MultiVersionStructV0.deserialize(struct.serialize(null));
151            assertEquals(expected, output);
152            assertEquals(9, output.getVersion());
153        }
154
155        {
156            MultiVersionStructV1 expected = new MultiVersionStructV1();
157            expected.fInt32 = 123;
158            expected.fRect = newRect(5);
159
160            MultiVersionStructV1 output = MultiVersionStructV1.deserialize(struct.serialize(null));
161            assertEquals(expected, output);
162            assertEquals(9, output.getVersion());
163        }
164
165        {
166            MultiVersionStructV3 expected = new MultiVersionStructV3();
167            expected.fInt32 = 123;
168            expected.fRect = newRect(5);
169            expected.fString = "hello";
170
171            MultiVersionStructV3 output = MultiVersionStructV3.deserialize(struct.serialize(null));
172            assertEquals(expected, output);
173            assertEquals(9, output.getVersion());
174        }
175
176        {
177            MultiVersionStructV5 expected = new MultiVersionStructV5();
178            expected.fInt32 = 123;
179            expected.fRect = newRect(5);
180            expected.fString = "hello";
181            expected.fArray = new byte[] {10, 9, 8};
182
183            MultiVersionStructV5 output = MultiVersionStructV5.deserialize(struct.serialize(null));
184            assertEquals(expected, output);
185            assertEquals(9, output.getVersion());
186        }
187
188        {
189            int expectedHandle = 42;
190            MultiVersionStructV7 expected = new MultiVersionStructV7();
191            expected.fInt32 = 123;
192            expected.fRect = newRect(5);
193            expected.fString = "hello";
194            expected.fArray = new byte[] {10, 9, 8};
195            expected.fBool = true;
196
197            MultiVersionStruct input = struct;
198            input.fMessagePipe = CoreImpl.getInstance()
199                                         .acquireNativeHandle(expectedHandle)
200                                         .toMessagePipeHandle();
201
202            MultiVersionStructV7 output = MultiVersionStructV7.deserialize(input.serialize(null));
203
204            assertEquals(expectedHandle, output.fMessagePipe.releaseNativeHandle());
205            output.fMessagePipe = expected.fMessagePipe;
206
207            assertEquals(expected, output);
208            assertEquals(9, output.getVersion());
209        }
210    }
211}
212