servo: Merge #14206 - Rename blacklist to blocklist in WebBluetooth (from szeged:blacklist-to-blocklist); r=jdm
authorZakor Gyula <zakorgy@inf.u-szeged.hu>
Tue, 22 Nov 2016 05:55:02 -0600
changeset 340200 1edcbee8585714a0ecc59f31cec7bc1028ebbfa7
parent 340199 d9434f058fc55a97ea4efd69031e7d401396e78b
child 340201 635fc4362a296ed178bef1bf5b85422bfe83ace2
push id31307
push usergszorc@mozilla.com
push dateSat, 04 Feb 2017 00:59:06 +0000
treeherdermozilla-central@94079d43835f [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjdm
servo: Merge #14206 - Rename blacklist to blocklist in WebBluetooth (from szeged:blacklist-to-blocklist); r=jdm <!-- Please describe your changes on the following line: --> There was a renaming in the [specification](https://github.com/WebBluetoothCG/web-bluetooth/commit/1d5cfa4ee8790df0cbbd68cda2dd148ba4efe10f). --- <!-- Thank you for contributing to Servo! Please replace each `[ ]` by `[X]` when the step is complete, and replace `__` with appropriate data: --> - [x] `./mach build -d` does not report any errors - [x] `./mach test-tidy` does not report any errors - [x] There are tests for these changes OR <!-- Pull requests that do not address these steps are welcome, but they will require additional verification as part of the review process. --> Source-Repo: https://github.com/servo/servo Source-Revision: a89ba50180532bc652db7ff649f252ffdca33177
servo/components/bluetooth/lib.rs
servo/components/bluetooth/test.rs
servo/components/bluetooth_traits/blacklist.rs
servo/components/bluetooth_traits/blocklist.rs
servo/components/bluetooth_traits/lib.rs
servo/components/script/dom/bluetooth.rs
servo/components/script/dom/bluetoothremotegattcharacteristic.rs
servo/components/script/dom/bluetoothremotegattdescriptor.rs
servo/components/script/dom/bluetoothremotegattserver.rs
servo/components/script/dom/bluetoothremotegattservice.rs
servo/resources/gatt_blacklist.txt
servo/resources/gatt_blocklist.txt
--- a/servo/components/bluetooth/lib.rs
+++ b/servo/components/bluetooth/lib.rs
@@ -13,17 +13,17 @@ extern crate tinyfiledialogs;
 extern crate util;
 extern crate uuid;
 
 pub mod test;
 
 use bluetooth_traits::{BluetoothCharacteristicMsg, BluetoothDescriptorMsg, BluetoothServiceMsg};
 use bluetooth_traits::{BluetoothDeviceMsg, BluetoothRequest, BluetoothResponse};
 use bluetooth_traits::{BluetoothError, BluetoothResponseResult, BluetoothResult};
-use bluetooth_traits::blacklist::{uuid_is_blacklisted, Blacklist};
+use bluetooth_traits::blocklist::{uuid_is_blocklisted, Blocklist};
 use bluetooth_traits::scanfilter::{BluetoothScanfilter, BluetoothScanfilterSequence, RequestDeviceoptions};
 use device::bluetooth::{BluetoothAdapter, BluetoothDevice, BluetoothGATTCharacteristic};
 use device::bluetooth::{BluetoothGATTDescriptor, BluetoothGATTService};
 use ipc_channel::ipc::{self, IpcReceiver, IpcSender};
 use rand::Rng;
 use std::borrow::ToOwned;
 use std::collections::{HashMap, HashSet};
 use std::string::String;
@@ -681,17 +681,17 @@ impl BluetoothManager {
                             uuid: uuid,
                             is_primary: true,
                             instance_id: service.get_id(),
                         }
                     );
                 }
             }
         }
-        services_vec.retain(|s| !uuid_is_blacklisted(&s.uuid, Blacklist::All) &&
+        services_vec.retain(|s| !uuid_is_blocklisted(&s.uuid, Blocklist::All) &&
                                 self.allowed_services
                                     .get(&device_id)
                                     .map_or(false, |uuids| uuids.contains(&s.uuid)));
         if services_vec.is_empty() {
             return drop(sender.send(Err(BluetoothError::NotFound)));
         }
 
         return drop(sender.send(Ok(BluetoothResponse::GetPrimaryServices(services_vec))));
@@ -759,17 +759,17 @@ impl BluetoothManager {
                         instance_id: service.get_id(),
                     }
                 );
             }
         }
         if let Some(uuid) = uuid {
             services_vec.retain(|ref s| s.uuid == uuid);
         }
-        services_vec.retain(|s| !uuid_is_blacklisted(&s.uuid, Blacklist::All));
+        services_vec.retain(|s| !uuid_is_blocklisted(&s.uuid, Blocklist::All));
         if services_vec.is_empty() {
             return drop(sender.send(Err(BluetoothError::NotFound)));
         }
 
         return drop(sender.send(Ok(BluetoothResponse::GetIncludedServices(services_vec))));
     }
 
     fn get_characteristic(&mut self,
@@ -837,17 +837,17 @@ impl BluetoothManager {
                         indicate: properties.contains(INDICATE),
                         authenticated_signed_writes: properties.contains(AUTHENTICATED_SIGNED_WRITES),
                         reliable_write: properties.contains(RELIABLE_WRITE),
                         writable_auxiliaries: properties.contains(WRITABLE_AUXILIARIES),
                     }
                 );
             }
         }
