def test_hash(self): from typecheck import Length eq_tests = [(Length(4), Length(4)), (Length(4.0), Length(4))] ne_tests = [(Length(5), Length(4))] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import Typeclass eq_tests = [ (Typeclass(int), Typeclass(int)), (Typeclass(int, float), Typeclass(float, int)), (Typeclass(int, int), Typeclass(int)), (Typeclass(int), Typeclass(Typeclass(int))) ] ne_tests = [ (Typeclass(int), Typeclass(float)) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import Empty eq_tests = [ (Empty(list), Empty(list)), (Empty(dict), Empty(dict)), (Empty(set), Empty(set)) ] ne_tests = [ (Empty(list), Empty(dict)), (Empty(list), Empty(set)), (Empty(dict), Empty(set)) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import YieldSeq, And eq_tests = [ (YieldSeq(int, float), YieldSeq(int, float)), (YieldSeq(And(int, str), float), YieldSeq(And(int, str), float)) ] ne_tests = [ (YieldSeq(float, str), YieldSeq(int, float)), (YieldSeq(int, float), YieldSeq(int, int, int, float)), (YieldSeq(int, float, str), YieldSeq(int, float)), (YieldSeq(int, float), YieldSeq(int, float, str)), (YieldSeq(int, float), And(int, float)), (YieldSeq(int, int, int, float), YieldSeq(int, float)) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import Exact eq_tests = [ (Exact(4), Exact(4)), (Exact([4, 5]), Exact([4, 5])), (Exact(Exact), Exact(Exact)) ] ne_tests = [ (Exact(4), Exact(5)), (Exact([5, 4]), Exact([4, 5])), (Exact(Exact), Exact(object)), (Exact(object), Exact(dict)), (Exact([5, 4]), Exact(set([]))) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import Single class A(object): pass class B(A): pass eq_tests = [ (Single(int), Single(int)), (Single(A), Single(A)), (Single(B), Single(B)) ] ne_tests = [ (Single(int), Single(float)), (Single(A), Single(B)) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import Dict class A(object): pass class B(A): pass eq_tests = [ (Dict(str, int), Dict(str, int)), (Dict(str, A), Dict(str, A)), (Dict(str, Dict(str, int)), Dict(str, Dict(str, int))) ] ne_tests = [ (Dict(str, int), Dict(int, str)), (Dict(str, Dict(str, int)), Dict(str, Dict(int, str))) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import Or, And eq_tests = [ (Or(int, float), Or(int, float)), (Or(int, float), Or(int, int, int, float)), (Or(int, int, int, float), Or(int, float)), (Or(int, float), Or(float, int)), (Or(Or(int, str), float), Or(float, Or(str, int))), (Or(Or(int, str), float), Or(int, str, float)) ] ne_tests = [ (Or(float, str), Or(int, float)), (Or(int, float, str), Or(int, float)), (Or(int, float), Or(int, float, str)), (Or(int, float), And(int, float)) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import HasAttr, Any eq_tests = [ (HasAttr(['a']), HasAttr(['a'])), (HasAttr(['a', 'b']), HasAttr(['b', 'a'])), (HasAttr({'a': int}), HasAttr({'a': int})), (HasAttr({'a': int, 'b': int}), HasAttr({'b': int, 'a': int})), (HasAttr({'a': HasAttr(['a'])}), HasAttr({'a': HasAttr(['a'])})), (HasAttr(['a'], {'b': int, 'c': int}), HasAttr(['a'], {'b': int, 'c': int})), (HasAttr(['a']), HasAttr({'a': Any()})), (HasAttr({'a': int, 'b': float, 'c': str}), HasAttr({'a': int, 'b': float, 'c': str})) ] ne_tests = [ (HasAttr(['a', 'b']), HasAttr(['b'])), (HasAttr(['a', 'b']), HasAttr(['a'], {'b': int})), (HasAttr({'a': HasAttr(['a'])}), HasAttr({'a': HasAttr(['b'])})), ] test_hash(eq_tests, ne_tests, 100)
def test_hash(self): from typecheck import Not, Or eq_tests = [ (Not(int, float), Not(int, float)), (Not(int, float), Not(int, int, int, float)), (Not(int, int, int, float), Not(int, float)), (Not(int, float), Not(float, int)), (Not(Not(int, str), float), Not(float, Not(str, int))) ] ne_tests = [ (Not(float, str), Not(int, float)), (Not(int, float, str), Not(int, float)), (Not(int, float), Not(int, float, str)), (Not(int, float), Or(int, float)), (Not(Not(int, str), float), Not(int, str, float)), (Not(Not(int, float), Not(str, int)), Not(int, float, str)) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import And, Or eq_tests = [ (And(int, float), And(int, float)), (And(int, float), And(int, int, int, float)), (And(int, int, int, float), And(int, float)), (And(int, float), And(float, int)), (And(And(int, str), float), And(float, And(str, int))), (And(And(int, str), float), And(int, str, float)), (And(And(int, float), And(str, int)), And(int, float, str)) ] ne_tests = [ (And(float, str), And(int, float)), (And(int, float, str), And(int, float)), (And(int, float), And(int, float, str)), (And(int, float), Or(int, float)) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import Xor, Or eq_tests = [ (Xor(int, float), Xor(int, float)), (Xor(int, float), Xor(int, int, int, float)), (Xor(int, int, int, float), Xor(int, float)), (Xor(int, float), Xor(float, int)), (Xor(Xor(int, str), float), Xor(float, Xor(str, int))), (Xor(Xor(int, str), float), Xor(int, str, float)), (Xor(Xor(int, float), Xor(str, int)), Xor(int, float, str)) ] ne_tests = [ (Xor(float, str), Xor(int, float)), (Xor(int, float, str), Xor(int, float)), (Xor(int, float), Xor(int, float, str)), (Xor(int, float), Or(int, float)) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import Tuple class A(object): pass class B(A): pass eq_tests = [ (Tuple(str, int), Tuple(str, int)), (Tuple(str, A), Tuple(str, A)), (Tuple(), Tuple()), (Tuple(str, Tuple(str, int)), Tuple(str, Tuple(str, int))) ] ne_tests = [ (Tuple(str, int), Tuple(int, str)), (Tuple(A, A), Tuple(A, B)), (Tuple(str, int, float), Tuple()), (Tuple(str, Tuple(str, int)), Tuple(str, Tuple(int, str))) ] test_hash(eq_tests, ne_tests)
def test_hash(self): from typecheck import List class A(object): pass class B(A): pass eq_tests = [ (List(str, str), List(str, str)), (List(A, B), List(A, B)), (List(List(int, int), int), List(List(int, int), int)) ] ne_tests = [ (List(str, int), List(int, str)), (List(A, B), List(B, B)), (List(A, B), List(A, A)), (List(), List(int, int)), (List(List(int, int)), List(List(List(int, int)))), (List(int, int), List(int, int, int)) ] test_hash(eq_tests, ne_tests)
def test_hash(self): class A(object): pass class B(A): pass eq_tests = [(Set([str]), Set([str])), (Set([A, B]), Set([A, B])), (Set([]), Set([])), (Set([int, int, str]), Set([int, str])), (Set([int, str]), Set([str, int])), (Set([Set([int, float]), int]), Set([Set([float, int]), int])), (Set([Set([int, str]), Set([int, str])]), Set([Set([int, str])]))] ne_tests = [(Set([A, B]), Set([B, B])), (Set([A, B]), Set([A, A])), (Set([]), Set([int, int])), (Set([Set([int, str])]), Set([Set([Set([int, str])])]))] test_hash(eq_tests, ne_tests)