Python strategy_test_suite示例

示例#1

文件： test_fake_factory.py 项目： mgedmin/hypothesis

    with pytest.raises(ValueError):
        FakeFactory('spoon')


def test_fake_factory_errors_if_private_ish_method():
    with pytest.raises(ValueError):
        FakeFactory('_Generator__config')


def test_can_get_specification_for_fake_factory():
    ff = FakeFactory('email')
    strategy(ff)


TestFakeEmail = strategy_test_suite(
    FakeFactory('email')
)

TestFakeNames = strategy_test_suite(
    FakeFactory('name')
)

TestFakeEnglishNames = strategy_test_suite(
    FakeFactory('name', locale='en_US')
)


def test_equality():
    assert FakeFactory('email') == FakeFactory('email')
    assert FakeFactory('email') != FakeFactory('name')
    assert FakeFactory('email') != FakeFactory('email', locale='en_US')

示例#2

# v. 2.0. If a copy of the MPL was not distributed with this file, You can
# obtain one at http://mozilla.org/MPL/2.0/.

# END HEADER

from __future__ import division, print_function, absolute_import, \
    unicode_literals

import numpy as np
import pytest
from hypothesis import find, given, strategy
from hypothesis.extra.numpy import arrays
from hypothesis.strategytests import strategy_test_suite
from hypothesis.internal.compat import text_type, binary_type

TestFloats = strategy_test_suite(arrays(float, ()))
TestIntMatrix = strategy_test_suite(arrays(int, (3, 2)))
TestBoolTensor = strategy_test_suite(arrays(bool, (2, 2, 2)))

STANDARD_TYPES = list(
    map(np.dtype, [
        'int8', 'int32', 'int64', 'float', 'float32', 'float64', complex, bool,
        text_type, binary_type
    ]))


@pytest.mark.parametrize('t', STANDARD_TYPES)
def test_produces_instances(t):
    @given(t)
    def test_is_t(x):
        assert isinstance(x, t.type)

示例#3

from hypothesis import Settings, strategy
from tests.common.basic import Bitfields, BoringBitfields, \
    simplify_bitfield
from hypothesis.stateful import StateMachineSearchStrategy
from hypothesis.strategies import just, none, sets, text, basic, lists, \
    binary, builds, floats, one_of, tuples, randoms, booleans, decimals, \
    integers, fractions, streaming, frozensets, dictionaries, \
    sampled_from, complex_numbers, fixed_dictionaries
from hypothesis.strategytests import mutate_basic, templates_for, \
    strategy_test_suite
from hypothesis.internal.compat import hrange
from hypothesis.searchstrategy.narytree import n_ary_tree

