getAnimations();
+};
+
+Element includes Animatable;
+
+CSSPseudoElement includes Animatable;
+
+[Exposed=Window,
+ Constructor (DOMString type, optional AnimationPlaybackEventInit eventInitDict)]
+interface AnimationPlaybackEvent : Event {
+ readonly attribute double? currentTime;
+ readonly attribute double? timelineTime;
+};
+dictionary AnimationPlaybackEventInit : EventInit {
+ double? currentTime = null;
+ double? timelineTime = null;
+};
diff --git a/tests/wpt/web-platform-tests/keyboard-lock/idlharness.https.html b/tests/wpt/web-platform-tests/keyboard-lock/idlharness.https.html
index 9caa379f4f6..1c3ade02842 100644
--- a/tests/wpt/web-platform-tests/keyboard-lock/idlharness.https.html
+++ b/tests/wpt/web-platform-tests/keyboard-lock/idlharness.https.html
@@ -1,41 +1,34 @@
-Keyboard Lock IDL tests
-Keyboard IDL tests
+
-interface Navigator {
-};
-
-
-
-partial interface Navigator {
- [SecureContext] Promise keyboardLock(optional sequence keyCodes = []);
- [SecureContext] void keyboardUnlock();
-};
-
-
-
-
diff --git a/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardLock-two-parallel-requests.https.html b/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-lock-two-parallel-requests.https.html
similarity index 57%
rename from tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardLock-two-parallel-requests.https.html
rename to tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-lock-two-parallel-requests.https.html
index d553c064d50..501f36fb358 100644
--- a/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardLock-two-parallel-requests.https.html
+++ b/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-lock-two-parallel-requests.https.html
@@ -5,11 +5,11 @@
'use strict';
promise_test((t) => {
- const p1 = navigator.keyboardLock(['a', 'b']);
- const p2 = navigator.keyboardLock(['c', 'd']);
+ const p1 = navigator.keyboard.lock(['a', 'b']);
+ const p2 = navigator.keyboard.lock(['c', 'd']);
return promise_rejects(t, null, p2,
- 'keyboardLock() should only be ' +
+ 'keyboard.lock() should only be ' +
'executed if another request has finished.');
-}, 'Keyboard Lock keyboardLock twice in parallel');
+}, '[Keyboard Lock] keyboard.lock twice in parallel');
diff --git a/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardLock-two-sequential-requests.https.html b/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-lock-two-sequential-requests.https.html
similarity index 56%
rename from tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardLock-two-sequential-requests.https.html
rename to tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-lock-two-sequential-requests.https.html
index 7670be4f383..4403930bf62 100644
--- a/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardLock-two-sequential-requests.https.html
+++ b/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-lock-two-sequential-requests.https.html
@@ -5,10 +5,10 @@
'use strict';
promise_test(() => {
- return navigator.keyboardLock(['a', 'b'])
+ return navigator.keyboard.lock(['a', 'b'])
.then(() => {
- return navigator.keyboardLock(['c', 'd']);
+ return navigator.keyboard.lock(['c', 'd']);
});
-}, 'Keyboard Lock keyboardLock twice sequentially');
+}, '[Keyboard Lock] keyboard.lock called twice sequentially');
diff --git a/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardLock.https.html b/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-lock.https.html
similarity index 72%
rename from tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardLock.https.html
rename to tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-lock.https.html
index 6711decc121..d39e8907647 100644
--- a/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardLock.https.html
+++ b/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-lock.https.html
@@ -5,9 +5,9 @@
'use strict';
promise_test(() => {
- const p = navigator.keyboardLock(['a', 'b']);
+ const p = navigator.keyboard.lock(['a', 'b']);
assert_true(p instanceof Promise);
return p;
-}, 'Keyboard Lock keyboardLock');
+}, '[Keyboard Lock] keyboard.lock');
diff --git a/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardUnlock.https.html b/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-unlock.https.html
similarity index 70%
rename from tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardUnlock.https.html
rename to tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-unlock.https.html
index ceb7a968949..87b10ee49a9 100644
--- a/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboardUnlock.https.html
+++ b/tests/wpt/web-platform-tests/keyboard-lock/navigator-keyboard-unlock.https.html
@@ -5,8 +5,8 @@
'use strict';
test(() => {
- assert_equals(navigator.keyboardUnlock(),
+ assert_equals(navigator.keyboard.unlock(),
undefined);
-}, 'Keyboard Lock keyboardUnlock');
+}, '[Keyboard Lock] keyboard.unlock');
diff --git a/tests/wpt/web-platform-tests/mathml/presentation-markup/scripts/subsup-parameters-2.html b/tests/wpt/web-platform-tests/mathml/presentation-markup/scripts/subsup-parameters-2.html
new file mode 100644
index 00000000000..eaa4f0ffab1
--- /dev/null
+++ b/tests/wpt/web-platform-tests/mathml/presentation-markup/scripts/subsup-parameters-2.html
@@ -0,0 +1,132 @@
+
+
+
+Subscripts and Superscripts parameters
+
+ Null Italic Correction
+
+
+
+ ⫿
+
+
+
+
+ ⫿
+
+
+
+
+ ⫿
+
+
+
+
+ ⫿
+
+
+
+ NonNull Italic Correction
+
+
+
+ ⫿
+
+
+
+
+ ⫿
+
+
+
+
+ ⫿
+
+
+
+
+ ⫿
+
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/mathml/tools/largeop.py b/tests/wpt/web-platform-tests/mathml/tools/largeop.py
index 3c9c6c4c949..73d967689bb 100644
--- a/tests/wpt/web-platform-tests/mathml/tools/largeop.py
+++ b/tests/wpt/web-platform-tests/mathml/tools/largeop.py
@@ -12,3 +12,21 @@ g = f.createChar(-1, "uni2AFF.display")
mathfont.drawRectangleGlyph(g, mathfont.em, v1, 0)
f[nAryWhiteVerticalBarCodePoint].verticalVariants = "uni2AFF uni2AFF.display"
mathfont.save(f)
+
+v1 = 2 * mathfont.em
+v2 = 3 * mathfont.em
+f = mathfont.create("largeop-displayoperatorminheight%d-2AFF-italiccorrection%d" % (v1, v2))
+f.copyright = "Copyright (c) 2018 Igalia S.L."
+f.math.DisplayOperatorMinHeight = v1
+mathfont.createSquareGlyph(f, nAryWhiteVerticalBarCodePoint)
+g = f.createChar(-1, "uni2AFF.display")
+p = g.glyphPen()
+p.moveTo(0, 0)
+p.lineTo(v2, v1)
+p.lineTo(v2 + mathfont.em, v1)
+p.lineTo(mathfont.em, 0)
+p.closePath();
+g.width = mathfont.em + v2
+g.italicCorrection = v2
+f[nAryWhiteVerticalBarCodePoint].verticalVariants = "uni2AFF uni2AFF.display"
+mathfont.save(f)
diff --git a/tests/wpt/web-platform-tests/payment-request/PaymentItem/type_member.https.html b/tests/wpt/web-platform-tests/payment-request/PaymentItem/type_member.https.html
new file mode 100644
index 00000000000..dc62a83f597
--- /dev/null
+++ b/tests/wpt/web-platform-tests/payment-request/PaymentItem/type_member.https.html
@@ -0,0 +1,77 @@
+
+
+ PaymentItem type member
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/payment-request/payment-request-insecure.http.html b/tests/wpt/web-platform-tests/payment-request/payment-request-insecure.http.html
new file mode 100644
index 00000000000..02122203d51
--- /dev/null
+++ b/tests/wpt/web-platform-tests/payment-request/payment-request-insecure.http.html
@@ -0,0 +1,13 @@
+
+
+Test for PaymentRequest Constructor (insecure)
+Test PaymentRequest.show() triggered by user activation using postMessage()
diff --git a/tests/wpt/web-platform-tests/resources/chromium/fake_bluetooth.mojom.js b/tests/wpt/web-platform-tests/resources/chromium/fake_bluetooth.mojom.js
index 4daf3f058e2..08c26b68f61 100644
--- a/tests/wpt/web-platform-tests/resources/chromium/fake_bluetooth.mojom.js
+++ b/tests/wpt/web-platform-tests/resources/chromium/fake_bluetooth.mojom.js
@@ -2270,6 +2270,155 @@
encoder.writeUint32(0);
encoder.encodeStruct(codec.NullableString, val.descriptorId);
};
+ function FakeCentral_RemoveFakeDescriptor_Params(values) {
+ this.initDefaults_();
+ this.initFields_(values);
+ }
+
+
+ FakeCentral_RemoveFakeDescriptor_Params.prototype.initDefaults_ = function() {
+ this.descriptorId = null;
+ this.characteristicId = null;
+ this.serviceId = null;
+ this.peripheralAddress = null;
+ };
+ FakeCentral_RemoveFakeDescriptor_Params.prototype.initFields_ = function(fields) {
+ for(var field in fields) {
+ if (this.hasOwnProperty(field))
+ this[field] = fields[field];
+ }
+ };
+
+ FakeCentral_RemoveFakeDescriptor_Params.validate = function(messageValidator, offset) {
+ var err;
+ err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ var kVersionSizes = [
+ {version: 0, numBytes: 40}
+ ];
+ err = messageValidator.validateStructVersion(offset, kVersionSizes);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_RemoveFakeDescriptor_Params.descriptorId
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_RemoveFakeDescriptor_Params.characteristicId
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 8, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_RemoveFakeDescriptor_Params.serviceId
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 16, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_RemoveFakeDescriptor_Params.peripheralAddress
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 24, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ return validator.validationError.NONE;
+ };
+
+ FakeCentral_RemoveFakeDescriptor_Params.encodedSize = codec.kStructHeaderSize + 32;
+
+ FakeCentral_RemoveFakeDescriptor_Params.decode = function(decoder) {
+ var packed;
+ var val = new FakeCentral_RemoveFakeDescriptor_Params();
+ var numberOfBytes = decoder.readUint32();
+ var version = decoder.readUint32();
+ val.descriptorId = decoder.decodeStruct(codec.String);
+ val.characteristicId = decoder.decodeStruct(codec.String);
+ val.serviceId = decoder.decodeStruct(codec.String);
+ val.peripheralAddress = decoder.decodeStruct(codec.String);
+ return val;
+ };
+
+ FakeCentral_RemoveFakeDescriptor_Params.encode = function(encoder, val) {
+ var packed;
+ encoder.writeUint32(FakeCentral_RemoveFakeDescriptor_Params.encodedSize);
+ encoder.writeUint32(0);
+ encoder.encodeStruct(codec.String, val.descriptorId);
+ encoder.encodeStruct(codec.String, val.characteristicId);
+ encoder.encodeStruct(codec.String, val.serviceId);
+ encoder.encodeStruct(codec.String, val.peripheralAddress);
+ };
+ function FakeCentral_RemoveFakeDescriptor_ResponseParams(values) {
+ this.initDefaults_();
+ this.initFields_(values);
+ }
+
+
+ FakeCentral_RemoveFakeDescriptor_ResponseParams.prototype.initDefaults_ = function() {
+ this.success = false;
+ };
+ FakeCentral_RemoveFakeDescriptor_ResponseParams.prototype.initFields_ = function(fields) {
+ for(var field in fields) {
+ if (this.hasOwnProperty(field))
+ this[field] = fields[field];
+ }
+ };
+
+ FakeCentral_RemoveFakeDescriptor_ResponseParams.validate = function(messageValidator, offset) {
+ var err;
+ err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ var kVersionSizes = [
+ {version: 0, numBytes: 16}
+ ];
+ err = messageValidator.validateStructVersion(offset, kVersionSizes);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ return validator.validationError.NONE;
+ };
+
+ FakeCentral_RemoveFakeDescriptor_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
+
+ FakeCentral_RemoveFakeDescriptor_ResponseParams.decode = function(decoder) {
+ var packed;
+ var val = new FakeCentral_RemoveFakeDescriptor_ResponseParams();
+ var numberOfBytes = decoder.readUint32();
+ var version = decoder.readUint32();
+ packed = decoder.readUint8();
+ val.success = (packed >> 0) & 1 ? true : false;
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ return val;
+ };
+
+ FakeCentral_RemoveFakeDescriptor_ResponseParams.encode = function(encoder, val) {
+ var packed;
+ encoder.writeUint32(FakeCentral_RemoveFakeDescriptor_ResponseParams.encodedSize);
+ encoder.writeUint32(0);
+ packed = 0;
+ packed |= (val.success & 1) << 0
+ encoder.writeUint8(packed);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ };
function FakeCentral_SetNextReadCharacteristicResponse_Params(values) {
this.initDefaults_();
this.initFields_(values);
@@ -2747,25 +2896,25 @@
encoder.skip(1);
encoder.skip(1);
};
- function FakeCentral_GetLastWrittenValue_Params(values) {
+ function FakeCentral_GetLastWrittenCharacteristicValue_Params(values) {
this.initDefaults_();
this.initFields_(values);
}
- FakeCentral_GetLastWrittenValue_Params.prototype.initDefaults_ = function() {
+ FakeCentral_GetLastWrittenCharacteristicValue_Params.prototype.initDefaults_ = function() {
this.characteristicId = null;
this.serviceId = null;
this.peripheralAddress = null;
};
- FakeCentral_GetLastWrittenValue_Params.prototype.initFields_ = function(fields) {
+ FakeCentral_GetLastWrittenCharacteristicValue_Params.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
- FakeCentral_GetLastWrittenValue_Params.validate = function(messageValidator, offset) {
+ FakeCentral_GetLastWrittenCharacteristicValue_Params.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
@@ -2779,19 +2928,19 @@
return err;
- // validate FakeCentral_GetLastWrittenValue_Params.characteristicId
+ // validate FakeCentral_GetLastWrittenCharacteristicValue_Params.characteristicId
err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false)
if (err !== validator.validationError.NONE)
return err;
- // validate FakeCentral_GetLastWrittenValue_Params.serviceId
+ // validate FakeCentral_GetLastWrittenCharacteristicValue_Params.serviceId
err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 8, false)
if (err !== validator.validationError.NONE)
return err;
- // validate FakeCentral_GetLastWrittenValue_Params.peripheralAddress
+ // validate FakeCentral_GetLastWrittenCharacteristicValue_Params.peripheralAddress
err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 16, false)
if (err !== validator.validationError.NONE)
return err;
@@ -2799,11 +2948,11 @@
return validator.validationError.NONE;
};
- FakeCentral_GetLastWrittenValue_Params.encodedSize = codec.kStructHeaderSize + 24;
+ FakeCentral_GetLastWrittenCharacteristicValue_Params.encodedSize = codec.kStructHeaderSize + 24;
- FakeCentral_GetLastWrittenValue_Params.decode = function(decoder) {
+ FakeCentral_GetLastWrittenCharacteristicValue_Params.decode = function(decoder) {
var packed;
- var val = new FakeCentral_GetLastWrittenValue_Params();
+ var val = new FakeCentral_GetLastWrittenCharacteristicValue_Params();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
val.characteristicId = decoder.decodeStruct(codec.String);
@@ -2812,32 +2961,32 @@
return val;
};
- FakeCentral_GetLastWrittenValue_Params.encode = function(encoder, val) {
+ FakeCentral_GetLastWrittenCharacteristicValue_Params.encode = function(encoder, val) {
var packed;
- encoder.writeUint32(FakeCentral_GetLastWrittenValue_Params.encodedSize);
+ encoder.writeUint32(FakeCentral_GetLastWrittenCharacteristicValue_Params.encodedSize);
encoder.writeUint32(0);
encoder.encodeStruct(codec.String, val.characteristicId);
encoder.encodeStruct(codec.String, val.serviceId);
encoder.encodeStruct(codec.String, val.peripheralAddress);
};
- function FakeCentral_GetLastWrittenValue_ResponseParams(values) {
+ function FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams(values) {
this.initDefaults_();
this.initFields_(values);
}
- FakeCentral_GetLastWrittenValue_ResponseParams.prototype.initDefaults_ = function() {
+ FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams.prototype.initDefaults_ = function() {
this.success = false;
this.value = null;
};
- FakeCentral_GetLastWrittenValue_ResponseParams.prototype.initFields_ = function(fields) {
+ FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams.prototype.initFields_ = function(fields) {
for(var field in fields) {
if (this.hasOwnProperty(field))
this[field] = fields[field];
}
};
- FakeCentral_GetLastWrittenValue_ResponseParams.validate = function(messageValidator, offset) {
+ FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams.validate = function(messageValidator, offset) {
var err;
err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
if (err !== validator.validationError.NONE)
@@ -2852,7 +3001,7 @@
- // validate FakeCentral_GetLastWrittenValue_ResponseParams.value
+ // validate FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams.value
err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 1, codec.Uint8, true, [0], 0);
if (err !== validator.validationError.NONE)
return err;
@@ -2860,11 +3009,11 @@
return validator.validationError.NONE;
};
- FakeCentral_GetLastWrittenValue_ResponseParams.encodedSize = codec.kStructHeaderSize + 16;
+ FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams.encodedSize = codec.kStructHeaderSize + 16;
- FakeCentral_GetLastWrittenValue_ResponseParams.decode = function(decoder) {
+ FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams.decode = function(decoder) {
var packed;
- var val = new FakeCentral_GetLastWrittenValue_ResponseParams();
+ var val = new FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams();
var numberOfBytes = decoder.readUint32();
var version = decoder.readUint32();
packed = decoder.readUint8();
@@ -2880,9 +3029,9 @@
return val;
};
- FakeCentral_GetLastWrittenValue_ResponseParams.encode = function(encoder, val) {
+ FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams.encode = function(encoder, val) {
var packed;
- encoder.writeUint32(FakeCentral_GetLastWrittenValue_ResponseParams.encodedSize);
+ encoder.writeUint32(FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams.encodedSize);
encoder.writeUint32(0);
packed = 0;
packed |= (val.success & 1) << 0
@@ -3070,6 +3219,329 @@
encoder.skip(1);
encoder.skip(1);
};
+ function FakeCentral_SetNextWriteDescriptorResponse_Params(values) {
+ this.initDefaults_();
+ this.initFields_(values);
+ }
+
+
+ FakeCentral_SetNextWriteDescriptorResponse_Params.prototype.initDefaults_ = function() {
+ this.gattCode = 0;
+ this.descriptorId = null;
+ this.characteristicId = null;
+ this.serviceId = null;
+ this.peripheralAddress = null;
+ };
+ FakeCentral_SetNextWriteDescriptorResponse_Params.prototype.initFields_ = function(fields) {
+ for(var field in fields) {
+ if (this.hasOwnProperty(field))
+ this[field] = fields[field];
+ }
+ };
+
+ FakeCentral_SetNextWriteDescriptorResponse_Params.validate = function(messageValidator, offset) {
+ var err;
+ err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ var kVersionSizes = [
+ {version: 0, numBytes: 48}
+ ];
+ err = messageValidator.validateStructVersion(offset, kVersionSizes);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+
+ // validate FakeCentral_SetNextWriteDescriptorResponse_Params.descriptorId
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 8, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_SetNextWriteDescriptorResponse_Params.characteristicId
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 16, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_SetNextWriteDescriptorResponse_Params.serviceId
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 24, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_SetNextWriteDescriptorResponse_Params.peripheralAddress
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 32, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ return validator.validationError.NONE;
+ };
+
+ FakeCentral_SetNextWriteDescriptorResponse_Params.encodedSize = codec.kStructHeaderSize + 40;
+
+ FakeCentral_SetNextWriteDescriptorResponse_Params.decode = function(decoder) {
+ var packed;
+ var val = new FakeCentral_SetNextWriteDescriptorResponse_Params();
+ var numberOfBytes = decoder.readUint32();
+ var version = decoder.readUint32();
+ val.gattCode = decoder.decodeStruct(codec.Uint16);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ val.descriptorId = decoder.decodeStruct(codec.String);
+ val.characteristicId = decoder.decodeStruct(codec.String);
+ val.serviceId = decoder.decodeStruct(codec.String);
+ val.peripheralAddress = decoder.decodeStruct(codec.String);
+ return val;
+ };
+
+ FakeCentral_SetNextWriteDescriptorResponse_Params.encode = function(encoder, val) {
+ var packed;
+ encoder.writeUint32(FakeCentral_SetNextWriteDescriptorResponse_Params.encodedSize);
+ encoder.writeUint32(0);
+ encoder.encodeStruct(codec.Uint16, val.gattCode);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.encodeStruct(codec.String, val.descriptorId);
+ encoder.encodeStruct(codec.String, val.characteristicId);
+ encoder.encodeStruct(codec.String, val.serviceId);
+ encoder.encodeStruct(codec.String, val.peripheralAddress);
+ };
+ function FakeCentral_SetNextWriteDescriptorResponse_ResponseParams(values) {
+ this.initDefaults_();
+ this.initFields_(values);
+ }
+
+
+ FakeCentral_SetNextWriteDescriptorResponse_ResponseParams.prototype.initDefaults_ = function() {
+ this.success = false;
+ };
+ FakeCentral_SetNextWriteDescriptorResponse_ResponseParams.prototype.initFields_ = function(fields) {
+ for(var field in fields) {
+ if (this.hasOwnProperty(field))
+ this[field] = fields[field];
+ }
+ };
+
+ FakeCentral_SetNextWriteDescriptorResponse_ResponseParams.validate = function(messageValidator, offset) {
+ var err;
+ err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ var kVersionSizes = [
+ {version: 0, numBytes: 16}
+ ];
+ err = messageValidator.validateStructVersion(offset, kVersionSizes);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ return validator.validationError.NONE;
+ };
+
+ FakeCentral_SetNextWriteDescriptorResponse_ResponseParams.encodedSize = codec.kStructHeaderSize + 8;
+
+ FakeCentral_SetNextWriteDescriptorResponse_ResponseParams.decode = function(decoder) {
+ var packed;
+ var val = new FakeCentral_SetNextWriteDescriptorResponse_ResponseParams();
+ var numberOfBytes = decoder.readUint32();
+ var version = decoder.readUint32();
+ packed = decoder.readUint8();
+ val.success = (packed >> 0) & 1 ? true : false;
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ return val;
+ };
+
+ FakeCentral_SetNextWriteDescriptorResponse_ResponseParams.encode = function(encoder, val) {
+ var packed;
+ encoder.writeUint32(FakeCentral_SetNextWriteDescriptorResponse_ResponseParams.encodedSize);
+ encoder.writeUint32(0);
+ packed = 0;
+ packed |= (val.success & 1) << 0
+ encoder.writeUint8(packed);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ };
+ function FakeCentral_GetLastWrittenDescriptorValue_Params(values) {
+ this.initDefaults_();
+ this.initFields_(values);
+ }
+
+
+ FakeCentral_GetLastWrittenDescriptorValue_Params.prototype.initDefaults_ = function() {
+ this.descriptorId = null;
+ this.characteristicId = null;
+ this.serviceId = null;
+ this.peripheralAddress = null;
+ };
+ FakeCentral_GetLastWrittenDescriptorValue_Params.prototype.initFields_ = function(fields) {
+ for(var field in fields) {
+ if (this.hasOwnProperty(field))
+ this[field] = fields[field];
+ }
+ };
+
+ FakeCentral_GetLastWrittenDescriptorValue_Params.validate = function(messageValidator, offset) {
+ var err;
+ err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ var kVersionSizes = [
+ {version: 0, numBytes: 40}
+ ];
+ err = messageValidator.validateStructVersion(offset, kVersionSizes);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_GetLastWrittenDescriptorValue_Params.descriptorId
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_GetLastWrittenDescriptorValue_Params.characteristicId
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 8, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_GetLastWrittenDescriptorValue_Params.serviceId
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 16, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+ // validate FakeCentral_GetLastWrittenDescriptorValue_Params.peripheralAddress
+ err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 24, false)
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ return validator.validationError.NONE;
+ };
+
+ FakeCentral_GetLastWrittenDescriptorValue_Params.encodedSize = codec.kStructHeaderSize + 32;
+
+ FakeCentral_GetLastWrittenDescriptorValue_Params.decode = function(decoder) {
+ var packed;
+ var val = new FakeCentral_GetLastWrittenDescriptorValue_Params();
+ var numberOfBytes = decoder.readUint32();
+ var version = decoder.readUint32();
+ val.descriptorId = decoder.decodeStruct(codec.String);
+ val.characteristicId = decoder.decodeStruct(codec.String);
+ val.serviceId = decoder.decodeStruct(codec.String);
+ val.peripheralAddress = decoder.decodeStruct(codec.String);
+ return val;
+ };
+
+ FakeCentral_GetLastWrittenDescriptorValue_Params.encode = function(encoder, val) {
+ var packed;
+ encoder.writeUint32(FakeCentral_GetLastWrittenDescriptorValue_Params.encodedSize);
+ encoder.writeUint32(0);
+ encoder.encodeStruct(codec.String, val.descriptorId);
+ encoder.encodeStruct(codec.String, val.characteristicId);
+ encoder.encodeStruct(codec.String, val.serviceId);
+ encoder.encodeStruct(codec.String, val.peripheralAddress);
+ };
+ function FakeCentral_GetLastWrittenDescriptorValue_ResponseParams(values) {
+ this.initDefaults_();
+ this.initFields_(values);
+ }
+
+
+ FakeCentral_GetLastWrittenDescriptorValue_ResponseParams.prototype.initDefaults_ = function() {
+ this.success = false;
+ this.value = null;
+ };
+ FakeCentral_GetLastWrittenDescriptorValue_ResponseParams.prototype.initFields_ = function(fields) {
+ for(var field in fields) {
+ if (this.hasOwnProperty(field))
+ this[field] = fields[field];
+ }
+ };
+
+ FakeCentral_GetLastWrittenDescriptorValue_ResponseParams.validate = function(messageValidator, offset) {
+ var err;
+ err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ var kVersionSizes = [
+ {version: 0, numBytes: 24}
+ ];
+ err = messageValidator.validateStructVersion(offset, kVersionSizes);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+
+
+ // validate FakeCentral_GetLastWrittenDescriptorValue_ResponseParams.value
+ err = messageValidator.validateArrayPointer(offset + codec.kStructHeaderSize + 8, 1, codec.Uint8, true, [0], 0);
+ if (err !== validator.validationError.NONE)
+ return err;
+
+ return validator.validationError.NONE;
+ };
+
+ FakeCentral_GetLastWrittenDescriptorValue_ResponseParams.encodedSize = codec.kStructHeaderSize + 16;
+
+ FakeCentral_GetLastWrittenDescriptorValue_ResponseParams.decode = function(decoder) {
+ var packed;
+ var val = new FakeCentral_GetLastWrittenDescriptorValue_ResponseParams();
+ var numberOfBytes = decoder.readUint32();
+ var version = decoder.readUint32();
+ packed = decoder.readUint8();
+ val.success = (packed >> 0) & 1 ? true : false;
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ decoder.skip(1);
+ val.value = decoder.decodeArrayPointer(codec.Uint8);
+ return val;
+ };
+
+ FakeCentral_GetLastWrittenDescriptorValue_ResponseParams.encode = function(encoder, val) {
+ var packed;
+ encoder.writeUint32(FakeCentral_GetLastWrittenDescriptorValue_ResponseParams.encodedSize);
+ encoder.writeUint32(0);
+ packed = 0;
+ packed |= (val.success & 1) << 0
+ encoder.writeUint8(packed);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.skip(1);
+ encoder.encodeArrayPointer(codec.Uint8, val.value);
+ };
var kFakeBluetooth_SetLESupported_Name = 0;
var kFakeBluetooth_SimulateCentral_Name = 1;
var kFakeBluetooth_AllResponsesConsumed_Name = 2;
@@ -3310,11 +3782,14 @@
var kFakeCentral_AddFakeCharacteristic_Name = 8;
var kFakeCentral_RemoveFakeCharacteristic_Name = 9;
var kFakeCentral_AddFakeDescriptor_Name = 10;
- var kFakeCentral_SetNextReadCharacteristicResponse_Name = 11;
- var kFakeCentral_SetNextWriteCharacteristicResponse_Name = 12;
- var kFakeCentral_SetNextSubscribeToNotificationsResponse_Name = 13;
- var kFakeCentral_GetLastWrittenValue_Name = 14;
- var kFakeCentral_SetNextReadDescriptorResponse_Name = 15;
+ var kFakeCentral_RemoveFakeDescriptor_Name = 11;
+ var kFakeCentral_SetNextReadCharacteristicResponse_Name = 12;
+ var kFakeCentral_SetNextWriteCharacteristicResponse_Name = 13;
+ var kFakeCentral_SetNextSubscribeToNotificationsResponse_Name = 14;
+ var kFakeCentral_GetLastWrittenCharacteristicValue_Name = 15;
+ var kFakeCentral_SetNextReadDescriptorResponse_Name = 16;
+ var kFakeCentral_SetNextWriteDescriptorResponse_Name = 17;
+ var kFakeCentral_GetLastWrittenDescriptorValue_Name = 18;
function FakeCentralPtr(handleOrPtrInfo) {
this.ptr = new bindings.InterfacePtrController(FakeCentral,
@@ -3623,6 +4098,34 @@
});
}.bind(this));
};
+ FakeCentralPtr.prototype.removeFakeDescriptor = function() {
+ return FakeCentralProxy.prototype.removeFakeDescriptor
+ .apply(this.ptr.getProxy(), arguments);
+ };
+
+ FakeCentralProxy.prototype.removeFakeDescriptor = function(descriptorId, characteristicId, serviceId, peripheralAddress) {
+ var params = new FakeCentral_RemoveFakeDescriptor_Params();
+ params.descriptorId = descriptorId;
+ params.characteristicId = characteristicId;
+ params.serviceId = serviceId;
+ params.peripheralAddress = peripheralAddress;
+ return new Promise(function(resolve, reject) {
+ var builder = new codec.MessageV1Builder(
+ kFakeCentral_RemoveFakeDescriptor_Name,
+ codec.align(FakeCentral_RemoveFakeDescriptor_Params.encodedSize),
+ codec.kMessageExpectsResponse, 0);
+ builder.encodeStruct(FakeCentral_RemoveFakeDescriptor_Params, params);
+ var message = builder.finish();
+ this.receiver_.acceptAndExpectResponse(message).then(function(message) {
+ var reader = new codec.MessageReader(message);
+ var responseParams =
+ reader.decodeStruct(FakeCentral_RemoveFakeDescriptor_ResponseParams);
+ resolve(responseParams);
+ }).catch(function(result) {
+ reject(Error("Connection error: " + result));
+ });
+ }.bind(this));
+ };
FakeCentralPtr.prototype.setNextReadCharacteristicResponse = function() {
return FakeCentralProxy.prototype.setNextReadCharacteristicResponse
.apply(this.ptr.getProxy(), arguments);
@@ -3708,27 +4211,27 @@
});
}.bind(this));
};
- FakeCentralPtr.prototype.getLastWrittenValue = function() {
- return FakeCentralProxy.prototype.getLastWrittenValue
+ FakeCentralPtr.prototype.getLastWrittenCharacteristicValue = function() {
+ return FakeCentralProxy.prototype.getLastWrittenCharacteristicValue
.apply(this.ptr.getProxy(), arguments);
};
- FakeCentralProxy.prototype.getLastWrittenValue = function(characteristicId, serviceId, peripheralAddress) {
- var params = new FakeCentral_GetLastWrittenValue_Params();
+ FakeCentralProxy.prototype.getLastWrittenCharacteristicValue = function(characteristicId, serviceId, peripheralAddress) {
+ var params = new FakeCentral_GetLastWrittenCharacteristicValue_Params();
params.characteristicId = characteristicId;
params.serviceId = serviceId;
params.peripheralAddress = peripheralAddress;
return new Promise(function(resolve, reject) {
var builder = new codec.MessageV1Builder(
- kFakeCentral_GetLastWrittenValue_Name,
- codec.align(FakeCentral_GetLastWrittenValue_Params.encodedSize),
+ kFakeCentral_GetLastWrittenCharacteristicValue_Name,
+ codec.align(FakeCentral_GetLastWrittenCharacteristicValue_Params.encodedSize),
codec.kMessageExpectsResponse, 0);
- builder.encodeStruct(FakeCentral_GetLastWrittenValue_Params, params);
+ builder.encodeStruct(FakeCentral_GetLastWrittenCharacteristicValue_Params, params);
var message = builder.finish();
this.receiver_.acceptAndExpectResponse(message).then(function(message) {
var reader = new codec.MessageReader(message);
var responseParams =
- reader.decodeStruct(FakeCentral_GetLastWrittenValue_ResponseParams);
+ reader.decodeStruct(FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams);
resolve(responseParams);
}).catch(function(result) {
reject(Error("Connection error: " + result));
@@ -3765,6 +4268,63 @@
});
}.bind(this));
};
+ FakeCentralPtr.prototype.setNextWriteDescriptorResponse = function() {
+ return FakeCentralProxy.prototype.setNextWriteDescriptorResponse
+ .apply(this.ptr.getProxy(), arguments);
+ };
+
+ FakeCentralProxy.prototype.setNextWriteDescriptorResponse = function(gattCode, descriptorId, characteristicId, serviceId, peripheralAddress) {
+ var params = new FakeCentral_SetNextWriteDescriptorResponse_Params();
+ params.gattCode = gattCode;
+ params.descriptorId = descriptorId;
+ params.characteristicId = characteristicId;
+ params.serviceId = serviceId;
+ params.peripheralAddress = peripheralAddress;
+ return new Promise(function(resolve, reject) {
+ var builder = new codec.MessageV1Builder(
+ kFakeCentral_SetNextWriteDescriptorResponse_Name,
+ codec.align(FakeCentral_SetNextWriteDescriptorResponse_Params.encodedSize),
+ codec.kMessageExpectsResponse, 0);
+ builder.encodeStruct(FakeCentral_SetNextWriteDescriptorResponse_Params, params);
+ var message = builder.finish();
+ this.receiver_.acceptAndExpectResponse(message).then(function(message) {
+ var reader = new codec.MessageReader(message);
+ var responseParams =
+ reader.decodeStruct(FakeCentral_SetNextWriteDescriptorResponse_ResponseParams);
+ resolve(responseParams);
+ }).catch(function(result) {
+ reject(Error("Connection error: " + result));
+ });
+ }.bind(this));
+ };
+ FakeCentralPtr.prototype.getLastWrittenDescriptorValue = function() {
+ return FakeCentralProxy.prototype.getLastWrittenDescriptorValue
+ .apply(this.ptr.getProxy(), arguments);
+ };
+
+ FakeCentralProxy.prototype.getLastWrittenDescriptorValue = function(descriptorId, characteristicId, serviceId, peripheralAddress) {
+ var params = new FakeCentral_GetLastWrittenDescriptorValue_Params();
+ params.descriptorId = descriptorId;
+ params.characteristicId = characteristicId;
+ params.serviceId = serviceId;
+ params.peripheralAddress = peripheralAddress;
+ return new Promise(function(resolve, reject) {
+ var builder = new codec.MessageV1Builder(
+ kFakeCentral_GetLastWrittenDescriptorValue_Name,
+ codec.align(FakeCentral_GetLastWrittenDescriptorValue_Params.encodedSize),
+ codec.kMessageExpectsResponse, 0);
+ builder.encodeStruct(FakeCentral_GetLastWrittenDescriptorValue_Params, params);
+ var message = builder.finish();
+ this.receiver_.acceptAndExpectResponse(message).then(function(message) {
+ var reader = new codec.MessageReader(message);
+ var responseParams =
+ reader.decodeStruct(FakeCentral_GetLastWrittenDescriptorValue_ResponseParams);
+ resolve(responseParams);
+ }).catch(function(result) {
+ reject(Error("Connection error: " + result));
+ });
+ }.bind(this));
+ };
function FakeCentralStub(delegate) {
this.delegate_ = delegate;
@@ -3802,6 +4362,9 @@
FakeCentralStub.prototype.addFakeDescriptor = function(descriptorUuid, characteristicId, serviceId, peripheralAddress) {
return this.delegate_ && this.delegate_.addFakeDescriptor && this.delegate_.addFakeDescriptor(descriptorUuid, characteristicId, serviceId, peripheralAddress);
}
+ FakeCentralStub.prototype.removeFakeDescriptor = function(descriptorId, characteristicId, serviceId, peripheralAddress) {
+ return this.delegate_ && this.delegate_.removeFakeDescriptor && this.delegate_.removeFakeDescriptor(descriptorId, characteristicId, serviceId, peripheralAddress);
+ }
FakeCentralStub.prototype.setNextReadCharacteristicResponse = function(gattCode, value, characteristicId, serviceId, peripheralAddress) {
return this.delegate_ && this.delegate_.setNextReadCharacteristicResponse && this.delegate_.setNextReadCharacteristicResponse(gattCode, value, characteristicId, serviceId, peripheralAddress);
}
@@ -3811,12 +4374,18 @@
FakeCentralStub.prototype.setNextSubscribeToNotificationsResponse = function(gattCode, characteristicId, serviceId, peripheralAddress) {
return this.delegate_ && this.delegate_.setNextSubscribeToNotificationsResponse && this.delegate_.setNextSubscribeToNotificationsResponse(gattCode, characteristicId, serviceId, peripheralAddress);
}
- FakeCentralStub.prototype.getLastWrittenValue = function(characteristicId, serviceId, peripheralAddress) {
- return this.delegate_ && this.delegate_.getLastWrittenValue && this.delegate_.getLastWrittenValue(characteristicId, serviceId, peripheralAddress);
+ FakeCentralStub.prototype.getLastWrittenCharacteristicValue = function(characteristicId, serviceId, peripheralAddress) {
+ return this.delegate_ && this.delegate_.getLastWrittenCharacteristicValue && this.delegate_.getLastWrittenCharacteristicValue(characteristicId, serviceId, peripheralAddress);
}
FakeCentralStub.prototype.setNextReadDescriptorResponse = function(gattCode, value, descriptorId, characteristicId, serviceId, peripheralAddress) {
return this.delegate_ && this.delegate_.setNextReadDescriptorResponse && this.delegate_.setNextReadDescriptorResponse(gattCode, value, descriptorId, characteristicId, serviceId, peripheralAddress);
}
+ FakeCentralStub.prototype.setNextWriteDescriptorResponse = function(gattCode, descriptorId, characteristicId, serviceId, peripheralAddress) {
+ return this.delegate_ && this.delegate_.setNextWriteDescriptorResponse && this.delegate_.setNextWriteDescriptorResponse(gattCode, descriptorId, characteristicId, serviceId, peripheralAddress);
+ }
+ FakeCentralStub.prototype.getLastWrittenDescriptorValue = function(descriptorId, characteristicId, serviceId, peripheralAddress) {
+ return this.delegate_ && this.delegate_.getLastWrittenDescriptorValue && this.delegate_.getLastWrittenDescriptorValue(descriptorId, characteristicId, serviceId, peripheralAddress);
+ }
FakeCentralStub.prototype.accept = function(message) {
var reader = new codec.MessageReader(message);
@@ -4004,6 +4573,22 @@
responder.accept(message);
});
return true;
+ case kFakeCentral_RemoveFakeDescriptor_Name:
+ var params = reader.decodeStruct(FakeCentral_RemoveFakeDescriptor_Params);
+ this.removeFakeDescriptor(params.descriptorId, params.characteristicId, params.serviceId, params.peripheralAddress).then(function(response) {
+ var responseParams =
+ new FakeCentral_RemoveFakeDescriptor_ResponseParams();
+ responseParams.success = response.success;
+ var builder = new codec.MessageV1Builder(
+ kFakeCentral_RemoveFakeDescriptor_Name,
+ codec.align(FakeCentral_RemoveFakeDescriptor_ResponseParams.encodedSize),
+ codec.kMessageIsResponse, reader.requestID);
+ builder.encodeStruct(FakeCentral_RemoveFakeDescriptor_ResponseParams,
+ responseParams);
+ var message = builder.finish();
+ responder.accept(message);
+ });
+ return true;
case kFakeCentral_SetNextReadCharacteristicResponse_Name:
var params = reader.decodeStruct(FakeCentral_SetNextReadCharacteristicResponse_Params);
this.setNextReadCharacteristicResponse(params.gattCode, params.value, params.characteristicId, params.serviceId, params.peripheralAddress).then(function(response) {
@@ -4052,18 +4637,18 @@
responder.accept(message);
});
return true;
- case kFakeCentral_GetLastWrittenValue_Name:
- var params = reader.decodeStruct(FakeCentral_GetLastWrittenValue_Params);
- this.getLastWrittenValue(params.characteristicId, params.serviceId, params.peripheralAddress).then(function(response) {
+ case kFakeCentral_GetLastWrittenCharacteristicValue_Name:
+ var params = reader.decodeStruct(FakeCentral_GetLastWrittenCharacteristicValue_Params);
+ this.getLastWrittenCharacteristicValue(params.characteristicId, params.serviceId, params.peripheralAddress).then(function(response) {
var responseParams =
- new FakeCentral_GetLastWrittenValue_ResponseParams();
+ new FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams();
responseParams.success = response.success;
responseParams.value = response.value;
var builder = new codec.MessageV1Builder(
- kFakeCentral_GetLastWrittenValue_Name,
- codec.align(FakeCentral_GetLastWrittenValue_ResponseParams.encodedSize),
+ kFakeCentral_GetLastWrittenCharacteristicValue_Name,
+ codec.align(FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams.encodedSize),
codec.kMessageIsResponse, reader.requestID);
- builder.encodeStruct(FakeCentral_GetLastWrittenValue_ResponseParams,
+ builder.encodeStruct(FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams,
responseParams);
var message = builder.finish();
responder.accept(message);
@@ -4085,6 +4670,39 @@
responder.accept(message);
});
return true;
+ case kFakeCentral_SetNextWriteDescriptorResponse_Name:
+ var params = reader.decodeStruct(FakeCentral_SetNextWriteDescriptorResponse_Params);
+ this.setNextWriteDescriptorResponse(params.gattCode, params.descriptorId, params.characteristicId, params.serviceId, params.peripheralAddress).then(function(response) {
+ var responseParams =
+ new FakeCentral_SetNextWriteDescriptorResponse_ResponseParams();
+ responseParams.success = response.success;
+ var builder = new codec.MessageV1Builder(
+ kFakeCentral_SetNextWriteDescriptorResponse_Name,
+ codec.align(FakeCentral_SetNextWriteDescriptorResponse_ResponseParams.encodedSize),
+ codec.kMessageIsResponse, reader.requestID);
+ builder.encodeStruct(FakeCentral_SetNextWriteDescriptorResponse_ResponseParams,
+ responseParams);
+ var message = builder.finish();
+ responder.accept(message);
+ });
+ return true;
+ case kFakeCentral_GetLastWrittenDescriptorValue_Name:
+ var params = reader.decodeStruct(FakeCentral_GetLastWrittenDescriptorValue_Params);
+ this.getLastWrittenDescriptorValue(params.descriptorId, params.characteristicId, params.serviceId, params.peripheralAddress).then(function(response) {
+ var responseParams =
+ new FakeCentral_GetLastWrittenDescriptorValue_ResponseParams();
+ responseParams.success = response.success;
+ responseParams.value = response.value;
+ var builder = new codec.MessageV1Builder(
+ kFakeCentral_GetLastWrittenDescriptorValue_Name,
+ codec.align(FakeCentral_GetLastWrittenDescriptorValue_ResponseParams.encodedSize),
+ codec.kMessageIsResponse, reader.requestID);
+ builder.encodeStruct(FakeCentral_GetLastWrittenDescriptorValue_ResponseParams,
+ responseParams);
+ var message = builder.finish();
+ responder.accept(message);
+ });
+ return true;
default:
return false;
}
@@ -4138,6 +4756,10 @@
if (message.expectsResponse())
paramsClass = FakeCentral_AddFakeDescriptor_Params;
break;
+ case kFakeCentral_RemoveFakeDescriptor_Name:
+ if (message.expectsResponse())
+ paramsClass = FakeCentral_RemoveFakeDescriptor_Params;
+ break;
case kFakeCentral_SetNextReadCharacteristicResponse_Name:
if (message.expectsResponse())
paramsClass = FakeCentral_SetNextReadCharacteristicResponse_Params;
@@ -4150,14 +4772,22 @@
if (message.expectsResponse())
paramsClass = FakeCentral_SetNextSubscribeToNotificationsResponse_Params;
break;
- case kFakeCentral_GetLastWrittenValue_Name:
+ case kFakeCentral_GetLastWrittenCharacteristicValue_Name:
if (message.expectsResponse())
- paramsClass = FakeCentral_GetLastWrittenValue_Params;
+ paramsClass = FakeCentral_GetLastWrittenCharacteristicValue_Params;
break;
case kFakeCentral_SetNextReadDescriptorResponse_Name:
if (message.expectsResponse())
paramsClass = FakeCentral_SetNextReadDescriptorResponse_Params;
break;
+ case kFakeCentral_SetNextWriteDescriptorResponse_Name:
+ if (message.expectsResponse())
+ paramsClass = FakeCentral_SetNextWriteDescriptorResponse_Params;
+ break;
+ case kFakeCentral_GetLastWrittenDescriptorValue_Name:
+ if (message.expectsResponse())
+ paramsClass = FakeCentral_GetLastWrittenDescriptorValue_Params;
+ break;
}
if (paramsClass === null)
return validator.validationError.NONE;
@@ -4212,6 +4842,10 @@
if (message.isResponse())
paramsClass = FakeCentral_AddFakeDescriptor_ResponseParams;
break;
+ case kFakeCentral_RemoveFakeDescriptor_Name:
+ if (message.isResponse())
+ paramsClass = FakeCentral_RemoveFakeDescriptor_ResponseParams;
+ break;
case kFakeCentral_SetNextReadCharacteristicResponse_Name:
if (message.isResponse())
paramsClass = FakeCentral_SetNextReadCharacteristicResponse_ResponseParams;
@@ -4224,14 +4858,22 @@
if (message.isResponse())
paramsClass = FakeCentral_SetNextSubscribeToNotificationsResponse_ResponseParams;
break;
- case kFakeCentral_GetLastWrittenValue_Name:
+ case kFakeCentral_GetLastWrittenCharacteristicValue_Name:
if (message.isResponse())
- paramsClass = FakeCentral_GetLastWrittenValue_ResponseParams;
+ paramsClass = FakeCentral_GetLastWrittenCharacteristicValue_ResponseParams;
break;
case kFakeCentral_SetNextReadDescriptorResponse_Name:
if (message.isResponse())
paramsClass = FakeCentral_SetNextReadDescriptorResponse_ResponseParams;
break;
+ case kFakeCentral_SetNextWriteDescriptorResponse_Name:
+ if (message.isResponse())
+ paramsClass = FakeCentral_SetNextWriteDescriptorResponse_ResponseParams;
+ break;
+ case kFakeCentral_GetLastWrittenDescriptorValue_Name:
+ if (message.isResponse())
+ paramsClass = FakeCentral_GetLastWrittenDescriptorValue_ResponseParams;
+ break;
}
if (paramsClass === null)
return validator.validationError.NONE;
diff --git a/tests/wpt/web-platform-tests/resources/chromium/web-bluetooth-test.js b/tests/wpt/web-platform-tests/resources/chromium/web-bluetooth-test.js
index c10685f376c..e08c8c4afa2 100644
--- a/tests/wpt/web-platform-tests/resources/chromium/web-bluetooth-test.js
+++ b/tests/wpt/web-platform-tests/resources/chromium/web-bluetooth-test.js
@@ -377,7 +377,7 @@ class FakeRemoteGATTCharacteristic {
await this.fake_central_ptr_.setNextWriteCharacteristicResponse(
gatt_code, ...this.ids_);
- if (!success) throw 'setNextWriteResponse failed';
+ if (!success) throw 'setNextWriteCharacteristicResponse failed';
}
// Sets the next subscribe to notifications response for characteristic with
@@ -397,9 +397,10 @@ class FakeRemoteGATTCharacteristic {
// Returns null if no value has yet been written to the characteristic.
async getLastWrittenValue() {
let {success, value} =
- await this.fake_central_ptr_.getLastWrittenValue(...this.ids_);
+ await this.fake_central_ptr_.getLastWrittenCharacteristicValue(
+ ...this.ids_);
- if (!success) throw 'getLastWrittenValue failed';
+ if (!success) throw 'getLastWrittenCharacteristicValue failed';
return value;
}
@@ -444,6 +445,39 @@ class FakeRemoteGATTDescriptor {
if (!success) throw 'setNextReadDescriptorResponse failed';
}
+
+ // Sets the next write response for this descriptor to |code|.
+ // |code| could be a GATT Error Response from
+ // BT 4.2 Vol 3 Part F 3.4.1.1 Error Response or a number outside that range
+ // returned by specific platforms e.g. Android returns 0x101 to signal a GATT
+ // failure.
+ async setNextWriteResponse(gatt_code) {
+ let {success} =
+ await this.fake_central_ptr_.setNextWriteDescriptorResponse(
+ gatt_code, ...this.ids_);
+
+ if (!success) throw 'setNextWriteDescriptorResponse failed';
+ }
+
+ // Gets the last successfully written value to the descriptor.
+ // Returns null if no value has yet been written to the descriptor.
+ async getLastWrittenValue() {
+ let {success, value} =
+ await this.fake_central_ptr_.getLastWrittenDescriptorValue(
+ ...this.ids_);
+
+ if (!success) throw 'getLastWrittenDescriptorValue failed';
+
+ return value;
+ }
+
+ // Removes the fake GATT Descriptor from its fake characteristic.
+ async remove() {
+ let {success} =
+ await this.fake_central_ptr_.removeFakeDescriptor(...this.ids_);
+
+ if (!success) throw 'remove failed';
+ }
}
// FakeChooser allows clients to simulate events that a user would trigger when
diff --git a/tests/wpt/web-platform-tests/resources/idlharness.js b/tests/wpt/web-platform-tests/resources/idlharness.js
index af17cee66a6..fee33fd15a9 100644
--- a/tests/wpt/web-platform-tests/resources/idlharness.js
+++ b/tests/wpt/web-platform-tests/resources/idlharness.js
@@ -177,7 +177,7 @@ IdlArray.prototype.add_idls = function(raw_idls, options)
};
//@}
-IdlArray.prototype.add_untested_idls = function(raw_idls)
+IdlArray.prototype.add_untested_idls = function(raw_idls, options)
//@{
{
/** Entry point. See documentation at beginning of file. */
@@ -193,7 +193,7 @@ IdlArray.prototype.add_untested_idls = function(raw_idls)
}
}
}
- this.internal_add_idls(parsed_idls);
+ this.internal_add_idls(parsed_idls, options);
};
//@}
@@ -274,14 +274,14 @@ IdlArray.prototype.internal_add_idls = function(parsed_idls, options)
}
parsed_idl.array = this;
- if (parsed_idl.name in this.members)
- {
- throw "Duplicate identifier " + parsed_idl.name;
- }
if (should_skip(parsed_idl.name))
{
return;
}
+ if (parsed_idl.name in this.members)
+ {
+ throw "Duplicate identifier " + parsed_idl.name;
+ }
switch(parsed_idl.type)
{
case "interface":
@@ -2069,6 +2069,7 @@ IdlInterface.prototype.add_iterable_members = function(member)
};
IdlInterface.prototype.test_to_json_operation = function(memberHolderObject, member) {
+ var instanceName = memberHolderObject.constructor.name;
if (member.has_extended_attribute("Default")) {
var map = this.default_to_json_operation();
test(function() {
@@ -2082,12 +2083,12 @@ IdlInterface.prototype.test_to_json_operation = function(memberHolderObject, mem
this.array.assert_type_is(json[k], type);
delete json[k];
}, this);
- }.bind(this), "Test default toJSON operation of " + this.name);
+ }.bind(this), "Test default toJSON operation of " + instanceName);
} else {
test(function() {
- assert_true(this.array.is_json_type(member.idlType), JSON.stringify(member.idlType) + " is not an appropriate return value for the toJSON operation of " + this.name);
+ assert_true(this.array.is_json_type(member.idlType), JSON.stringify(member.idlType) + " is not an appropriate return value for the toJSON operation of " + instanceName);
this.array.assert_type_is(memberHolderObject.toJSON(), member.idlType);
- }.bind(this), "Test toJSON operation of " + this.name);
+ }.bind(this), "Test toJSON operation of " + instanceName);
}
};
diff --git a/tests/wpt/web-platform-tests/resources/test/conftest.py b/tests/wpt/web-platform-tests/resources/test/conftest.py
index 047ca1caed2..4688421af23 100644
--- a/tests/wpt/web-platform-tests/resources/test/conftest.py
+++ b/tests/wpt/web-platform-tests/resources/test/conftest.py
@@ -24,8 +24,8 @@ def pytest_configure(config):
config.driver = webdriver.Firefox(firefox_binary=config.getoption("--binary"))
config.server = WPTServer(WPT_ROOT)
config.server.start()
- config.add_cleanup(lambda: config.server.stop())
- config.add_cleanup(lambda: config.driver.quit())
+ config.add_cleanup(config.server.stop)
+ config.add_cleanup(config.driver.quit)
class HTMLItem(pytest.Item, pytest.Collector):
def __init__(self, filename, parent):
diff --git a/tests/wpt/web-platform-tests/resources/test/tests/idlharness/IdlInterface/test_to_json_operation.html b/tests/wpt/web-platform-tests/resources/test/tests/idlharness/IdlInterface/test_to_json_operation.html
index c758d5bd327..d9c3fcf611c 100644
--- a/tests/wpt/web-platform-tests/resources/test/tests/idlharness/IdlInterface/test_to_json_operation.html
+++ b/tests/wpt/web-platform-tests/resources/test/tests/idlharness/IdlInterface/test_to_json_operation.html
@@ -12,7 +12,7 @@
+
+
+
+
diff --git a/tests/wpt/web-platform-tests/tools/.gitignore b/tests/wpt/web-platform-tests/tools/.gitignore
index 034e3ccb760..f888ce9935a 100644
--- a/tests/wpt/web-platform-tests/tools/.gitignore
+++ b/tests/wpt/web-platform-tests/tools/.gitignore
@@ -3,7 +3,6 @@
.coverage.*
htmlcov/
coverage.xml
-.tox/
.cache/
.hypothesis/
*.py[co]
diff --git a/tests/wpt/web-platform-tests/tools/gitignore/gitignore.py b/tests/wpt/web-platform-tests/tools/gitignore/gitignore.py
index 629ed6b412e..0be6f8f4c9c 100644
--- a/tests/wpt/web-platform-tests/tools/gitignore/gitignore.py
+++ b/tests/wpt/web-platform-tests/tools/gitignore/gitignore.py
@@ -17,6 +17,12 @@ def fnmatch_translate(pat, path_name=False):
else:
any_char = "."
parts.append("^(?:.*/)?")
+ if pat[-1] == "/":
+ # If the last character is / match this directory or any subdirectory
+ pat = pat[:-1]
+ suffix = "(?:/|$)"
+ else:
+ suffix = "$"
while i < len(pat):
c = pat[i]
if c == "\\":
@@ -63,7 +69,7 @@ def fnmatch_translate(pat, path_name=False):
if seq:
raise ValueError
- parts.append("$")
+ parts.append(suffix)
try:
return re.compile("".join(parts))
except Exception:
@@ -84,7 +90,7 @@ def parse_line(line):
if dir_only:
line = line[:-1]
- return invert, dir_only, fnmatch_translate(line, "/" in line)
+ return invert, dir_only, fnmatch_translate(line, dir_only)
class PathFilter(object):
diff --git a/tests/wpt/web-platform-tests/tools/gitignore/tests/test_gitignore.py b/tests/wpt/web-platform-tests/tools/gitignore/tests/test_gitignore.py
index 44f3353e941..75a0d58b2c6 100644
--- a/tests/wpt/web-platform-tests/tools/gitignore/tests/test_gitignore.py
+++ b/tests/wpt/web-platform-tests/tools/gitignore/tests/test_gitignore.py
@@ -11,7 +11,8 @@ match_data = [
("/*.c", False, ["a.c", ".c"]),
("**/b", False, ["a/b", "a/c/b"]),
("*b", True, ["ab"]),
- ("**/b", True, ["a/b"])
+ ("**/b", True, ["a/b"]),
+ ("a/", True, ["a", "a/b", "a/b/c"])
]
mismatch_data = [
@@ -23,6 +24,7 @@ mismatch_data = [
("**b", True, ["a/b"]),
("a[/]b", True, ["a/b"]),
("**/b", True, ["a/c/b"]),
+ ("a", True, ["ab"])
]
invalid_data = [
@@ -40,21 +42,25 @@ filter_data = [
("c/b", True)
]
+
def expand_data(compact_data):
for pattern, path_name, inputs in compact_data:
for input in inputs:
yield pattern, input, path_name
+
@pytest.mark.parametrize("pattern, input, path_name", expand_data(match_data))
def tests_match(pattern, input, path_name):
regexp = fnmatch_translate(pattern, path_name)
assert regexp.match(input) is not None
+
@pytest.mark.parametrize("pattern, input, path_name", expand_data(mismatch_data))
def tests_no_match(pattern, input, path_name):
regexp = fnmatch_translate(pattern, path_name)
assert regexp.match(input) is None
+
@pytest.mark.parametrize("pattern", invalid_data)
def tests_invalid(pattern):
with pytest.raises(ValueError):
@@ -62,6 +68,7 @@ def tests_invalid(pattern):
with pytest.raises(ValueError):
fnmatch_translate(pattern, True)
+
@pytest.mark.parametrize("path, expected", filter_data)
def test_path_filter(path, expected):
extras = [
diff --git a/tests/wpt/web-platform-tests/tools/lint/lint.py b/tests/wpt/web-platform-tests/tools/lint/lint.py
index 7eb3d4ac7ec..8c53d2132f5 100644
--- a/tests/wpt/web-platform-tests/tools/lint/lint.py
+++ b/tests/wpt/web-platform-tests/tools/lint/lint.py
@@ -60,7 +60,7 @@ you could add the following line to the lint.whitelist file.
%s: %s"""
def all_filesystem_paths(repo_root, subdir=None):
- path_filter = PathFilter(repo_root, extras=[".git/*"])
+ path_filter = PathFilter(repo_root, extras=[".git/"])
if subdir:
expanded_path = subdir
else:
@@ -72,8 +72,7 @@ def all_filesystem_paths(repo_root, subdir=None):
yield path
dirnames[:] = [item for item in dirnames if
path_filter(os.path.relpath(os.path.join(dirpath, item) + "/",
- repo_root))]
-
+ repo_root)+"/")]
def _all_files_equal(paths):
"""
diff --git a/tests/wpt/web-platform-tests/web-animations/interfaces/Animation/idlharness.html b/tests/wpt/web-platform-tests/web-animations/interfaces/Animation/idlharness.html
index 20fca1361e7..0b737a5882e 100644
--- a/tests/wpt/web-platform-tests/web-animations/interfaces/Animation/idlharness.html
+++ b/tests/wpt/web-platform-tests/web-animations/interfaces/Animation/idlharness.html
@@ -7,43 +7,22 @@
-
diff --git a/tests/wpt/web-platform-tests/web-animations/interfaces/AnimationPlaybackEvent/idlharness.html b/tests/wpt/web-platform-tests/web-animations/interfaces/AnimationPlaybackEvent/idlharness.html
index 0c3517387cd..9570c0f0dbf 100644
--- a/tests/wpt/web-platform-tests/web-animations/interfaces/AnimationPlaybackEvent/idlharness.html
+++ b/tests/wpt/web-platform-tests/web-animations/interfaces/AnimationPlaybackEvent/idlharness.html
@@ -8,39 +8,32 @@
-
diff --git a/tests/wpt/web-platform-tests/web-animations/interfaces/DocumentTimeline/idlharness.html b/tests/wpt/web-platform-tests/web-animations/interfaces/DocumentTimeline/idlharness.html
index 696f4f79385..6b22c91780e 100644
--- a/tests/wpt/web-platform-tests/web-animations/interfaces/DocumentTimeline/idlharness.html
+++ b/tests/wpt/web-platform-tests/web-animations/interfaces/DocumentTimeline/idlharness.html
@@ -7,30 +7,24 @@
-
-
diff --git a/tests/wpt/web-platform-tests/web-animations/interfaces/KeyframeEffect/idlharness.html b/tests/wpt/web-platform-tests/web-animations/interfaces/KeyframeEffect/idlharness.html
index 0340a19d31c..00cdd998cfa 100644
--- a/tests/wpt/web-platform-tests/web-animations/interfaces/KeyframeEffect/idlharness.html
+++ b/tests/wpt/web-platform-tests/web-animations/interfaces/KeyframeEffect/idlharness.html
@@ -10,14 +10,6 @@
-
diff --git a/tests/wpt/web-platform-tests/webaudio/idlharness.https.html b/tests/wpt/web-platform-tests/webaudio/idlharness.https.html
index a8be8d0ea53..9e15e4798de 100644
--- a/tests/wpt/web-platform-tests/webaudio/idlharness.https.html
+++ b/tests/wpt/web-platform-tests/webaudio/idlharness.https.html
@@ -25,12 +25,15 @@ promise_test(async t => {
const idl_array = new IdlArray();
-
- idl_array.add_untested_idls('interface LinkStyle {};'); // Dependency of HTML
+ // Dependencies of HTML
+ idl_array.add_untested_idls('interface LinkStyle {};');
+ idl_array.add_untested_idls('interface SVGElement {};');
idl_array.add_untested_idls(html);
+
idl_array.add_untested_idls(dom);
idl_array.add_untested_idls(mediacapture);
idl_array.add_untested_idls('interface Worklet {};');
+
idl_array.add_idls(webaudio);
const sample_rate = 44100;
diff --git a/tests/wpt/web-platform-tests/webrtc/RTCPeerConnection-setLocalDescription-offer.html b/tests/wpt/web-platform-tests/webrtc/RTCPeerConnection-setLocalDescription-offer.html
index 5de04e916e6..76df63a8a80 100644
--- a/tests/wpt/web-platform-tests/webrtc/RTCPeerConnection-setLocalDescription-offer.html
+++ b/tests/wpt/web-platform-tests/webrtc/RTCPeerConnection-setLocalDescription-offer.html
@@ -99,11 +99,12 @@
*/
promise_test(t => {
const pc = new RTCPeerConnection();
+ const pc2 = new RTCPeerConnection();
return generateOffer({ pc, data: true })
.then(offer =>
promise_rejects(t, 'InvalidModificationError',
- pc.setLocalDescription(offer)));
+ pc2.setLocalDescription(offer)));
}, 'setLocalDescription() with offer not created by own createOffer() should reject with InvalidModificationError');
promise_test(t => {
diff --git a/tests/wpt/web-platform-tests/workers/modules/dedicated-worker-options-type.html b/tests/wpt/web-platform-tests/workers/modules/dedicated-worker-options-type.html
new file mode 100644
index 00000000000..b7c96b15295
--- /dev/null
+++ b/tests/wpt/web-platform-tests/workers/modules/dedicated-worker-options-type.html
@@ -0,0 +1,47 @@
+
+DedicatedWorker: WorkerOptions 'type'
+
+
+
diff --git a/tests/wpt/web-platform-tests/workers/modules/dedicated-worker-static-import.html b/tests/wpt/web-platform-tests/workers/modules/dedicated-worker-static-import.html
new file mode 100644
index 00000000000..ee5de185800
--- /dev/null
+++ b/tests/wpt/web-platform-tests/workers/modules/dedicated-worker-static-import.html
@@ -0,0 +1,21 @@
+
+DedicatedWorker: static import
+
+
+
diff --git a/tests/wpt/web-platform-tests/workers/modules/resources/nested-static-import-worker.js b/tests/wpt/web-platform-tests/workers/modules/resources/nested-static-import-worker.js
new file mode 100644
index 00000000000..bcaf7d89c58
--- /dev/null
+++ b/tests/wpt/web-platform-tests/workers/modules/resources/nested-static-import-worker.js
@@ -0,0 +1 @@
+import './static-import-worker.js';
diff --git a/tests/wpt/web-platform-tests/workers/modules/resources/post-message-on-load-worker.js b/tests/wpt/web-platform-tests/workers/modules/resources/post-message-on-load-worker.js
new file mode 100644
index 00000000000..93818ccad90
--- /dev/null
+++ b/tests/wpt/web-platform-tests/workers/modules/resources/post-message-on-load-worker.js
@@ -0,0 +1 @@
+postMessage('LOADED');
diff --git a/tests/wpt/web-platform-tests/workers/modules/resources/static-import-worker.js b/tests/wpt/web-platform-tests/workers/modules/resources/static-import-worker.js
new file mode 100644
index 00000000000..edb8caf34af
--- /dev/null
+++ b/tests/wpt/web-platform-tests/workers/modules/resources/static-import-worker.js
@@ -0,0 +1 @@
+import './post-message-on-load-worker.js';