DO NOT SUBMIT bluetooth-fuzzer: Draft fuzzer

third_party/WebKit/Source/modules/bluetooth/testing/clusterfuzz/constraints.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Module to get random numbers, strings, etc.
 
    The values returned by the various functions can be replaced in
    templates to generate test cases.
 """
 
@@ skipping 16 matching lines @@
 # fields are replaced by Get*Base() functions below to generate valid test
 # cases.
 BASIC_BASE = \
     '  return setBluetoothFakeAdapter({fake_adapter_name})\n'\
     '    .then(() => {{\n'
 
 DEVICE_DISCOVERY_BASE = BASIC_BASE + \
     '      return requestDeviceWithKeyDown({{\n'\
     '        filters: [{{services: [{service_uuid}]}}]}});\n'\
     '    }})\n'\
-    '    .then(device => {{\n'
+    '    .then(device => {{\n'\
+    '      var gatt = device.gatt;\n'
 
 CONNECTABLE_BASE = DEVICE_DISCOVERY_BASE + \
-    '      return device.gatt.connect();\n'\
+    '      return gatt.connect();\n'\
     '    }})\n'\
-    '    .then(gatt => {{\n'
+    '    .then(gatt => {{\n'\
+    '      var device = gatt.device;\n'
 
 SERVICE_RETRIEVED_BASE = CONNECTABLE_BASE + \
     '      return gatt.getPrimaryService({service_uuid});\n'\
     '    }})\n'\
-    '    .then(service => {{\n'
+    '    .then(services => {{\n'\
+    '      var device = services.device;\n'\
+    '      var gatt = device.gatt;\n'
 
+SERVICES_RETRIEVED_BASE = CONNECTABLE_BASE + \
+    '      return gatt.getPrimaryServices({optional_service_uuid});\n'\
+    '    }})\n'\
+    '    .then(services => {{\n'\
+    '      var device = services[0].device;\n'\
+    '      var gatt = device.gatt;\n'
+
+CHARACTERISTIC_RETRIEVED_BASE = \
+    '      TRANSFORM_PICK_A_SERVICE;\n'\
+    '      return service.getCharacteristic({characteristic_uuid});\n'\
+    '    }})\n'\
+    '    .then(characteristics => {{\n'\
+    '      var service = characteristics.service;\n'\
+    '      var device = service.device;\n'\
+    '      var gatt = device.gatt;\n'
+
+CHARACTERISTICS_RETRIEVED_BASE = \
+    '      TRANSFORM_PICK_A_SERVICE;\n'\
+    '      return service.getCharacteristics({optional_characteristic_uuid});\n'\
+    '    }})\n'\
+    '    .then(characteristics => {{\n'\
+    '      var service = characteristics[0].service;\n'\
+    '      var device = service.device;\n'\
+    '      var gatt = device.gatt;\n'
 
 def _ToJsStr(s):
     return u'\'{}\''.format(s)
 
 
+def _GetOptional(s):
+  return random.choice(['', s])
+
+
+def _GetRandomNumber():
+  return utils.UniformExpoInteger(0, sys.maxsize.bit_length() + 1)
+
+
 def _GetFuzzedJsString(s):
     """Returns a fuzzed string based on |s|.
 
     Args:
       s: The base string to fuzz.
     Returns:
       A single line string surrounded by quotes.
     """
     while True:
         fuzzed_string = fuzzy_types.FuzzyString(s)
         try:
             fuzzed_string = fuzzed_string.decode('utf8')
         except UnicodeDecodeError:
             print 'Can\'t decode fuzzed string. Trying again.'
         else:
             fuzzed_string = '\\n'.join(fuzzed_string.split())
+            fuzzed_string = fuzzed_string.replace('\\', r'\\')
             fuzzed_string = fuzzed_string.replace('\'', r'\'')
             return _ToJsStr(fuzzed_string)
 
 
 def GetAdvertisedServiceUUIDFromFakes():
     """Returns a random service string from the list of fake services."""
     return _ToJsStr(random.choice(wbt_fakes.ADVERTISED_SERVICES))
 
 
+def GetServiceUUIDFromFakes():
+    """Returns a random service string from the list of fake services."""
+    return _ToJsStr(random.choice(wbt_fakes.SERVICES))
+
+
+def GetCharacteristicUUIDFromFakes():
+  return _ToJsStr(random.choice(wbt_fakes.CHARACTERISTICS))
+
+
 def GetValidServiceAlias():
     """Returns a valid service alias from the list of services aliases."""
     return _ToJsStr(random.choice(gatt_aliases.SERVICES))
 
 
 def GetRandomUUID():
     """Returns a random UUID, a random number or a fuzzed uuid or alias."""
     choice = random.choice(['uuid', 'number', 'fuzzed string'])
     if choice == 'uuid':
         return _ToJsStr(uuid.uuid4())
     elif choice == 'number':
-        return utils.UniformExpoInteger(0, sys.maxsize.bit_length() + 1)
+        return _GetRandomNumber()
     elif choice == 'fuzzed string':
         choice2 = random.choice(['uuid', 'alias'])
         if choice2 == 'uuid':
             random_uuid = str(uuid.uuid4())
             return _GetFuzzedJsString(random_uuid)
         elif choice2 == 'alias':
             alias = random.choice(gatt_aliases.SERVICES)
             return _GetFuzzedJsString(alias)
 
 
 def GetAdvertisedServiceUUID():
     """Generates a random Service UUID from a set of functions.
 