with Settings(average_list_length=5.0):
    TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5))
    TestGiantIntegerRange = strategy_test_suite(
        integers(min_value=(-(2**129)), max_value=(2**129)))
    TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10))
    TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10))))
    TestSampled1 = strategy_test_suite(sampled_from(elements=(1, )))
    TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2)))

    TestIntegersFrom = strategy_test_suite(integers(min_value=13))
    TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024))

    TestOneOf = strategy_test_suite(one_of(integers(), integers(), booleans()))

    TestOneOfSameType = strategy_test_suite(
        one_of(
            integers(min_value=1, max_value=10),

示例#4

文件： bintree.py 项目： jwg4/hypothesis

# Hypothesis convention is to wrap all strategy production into helper
# functions rather than expose strategy classes directly. This isn't strictly
# necessary in this case but is generally good practice.

def binary_trees(leaves):
    # The call to strategy is part of the deprecated strategy building API.
    # Until Hypothesis 2.0 this will work but will emit a warning (error in
    # strict mode) when called with a non-strategy argument.
    return BinaryTreeStrategy(strategy(leaves))

# We now want to test our implementation. Hypothesis provides a standard suite
# of tests you can run to check that your implementation is working correctly.
# We test two examples: One with empty labels, the other with integer labels.

TestBinaryTreeOfNone = strategy_test_suite(binary_trees(just(None)))
TestBinaryTreeOfInts = strategy_test_suite(binary_trees(integers()))


# If we've got to here we should now have a working strategy. Now lets look
# at some explicit examples to make sure that everything is simplifying well
# and we can find the examples we want to find.


# First we'll define some convenience functions that we'll need for delineating
# different areas of the search space and testing our results.

def labels(tree):
    """Convenience function for getting all labels out of a tree, no matter how
    deep they are."""
    if isinstance(tree, Leaf):

示例#5

文件： test_datetime.py 项目： alex/hypothesis

from __future__ import division, print_function, absolute_import

from datetime import MINYEAR

import pytz
import pytest

import hypothesis._settings as hs
from hypothesis import given, assume, settings
from hypothesis.errors import InvalidArgument
from hypothesis.strategytests import strategy_test_suite
from hypothesis.extra.datetime import datetimes
from hypothesis.internal.debug import minimal
from hypothesis.internal.compat import hrange

TestStandardDescriptorFeatures1 = strategy_test_suite(datetimes())
TestStandardDescriptorFeatures2 = strategy_test_suite(
    datetimes(allow_naive=False))
TestStandardDescriptorFeatures3 = strategy_test_suite(
    datetimes(timezones=[]),
)


def test_can_find_after_the_year_2000():
    assert minimal(datetimes(), lambda x: x.year > 2000).year == 2001


def test_can_find_before_the_year_2000():
    assert minimal(datetimes(), lambda x: x.year < 2000).year == 1999

示例#6

文件： test_descriptortests.py 项目： adamchainz/hypothesis

import math
from random import Random
from collections import namedtuple

from hypothesis.stateful import StateMachineSearchStrategy
from hypothesis.strategies import just, none, sets, text, lists, binary, \
    builds, floats, one_of, tuples, randoms, booleans, decimals, \
    integers, composite, fractions, recursive, streaming, frozensets, \
    dictionaries, sampled_from, complex_numbers, fixed_dictionaries
from hypothesis.strategytests import mutate_basic, templates_for, \
    strategy_test_suite
from hypothesis.internal.compat import hrange, OrderedDict
from hypothesis.searchstrategy.morphers import MorpherStrategy

TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5))
TestGiantIntegerRange = strategy_test_suite(
    integers(min_value=(-(2 ** 129)), max_value=(2 ** 129))
)
TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10))
TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10))))
TestSampled1 = strategy_test_suite(sampled_from(elements=(1,)))
TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2)))

TestIntegersFrom = strategy_test_suite(integers(min_value=13))
TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024))

TestOneOf = strategy_test_suite(one_of(
    integers(), integers(), booleans()))

TestOneOfSameType = strategy_test_suite(

示例#7

文件： test_descriptortests.py 项目： kbara/hypothesis

from fractions import Fraction
from collections import OrderedDict, namedtuple

from hypothesis import strategy
from tests.common.basic import Bitfields, BoringBitfields, \
    simplify_bitfield
from hypothesis.specifiers import just, one_of, strings, streaming, \
    dictionary, sampled_from, integers_from, floats_in_range, \
    integers_in_range
from tests.common.specifiers import Descriptor
from hypothesis.strategytests import TemplatesFor, strategy_test_suite
from hypothesis.internal.compat import text_type, binary_type
from hypothesis.searchstrategy.basic import basic_strategy
from hypothesis.searchstrategy.narytree import NAryTree

TestIntegerRange = strategy_test_suite(integers_in_range(0, 5))
TestGiantIntegerRange = strategy_test_suite(
    integers_in_range(-(2 ** 129), 2 ** 129)
)
TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10))
TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10))))
TestSampled1 = strategy_test_suite(sampled_from(elements=(1,)))
TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2)))

TestIntegersFrom = strategy_test_suite(integers_from(13))

TestOneOf = strategy_test_suite(one_of((int, int, bool)))
TestOneOfSameType = strategy_test_suite(
    one_of((integers_in_range(1, 10), integers_in_range(8, 15)))
)
TestRandom = strategy_test_suite(Random)

示例#8

        return simplify_bitfield(random, value)

    def copy(self, value):
        return value


def popcount(x):
    # don't judge
    tot = 0
    while x:
        tot += (x & 1)
        x >>= 1
    return tot


TestBoringBitfieldsClass = strategy_test_suite(BoringBitfields)
TestBitfieldsClass = strategy_test_suite(Bitfields)
TestBitfieldsInstance = strategy_test_suite(Bitfields())

