from haskpy.testing import make_test_class from haskpy import Dictionary TestDictionary = make_test_class(Dictionary) def test_dictionary_apply(): """Test Dictionary.apply Laws don't guarantee a specific behavior, only consistent, so let's check that the output is what we want. """ fs = Dictionary( foo=lambda x: x + 1, bar=lambda x: 2 * x, ) xs = Dictionary( bar=42, baz=666, ) assert (fs @ xs) == Dictionary(bar=84) return def test_dictionary_eq(): """Test Dictionary.eq Laws don't guarantee a specific behavior, only consistent, so let's check that the output is what we want.
from haskpy import Maybe, Just, Nothing, MaybeT, List, Function, Compose, Either from haskpy.testing import make_test_class # Test typeclass laws for Maybe TestMaybe = make_test_class(Maybe) def test_maybe_match(): """Make sure the given value is actually stored""" assert Just(42).match(Nothing=lambda: 666, Just=lambda x: x) == 42 assert Nothing.match(Nothing=lambda: 666, Just=lambda x: x) == 666 return def test_maybe_map(): """Make sure the originally given value isn't kept constant""" assert Just(42).map(lambda x: x + 1) == Just(43) return def test_maybe_foldl(): """Make sure the folding is done as we expect""" assert Just("foo").foldl(lambda x: lambda y: x + y, "bar") == "barfoo" return # Test typeclass laws for MaybeT monad transformer (using some example monad). TestMaybeT = make_test_class(MaybeT(Either)) TestMaybeT = make_test_class(MaybeT(Function)) TestMaybeT = make_test_class(MaybeT(List))
from haskpy.types.list import List from haskpy.testing import make_test_class # Test typeclass laws for List TestList = make_test_class(List) def test_list_map(): # Test that the list elements are correctly modified. Just obeying the laws # doesn't force that because, for instance, keeping values as constant # would be a trivial solution but not what we want here. assert List(1, 2, 3).map(lambda x: x * 10) == List(10, 20, 30) return def test_list_apply(): """Test apply puts values in desired order Again, the laws don't force the ordering but we want them in particular order. """ assert List(1, 2).apply(List(lambda x: x+10, lambda x: x+100)) == \ List(11, 12, 101, 102) def test_list_foldr(): # Foldable laws are tested already, but let's check that folding also does # what we expect, because the laws can be satisfied by some trivial # solutions too (e.g., foldr/foldl returns initial). There's nothing wrong # in such solutions, we just don't want those for our List. Also, these
from haskpy.types.either import Either, Left, Right from haskpy.testing import make_test_class # Test typeclass laws for Either TestEither = make_test_class(Either) def test_either_match(): """Make sure the given value is actually stored""" assert Left(42).match(Left=lambda x: x - 1, Right=lambda x: 666) == 41 assert Right(42).match(Left=lambda x: 666, Right=lambda x: x + 1) == 43 return def test_either_map(): """Make sure the originally given value isn't kept constant""" assert Right(42).map(lambda x: x + 1) == Right(43) return
from haskpy import Identity, IdentityT, Function, List, Either from haskpy.testing import make_test_class # Test typeclass laws for Identity TestIdentity = make_test_class(Identity) def test_identity_map(): """Make sure the originally given value isn't kept constant""" assert Identity(42).map(lambda x: x + 1) == Identity(43) return TestIdentityT = make_test_class(IdentityT(Either)) TestIdentityT = make_test_class(IdentityT(List)) TestIdentityT = make_test_class(IdentityT(Function))
from hypothesis import given import hypothesis.strategies as st from haskpy.testing import make_test_class from haskpy import Sum, All, Any, String, Endo, Function from haskpy import testing TestSum = make_test_class(Sum) TestAll = make_test_class(All) TestAny = make_test_class(Any) TestString = make_test_class(String) TestEndo = make_test_class(Endo) @given(st.data()) def test_function_type_in_endo(data): """Test functions as the input/output type of endo functions This needs to be written manually because functions aren't hashable so we cannot use them as the input type of functions automatically. Endofunction has type ``a -> a``. This test will use ``(a -> b) -> (a -> b)``. """ def scale_output(f): def scaled(x):
from haskpy import Function, FunctionMonoid, Sum from haskpy.testing import make_test_class TestFunction = make_test_class(Function) # Testing the Monoid instance requires some Monoid type. Otherwise, only # Semigroup laws can be tested. TestFunctionMonoid = make_test_class(FunctionMonoid(Sum)) def test_function_nesting(): @Function def f(a, b, c): return a + b + c g1 = f("a") h1 = g1("b") assert h1("c") == "abc" g2 = Function(f("a")) h2 = Function(g2("b")) assert h2("c") == "abc" def test_function_composition(): assert (Function(lambda x: 10 * x)**Function(lambda x: x + 1)**Function( lambda x: 2 * x))(3) == 70
from haskpy import UncurriedFunction, UncurriedFunctionMonoid, Sum from haskpy.testing import make_test_class TestUncurriedFunction = make_test_class(UncurriedFunction) # Testing the Monoid instance requires some Monoid type. Otherwise, only # Semigroup laws can be tested. TestUncurriedFunctionMonoid = make_test_class(UncurriedFunctionMonoid(Sum)) def test_uncurried_function_apply(): @UncurriedFunction def f(a, *_, b=42): return a + b @UncurriedFunction def g(a, *_, b=1): return lambda y: (a + b) * y assert (g @ f)(2) == 44 * 3 assert (g @ f)(2, b=5) == 7 * 7 return
from haskpy.testing import make_test_class from haskpy import Compose, Maybe, Identity, Just MaybeIdentity = Compose(Maybe, Identity) TestMaybeIdentity = make_test_class(MaybeIdentity) def test_maybe_identity_pure(): assert MaybeIdentity.pure(42).decomposed == Maybe.pure(Identity.pure(42)) return def test_maybe_identity_apply(): x = MaybeIdentity(Just(Identity(42))) f = MaybeIdentity(Just(Identity(lambda x: x + 1))) assert x.apply(f).decomposed == Just(Identity(43)) return