def test_join_ok(self) -> None: def f(items: List[str]) -> str: ''' post: True ''' return ', '.join(items) self.assertEqual(*check_unknown(f))
def test_union_ok(self) -> None: def f(a: Set[str], b: Set[str]) -> Set[str]: ''' post: all(((i in a) or (i in b)) for i in _) ''' return a | b self.assertEqual(*check_unknown(f))
def test_upper_unknown(self) -> None: def f(s: str) -> str: """ post: __return__ != "FOOBAR" """ return s.upper() self.assertEqual(*check_unknown( f)) # Ideally we'd find the counterexample input, "foobar"
def test_hashable_values_ok(self) -> None: def f(a: Tuple[str, int, float, bool], b: Tuple[str, int, float, bool]) -> int: """ post: _ or not (a == b) """ return hash(a) == hash(b) self.assertEqual(*check_unknown(f))
def test_full_symbolic_multiply_unknown(self) -> None: def f(s: str, i: int) -> str: ''' pre: s and i > 0 post: _[0] == s[0] ''' return s * i self.assertEqual(*check_unknown(f))
def test_round_unknown(self) -> None: def f(num: float, ndigits: Optional[int]) -> float: ''' post: isinstance(_, int) == (ndigits is None) ''' return round(num, ndigits) # TODO: this is unknown (rounding reals is hard) self.assertEqual(*check_unknown(f))
def test_symbolic_dict_has_unique_keys(self) -> None: def f(d: Dict[Tuple[int, str], int]) -> None: ''' pre: (1, 'one') in d post[d]: (1, 'one') not in d ''' del d[(1, 'one')] self.assertEqual(*check_unknown(f))
def test_max_ok(self) -> None: def f(l: List[int]) -> int: ''' pre: bool(l) post[]: _ in l ''' return max(l) self.assertEqual(*check_unknown(f))
def test_slice_outside_range_ok(self) -> None: def f(l: List[int], i: int) -> List[int]: ''' pre: i >= len(l) post: _ == l ''' return l[:i] self.assertEqual(*check_unknown(f))
def test_round_unknown(self) -> None: def f(num: float, ndigits: Optional[int]) -> float: ''' post: isinstance(_, int) == (ndigits is None) ''' return round(num, ndigits) # TODO: this is unknown (z3 can't solve 10**x != 0 right now) self.assertEqual(*check_unknown(f))
def test_repr_equiv(self) -> None: def f(symbolic: DefaultDict[int, int]) -> Tuple[dict, dict]: """ post: _[0] == _[1] """ concrete = collections.defaultdict(symbolic.default_factory, symbolic.items()) return (symbolic, concrete) self.assertEqual(*check_unknown(f))
def test_realized_compare(self) -> None: def f(a: str, b: str) -> bool: """ post: implies(_, a == b) """ return realize(a) == b self.assertEqual(*check_unknown(f))
def test_percent_format(self) -> None: def f(fmt: str) -> str: ''' pre: '%' not in fmt post: True ''' return fmt % () self.assertEqual(*check_unknown(f))
def test_contains_different_but_equivalent(self) -> None: def f(s: Set[Union[int, str]]) -> None: ''' pre: "foobar" in s post: (_ + "bar") in s ''' return "foo" self.assertEqual(*check_unknown(f))
def test_min_ok(self) -> None: def f(l: List[float]) -> float: ''' pre: bool(l) post[]: _ in l ''' return min(l) self.assertEqual(*check_unknown(f))
def test_average(self) -> None: def average(numbers: List[float]) -> float: ''' pre: len(numbers) > 0 post: min(numbers) <= _ <= max(numbers) ''' return sum(numbers) / len(numbers) self.assertEqual(*check_unknown(average))
def test_plus_unknown(self) -> None: def f(s: str) -> bool: """ pre: len(s) > 0 post: _ """ return bool(re.fullmatch(".+", s, re.DOTALL)) self.assertEqual(*check_unknown(f))
def test_slice_assignment_out_of_bounds(self) -> None: def f(l: List[int], i: int) -> None: """ pre: i != -1 post: l == __old__.l[:i] + __old__.l[i+1:] """ l[i:i + 1] = [] self.assertEqual(*check_unknown(f))
def test_iterable(self) -> None: T = TypeVar('T') def f(a: Iterable[T]) -> T: ''' pre: a post: _ in a ''' return next(iter(a)) self.assertEqual(*check_unknown(f))
def test_date_plus_delta_unknown(self) -> None: def f(delta: datetime.timedelta) -> datetime.date: """ post: _.year != -9999 raises: OverflowError """ return datetime.date(2000, 1, 1) + delta self.assertEqual(*check_unknown(f))
def test_plus_unknown(self) -> None: def f(s: str) -> bool: ''' pre: len(s) > 0 post: _ ''' return bool(re.fullmatch('.+', s, re.DOTALL)) self.assertEqual(*check_unknown(f))
def test_csv_example(self) -> None: def f(lines: List[str]) -> List[str]: ''' pre: all(',' in line for line in lines) post: __return__ == [line.split(',')[0] for line in lines] ''' return [line[:line.index(',')] for line in lines] # TODO: the model generation doesn't work right here (getting a lot of empty strings): self.assertEqual(*check_unknown(f))
def test_extend_literal_unknown(self) -> None: def f(l: List[int]) -> List[int]: ''' post: _[:2] == [1, 2] ''' r = [1, 2, 3] r.extend(l) return r self.assertEqual(*check_unknown(f))
def test_callable_with_typevar_in_return(self) -> None: # For now, just don't explode. But we should be able to make these fail with # some work. See https://github.com/pschanely/CrossHair/issues/85 T = TypeVar("T") def f(a: Callable[[int], T], x: int) -> T: """post: _""" return a(x) self.assertEqual(*check_unknown(f))
def test_csv_example(self) -> None: def f(lines: List[str]) -> List[str]: """ pre: all(',' in line for line in lines) post: __return__ == [line.split(',')[0] for line in lines] """ return [line[:line.index(",")] for line in lines] # TODO: the model generation doesn't work right here (getting a lot of empty strings): options = AnalysisOptionSet(per_path_timeout=0.5, per_condition_timeout=5) self.assertEqual(*check_unknown(f, options))
def test_unrelated_regex(self) -> None: def f(s: str) -> bool: """ post: True """ return bool(re.match(r"(\d+)", s)) self.assertEqual(*check_unknown(f))
def test_equality_ok(self) -> None: def f(d: Dict[int, int]) -> Dict[int, int]: """ post: _ == {**_} """ return d self.assertEqual(*check_unknown(f))
def test_range_can_be_called(self) -> None: def f(a: int) -> Iterable[int]: ''' post: len(_) == a or a < 0 ''' return range(a) self.assertEqual(*check_unknown(f))
def test_consistent_ordering(self) -> None: def f(symbolic: Dict[int, int]) -> Tuple[List[int], List[int]]: """ post: _[0] == _[1] """ return (list(symbolic.keys()), list(symbolic.keys())) self.assertEqual(*check_unknown(f))
def test_fallback_when_smt_values_out_themselves(self) -> None: def f(items: List[str]) -> str: """ post: True """ return ",".join(items) self.assertEqual(*check_unknown(f))