TestBitfields = strategy_test_suite([
    basic_strategy(
        generate=lambda r, p: r.getrandbits(128),
        simplify=simplify_bitfield,
        copy=lambda x: x,
    )
])

TestBitfieldsSet = strategy_test_suite({
    basic_strategy(
        generate=lambda r, p: r.getrandbits(128),
        simplify=simplify_bitfield,

示例#9

文件： test_strategytests.py 项目： Mystery-College-of-The-Adapts/hypothesis

# coding=utf-8

# Copyright (C) 2013-2015 David R. MacIver ([email protected])

# This file is part of Hypothesis (https://github.com/DRMacIver/hypothesis)

# This Source Code Form is subject to the terms of the Mozilla Public License,
# v. 2.0. If a copy of the MPL was not distributed with this file, You can
# obtain one at http://mozilla.org/MPL/2.0/.

# END HEADER

# most interesting tests of this nature are exected in nocover, but we have
# a few here to make sure we have coverage of the strategytests module itself.

from __future__ import division, print_function, absolute_import, \
    unicode_literals

from hypothesis.strategies import sets, booleans, integers
from hypothesis.strategytests import strategy_test_suite

TestBoolSets = strategy_test_suite(sets(booleans()))
TestInts = strategy_test_suite(integers())

示例#10

import datetime as dt

import pytest
from flaky import flaky

from hypothesis import find, given, settings
from tests.common.debug import minimal
from hypothesis.strategies import none, dates, times, binary, datetimes, \
    timedeltas
from hypothesis.strategytests import strategy_test_suite
from hypothesis.internal.compat import hrange
from hypothesis.searchstrategy.datetime import DatetimeStrategy
from hypothesis.internal.conjecture.data import Status, StopTest, \
    ConjectureData

TestStandardDescriptorFeatures_timedeltas1 = strategy_test_suite(timedeltas())


def test_can_find_positive_delta():
    assert minimal(timedeltas(), lambda x: x.days > 0) == dt.timedelta(1)


def test_can_find_negative_delta():
    assert minimal(timedeltas(max_delta=dt.timedelta(10**6)),
                   lambda x: x.days < 0) == dt.timedelta(-1)


def test_can_find_on_the_second():
    minimal(timedeltas(), lambda x: x.seconds == 0)

示例#11

文件： test_descriptortests.py 项目： wrhall/hypothesis

# END HEADER

from __future__ import division, print_function, absolute_import, \
    unicode_literals

from random import Random
from collections import namedtuple

from hypothesis.specifiers import just, one_of, sampled_from, \
    floats_in_range, integers_in_range
from tests.common.specifiers import Descriptor, DescriptorWithValue
from hypothesis.strategytests import TemplatesFor, strategy_test_suite
from hypothesis.internal.compat import text_type, binary_type
from hypothesis.searchstrategy.narytree import NAryTree

TestIntegerRange = strategy_test_suite(integers_in_range(0, 5))
TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10))
TestSampled = strategy_test_suite(sampled_from(elements=(1, 2, 3)))

TestOneOf = strategy_test_suite(one_of((int, int, bool)))
TestOneOfSameType = strategy_test_suite(
    one_of((integers_in_range(1, 10), integers_in_range(8, 15)))
)
TestRandom = strategy_test_suite(Random)
TestInts = strategy_test_suite(int)
TestBoolLists = strategy_test_suite([bool])
TestString = strategy_test_suite(text_type)
BinaryString = strategy_test_suite(binary_type)
TestIntBool = strategy_test_suite((int, bool))
TestFloats = strategy_test_suite(float)
TestComplex = strategy_test_suite(complex)

示例#12

from __future__ import division, print_function, absolute_import

import datetime as dt

import pytz
import pytest

from hypothesis import given, assume
from hypothesis.errors import InvalidArgument
from tests.common.debug import minimal
from hypothesis.extra.pytz import timezones
from hypothesis.strategies import times, datetimes, sampled_from
from hypothesis.strategytests import strategy_test_suite

TestStandardDescriptorFeatures1 = strategy_test_suite(timezones())
TestStandardDescriptorFeatures_datetimes2 = strategy_test_suite(
    datetimes(timezones=timezones()))


def test_utc_is_minimal():
    assert pytz.UTC is minimal(timezones())


def test_can_generate_non_naive_time():
    assert minimal(times(timezones=timezones()),
                   lambda d: d.tzinfo).tzinfo == pytz.UTC


def test_can_generate_non_naive_datetime():
    assert minimal(datetimes(timezones=timezones()),

示例#13

文件： test_streams.py 项目： itkovian/hypothesis

from __future__ import division, print_function, absolute_import, \
    unicode_literals

from itertools import islice

import pytest
from hypothesis import given, assume
from hypothesis.errors import InvalidArgument
from hypothesis.specifiers import streaming
from hypothesis.utils.show import show
from hypothesis.strategytests import strategy_test_suite
from hypothesis.internal.debug import minimal, via_database, some_template
from hypothesis.internal.compat import text_type, integer_types
from hypothesis.searchstrategy.streams import Stream, StreamTemplate

TestIntStreams = strategy_test_suite(streaming(int))
TestStreamLists = strategy_test_suite(streaming(int))
TestIntStreamStreams = strategy_test_suite(streaming(streaming(int)))


@given([bool])
def test_stream_give_lists(xs):
    s = Stream(iter(xs))
    assert list(s) == xs
    assert list(s) == xs


@given([bool])
def test_can_zip_streams_with_self(xs):
    s = Stream(iter(xs))
    assert list(zip(s, s)) == list(zip(xs, xs))

示例#14

文件： test_basic_strategy.py 项目： AlbertoPeon/hypothesis

        return simplify_bitfield(random, value)

    def copy(self, value):
        return value


def popcount(x):
    # don't judge
    tot = 0
    while x:
        tot += (x & 1)
        x >>= 1
    return tot


TestBoringBitfieldsClass = strategy_test_suite(BoringBitfields)
TestBitfieldsClass = strategy_test_suite(Bitfields)
TestBitfieldsInstance = strategy_test_suite(Bitfields())


TestBitfields = strategy_test_suite([
    basic_strategy(
        generate=lambda r, p: r.getrandbits(128),
        simplify=simplify_bitfield,
        copy=lambda x: x,
    )
])

TestBitfieldsSet = strategy_test_suite({
    basic_strategy(
        generate=lambda r, p: r.getrandbits(128),

示例#15

文件： test_fake_factory.py 项目： Jeff-Meadows/hypothesis

def test_fake_factory_errors_with_unsupported_locale():
    with pytest.raises(ValueError):
        fake_factory("name", locale="badger_BADGER")


def test_fake_factory_errors_if_any_locale_is_unsupported():
    with pytest.raises(ValueError):
        fake_factory("name", locales=["fr_FR", "en_US", "mushroom_MUSHROOM"])


def test_fake_factory_errors_if_unsupported_method():
    with pytest.raises(ValueError):
        fake_factory("spoon")


def test_fake_factory_errors_if_private_ish_method():
    with pytest.raises(ValueError):
        fake_factory("_Generator__config")


def test_can_get_specification_for_fake_factory():
    ff = fake_factory("email")
    strategy(ff)


TestFakeEmail = strategy_test_suite(fake_factory("email"))

TestFakeNames = strategy_test_suite(fake_factory("name"))

TestFakeEnglishNames = strategy_test_suite(fake_factory("name", locale="en_US"))

示例#16

文件： test_descriptortests.py 项目： subsetpark/hypothesis

from hypothesis import Settings, strategy
from tests.common.basic import Bitfields, BoringBitfields, \
    simplify_bitfield
from hypothesis.stateful import StateMachineSearchStrategy
from hypothesis.strategies import just, none, sets, text, basic, lists, \
    binary, builds, floats, one_of, tuples, randoms, booleans, decimals, \
    integers, fractions, streaming, frozensets, dictionaries, \
    sampled_from, complex_numbers, fixed_dictionaries
from hypothesis.strategytests import mutate_basic, templates_for, \
    strategy_test_suite
from hypothesis.internal.compat import hrange
from hypothesis.searchstrategy.narytree import n_ary_tree

with Settings(average_list_length=5.0):
    TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5))
    TestGiantIntegerRange = strategy_test_suite(
        integers(min_value=(-(2 ** 129)), max_value=(2 ** 129))
    )
    TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10))
    TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10))))
    TestSampled1 = strategy_test_suite(sampled_from(elements=(1,)))
    TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2)))

    TestIntegersFrom = strategy_test_suite(integers(min_value=13))
    TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024))

    TestOneOf = strategy_test_suite(one_of(
        integers(), integers(), booleans()))

    TestOneOfSameType = strategy_test_suite(

示例#17

文件： test_gen_data.py 项目： degustaf/hypothesis

#
# END HEADER

from __future__ import division, print_function, absolute_import

import numpy as np
import pytest

import hypothesis.strategies as st
from flaky import flaky
from hypothesis import find, given, settings
from hypothesis.extra.numpy import arrays, from_dtype
from hypothesis.strategytests import strategy_test_suite
from hypothesis.internal.compat import text_type, binary_type

TestFloats = strategy_test_suite(arrays(float, ()))
TestIntMatrix = strategy_test_suite(arrays(int, (3, 2)))
TestBoolTensor = strategy_test_suite(arrays(bool, (2, 2, 2)))


STANDARD_TYPES = list(map(np.dtype, [
    u'int8', u'int32', u'int64',
    u'float', u'float32', u'float64',
    complex,
    bool, text_type, binary_type
]))


@pytest.mark.parametrize(u't', STANDARD_TYPES)
def test_produces_instances(t):
    @given(from_dtype(t))

示例#18

文件： test_descriptortests.py 项目： pkqk/hypothesis

from __future__ import division, print_function, absolute_import, \
    unicode_literals

from random import Random
from decimal import Decimal
from fractions import Fraction
from collections import namedtuple

from hypothesis.specifiers import just, one_of, sampled_from, \
    integers_from, floats_in_range, integers_in_range
from tests.common.specifiers import Descriptor, DescriptorWithValue
from hypothesis.strategytests import TemplatesFor, strategy_test_suite
from hypothesis.internal.compat import text_type, binary_type
from hypothesis.searchstrategy.narytree import NAryTree

TestIntegerRange = strategy_test_suite(integers_in_range(0, 5))
TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10))
TestSampled = strategy_test_suite(sampled_from(elements=(1, 2, 3)))