-        characteristics_vec.retain(|c| !uuid_is_blacklisted(&c.uuid, Blacklist::All));
+        characteristics_vec.retain(|c| !uuid_is_blocklisted(&c.uuid, Blocklist::All));
         if characteristics_vec.is_empty() {
             return drop(sender.send(Err(BluetoothError::NotFound)));
         }
 
         return drop(sender.send(Ok(BluetoothResponse::GetCharacteristics(characteristics_vec))));
     }
 
     fn get_descriptor(&mut self,
@@ -898,17 +898,17 @@ impl BluetoothManager {
                 descriptors_vec.push(
                     BluetoothDescriptorMsg {
                         uuid: uuid,
                         instance_id: descriptor.get_id(),
                     }
                 );
             }
         }
-        descriptors_vec.retain(|d| !uuid_is_blacklisted(&d.uuid, Blacklist::All));
+        descriptors_vec.retain(|d| !uuid_is_blocklisted(&d.uuid, Blocklist::All));
         if descriptors_vec.is_empty() {
             return drop(sender.send(Err(BluetoothError::NotFound)));
         }
         return drop(sender.send(Ok(BluetoothResponse::GetDescriptors(descriptors_vec))));
     }
 
     fn read_value(&mut self, id: String, sender: IpcSender<BluetoothResponseResult>) {
         let mut adapter = get_adapter_or_return_error!(self, sender);
--- a/servo/components/bluetooth/test.rs
+++ b/servo/components/bluetooth/test.rs
@@ -38,17 +38,17 @@ const MISSING_DESCRIPTOR_HEART_RATE_ADAP
 // https://cs.chromium.org/chromium/src/content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h?l=234
 const HEART_RATE_ADAPTER: &'static str = "HeartRateAdapter";
 // https://cs.chromium.org/chromium/src/content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h?l=250
 const EMPTY_NAME_HEART_RATE_ADAPTER: &'static str = "EmptyNameHeartRateAdapter";
 // https://cs.chromium.org/chromium/src/content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h?l=267
 const NO_NAME_HEART_RATE_ADAPTER: &'static str = "NoNameHeartRateAdapter";
 // https://cs.chromium.org/chromium/src/content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h?l=284
 const TWO_HEART_RATE_SERVICES_ADAPTER: &'static str = "TwoHeartRateServicesAdapter";
-const BLACKLIST_TEST_ADAPTER: &'static str = "BlacklistTestAdapter";
+const BLOCKLIST_TEST_ADAPTER: &'static str = "BlocklistTestAdapter";
 
 // Device names
 const CONNECTABLE_DEVICE_NAME: &'static str = "Connectable Device";
 const EMPTY_DEVICE_NAME: &'static str = "";
 // https://webbluetoothcg.github.io/web-bluetooth/tests.html#glucosedevice
 const GLUCOSE_DEVICE_NAME: &'static str = "Glucose Device";
 // https://webbluetoothcg.github.io/web-bluetooth/tests.html#heartratedevice
 const HEART_RATE_DEVICE_NAME: &'static str = "Heart Rate Device";
@@ -58,33 +58,33 @@ const UNICODE_DEVICE_NAME: &'static str = "❤❤❤❤❤❤❤❤❤";
 const CONNECTABLE_DEVICE_ADDRESS: &'static str = "00:00:00:00:00:04";
 // https://webbluetoothcg.github.io/web-bluetooth/tests.html#glucosedevice
 const GLUCOSE_DEVICE_ADDRESS: &'static str = "00:00:00:00:00:02";
 // https://webbluetoothcg.github.io/web-bluetooth/tests.html#heartratedevice
 const HEART_RATE_DEVICE_ADDRESS: &'static str = "00:00:00:00:00:03";
 const UNICODE_DEVICE_ADDRESS: &'static str = "00:00:00:00:00:01";
 
 // Service UUIDs
-const BLACKLIST_TEST_SERVICE_UUID: &'static str = "611c954a-263b-4f4a-aab6-01ddb953f985";
+const BLOCKLIST_TEST_SERVICE_UUID: &'static str = "611c954a-263b-4f4a-aab6-01ddb953f985";
 // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.service.device_information.xml
 const DEVICE_INFORMATION_UUID: &'static str = "0000180a-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.service.generic_access.xml
 const GENERIC_ACCESS_SERVICE_UUID: &'static str = "00001800-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.service.glucose.xml
 const GLUCOSE_SERVICE_UUID: &'static str = "00001808-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.service.heart_rate.xml
 const HEART_RATE_SERVICE_UUID: &'static str = "0000180d-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/
 // viewer?attributeXmlFile=org.bluetooth.service.human_interface_device.xml
 const HUMAN_INTERFACE_DEVICE_SERVICE_UUID: &'static str = "00001812-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.service.tx_power.xml
 const TX_POWER_SERVICE_UUID: &'static str = "00001804-0000-1000-8000-00805f9b34fb";
 
 // Characteristic UUIDs
-const BLACKLIST_EXCLUDE_READS_CHARACTERISTIC_UUID: &'static str = "bad1c9a2-9a5b-4015-8b60-1579bbbf2135";
+const BLOCKLIST_EXCLUDE_READS_CHARACTERISTIC_UUID: &'static str = "bad1c9a2-9a5b-4015-8b60-1579bbbf2135";
 // https://www.bluetooth.com/specifications/gatt/
 // viewer?attributeXmlFile=org.bluetooth.characteristic.body_sensor_location.xml
 const BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID: &'static str = "00002a38-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/
 // viewer?attributeXmlFile=org.bluetooth.characteristic.gap.device_name.xml
 const DEVICE_NAME_CHARACTERISTIC_UUID: &'static str = "00002a00-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/
 // viewer?attributeXmlFile=org.bluetooth.characteristic.heart_rate_measurement.xml
@@ -92,18 +92,18 @@ const HEART_RATE_MEASUREMENT_CHARACTERIS
 // https://www.bluetooth.com/specifications/gatt/
 // viewer?attributeXmlFile=org.bluetooth.characteristic.gap.peripheral_privacy_flag.xml
 const PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC_UUID: &'static str = "00002a02-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/
 // viewer?attributeXmlFile=org.bluetooth.characteristic.serial_number_string.xml
 const SERIAL_NUMBER_STRING_UUID: &'static str = "00002a25-0000-1000-8000-00805f9b34fb";
 
 // Descriptor UUIDs
-const BLACKLIST_EXCLUDE_READS_DESCRIPTOR_UUID: &'static str = "aaaaaaaa-aaaa-1181-0510-810819516110";
-const BLACKLIST_DESCRIPTOR_UUID: &'static str = "07711111-6104-0970-7011-1107105110aaa";
+const BLOCKLIST_EXCLUDE_READS_DESCRIPTOR_UUID: &'static str = "aaaaaaaa-aaaa-1181-0510-810819516110";
+const BLOCKLIST_DESCRIPTOR_UUID: &'static str = "07711111-6104-0970-7011-1107105110aaa";
 // https://www.bluetooth.com/specifications/gatt/
 // viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.characteristic_user_description.xml
 const CHARACTERISTIC_USER_DESCRIPTION_UUID: &'static str = "00002901-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/
 // viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.client_characteristic_configuration.xml
 const CLIENT_CHARACTERISTIC_CONFIGURATION_UUID: &'static str = "00002902-0000-1000-8000-00805f9b34fb";
 // https://www.bluetooth.com/specifications/gatt/
 // viewer?attributeXmlFile=org.bluetooth.descriptor.number_of_digitals.xml
@@ -369,43 +369,43 @@ fn create_two_heart_rate_services_device
 
     let _body_sensor_location_characteristic_2 =
         try!(create_characteristic_with_value(&heart_rate_service_empty_2,
                                               BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID.to_owned(),
                                               vec![50]));
     Ok(())
 }
 
