# Helper module to use the Hypothesis tool in tests

#

# Copyright 2015 David R. MacIver

#

# For details see http://hypothesis.readthedocs.org

import os

import sys

import traceback

try:

    # hypothesis 2.x

    from hypothesis.configuration import set_hypothesis_home_dir

    from hypothesis import settings

except ImportError:

    # hypothesis 1.x

    from hypothesis.settings import set_hypothesis_home_dir

    from hypothesis import Settings as settings

import hypothesis.strategies as st

from hypothesis import given

# hypothesis store data regarding generate example and code

set_hypothesis_home_dir(os.path.join(

    os.getenv('TESTTMP'), ".hypothesis"

))

def check(*args, **kwargs):

    """decorator to make a function a hypothesis test

    Decorated function are run immediately (to be used doctest style)"""

    def accept(f):

        # Workaround for https://github.com/DRMacIver/hypothesis/issues/206

        # Fixed in version 1.13 (released 2015 october 29th)

        f.__module__ = '__anon__'

        try:

            with settings(max_examples=2000):

                given(*args, **kwargs)(f)()

        except Exception:

            traceback.print_exc(file=sys.stdout)

            sys.exit(1)

    return accept

def roundtrips(data, decode, encode):

    """helper to tests function that must do proper encode/decode roundtripping

    """

    @given(data)

    def testroundtrips(value):

        encoded = encode(value)

        decoded = decode(encoded)

        if decoded != value:

            raise ValueError(

                "Round trip failed: %s(%r) -> %s(%r) -> %r" % (

                    encode.__name__, value, decode.__name__, encoded,

                    decoded

                ))

    try:

        testroundtrips()

    except Exception:

        # heredoc swallow traceback, we work around it

        traceback.print_exc(file=sys.stdout)

        raise

    print("Round trip OK")

# strategy for generating bytestring that might be an issue for Mercurial

bytestrings = (

    st.builds(lambda s, e: s.encode(e), st.text(), st.sampled_from([

        'utf-8', 'utf-16',

    ]))) | st.binary()