TestIntegersFrom = strategy_test_suite(integers_from(13))

TestOneOf = strategy_test_suite(one_of((int, int, bool)))
TestOneOfSameType = strategy_test_suite(
    one_of((integers_in_range(1, 10), integers_in_range(8, 15)))
)
TestRandom = strategy_test_suite(Random)
TestInts = strategy_test_suite(int)
TestBoolLists = strategy_test_suite([bool])
TestString = strategy_test_suite(text_type)
BinaryString = strategy_test_suite(binary_type)
TestIntBool = strategy_test_suite((int, bool))

示例#19

文件： test_descriptortests.py 项目： raamana/hypothesis-python

#
# END HEADER

from __future__ import division, print_function, absolute_import

import math
from collections import Container, namedtuple

from hypothesis.strategies import just, none, sets, text, lists, binary, \
    builds, floats, one_of, tuples, randoms, booleans, decimals, \
    integers, composite, fractions, recursive, frozensets, dictionaries, \
    sampled_from, complex_numbers, fixed_dictionaries
from hypothesis.strategytests import strategy_test_suite
from hypothesis.internal.compat import OrderedDict

TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5))
TestGiantIntegerRange = strategy_test_suite(
    integers(min_value=(-(2**129)), max_value=(2**129)))
TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10))
TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10))))
TestSampled1 = strategy_test_suite(sampled_from(elements=(1, )))
TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2)))