-fn create_blacklisted_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
+fn create_blocklisted_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
     let connectable_device =
     try!(create_device_with_uuids(adapter,
                                  CONNECTABLE_DEVICE_NAME.to_owned(),
                                  CONNECTABLE_DEVICE_ADDRESS.to_owned(),
-                                 vec![BLACKLIST_TEST_SERVICE_UUID.to_owned(),
+                                 vec![BLOCKLIST_TEST_SERVICE_UUID.to_owned(),
                                       DEVICE_INFORMATION_UUID.to_owned(),
                                       GENERIC_ACCESS_SERVICE_UUID.to_owned(),
                                       HEART_RATE_SERVICE_UUID.to_owned(),
                                       HUMAN_INTERFACE_DEVICE_SERVICE_UUID.to_owned()]));
 
-    let blacklist_test_service = try!(create_service(&connectable_device, BLACKLIST_TEST_SERVICE_UUID.to_owned()));
+    let blocklist_test_service = try!(create_service(&connectable_device, BLOCKLIST_TEST_SERVICE_UUID.to_owned()));
 
-    let blacklist_exclude_reads_characteristic =
-        try!(create_characteristic(&blacklist_test_service,
-                                   BLACKLIST_EXCLUDE_READS_CHARACTERISTIC_UUID.to_owned()));
-    try!(blacklist_exclude_reads_characteristic
+    let blocklist_exclude_reads_characteristic =
+        try!(create_characteristic(&blocklist_test_service,
+                                   BLOCKLIST_EXCLUDE_READS_CHARACTERISTIC_UUID.to_owned()));
+    try!(blocklist_exclude_reads_characteristic
          .set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
 
-    let _blacklist_exclude_reads_descriptor =
-        try!(create_descriptor_with_value(&blacklist_exclude_reads_characteristic,
-                                          BLACKLIST_EXCLUDE_READS_DESCRIPTOR_UUID.to_owned(),
+    let _blocklist_exclude_reads_descriptor =
+        try!(create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
+                                          BLOCKLIST_EXCLUDE_READS_DESCRIPTOR_UUID.to_owned(),
                                           vec![54; 3]));
 
-    let _blacklist_descriptor =
-        try!(create_descriptor_with_value(&blacklist_exclude_reads_characteristic,
-                                          BLACKLIST_DESCRIPTOR_UUID.to_owned(),
+    let _blocklist_descriptor =
+        try!(create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
+                                          BLOCKLIST_DESCRIPTOR_UUID.to_owned(),
                                           vec![54; 3]));
 
     let device_information_service = try!(create_service(&connectable_device, DEVICE_INFORMATION_UUID.to_owned()));
 
     let _serial_number_string_characteristic =
         try!(create_characteristic(&device_information_service, SERIAL_NUMBER_STRING_UUID.to_owned()));
 
     let _generic_access_service = try!(create_generic_access_service(&connectable_device, false));
@@ -485,17 +485,17 @@ pub fn test(manager: &mut BluetoothManag
             let heart_rate_device = try!(create_heart_rate_device(adapter, false));
             try!(heart_rate_device.set_name(None));
         },
         TWO_HEART_RATE_SERVICES_ADAPTER => {
             try!(set_adapter(adapter, TWO_HEART_RATE_SERVICES_ADAPTER.to_owned()));
 
             let _ = try!(create_two_heart_rate_services_device(adapter));
         },
-        BLACKLIST_TEST_ADAPTER => {
-            try!(set_adapter(adapter, BLACKLIST_TEST_ADAPTER.to_owned()));
+        BLOCKLIST_TEST_ADAPTER => {
+            try!(set_adapter(adapter, BLOCKLIST_TEST_ADAPTER.to_owned()));
 
-            let _ = try!(create_blacklisted_device(adapter));
+            let _ = try!(create_blocklisted_device(adapter));
         },
         _ => return Err(Box::from(WRONG_DATA_SET_ERROR.to_string())),
     }
     return Ok(());
 }
deleted file mode 100644
--- a/servo/components/bluetooth_traits/blacklist.rs
+++ /dev/null
@@ -1,124 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-use regex::Regex;
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::io::BufRead;
-use std::string::String;
-use util::resource_files::read_resource_file;
-
-const BLACKLIST_FILE: &'static str = "gatt_blacklist.txt";
-const BLACKLIST_FILE_NOT_FOUND: &'static str = "Could not find gatt_blacklist.txt file";
-const EXCLUDE_READS: &'static str = "exclude-reads";
-const EXCLUDE_WRITES: &'static str = "exclude-writes";
-const VALID_UUID_REGEX: &'static str = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
-
-thread_local!(pub static BLUETOOTH_BLACKLIST: RefCell<BluetoothBlacklist> =
-              RefCell::new(BluetoothBlacklist(parse_blacklist())));
-
-pub fn uuid_is_blacklisted(uuid: &str, exclude_type: Blacklist) -> bool {
-    BLUETOOTH_BLACKLIST.with(|blist| {
-        match exclude_type {
-            Blacklist::All => {
-                blist.borrow().is_blacklisted(uuid)
-            },
-            Blacklist::Reads => {
-                blist.borrow().is_blacklisted_for_reads(uuid)
-            }
-            Blacklist::Writes => {
-                blist.borrow().is_blacklisted_for_writes(uuid)
-            }
-        }
-    })
-}
-
-pub struct BluetoothBlacklist(Option<HashMap<String, Blacklist>>);
-
-#[derive(Eq, PartialEq)]
-pub enum Blacklist {
-    All, // Read and Write
-    Reads,
-    Writes,
-}
-
-impl BluetoothBlacklist {
-    // https://webbluetoothcg.github.io/web-bluetooth/#blacklisted
-    pub fn is_blacklisted(&self, uuid: &str) -> bool {
-        match self.0 {
-            Some(ref map) => map.get(uuid).map_or(false, |et| et.eq(&Blacklist::All)),
-            None => false,
-        }
-    }
-
-    // https://webbluetoothcg.github.io/web-bluetooth/#blacklisted-for-reads
-    pub fn is_blacklisted_for_reads(&self, uuid: &str) -> bool {
-        match self.0 {
-            Some(ref map) => map.get(uuid).map_or(false, |et| et.eq(&Blacklist::All) ||
-                                                              et.eq(&Blacklist::Reads)),
-            None => false,
-        }
-    }
-
-    // https://webbluetoothcg.github.io/web-bluetooth/#blacklisted-for-writes
-    pub fn is_blacklisted_for_writes(&self, uuid: &str) -> bool {
-        match self.0 {
-            Some(ref map) => map.get(uuid).map_or(false, |et| et.eq(&Blacklist::All) ||
-                                                              et.eq(&Blacklist::Writes)),
-            None => false,
-        }
-    }
-}
-
-// https://webbluetoothcg.github.io/web-bluetooth/#parsing-the-blacklist
-fn parse_blacklist() -> Option<HashMap<String, Blacklist>> {
-    // Step 1 missing, currently we parse ./resources/gatt_blacklist.txt.
-    let valid_uuid_regex = Regex::new(VALID_UUID_REGEX).unwrap();
-    let content = read_resource_file(BLACKLIST_FILE).expect(BLACKLIST_FILE_NOT_FOUND);
-    // Step 3
-    let mut result = HashMap::new();
-    // Step 2 and 4
-    for line in content.lines() {
-        let line = match line {
-            Ok(l) => l,
-            Err(_) => return None,
-        };
-        // Step 4.1
-        if line.is_empty() || line.starts_with('#') {
-            continue;
-        }
-        let mut exclude_type = Blacklist::All;
-        let mut words = line.split_whitespace();
-        let uuid = match words.next() {
-            Some(uuid) => uuid,
-            None => continue,
-        };
-        if !valid_uuid_regex.is_match(uuid) {
-            return None;
-        }
-        match words.next() {
-            // Step 4.2 We already have an initialized exclude_type variable with Blacklist::All.
-            None => {},
-            // Step 4.3
-            Some(EXCLUDE_READS) => {
-                exclude_type = Blacklist::Reads;
-            },
-            Some(EXCLUDE_WRITES) => {
-                exclude_type  = Blacklist::Writes;
-            },
-            // Step 4.4
-            _ => {
-                return None;
-            },
-        }
-        // Step 4.5
-        if result.contains_key(uuid) {
-            return None;
-        }
-        // Step 4.6
-        result.insert(uuid.to_string(), exclude_type);
-    }
-    // Step 5
-    return Some(result);
-}
new file mode 100644
--- /dev/null
+++ b/servo/components/bluetooth_traits/blocklist.rs
@@ -0,0 +1,124 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use regex::Regex;
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::io::BufRead;
+use std::string::String;
+use util::resource_files::read_resource_file;
+
+const BLOCKLIST_FILE: &'static str = "gatt_blocklist.txt";
+const BLOCKLIST_FILE_NOT_FOUND: &'static str = "Could not find gatt_blocklist.txt file";
+const EXCLUDE_READS: &'static str = "exclude-reads";
+const EXCLUDE_WRITES: &'static str = "exclude-writes";
+const VALID_UUID_REGEX: &'static str = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+
+thread_local!(pub static BLUETOOTH_BLOCKLIST: RefCell<BluetoothBlocklist> =
+              RefCell::new(BluetoothBlocklist(parse_blocklist())));
+
+pub fn uuid_is_blocklisted(uuid: &str, exclude_type: Blocklist) -> bool {
+    BLUETOOTH_BLOCKLIST.with(|blist| {
+        match exclude_type {
+            Blocklist::All => {
+                blist.borrow().is_blocklisted(uuid)
+            },
+            Blocklist::Reads => {
+                blist.borrow().is_blocklisted_for_reads(uuid)
+            }
+            Blocklist::Writes => {
+                blist.borrow().is_blocklisted_for_writes(uuid)
+            }
+        }
+    })
+}
+
+pub struct BluetoothBlocklist(Option<HashMap<String, Blocklist>>);
+
+#[derive(Eq, PartialEq)]
+pub enum Blocklist {
+    All, // Read and Write
+    Reads,
+    Writes,
+}
+
+impl BluetoothBlocklist {
+    // https://webbluetoothcg.github.io/web-bluetooth/#blocklisted
+    pub fn is_blocklisted(&self, uuid: &str) -> bool {
+        match self.0 {
+            Some(ref map) => map.get(uuid).map_or(false, |et| et.eq(&Blocklist::All)),
+            None => false,
+        }
+    }
+
+    // https://webbluetoothcg.github.io/web-bluetooth/#blocklisted-for-reads
+    pub fn is_blocklisted_for_reads(&self, uuid: &str) -> bool {
+        match self.0 {
+            Some(ref map) => map.get(uuid).map_or(false, |et| et.eq(&Blocklist::All) ||
+                                                              et.eq(&Blocklist::Reads)),
+            None => false,
+        }
+    }
+
+    // https://webbluetoothcg.github.io/web-bluetooth/#blocklisted-for-writes
+    pub fn is_blocklisted_for_writes(&self, uuid: &str) -> bool {
+        match self.0 {
+            Some(ref map) => map.get(uuid).map_or(false, |et| et.eq(&Blocklist::All) ||
+                                                              et.eq(&Blocklist::Writes)),
+            None => false,
+        }
+    }
+}
+
+// https://webbluetoothcg.github.io/web-bluetooth/#parsing-the-blocklist
+fn parse_blocklist() -> Option<HashMap<String, Blocklist>> {
+    // Step 1 missing, currently we parse ./resources/gatt_blocklist.txt.
+    let valid_uuid_regex = Regex::new(VALID_UUID_REGEX).unwrap();
+    let content = read_resource_file(BLOCKLIST_FILE).expect(BLOCKLIST_FILE_NOT_FOUND);
+    // Step 3
+    let mut result = HashMap::new();
+    // Step 2 and 4
+    for line in content.lines() {
+        let line = match line {
+            Ok(l) => l,
+            Err(_) => return None,
+        };
+        // Step 4.1
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let mut exclude_type = Blocklist::All;
+        let mut words = line.split_whitespace();
+        let uuid = match words.next() {
+            Some(uuid) => uuid,
+            None => continue,
+        };
+        if !valid_uuid_regex.is_match(uuid) {
+            return None;
+        }
+        match words.next() {
+            // Step 4.2 We already have an initialized exclude_type variable with Blocklist::All.
+            None => {},
+            // Step 4.3
+            Some(EXCLUDE_READS) => {
+                exclude_type = Blocklist::Reads;
+            },
+            Some(EXCLUDE_WRITES) => {
+                exclude_type  = Blocklist::Writes;
+            },
+            // Step 4.4
+            _ => {
+                return None;
+            },
+        }
+        // Step 4.5
+        if result.contains_key(uuid) {
+            return None;
+        }
+        // Step 4.6
+        result.insert(uuid.to_string(), exclude_type);
+    }
+    // Step 5
+    return Some(result);
+}
--- a/servo/components/bluetooth_traits/lib.rs
+++ b/servo/components/bluetooth_traits/lib.rs
@@ -5,17 +5,17 @@
 #![feature(proc_macro)]
 
 extern crate ipc_channel;
 extern crate regex;
 #[macro_use]
 extern crate serde_derive;
 extern crate util;
 
-pub mod blacklist;
+pub mod blocklist;
 pub mod scanfilter;
 
 use ipc_channel::ipc::IpcSender;
 use scanfilter::RequestDeviceoptions;
 
 #[derive(Deserialize, Serialize)]
 pub enum BluetoothError {
     Type(String),
--- a/servo/components/script/dom/bluetooth.rs
+++ b/servo/components/script/dom/bluetooth.rs
@@ -1,15 +1,15 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use bluetooth_traits::{BluetoothError, BluetoothRequest};
 use bluetooth_traits::{BluetoothResponse, BluetoothResponseListener, BluetoothResponseResult};
-use bluetooth_traits::blacklist::{Blacklist, uuid_is_blacklisted};
+use bluetooth_traits::blocklist::{Blocklist, uuid_is_blocklisted};
 use bluetooth_traits::scanfilter::{BluetoothScanfilter, BluetoothScanfilterSequence};
 use bluetooth_traits::scanfilter::{RequestDeviceoptions, ServiceUUIDSequence};
 use core::clone::Clone;
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::BluetoothBinding::{self, BluetoothMethods, BluetoothRequestDeviceFilter};
 use dom::bindings::codegen::Bindings::BluetoothBinding::RequestDeviceOptions;
 use dom::bindings::error::Error::{self, NotFound, Security, Type};
 use dom::bindings::error::Fallible;
@@ -188,19 +188,19 @@ fn convert_request_device_options(filter
 
     let mut optional_services_uuids = vec!();
     if let &Some(ref opt_services) = optional_services {
         for opt_service in opt_services {
             // Step 2.5 - 2.6.
             let uuid = try!(BluetoothUUID::service(opt_service.clone())).to_string();
 
             // Step 2.7.
-            // Note: What we are doing here is adding the not blacklisted UUIDs to the result vector,
-            // instead of removing them from an already filled vector.
-            if !uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+            // Note: What we are doing here is adding the not blocklisted UUIDs to the result vector,
+            // insted of removing them from an already filled vector.
+            if !uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
                 optional_services_uuids.push(uuid);
             }
         }
     }
 
     Ok(RequestDeviceoptions::new(BluetoothScanfilterSequence::new(uuid_filters),
                                  ServiceUUIDSequence::new(optional_services_uuids)))
 }
@@ -229,17 +229,17 @@ fn canonicalize_filter(filter: &Bluetoot
 
             let mut services_vec = vec!();
 
             for service in services {
                 // Step 2.4.3.2 - 2.4.3.3.
                 let uuid = try!(BluetoothUUID::service(service.clone())).to_string();
 
                 // Step 2.4.3.4.
-                if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+                if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
                     return Err(Security)
                 }
 
                 services_vec.push(uuid);
             }
             // Step 2.4.3.5.
             services_vec
             // Step 2.4.3.6: There is no requiredServiceUUIDS, we scan for all devices.
@@ -290,17 +290,17 @@ fn canonicalize_filter(filter: &Bluetoot
 
     // Step 2.4.7.
     let service_data_uuid = match filter.serviceDataUUID {
         Some(ref service_data_uuid) => {
             // Step 2.4.7.1 - 2.4.7.2.
             let uuid = try!(BluetoothUUID::service(service_data_uuid.clone())).to_string();
 
             // Step 2.4.7.3.
-            if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+            if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
                 return Err(Security)
             }
 
             // Step 2.4.7.4.
             uuid
         },
         None => String::new(),
     };
--- a/servo/components/script/dom/bluetoothremotegattcharacteristic.rs
+++ b/servo/components/script/dom/bluetoothremotegattcharacteristic.rs
@@ -1,14 +1,14 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use bluetooth_traits::{BluetoothRequest, BluetoothResponse};
-use bluetooth_traits::blacklist::{Blacklist, uuid_is_blacklisted};
+use bluetooth_traits::blocklist::{Blocklist, uuid_is_blocklisted};
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::BluetoothCharacteristicPropertiesBinding::
     BluetoothCharacteristicPropertiesMethods;
 use dom::bindings::codegen::Bindings::BluetoothDeviceBinding::BluetoothDeviceMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTCharacteristicBinding;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTCharacteristicBinding::
     BluetoothRemoteGATTCharacteristicMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding::BluetoothRemoteGATTServerMethods;
@@ -105,17 +105,17 @@ impl BluetoothRemoteGATTCharacteristicMe
         let p_cx = p.global().get_cx();
         let uuid = match BluetoothUUID::descriptor(descriptor) {
             Ok(uuid) => uuid.to_string(),
             Err(e) => {
                 p.reject_error(p_cx, e);
                 return p;
             }
         };
-        if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+        if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
             p.reject_error(p_cx, Security);
             return p;
         }
         if !self.Service().Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
         }
         let sender = response_async(&p, self);
@@ -136,17 +136,17 @@ impl BluetoothRemoteGATTCharacteristicMe
             uuid = match BluetoothUUID::descriptor(d) {
                 Ok(uuid) => Some(uuid.to_string()),
                 Err(e) => {
                     p.reject_error(p_cx, e);
                     return p;
                 }
             };
             if let Some(ref uuid) = uuid {
-                if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+                if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
                     p.reject_error(p_cx, Security);
                     return p;
                 }
             }
         };
         if !self.Service().Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
