class OneCharStringStrategy(SearchStrategy): """A strategy which generates single character strings of text type.""" specifier = text_type ascii_characters = (text_type('0123456789') + text_type(string.ascii_letters) + text_type(' \t\n')) def produce_parameter(self, random): alphabet_size = 1 + dist.geometric(random, 0.1) alphabet = [] while len(alphabet) < alphabet_size: char = hunichr(random.randint(0, sys.maxunicode)) if unicodedata.category(char) != 'Cs': alphabet.append(char) return tuple(alphabet) def produce_template(self, context, p): return context.random.choice(p) def reify(self, value): return value def basic_simplify(self, random, x): if x in self.ascii_characters: for i in hrange(0, self.ascii_characters.index(x)): yield self.ascii_characters[i] else: o = ord(x) for c in self.ascii_characters: yield text_type(c) yield hunichr(o // 2) for t in hrange(o - 1, max(o - 10, -1), -1): yield hunichr(t)
class OneCharStringStrategy(SearchStrategy): """A strategy which generates single character strings of text type.""" descriptor = text_type ascii_characters = (text_type('0123456789') + text_type(string.ascii_letters) + text_type(' \t\n')) parameter = params.CompositeParameter( ascii_chance=params.UniformFloatParameter(0, 1)) def produce(self, random, pv): if dist.biased_coin(random, pv.ascii_chance): return random.choice(self.ascii_characters) else: while True: result = hunichr(random.randint(0, sys.maxunicode)) if unicodedata.category(result) != 'Cs': return result def simplify(self, x): if x in self.ascii_characters: for i in hrange(self.ascii_characters.index(x), -1, -1): yield self.ascii_characters[i] else: o = ord(x) for c in reversed(self.ascii_characters): yield text_type(c) if o > 0: yield hunichr(o // 2) yield hunichr(o - 1)
def test_has_ascii(x): if not x: return ascii_characters = ( text_type('0123456789') + text_type(string.ascii_letters) + text_type(' \t\n') ) assert any(c in ascii_characters for c in x)
def test_has_ascii(x): if not x: return ascii_characters = ( text_type(u'0123456789') + text_type(string.ascii_letters) + text_type(u' \t\n') ) assert any(c in ascii_characters for c in x)
def __init__(self, characters=None): SearchStrategy.__init__(self) if characters is not None and not isinstance(characters, text_type): raise ValueError('Invalid characters %r: Not a %s' % (characters, text_type)) self.characters = characters or (text_type('0123456789') + text_type(string.ascii_letters)) self.parameter = params.CompositeParameter()
def test_whitelisted_characters_overlap_blacklisted_characters(): good_chars = u'te02тест49st' bad_chars = u'ts94тсет' with pytest.raises(InvalidArgument) as exc: characters(min_codepoint=ord('0'), max_codepoint=ord('9'), whitelist_characters=good_chars, blacklist_characters=bad_chars).example() assert repr(good_chars) in text_type(exc) assert repr(bad_chars) in text_type(exc)
def text(alphabet=None, min_size=None, average_size=None, max_size=None): """Generates values of a unicode text type (unicode on python 2, str on python 3) with values drawn from alphabet, which should be an iterable of length one strings or a strategy generating such. If it is None it will default to generating the full unicode range. If it is an empty collection this will only generate empty strings. min_size, max_size and average_size have the usual interpretations. """ from hypothesis.searchstrategy.strings import OneCharStringStrategy, \ StringStrategy if alphabet is None: char_strategy = OneCharStringStrategy() elif not alphabet: if (min_size or 0) > 0: raise InvalidArgument( u'Invalid min_size %r > 0 for empty alphabet' % (min_size, )) return just(u'') elif isinstance(alphabet, SearchStrategy): char_strategy = alphabet else: char_strategy = sampled_from(text_type(alphabet)) return StringStrategy( lists(char_strategy, average_size=average_size, min_size=min_size, max_size=max_size))
def text( alphabet=None, min_size=None, average_size=None, max_size=None ): """Generates values of a unicode text type (unicode on python 2, str on python 3) with values drawn from alphabet, which should be an iterable of length one strings or a strategy generating such. If it is None it will default to generating the full unicode range. If it is an empty collection this will only generate empty strings. min_size, max_size and average_size have the usual interpretations. """ from hypothesis.searchstrategy.strings import OneCharStringStrategy, \ StringStrategy if alphabet is None: char_strategy = OneCharStringStrategy() elif not alphabet: if (min_size or 0) > 0: raise InvalidArgument( 'Invalid min_size %r > 0 for empty alphabet' % ( min_size, ) ) return just('') elif isinstance(alphabet, SearchStrategy): char_strategy = alphabet else: char_strategy = sampled_from(text_type(alphabet)) return StringStrategy(lists( char_strategy, average_size=average_size, min_size=min_size, max_size=max_size ))
def is_valid_template(self, template): if not (self.min_year <= template[0] <= self.max_year): return False tz = template[-1] if tz is None: return self.allow_naive else: return any(text_type(z.zone) == tz for z in self.timezones)
def mutate_basic(basic, random): if not random.randint(0, 2): if isinstance(basic, text_type): return list(basic) elif isinstance(basic, integer_types): return float(basic) else: return text_type(repr(basic)) return mess_with_basic_data(basic, random)
def gen_example(self, random): factory = self.factory_for(random.choice(self.locales)) original = globalrandom.getstate() seed = random.getrandbits(128) try: factory.seed(seed) return text_type(getattr(factory, self.source)()) finally: globalrandom.setstate(original)
def basic_simplify(self, random, x): if x in self.ascii_characters: for i in hrange(0, self.ascii_characters.index(x)): yield self.ascii_characters[i] else: o = ord(x) for c in self.ascii_characters: yield text_type(c) yield hunichr(o // 2) for t in hrange(o - 1, max(o - 10, -1), -1): yield hunichr(t)
def simplify(self, x): if x in self.ascii_characters: for i in hrange(self.ascii_characters.index(x), -1, -1): yield self.ascii_characters[i] else: o = ord(x) for c in reversed(self.ascii_characters): yield text_type(c) if o > 0: yield hunichr(o // 2) yield hunichr(o - 1)
def is_valid_template(self, template): if not (self.min_year <= template[0] <= self.max_year): return False tz = template[-1] if tz is None: return self.allow_naive else: return any( text_type(z.zone) == tz for z in self.timezones )
def templateize(self, dt): return ( dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond, text_type(dt.tzinfo.zone) if dt.tzinfo else None, )
def note(value): """Report this value in the final execution. Will always call string conversion function of the value even if not printing for consistency of execution """ value = text_type(value) context = _current_build_context.value if context is None: raise InvalidArgument(u'Cannot make notes outside of build context') if context.is_final: report(value)
def is_valid_template(self, template): if not (self.min_year <= template[0] <= self.max_year): return False tz = template[-1] if tz is None: return self.allow_naive else: if not any(text_type(z.zone) == tz for z in self.timezones): return False try: self.reify(template) return True except (OverflowError, ValueError): return False
def note(value): """Report this value in the final execution. Will always call string conversion function of the value even if not printing for consistency of execution """ value = text_type(value) context = _current_build_context.value if context is None: raise InvalidArgument( u'Cannot make notes outside of build context') if context.is_final: report(value)
def is_valid_template(self, template): if not (self.min_year <= template[0] <= self.max_year): return False tz = template[-1] if tz is None: return self.allow_naive else: if not any(text_type(z.zone) == tz for z in self.timezones): return False try: self.reify(template) return True # This is covered but hard to hit reliably except (OverflowError, ValueError): # pragma: no cover return False
def is_valid_template(self, template): if not (self.min_year <= template[0] <= self.max_year): return False tz = template[-1] if tz is None: return self.allow_naive else: if not any( text_type(z.zone) == tz for z in self.timezones ): return False try: self.reify(template) return True except (OverflowError, ValueError): return False
def __trackas__(self): data = list(self) if data[-1] is not None: data[-1] = text_type(data[-1].zone) return data
def gen_example(self, random, locales): factory = self.factory_for(random.choice(locales)) factory.seed(random.getrandbits(128)) return text_type(getattr(factory, self.source)())
def gen_example(self, random, locales): factory = faker.Faker(locale=random.choice(locales)) factory.seed(random.getrandbits(128)) for p in self.providers: factory.add_provider(p) return text_type(getattr(factory, self.source)())
def test_random_repr_has_seed(): rnd = strategy(random.Random).example() seed = rnd.seed assert text_type(seed) in repr(rnd)
def test_random_repr_has_seed(): rnd = randoms().example() seed = rnd.seed assert text_type(seed) in repr(rnd)
def pack(self, ls): return text_type('').join(ls)
def to_text(textish): if inspect.isfunction(textish): textish = textish() return text_type(textish)
def test_random_repr_has_seed(): rnd = strategy(random.Random).produce(random.Random(), None) seed = rnd.seed assert text_type(seed) in repr(rnd)
def test_has_ascii(x): if not x: return ascii_characters = text_type(u"0123456789") + text_type(string.ascii_letters) + text_type(u" \t\n") assert any(c in ascii_characters for c in x)
def to_basic(self, template): return text_type(template)
def from_basic(self, c): check_data_type(text_type, c) return text_type(c)
def strings(alphabet): return Strings(text_type(alphabet))
def produce_template(self, context, pv): factory = faker.Faker(locale=context.random.choice(pv)) factory.seed(context.random.getrandbits(128)) for p in self.providers: factory.add_provider(p) return text_type(getattr(factory, self.source)())
def test_random_repr_has_seed(): strat = strategy(random.Random) rnd = strat.reify( strat.produce_template(BuildContext(random.Random()), None)) seed = rnd.seed assert text_type(seed) in repr(rnd)
def draw_template(self, random, pv): factory = faker.Faker(locale=random.choice(pv)) factory.seed(random.getrandbits(128)) for p in self.providers: factory.add_provider(p) return text_type(getattr(factory, self.source)())