TestIntegersFrom = strategy_test_suite(integers(min_value=13))
TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024))

TestOneOf = strategy_test_suite(one_of(integers(), integers(), booleans()))

TestOneOfSameType = strategy_test_suite(
    one_of(
        integers(min_value=1, max_value=10),

示例#20

    unicode_literals

from random import Random
from decimal import Decimal
from fractions import Fraction
from collections import OrderedDict, namedtuple

from hypothesis import strategy
from hypothesis.specifiers import just, one_of, dictionary, sampled_from, \
    integers_from, floats_in_range, integers_in_range
from tests.common.specifiers import Descriptor, DescriptorWithValue
from hypothesis.strategytests import TemplatesFor, strategy_test_suite
from hypothesis.internal.compat import text_type, binary_type
from hypothesis.searchstrategy.narytree import NAryTree

TestIntegerRange = strategy_test_suite(integers_in_range(0, 5))
TestGiantIntegerRange = strategy_test_suite(
    integers_in_range(-(2**129), 2**129))
TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10))
TestSampled = strategy_test_suite(sampled_from(elements=(1, 2, 3)))

TestIntegersFrom = strategy_test_suite(integers_from(13))

TestOneOf = strategy_test_suite(one_of((int, int, bool)))
TestOneOfSameType = strategy_test_suite(
    one_of((integers_in_range(1, 10), integers_in_range(8, 15))))