@@ -162,17 +162,17 @@ impl BluetoothRemoteGATTCharacteristicMe
         self.value.borrow().clone()
     }
 
     #[allow(unrooted_must_root)]
     // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattcharacteristic-readvalue
     fn ReadValue(&self) -> Rc<Promise> {
         let p = Promise::new(&self.global());
         let p_cx = p.global().get_cx();
-        if uuid_is_blacklisted(self.uuid.as_ref(), Blacklist::Reads) {
+        if uuid_is_blocklisted(self.uuid.as_ref(), Blocklist::Reads) {
             p.reject_error(p_cx, Security);
             return p;
         }
         if !self.Service().Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
         }
         if !self.Properties().Read() {
@@ -185,17 +185,17 @@ impl BluetoothRemoteGATTCharacteristicMe
         return p;
     }
 
     #[allow(unrooted_must_root)]
     // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattcharacteristic-writevalue
     fn WriteValue(&self, value: Vec<u8>) -> Rc<Promise> {
         let p = Promise::new(&self.global());
         let p_cx = p.global().get_cx();
-        if uuid_is_blacklisted(self.uuid.as_ref(), Blacklist::Writes) {
+        if uuid_is_blocklisted(self.uuid.as_ref(), Blocklist::Writes) {
             p.reject_error(p_cx, Security);
             return p;
         }
         if value.len() > MAXIMUM_ATTRIBUTE_LENGTH {
             p.reject_error(p_cx, InvalidModification);
             return p;
         }
         if !self.Service().Device().Gatt().Connected() {
--- a/servo/components/script/dom/bluetoothremotegattdescriptor.rs
+++ b/servo/components/script/dom/bluetoothremotegattdescriptor.rs
@@ -1,14 +1,14 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use bluetooth_traits::{BluetoothRequest, BluetoothResponse};
-use bluetooth_traits::blacklist::{Blacklist, uuid_is_blacklisted};
+use bluetooth_traits::blocklist::{Blocklist, uuid_is_blocklisted};
 use dom::bindings::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::BluetoothDeviceBinding::BluetoothDeviceMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTCharacteristicBinding::
     BluetoothRemoteGATTCharacteristicMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTDescriptorBinding;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTDescriptorBinding::BluetoothRemoteGATTDescriptorMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding::BluetoothRemoteGATTServerMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding::BluetoothRemoteGATTServiceMethods;
@@ -85,17 +85,17 @@ impl BluetoothRemoteGATTDescriptorMethod
         self.value.borrow().clone()
     }
 
     #[allow(unrooted_must_root)]
     // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattdescriptor-readvalue
     fn ReadValue(&self) -> Rc<Promise> {
         let p = Promise::new(&self.global());
         let p_cx = p.global().get_cx();
-        if uuid_is_blacklisted(self.uuid.as_ref(), Blacklist::Reads) {
+        if uuid_is_blocklisted(self.uuid.as_ref(), Blocklist::Reads) {
             p.reject_error(p_cx, Security);
             return p;
         }
         if !self.Characteristic().Service().Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
         }
         let sender = response_async(&p, self);
@@ -104,17 +104,17 @@ impl BluetoothRemoteGATTDescriptorMethod
         return p;
     }
 
     #[allow(unrooted_must_root)]
     // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattdescriptor-writevalue
     fn WriteValue(&self, value: Vec<u8>) -> Rc<Promise> {
         let p = Promise::new(&self.global());
         let p_cx = p.global().get_cx();
-        if uuid_is_blacklisted(self.uuid.as_ref(), Blacklist::Writes) {
+        if uuid_is_blocklisted(self.uuid.as_ref(), Blocklist::Writes) {
             p.reject_error(p_cx, Security);
             return p;
         }
         if value.len() > MAXIMUM_ATTRIBUTE_LENGTH {
             p.reject_error(p_cx, InvalidModification);
             return p;
         }
         if !self.Characteristic().Service().Device().Gatt().Connected() {
--- a/servo/components/script/dom/bluetoothremotegattserver.rs
+++ b/servo/components/script/dom/bluetoothremotegattserver.rs
@@ -1,14 +1,14 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use bluetooth_traits::{BluetoothRequest, BluetoothResponse};
-use bluetooth_traits::blacklist::{Blacklist, uuid_is_blacklisted};
+use bluetooth_traits::blocklist::{Blocklist, uuid_is_blocklisted};
 use dom::bindings::codegen::Bindings::BluetoothDeviceBinding::BluetoothDeviceMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding::BluetoothRemoteGATTServerMethods;
 use dom::bindings::error::Error::{self, Network, Security};
 use dom::bindings::error::ErrorResult;
 use dom::bindings::js::{JS, MutHeap, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -96,17 +96,17 @@ impl BluetoothRemoteGATTServerMethods fo
         let p_cx = p.global().get_cx();
         let uuid = match BluetoothUUID::service(service) {
             Ok(uuid) => uuid.to_string(),
             Err(e) => {
                 p.reject_error(p_cx, e);
                 return p;
             }
         };
-        if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+        if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
             p.reject_error(p_cx, Security);
             return p;
         }
         if !self.Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
         }
         let sender = response_async(&p, self);
@@ -125,17 +125,17 @@ impl BluetoothRemoteGATTServerMethods fo
             uuid = match BluetoothUUID::service(s) {
                 Ok(uuid) => Some(uuid.to_string()),
                 Err(e) => {
                     p.reject_error(p_cx, e);
                     return p;
                 }
             };
             if let Some(ref uuid) = uuid {
-                if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+                if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
                     p.reject_error(p_cx, Security);
                     return p;
                 }
             }
         };
         if !self.Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
--- a/servo/components/script/dom/bluetoothremotegattservice.rs
+++ b/servo/components/script/dom/bluetoothremotegattservice.rs
@@ -1,14 +1,14 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use bluetooth_traits::{BluetoothRequest, BluetoothResponse};
-use bluetooth_traits::blacklist::{Blacklist, uuid_is_blacklisted};
+use bluetooth_traits::blocklist::{Blocklist, uuid_is_blocklisted};
 use dom::bindings::codegen::Bindings::BluetoothDeviceBinding::BluetoothDeviceMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServerBinding::BluetoothRemoteGATTServerMethods;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding;
 use dom::bindings::codegen::Bindings::BluetoothRemoteGATTServiceBinding::BluetoothRemoteGATTServiceMethods;
 use dom::bindings::error::Error::{self, Network, Security};
 use dom::bindings::js::{JS, MutHeap, Root};
 use dom::bindings::reflector::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::str::DOMString;
@@ -100,17 +100,17 @@ impl BluetoothRemoteGATTServiceMethods f
         let p_cx = p.global().get_cx();
         let uuid = match BluetoothUUID::characteristic(characteristic) {
             Ok(uuid) => uuid.to_string(),
             Err(e) => {
                 p.reject_error(p_cx, e);
                 return p;
             }
         };
-        if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+        if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
             p.reject_error(p_cx, Security);
             return p;
         }
         if !self.Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
         }
         let sender = response_async(&p, self);
@@ -131,17 +131,17 @@ impl BluetoothRemoteGATTServiceMethods f
             uuid = match BluetoothUUID::characteristic(c) {
                 Ok(uuid) => Some(uuid.to_string()),
                 Err(e) => {
                     p.reject_error(p_cx, e);
                     return p;
                 }
             };
             if let Some(ref uuid) = uuid {
-                if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+                if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
                     p.reject_error(p_cx, Security);
                     return p;
                 }
             }
         };
         if !self.Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
