really staying real

selfdrive/car/tests/test_car_interfaces.py

@@ -15,7 +15,7 @@ class TestCarInterfaces(unittest.TestCase):
 
   @parameterized.expand([(car,) for car in all_known_cars()])
   @settings(max_examples=5)
-  @given(cc_msg=get_random_msg(car.CarControl))
+  @given(cc_msg=get_random_msg(car.CarControl, real_floats=True))
   def test_car_interfaces(self, car_name, cc_msg):
     if car_name in FINGERPRINTS:
       fingerprint = FINGERPRINTS[car_name][0]

selfdrive/test/process_replay/fuzzy_generation.py

@@ -1,63 +1,69 @@
 import hypothesis.strategies as st
 import random
 
-def generate_native_type(field):
+class FuzzyGenerator:
-  def floats(**kwargs):
+  def __init__(self, real_floats):
-    return st.floats(**kwargs, allow_nan=False, allow_infinity=False)
+    self.real_floats=real_floats
 
-  if field == 'bool':
+  def generate_native_type(self, field):
-    return st.booleans()
+    def floats(**kwargs):
-  elif field == 'int8':
+      allow_nan = not self.real_floats
-    return st.integers(min_value=-2**7, max_value=2**7-1)
+      allow_infinity = not self.real_floats
-  elif field == 'int16':
+      return st.floats(**kwargs, allow_nan=allow_nan, allow_infinity=allow_infinity)
-    return st.integers(min_value=-2**15, max_value=2**15-1)
-  elif field == 'int32':
-    return st.integers(min_value=-2**31, max_value=2**31-1)
-  elif field == 'int64':
-    return st.integers(min_value=-2**63, max_value=2**63-1)
-  elif field == 'uint8':
-    return st.integers(min_value=0, max_value=2**8-1)
-  elif field == 'uint16':
-    return st.integers(min_value=0, max_value=2**16-1)
-  elif field == 'uint32':
-    return st.integers(min_value=0, max_value=2**32-1)
-  elif field == 'uint64':
-    return st.integers(min_value=0, max_value=2**64-1)
-  elif field == 'float32':
-    return floats(width=32)
-  elif field == 'float64':
-    return floats(width=64)
-  elif field == 'text':
-    return st.text(max_size=1000)
-  elif field == 'data':
-    return st.text(max_size=1000)
-  elif field == 'anyPointer':
-    return st.text()
-  else:
-    raise NotImplementedError(f'Invalid type : {field}')
 
-def generate_field(field):
+    if field == 'bool':
-  def rec(field_type):
+      return st.booleans()
-    if field_type.which() == 'struct':
+    elif field == 'int8':
-      return generate_struct(field.schema.elementType if base_type == 'list' else field.schema)
+      return st.integers(min_value=-2**7, max_value=2**7-1)
-    elif field_type.which() == 'list':
+    elif field == 'int16':
-      return st.lists(rec(field_type.list.elementType))
+      return st.integers(min_value=-2**15, max_value=2**15-1)
-    elif field_type.which() == 'enum':
+    elif field == 'int32':
-      schema = field.schema.elementType if base_type == 'list' else field.schema
+      return st.integers(min_value=-2**31, max_value=2**31-1)
-      return st.sampled_from(list(schema.enumerants.keys()))
+    elif field == 'int64':
+      return st.integers(min_value=-2**63, max_value=2**63-1)
+    elif field == 'uint8':
+      return st.integers(min_value=0, max_value=2**8-1)
+    elif field == 'uint16':
+      return st.integers(min_value=0, max_value=2**16-1)
+    elif field == 'uint32':
+      return st.integers(min_value=0, max_value=2**32-1)
+    elif field == 'uint64':
+      return st.integers(min_value=0, max_value=2**64-1)
+    elif field == 'float32':
+      return floats(width=32)
+    elif field == 'float64':
+      return floats(width=64)
+    elif field == 'text':
+      return st.text(max_size=1000)
+    elif field == 'data':
+      return st.text(max_size=1000)
+    elif field == 'anyPointer':
+      return st.text()
     else:
-      return generate_native_type(field_type.which())
+      raise NotImplementedError(f'Invalid type : {field}')
 
-  if 'slot' in field.proto.to_dict():
+  def generate_field(self, field):
-    base_type = field.proto.slot.type.which()
+    def rec(field_type):
-    return rec(field.proto.slot.type)
+      if field_type.which() == 'struct':
-  else:
+        return self.generate_struct(field.schema.elementType if base_type == 'list' else field.schema)
-    return generate_struct(field.schema)
+      elif field_type.which() == 'list':
+        return st.lists(rec(field_type.list.elementType))
+      elif field_type.which() == 'enum':
+        schema = field.schema.elementType if base_type == 'list' else field.schema
+        return st.sampled_from(list(schema.enumerants.keys()))
+      else:
+        return self.generate_native_type(field_type.which())
 
-def generate_struct(schema):
+    if 'slot' in field.proto.to_dict():
-  full_fill = list(schema.non_union_fields) if schema.non_union_fields else []
+      base_type = field.proto.slot.type.which()
-  single_fill = [random.choice(schema.union_fields)] if schema.union_fields else []
+      return rec(field.proto.slot.type)
-  return st.fixed_dictionaries(dict((field, generate_field(schema.fields[field])) for field in full_fill + single_fill))
+    else:
+      return self.generate_struct(field.schema)
+
+  def generate_struct(self, schema):
+    full_fill = list(schema.non_union_fields) if schema.non_union_fields else []
+    single_fill = [random.choice(schema.union_fields)] if schema.union_fields else []
+    return st.fixed_dictionaries(dict((field, self.generate_field(schema.fields[field])) for field in full_fill + single_fill))
 
-def get_random_msg(struct):
+def get_random_msg(struct, real_floats=False):
-  return generate_struct(struct.schema)
+  return FuzzyGenerator(real_floats=real_floats).generate_struct(struct.schema)