TestRandom = strategy_test_suite(Random)
TestInts = strategy_test_suite(int)
TestBoolLists = strategy_test_suite([bool])
TestDictionaries = strategy_test_suite(dictionary((int, int), bool))
TestOrderedDictionaries = strategy_test_suite(dictionary(

示例#21

文件： test_datetime.py 项目： trowt/hypothesis

from datetime import MAXYEAR, datetime

import pytz
import pytest
import hypothesis.settings as hs
from hypothesis import given, assume
from hypothesis.strategytests import strategy_test_suite
from hypothesis.extra.datetime import datetimes, any_datetime, \
    naive_datetime, timezone_aware_datetime
from hypothesis.internal.debug import minimal
from hypothesis.internal.compat import hrange
from hypothesis.searchstrategy.strategies import BadData

hs.Settings.default.max_examples = 1000

TestStandardDescriptorFeatures1 = strategy_test_suite(datetimes())
TestStandardDescriptorFeatures2 = strategy_test_suite(
    datetimes(allow_naive=False))
TestStandardDescriptorFeatures3 = strategy_test_suite(
    datetimes(timezones=[]), )


def test_can_find_after_the_year_2000():
    assert minimal(datetimes(), lambda x: x.year > 2000).year == 2001


def test_can_find_before_the_year_2000():
    assert minimal(datetimes(), lambda x: x.year < 2000).year == 1999


def test_can_find_each_month():

示例#22

文件： test_descriptortests.py 项目： AlbertoPeon/hypothesis

    unicode_literals

from random import Random
from decimal import Decimal
from fractions import Fraction
from collections import OrderedDict, namedtuple

from hypothesis import strategy
from hypothesis.specifiers import just, one_of, dictionary, sampled_from, \
    integers_from, floats_in_range, integers_in_range
from tests.common.specifiers import Descriptor, DescriptorWithValue
from hypothesis.strategytests import TemplatesFor, strategy_test_suite
from hypothesis.internal.compat import text_type, binary_type
from hypothesis.searchstrategy.narytree import NAryTree

TestIntegerRange = strategy_test_suite(integers_in_range(0, 5))
TestGiantIntegerRange = strategy_test_suite(
    integers_in_range(-(2 ** 129), 2 ** 129)
)
TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10))
TestSampled = strategy_test_suite(sampled_from(elements=(1, 2, 3)))

TestIntegersFrom = strategy_test_suite(integers_from(13))

TestOneOf = strategy_test_suite(one_of((int, int, bool)))
TestOneOfSameType = strategy_test_suite(
    one_of((integers_in_range(1, 10), integers_in_range(8, 15)))
)
TestRandom = strategy_test_suite(Random)
TestInts = strategy_test_suite(int)
TestBoolLists = strategy_test_suite([bool])

示例#23

文件： test_datetime.py 项目： AlbertoPeon/hypothesis

from datetime import datetime

import pytz
import hypothesis.settings as hs
from hypothesis import given, assume
from hypothesis.specifiers import one_of
from hypothesis.strategytests import strategy_test_suite
from hypothesis.extra.datetime import naive_datetime, \
    timezone_aware_datetime
from hypothesis.internal.debug import minimal
from hypothesis.internal.compat import hrange

hs.Settings.default.max_examples = 1000


TestStandardDescriptorFeatures1 = strategy_test_suite(datetime)
TestStandardDescriptorFeatures2 = strategy_test_suite(
    timezone_aware_datetime)