-    See GetServiceUUIDFromFakes(), GetValidServiceAlias() and GetRandomUUID()
-    for the different values this function can return.
+    See GetAdvertisedServiceUUIDFromFakes(), GetValidServiceAlias() and
+    GetRandomUUID() for the different values this function can return.
 
     This function weights GetServiceUUIDFromFakes() more heavily to increase the
     probability of generating test pages that can interact with the fake
     adapters.
 
     Returns:
       A string or a number that can be used as a Service UUID by the Web
       Bluetooth API.
     """
     roll = random.random()
     if roll < 0.8:
         return GetAdvertisedServiceUUIDFromFakes()
     elif roll < 0.9:
         return GetValidServiceAlias()
     else:
         return GetRandomUUID()
 
 
+def GetServiceUUID():
+    """Generates a random Service UUID from a set of functions.
+
+    Similar to GetAdvertisedServiceUUID() but weights GetServiceUUIDFromFakes()
+    more heavily to increase the  probability of generating test pages that can
+    interact with the fake adapters.
+
+    See GetServiceUUIDFromFakes(), GetValidServiceAlias() and
+    GetRandomUUID() for the different values this function can return.
+
+    Returns:
+      A string or a number that can be used as a Service UUID by the Web
+      Bluetooth API.
+    """
+    roll = random.random()
+    if roll < 0.8:
+        return GetServiceUUIDFromFakes()
+    elif roll < 0.9:
+        return GetValidServiceAlias()
+    else:
+        return GetRandomUUID()
+
+
+def GetCharacteristicUUID():
+    roll = random.random()
+    if roll < 0.8:
+        return GetCharacteristicUUIDFromFakes()
+    elif roll < 0.9:
+        return GetCharacteristicUUIDFromFakes()
+    else:
+        return GetRandomUUID()
+
+
 def GetRequestDeviceOptions():
     """Returns an object used by navigator.bluetooth.requestDevice."""
     # TODO(ortuno): Randomize the members, number of filters, services, etc.
 
     return '{filters: [{services: [ %s ]}]}' % GetAdvertisedServiceUUID()
 
 
 def GetBasicBase():
     """Returns a string that sets a random fake adapter."""
     adapter = _ToJsStr(random.choice(wbt_fakes.ALL_ADAPTERS))
@@ skipping 15 matching lines @@
       1. Sets an adapter to a fake adapter with a connectable device.
       2. Looks for the connectable device.
       3. Connects to it.
     """
     adapter, services = random.choice(wbt_fakes.ADAPTERS_WITH_DEVICES)
     return DEVICE_DISCOVERY_BASE.format(
         fake_adapter_name=_ToJsStr(adapter),
         service_uuid=_ToJsStr(random.choice(services)))
 
 