@@ -161,17 +161,17 @@ impl BluetoothRemoteGATTServiceMethods f
         let p_cx = p.global().get_cx();
         let uuid = match BluetoothUUID::service(service) {
             Ok(uuid) => uuid.to_string(),
             Err(e) => {
                 p.reject_error(p_cx, e);
                 return p;
             }
         };
-        if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+        if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
             p.reject_error(p_cx, Security);
             return p;
         }
         if !self.Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
         }
         let sender = response_async(&p, self);
@@ -195,17 +195,17 @@ impl BluetoothRemoteGATTServiceMethods f
             uuid = match BluetoothUUID::service(s) {
                 Ok(uuid) => Some(uuid.to_string()),
                 Err(e) => {
                     p.reject_error(p_cx, e);
                     return p;
                 }
             };
             if let Some(ref uuid) = uuid {
-                if uuid_is_blacklisted(uuid.as_ref(), Blacklist::All) {
+                if uuid_is_blocklisted(uuid.as_ref(), Blocklist::All) {
                     p.reject_error(p_cx, Security);
                     return p;
                 }
             }
         };
         if !self.Device().Gatt().Connected() {
             p.reject_error(p_cx, Network);
             return p;
rename from servo/resources/gatt_blacklist.txt
rename to servo/resources/gatt_blocklist.txt
--- a/servo/resources/gatt_blacklist.txt
+++ b/servo/resources/gatt_blocklist.txt
@@ -1,10 +1,10 @@
 # Source:
-# https://github.com/WebBluetoothCG/registries/blob/master/gatt_blacklist.txt
+# https://github.com/WebBluetoothCG/registries/blob/master/gatt_blocklist.txt
 # License:
 # https://github.com/WebBluetoothCG/registries/blob/master/LICENSE
 
 # This file holds a list of GATT UUIDs that websites using the Web
 # Bluetooth API are forbidden from accessing.
 
 ## Services
 
@@ -35,28 +35,28 @@ 00002a02-0000-1000-8000-00805f9b34fb exc
 # org.bluetooth.characteristic.gap.reconnection_address
 # Disallow messing with connection parameters
 00002a03-0000-1000-8000-00805f9b34fb
 
 # org.bluetooth.characteristic.serial_number_string
 # Block access to standardized unique identifiers, for privacy reasons.
 00002a25-0000-1000-8000-00805f9b34fb
 
-# Blacklisted characteristic used to test readValue function.
+# Blocklisted characteristic used to test readValue function.
 bad1c9a2-9a5b-4015-8b60-1579bbbf2135 exclude-reads
 
 
 ## Descriptors
 
 # org.bluetooth.descriptor.gatt.client_characteristic_configuration
 # Writing to this would let a web page interfere with other pages'
 # notifications and indications.
 00002902-0000-1000-8000-00805f9b34fb exclude-writes
 
 # org.bluetooth.descriptor.gatt.server_characteristic_configuration
 # Writing to this would let a web page interfere with the broadcasted services.
 00002903-0000-1000-8000-00805f9b34fb exclude-writes
 
-# Blacklisted descriptor used to test.
+# Blocklisted descriptor used to test.
 07711111-6104-0970-7011-1107105110aaa
 
-# Blacklisted descriptor used to test.
+# Blocklisted descriptor used to test.
 aaaaaaaa-aaaa-1181-0510-810819516110 exclude-reads
\ No newline at end of file