TestStandardDescriptorFeatures3 = strategy_test_suite(naive_datetime)
TestStandardDescriptorFeatures4 = strategy_test_suite(one_of((
    naive_datetime,
    timezone_aware_datetime,
)))


def test_can_find_after_the_year_2000():
    assert minimal(datetime, lambda x: x.year > 2000).year == 2001


def test_can_find_before_the_year_2000():
    assert minimal(datetime, lambda x: x.year < 2000).year == 1999

示例#24

def test_fake_factory_errors_if_unsupported_method():
    with pytest.raises(ValueError):
        FakeFactory('spoon')


def test_fake_factory_errors_if_private_ish_method():
    with pytest.raises(ValueError):
        FakeFactory('_Generator__config')


def test_can_get_specification_for_fake_factory():
    ff = FakeFactory('email')
    strategy(ff)


TestFakeEmail = strategy_test_suite(FakeFactory('email'))

TestFakeNames = strategy_test_suite(FakeFactory('name'))

TestFakeEnglishNames = strategy_test_suite(FakeFactory('name', locale='en_US'))


def test_equality():
    assert FakeFactory('email') == FakeFactory('email')
    assert FakeFactory('email') != FakeFactory('name')
    assert FakeFactory('email') != FakeFactory('email', locale='en_US')


def test_hashing():
    x = FakeFactory('email')
    assert hash(x) == hash(FakeFactory('email'))

示例#25

文件： test_descriptortests.py 项目： kbara/hypothesis

from fractions import Fraction
from collections import OrderedDict, namedtuple

from hypothesis import strategy
from tests.common.basic import Bitfields, BoringBitfields, \
    simplify_bitfield
from hypothesis.specifiers import just, one_of, strings, streaming, \
    dictionary, sampled_from, integers_from, floats_in_range, \
    integers_in_range
from tests.common.specifiers import Descriptor
from hypothesis.strategytests import TemplatesFor, strategy_test_suite
from hypothesis.internal.compat import text_type, binary_type
from hypothesis.searchstrategy.basic import basic_strategy
from hypothesis.searchstrategy.narytree import NAryTree

TestIntegerRange = strategy_test_suite(integers_in_range(0, 5))
TestGiantIntegerRange = strategy_test_suite(
    integers_in_range(-(2**129), 2**129))
TestFloatRange = strategy_test_suite(floats_in_range(0.5, 10))
TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10))))
TestSampled1 = strategy_test_suite(sampled_from(elements=(1, )))
TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2)))

TestIntegersFrom = strategy_test_suite(integers_from(13))

TestOneOf = strategy_test_suite(one_of((int, int, bool)))
TestOneOfSameType = strategy_test_suite(
    one_of((integers_in_range(1, 10), integers_in_range(8, 15))))
TestRandom = strategy_test_suite(Random)
TestInts = strategy_test_suite(int)
TestBoolLists = strategy_test_suite([bool])

示例#26

            check_length(2, data)
            return self._make_split(*map(self.from_basic, data))


# Hypothesis convention is to wrap all strategy production into helper
# functions rather than expose strategy classes directly. This isn't strictly
# necessary in this case but is generally good practice.

def binary_trees(leaves):
    return BinaryTreeStrategy(leaves)

# We now want to test our implementation. Hypothesis provides a standard suite
# of tests you can run to check that your implementation is working correctly.
# We test two examples: One with empty labels, the other with integer labels.

TestBinaryTreeOfNone = strategy_test_suite(binary_trees(just(None)))
TestBinaryTreeOfInts = strategy_test_suite(binary_trees(integers()))


# If we've got to here we should now have a working strategy. Now lets look
# at some explicit examples to make sure that everything is simplifying well
# and we can find the examples we want to find.


# First we'll define some convenience functions that we'll need for delineating
# different areas of the search space and testing our results.

def labels(tree):
    """Convenience function for getting all labels out of a tree, no matter how
    deep they are."""
    if isinstance(tree, Leaf):

示例#27

文件： test_fake_factory.py 项目： zooming-tan/hypothesis

def test_fake_factory_errors_if_unsupported_method():
    with pytest.raises(ValueError):
        fake_factory(u'spoon')


