Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(29)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/WebKit/LayoutTests/mojo/interface_ptr.html

Issue 2891193002: Mojo JS bindings: switch all mojo/ layout tests to use the new mode. (Closed)
Patch Set: . Created 3 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « third_party/WebKit/LayoutTests/mojo/connection.html ('k') | third_party/WebKit/LayoutTests/mojo/resources/validation_test_input_parser.js » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 <!DOCTYPE html> 1 <!DOCTYPE html>
2 <script src="../resources/testharness.js"></script> 2 <script src="../resources/testharness.js"></script>
3 <script src="../resources/testharnessreport.js"></script> 3 <script src="../resources/testharnessreport.js"></script>
4 <script src="../resources/mojo-helpers.js"></script> 4 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></scr ipt>
5 <script src="file:///gen/mojo/public/interfaces/bindings/tests/math_calculator.m ojom.js"></script>
6 <script src="file:///gen/mojo/public/interfaces/bindings/tests/sample_interfaces .mojom.js"></script>
5 <script> 7 <script>
6 'use strict'; 8 'use strict';
7 9
8 setup({ explicit_done: true }); 10 function CalculatorImpl() {
11 this.total = 0;
12 }
9 13
10 define([ 14 CalculatorImpl.prototype.clear = function() {
11 "mojo/public/js/bindings", 15 this.total = 0;
12 "mojo/public/js/core", 16 return Promise.resolve({value: this.total});
13 "mojo/public/interfaces/bindings/tests/math_calculator.mojom", 17 };
14 "mojo/public/interfaces/bindings/tests/sample_interfaces.mojom",
15 ], function(bindings, core, math, sampleInterfaces) {
16 18
17 function CalculatorImpl() { 19 CalculatorImpl.prototype.add = function(value) {
18 this.total = 0; 20 this.total += value;
19 } 21 return Promise.resolve({value: this.total});
22 };
20 23
21 CalculatorImpl.prototype.clear = function() { 24 CalculatorImpl.prototype.multiply = function(value) {
22 this.total = 0; 25 this.total *= value;
23 return Promise.resolve({value: this.total}); 26 return Promise.resolve({value: this.total});
24 }; 27 };
25 28
26 CalculatorImpl.prototype.add = function(value) { 29 function IntegerAccessorImpl() {
27 this.total += value; 30 this.integer = 0;
28 return Promise.resolve({value: this.total}); 31 }
29 };
30 32
31 CalculatorImpl.prototype.multiply = function(value) { 33 IntegerAccessorImpl.prototype.getInteger = function() {
32 this.total *= value; 34 return Promise.resolve({data: this.integer});
33 return Promise.resolve({value: this.total}); 35 };
34 };
35 36
36 function IntegerAccessorImpl() { 37 IntegerAccessorImpl.prototype.setInteger = function(value) {
37 this.integer = 0; 38 this.integer = value;
38 } 39 };
39 40
40 IntegerAccessorImpl.prototype.getInteger = function() { 41 test(() => {
41 return Promise.resolve({data: this.integer}); 42 var calc = new math.CalculatorPtr();
42 }; 43 assert_false(calc.ptr.isBound());
43 44
44 IntegerAccessorImpl.prototype.setInteger = function(value) { 45 var request = mojo.makeRequest(calc);
45 this.integer = value; 46 assert_true(calc.ptr.isBound());
46 };
47 47
48 test(() => { 48 calc.ptr.reset();
49 var calc = new math.CalculatorPtr(); 49 assert_false(calc.ptr.isBound());
50 assert_false(calc.ptr.isBound()); 50 }, 'is bound');
51 51
52 var request = bindings.makeRequest(calc); 52 promise_test(async () => {
53 assert_true(calc.ptr.isBound()); 53 var calc = new math.CalculatorPtr();
54 var calcBinding = new mojo.Binding(
55 math.Calculator, new CalculatorImpl(), mojo.makeRequest(calc));
54 56
55 calc.ptr.reset(); 57 assert_equals((await calc.add(2)).value, 2);
56 assert_false(calc.ptr.isBound()); 58 assert_equals((await calc.multiply(5)).value, 10);
57 }, 'is bound'); 59 assert_equals((await calc.clear()).value, 0);
60 }, 'end to end');
58 61
59 promise_test(async () => { 62 promise_test(async () => {
60 var calc = new math.CalculatorPtr(); 63 var calc = new math.CalculatorPtr();
61 var calcBinding = new bindings.Binding(math.Calculator, 64 var calcImpl1 = new CalculatorImpl();
62 new CalculatorImpl(), 65 var calcBinding1 = new mojo.Binding(math.Calculator, calcImpl1,
63 bindings.makeRequest(calc)); 66 mojo.makeRequest(calc));
67 var calcImpl2 = new CalculatorImpl();
68 var calcBinding2 = new mojo.Binding(math.Calculator, calcImpl2);
64 69
65 assert_equals((await calc.add(2)).value, 2); 70 assert_equals((await calc.add(2)).value, 2);
66 assert_equals((await calc.multiply(5)).value, 10); 71 calcBinding2.bind(mojo.makeRequest(calc));
67 assert_equals((await calc.clear()).value, 0); 72 assert_equals((await calc.add(2)).value, 2);
68 }, 'end to end'); 73 assert_equals(calcImpl1.total, 2);
74 assert_equals(calcImpl2.total, 2);
75 }, 'reusable');
69 76
70 promise_test(async () => { 77 promise_test(async () => {
71 var calc = new math.CalculatorPtr(); 78 var calc = new math.CalculatorPtr();
72 var calcImpl1 = new CalculatorImpl(); 79 var calcBinding = new mojo.Binding(math.Calculator, new CalculatorImpl(),
73 var calcBinding1 = new bindings.Binding(math.Calculator, 80 mojo.makeRequest(calc));
74 calcImpl1,
75 bindings.makeRequest(calc));
76 var calcImpl2 = new CalculatorImpl();
77 var calcBinding2 = new bindings.Binding(math.Calculator, calcImpl2);
78 81
79 assert_equals((await calc.add(2)).value, 2); 82 await new Promise((resolve, reject) => {
80 calcBinding2.bind(bindings.makeRequest(calc)); 83 calc.ptr.setConnectionErrorHandler(() => { resolve(); });
81 assert_equals((await calc.add(2)).value, 2); 84 calcBinding.close();
82 assert_equals(calcImpl1.total, 2); 85 });
83 assert_equals(calcImpl2.total, 2); 86 }, 'connection error');
84 }, 'reusable');
85 87
86 promise_test(async () => { 88 promise_test(async () => {
87 var calc = new math.CalculatorPtr(); 89 var calc = new math.CalculatorPtr();
88 var calcBinding = new bindings.Binding(math.Calculator, 90 var calcBinding = new mojo.Binding(math.Calculator, new CalculatorImpl(),
89 new CalculatorImpl(), 91 mojo.makeRequest(calc));
90 bindings.makeRequest(calc));
91 92
92 await new Promise((resolve, reject) => { 93 await new Promise((resolve, reject) => {
93 calc.ptr.setConnectionErrorHandler(() => { resolve(); }); 94 calc.ptr.setConnectionErrorHandler(({customReason, description}) => {
94 calcBinding.close(); 95 assert_equals(customReason, 42);
96 assert_equals(description, 'hey');
97 resolve();
95 }); 98 });
96 }, 'connection error'); 99 calcBinding.closeWithReason({customReason: 42, description: 'hey'});
100 });
101 }, 'connection error with reason');
97 102
98 promise_test(async () => { 103 promise_test(async () => {
99 var calc = new math.CalculatorPtr(); 104 var calc = new math.CalculatorPtr();
100 var calcBinding = new bindings.Binding(math.Calculator, 105 var newCalc = null;
101 new CalculatorImpl(), 106 var calcBinding = new mojo.Binding(math.Calculator, new CalculatorImpl(),
102 bindings.makeRequest(calc)); 107 mojo.makeRequest(calc));
103 108
104 await new Promise((resolve, reject) => { 109 assert_equals((await calc.add(2)).value, 2);
105 calc.ptr.setConnectionErrorHandler(({custom_reason, description}) => { 110 newCalc = new math.CalculatorPtr();
106 assert_equals(custom_reason, 42); 111 newCalc.ptr.bind(calc.ptr.passInterface());
107 assert_equals(description, 'hey'); 112 assert_false(calc.ptr.isBound());
108 resolve(); 113 assert_equals((await newCalc.add(2)).value, 4);
109 }); 114
110 calcBinding.closeWithReason({custom_reason: 42, description: 'hey'}); 115 }, 'pass interface');
116
117 promise_test(async () => {
118 var pipe = Mojo.createMessagePipe();
119 var calc = new math.CalculatorPtr(pipe.handle0);
120 var newCalc = null;
121 var calcBinding = new mojo.Binding(math.Calculator, new CalculatorImpl(),
122 pipe.handle1);
123
124 assert_equals((await calc.add(2)).value, 2);
125
126 }, 'bind raw handle');
127
128 promise_test(async () => {
129 var integerAccessorPtr = new sample.IntegerAccessorPtr();
130
131 var integerAccessorBinding = new mojo.Binding(
132 sample.IntegerAccessor, new IntegerAccessorImpl(),
133 mojo.makeRequest(integerAccessorPtr));
134 assert_equals(integerAccessorPtr.ptr.version, 0);
135
136 assert_equals(await integerAccessorPtr.ptr.queryVersion(), 3);
137 assert_equals(integerAccessorPtr.ptr.version, 3);
138 }, 'query version');
139
140 promise_test(async () => {
141 var integerAccessorImpl = new IntegerAccessorImpl();
142 var integerAccessorPtr = new sample.IntegerAccessorPtr();
143 var integerAccessorBinding = new mojo.Binding(
144 sample.IntegerAccessor, integerAccessorImpl,
145 mojo.makeRequest(integerAccessorPtr));
146
147 // Inital version is 0.
148 assert_equals(integerAccessorPtr.ptr.version, 0);
149
150 integerAccessorPtr.ptr.requireVersion(1);
151 assert_equals(integerAccessorPtr.ptr.version, 1);
152 integerAccessorPtr.setInteger(123, sample.Enum.VALUE);
153 assert_equals((await integerAccessorPtr.getInteger()).data, 123);
154
155 integerAccessorPtr.ptr.requireVersion(3);
156 assert_equals(integerAccessorPtr.ptr.version, 3);
157 integerAccessorPtr.setInteger(456, sample.Enum.VALUE);
158 assert_equals((await integerAccessorPtr.getInteger()).data, 456);
159
160 // Require a version that is not supported by the impl side.
161 integerAccessorPtr.ptr.requireVersion(4);
162 assert_equals(integerAccessorPtr.ptr.version, 4);
163 integerAccessorPtr.setInteger(789, sample.Enum.VALUE);
164
165 await new Promise((resolve, reject) => {
166 integerAccessorPtr.ptr.setConnectionErrorHandler(() => {
167 resolve();
111 }); 168 });
112 }, 'connection error with reason'); 169 });
170 assert_equals(integerAccessorImpl.integer, 456);
113 171
114 promise_test(async () => { 172 }, 'require version');
115 var calc = new math.CalculatorPtr();
116 var newCalc = null;
117 var calcBinding = new bindings.Binding(math.Calculator,
118 new CalculatorImpl(),
119 bindings.makeRequest(calc));
120
121 assert_equals((await calc.add(2)).value, 2);
122 newCalc = new math.CalculatorPtr();
123 newCalc.ptr.bind(calc.ptr.passInterface());
124 assert_false(calc.ptr.isBound());
125 assert_equals((await newCalc.add(2)).value, 4);
126
127 }, 'pass interface');
128
129 promise_test(async () => {
130 var pipe = core.createMessagePipe();
131 var calc = new math.CalculatorPtr(pipe.handle0);
132 var newCalc = null;
133 var calcBinding = new bindings.Binding(math.Calculator,
134 new CalculatorImpl(),
135 pipe.handle1);
136
137 assert_equals((await calc.add(2)).value, 2);
138
139 }, 'bind raw handle');
140
141 promise_test(async () => {
142 var integerAccessorPtr = new sampleInterfaces.IntegerAccessorPtr();
143
144 var integerAccessorBinding = new bindings.Binding(
145 sampleInterfaces.IntegerAccessor,
146 new IntegerAccessorImpl(),
147 bindings.makeRequest(integerAccessorPtr));
148 assert_equals(integerAccessorPtr.ptr.version, 0);
149
150 assert_equals(await integerAccessorPtr.ptr.queryVersion(), 3);
151 assert_equals(integerAccessorPtr.ptr.version, 3);
152 }, 'query version');
153
154 promise_test(async () => {
155 var integerAccessorImpl = new IntegerAccessorImpl();
156 var integerAccessorPtr = new sampleInterfaces.IntegerAccessorPtr();
157 var integerAccessorBinding = new bindings.Binding(
158 sampleInterfaces.IntegerAccessor,
159 integerAccessorImpl,
160 bindings.makeRequest(integerAccessorPtr));
161
162 // Inital version is 0.
163 assert_equals(integerAccessorPtr.ptr.version, 0);
164
165 integerAccessorPtr.ptr.requireVersion(1);
166 assert_equals(integerAccessorPtr.ptr.version, 1);
167 integerAccessorPtr.setInteger(123, sampleInterfaces.Enum.VALUE);
168 assert_equals((await integerAccessorPtr.getInteger()).data, 123);
169
170 integerAccessorPtr.ptr.requireVersion(3);
171 assert_equals(integerAccessorPtr.ptr.version, 3);
172 integerAccessorPtr.setInteger(456, sampleInterfaces.Enum.VALUE);
173 assert_equals((await integerAccessorPtr.getInteger()).data, 456);
174
175 // Require a version that is not supported by the impl side.
176 integerAccessorPtr.ptr.requireVersion(4);
177 assert_equals(integerAccessorPtr.ptr.version, 4);
178 integerAccessorPtr.setInteger(789, sampleInterfaces.Enum.VALUE);
179
180 await new Promise((resolve, reject) => {
181 integerAccessorPtr.ptr.setConnectionErrorHandler(() => {
182 resolve();
183 });
184 });
185 assert_equals(integerAccessorImpl.integer, 456);
186
187 }, 'require version');
188
189 done();
190 });
191 173
192 </script> 174 </script>
OLDNEW
« no previous file with comments | « third_party/WebKit/LayoutTests/mojo/connection.html ('k') | third_party/WebKit/LayoutTests/mojo/resources/validation_test_input_parser.js » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698