-def GetServiceRetrievedBase():
+def GetServicesRetrievedBase():
     """Returns a string that contains all steps to retrieve a service.
 
     Returns: A string that:
       1. Sets an adapter to a fake adapter with a connectable device with
          services.
       2. Use one of the device's services to look for that device.
       3. Connects to it.
       4. Retrieve the device's service used in 2.
     """
     adapter, services = random.choice(wbt_fakes.ADAPTERS_WITH_SERVICES)
-    return SERVICE_RETRIEVED_BASE.format(
+    service_uuid = _ToJsStr(random.choice(services))
+
+    base = random.choice([SERVICE_RETRIEVED_BASE, SERVICES_RETRIEVED_BASE])
+    return base.format(
         fake_adapter_name=_ToJsStr(adapter),
-        service_uuid=_ToJsStr(random.choice(services)))
+        service_uuid=service_uuid,
+        optional_service_uuid=_GetOptional(service_uuid))
+
+def GetCharacteristicsRetrievedBase():
+  adapter, services = random.choice(wbt_fakes.ADAPTERS_WITH_CHARACTERISTICS)
+
+  service_uuid, characteristics = random.choice(services)
+  service_uuid = _ToJsStr(service_uuid)
+  characteristic_uuid = _ToJsStr(random.choice(characteristics))
+
+  optional_service_uuid = _GetOptional(service_uuid)
+  optional_characteristic_uuid = _GetOptional(characteristic_uuid)
+
+  services_base = random.choice([SERVICE_RETRIEVED_BASE,
+                                 SERVICES_RETRIEVED_BASE])
+  characteristics_base = services_base + random.choice(
+      [CHARACTERISTIC_RETRIEVED_BASE,
+       CHARACTERISTICS_RETRIEVED_BASE])
+
+  return characteristics_base.format(
+      fake_adapter_name=_ToJsStr(adapter),
+      service_uuid=service_uuid,
+      optional_service_uuid=optional_service_uuid,
+      characteristic_uuid=characteristic_uuid,
+      optional_characteristic_uuid=optional_characteristic_uuid)
+
+def GetGetPrimaryServicesCall():
+  call = random.choice([u'getPrimaryService({service_uuid})',
+                        u'getPrimaryServices({optional_service_uuid})'])
+
+  return call.format(
+      service_uuid=GetServiceUUID(),
+      optional_service_uuid=_GetOptional(GetServiceUUID()))
+
+
+def GetCatch():
+  return ".catch(e => console.log(e.name + \' \' + e.message))"
+
+def GetPickAService():
+  s = \
+  'var service; '\
+  'if (typeof services !== \'undefined\') '\
+  ' service = Array.isArray(services) ? services[{} % services.length] :'\
+  ' services'
+  return s.format(random.randint(0, 10))
+
+def GetPickACharacteristic():
+  s = \
+  'var characteristic; '\
+  'if (typeof characteristics !== \'undefined\') '\
+  ' characteristic = Array.isArray(characteristics)'\
+  ' ? characteristics[{} % characteristics.length]'\
+  ' : characteristics'
+  return s.format(random.randint(0, 10))
+
+
+def GetGetCharacteristicsCall():
+  call = random.choice([u'getCharacteristic({characteristic_uuid})',
+                        u'getCharacteristics({optional_characteristic_uuid})'])
+
+  return call.format(
+      characteristic_uuid=GetCharacteristicUUID(),
+      optional_characteristic_uuid=_GetOptional(GetCharacteristicUUID()))
+
+
+def GetWriteValue():
+  return 'new Uint8Array([1,2,3,4])';
+
+
+def GetReturnArgs():
+  return \
+'if (typeof characteristics !== \'undefined\') return characteristics; '\
+'if (typeof services !== \'undefined\') return services; '\
+'if (typeof gatt !== \'undefined\') return gatt; '\
+'if (typeof device !== \'undefined\') return device;'
+
+def GetReloadId():
+  return _ToJsStr(_GetRandomNumber())