def test_fake_factory_errors_if_private_ish_method():
    with pytest.raises(ValueError):
        fake_factory(u'_Generator__config')


def test_can_get_specification_for_fake_factory():
    ff = fake_factory(u'email')
    strategy(ff)


TestFakeEmail = strategy_test_suite(
    fake_factory(u'email')
)

TestFakeNames = strategy_test_suite(
    fake_factory(u'name')
)

TestFakeEnglishNames = strategy_test_suite(
    fake_factory(u'name', locale=u'en_US')
)

TestStates = strategy_test_suite(
    fake_factory(u'state')
)

示例#28

from datetime import datetime

import hypothesis.settings as hs
from hypothesis import given, assume
from hypothesis.specifiers import one_of
from hypothesis.strategytests import strategy_test_suite
from hypothesis.extra.datetime import naive_datetime, \
    timezone_aware_datetime
from hypothesis.searchstrategy import strategy
from hypothesis.internal.compat import hrange
from hypothesis.internal.verifier import Verifier

hs.Settings.default.max_examples = 1000


TestStandardDescriptorFeatures1 = strategy_test_suite(datetime)
TestStandardDescriptorFeatures2 = strategy_test_suite(
    timezone_aware_datetime)
TestStandardDescriptorFeatures3 = strategy_test_suite(naive_datetime)
TestStandardDescriptorFeatures4 = strategy_test_suite(one_of((
    naive_datetime,
    timezone_aware_datetime,
)))


falsify = Verifier().falsify


def test_can_find_after_the_year_2000():
    falsify(lambda x: x.year > 2000, datetime)

示例#29

文件： test_times.py 项目： fschulze/hypothesis

from __future__ import division, print_function, absolute_import

from random import Random

import pytz
import pytest

import hypothesis._settings as hs
from hypothesis import given, assume
from hypothesis.errors import UnsatisfiedAssumption
from hypothesis.strategytests import strategy_test_suite
from hypothesis.extra.datetime import times
from hypothesis.internal.debug import minimal

TestStandardDescriptorFeatures1 = strategy_test_suite(times())


def test_can_find_midnight():
    minimal(
        times(),
        lambda x: (x.hour == 0 and x.minute == 0 and x.second == 0),
    )


def test_can_find_non_midnight():
    assert minimal(times(), lambda x: x.hour != 0).hour == 1


def test_can_find_off_the_minute():
    minimal(times(), lambda x: x.second == 0)

示例#30

文件： test_descriptortests.py 项目： zooming-tan/hypothesis

from hypothesis import Settings
from tests.common.basic import Bitfields, BoringBitfields, \
    simplify_bitfield
from hypothesis.stateful import StateMachineSearchStrategy
from hypothesis.strategies import just, none, sets, text, basic, lists, \
    binary, builds, floats, one_of, tuples, randoms, booleans, decimals, \
    integers, composite, fractions, recursive, streaming, frozensets, \
    dictionaries, sampled_from, complex_numbers, fixed_dictionaries
from hypothesis.strategytests import mutate_basic, templates_for, \
    strategy_test_suite
from hypothesis.internal.compat import hrange, OrderedDict
from hypothesis.searchstrategy.morphers import MorpherStrategy
from hypothesis.searchstrategy.narytree import n_ary_tree

with Settings(average_list_length=5.0):
    TestIntegerRange = strategy_test_suite(integers(min_value=0, max_value=5))
    TestGiantIntegerRange = strategy_test_suite(
        integers(min_value=(-(2**129)), max_value=(2**129)))
    TestFloatRange = strategy_test_suite(floats(min_value=0.5, max_value=10))
    TestSampled10 = strategy_test_suite(sampled_from(elements=list(range(10))))
    TestSampled1 = strategy_test_suite(sampled_from(elements=(1, )))
    TestSampled2 = strategy_test_suite(sampled_from(elements=(1, 2)))

    TestIntegersFrom = strategy_test_suite(integers(min_value=13))
    TestIntegersFrom = strategy_test_suite(integers(min_value=1 << 1024))

    TestOneOf = strategy_test_suite(one_of(integers(), integers(), booleans()))

    TestOneOfSameType = strategy_test_suite(
        one_of(
            integers(min_value=1, max_value=10),