Author: Armin Rigo <[email protected]>
Branch:
Changeset: r82683:bc2523a1a870
Date: 2016-03-03 19:09 +0100
http://bitbucket.org/pypy/pypy/changeset/bc2523a1a870/
Log: merge heads
diff --git a/pypy/interpreter/test/test_app_main.py
b/pypy/interpreter/test/test_app_main.py
--- a/pypy/interpreter/test/test_app_main.py
+++ b/pypy/interpreter/test/test_app_main.py
@@ -133,7 +133,7 @@
self.check(['-S', '-tO', '--info'], {}, output_contains='translation')
self.check(['-S', '-tO', '--version'], {}, output_contains='Python')
self.check(['-S', '-tOV'], {}, output_contains='Python')
- self.check(['--jit', 'foobar', '-S'], {}, sys_argv=[''],
+ self.check(['--jit', 'off', '-S'], {}, sys_argv=[''],
run_stdin=True, no_site=1)
self.check(['-c', 'pass'], {}, sys_argv=['-c'], run_command='pass')
self.check(['-cpass'], {}, sys_argv=['-c'], run_command='pass')
diff --git a/pypy/objspace/std/test/test_kwargsdict.py
b/pypy/objspace/std/test/test_kwargsdict.py
--- a/pypy/objspace/std/test/test_kwargsdict.py
+++ b/pypy/objspace/std/test/test_kwargsdict.py
@@ -118,10 +118,16 @@
def test_delitem(self):
pass # delitem devolves for now
+ def test_setdefault_fast(self):
+ pass # not based on hashing at all
+
class TestDevolvedKwargsDictImplementation(BaseTestDevolvedDictImplementation):
get_impl = get_impl
StrategyClass = KwargsDictStrategy
+ def test_setdefault_fast(self):
+ pass # not based on hashing at all
+
class AppTestKwargsDictStrategy(object):
def setup_class(cls):
diff --git a/rpython/rtyper/test/test_rdict.py
b/rpython/rtyper/test/test_rdict.py
--- a/rpython/rtyper/test/test_rdict.py
+++ b/rpython/rtyper/test/test_rdict.py
@@ -59,19 +59,6 @@
yield
-def not_really_random():
- """A random-ish generator, which also generates nice patterns from time to
time.
- Could be useful to detect problems associated with specific usage
patterns."""
- import random
- x = random.random()
- print 'random seed: %r' % (x,)
- for i in range(12000):
- r = 3.4 + i/20000.0
- x = r*x - x*x
- assert 0 <= x < 4
- yield x
-
-
class BaseTestRDict(BaseRtypingTest):
def test_dict_creation(self):
def createdict(i):
@@ -1048,7 +1035,7 @@
s_BA_dic = s.items[1]
r_AB_dic = rtyper.getrepr(s_AB_dic)
- r_BA_dic = rtyper.getrepr(s_AB_dic)
+ r_BA_dic = rtyper.getrepr(s_BA_dic)
assert r_AB_dic.lowleveltype == r_BA_dic.lowleveltype
@@ -1166,50 +1153,51 @@
st_keys = sampled_from(keytypes_s)
st_values = sampled_from(keytypes_s + [SomeString(can_be_None=True)])
-class Space(object):
+class MappingSpace(object):
def __init__(self, s_key, s_value):
self.s_key = s_key
self.s_value = s_value
rtyper = PseudoRTyper()
r_key = s_key.rtyper_makerepr(rtyper)
r_value = s_value.rtyper_makerepr(rtyper)
- dictrepr = rdict.DictRepr(rtyper, r_key, r_value,
+ dictrepr = self.MappingRepr(rtyper, r_key, r_value,
DictKey(None, s_key),
DictValue(None, s_value))
dictrepr.setup()
- self.l_dict = rdict.ll_newdict(dictrepr.DICT)
- self.reference = {}
+ self.l_dict = self.newdict(dictrepr)
+ self.reference = self.new_reference()
self.ll_key = r_key.convert_const
self.ll_value = r_value.convert_const
def setitem(self, key, value):
ll_key = self.ll_key(key)
ll_value = self.ll_value(value)
- rdict.ll_dict_setitem(self.l_dict, ll_key, ll_value)
+ self.ll_setitem(self.l_dict, ll_key, ll_value)
self.reference[key] = value
- assert rdict.ll_contains(self.l_dict, ll_key)
+ assert self.ll_contains(self.l_dict, ll_key)
def delitem(self, key):
ll_key = self.ll_key(key)
- rdict.ll_dict_delitem(self.l_dict, ll_key)
+ self.ll_delitem(self.l_dict, ll_key)
del self.reference[key]
- assert not rdict.ll_contains(self.l_dict, ll_key)
+ assert not self.ll_contains(self.l_dict, ll_key)
def copydict(self):
- self.l_dict = rdict.ll_copy(self.l_dict)
+ self.l_dict = self.ll_copy(self.l_dict)
+ assert self.ll_len(self.l_dict) == len(self.reference)
def cleardict(self):
- rdict.ll_clear(self.l_dict)
+ self.ll_clear(self.l_dict)
self.reference.clear()
- assert rdict.ll_dict_len(self.l_dict) == 0
+ assert self.ll_len(self.l_dict) == 0
def fullcheck(self):
- assert rdict.ll_dict_len(self.l_dict) == len(self.reference)
+ assert self.ll_len(self.l_dict) == len(self.reference)
for key, value in self.reference.iteritems():
- assert (rdict.ll_dict_getitem(self.l_dict, self.ll_key(key)) ==
+ assert (self.ll_getitem(self.l_dict, self.ll_key(key)) ==
self.ll_value(value))
-class StressTest(GenericStateMachine):
+class MappingSM(GenericStateMachine):
def __init__(self):
self.space = None
@@ -1239,7 +1227,7 @@
def execute_step(self, action):
if action.method == 'setup':
- self.space = Space(*action.args)
+ self.space = self.Space(*action.args)
self.st_keys = ann2strategy(self.space.s_key)
self.st_values = ann2strategy(self.space.s_value)
return
@@ -1250,5 +1238,24 @@
if self.space:
self.space.fullcheck()
+
+class DictSpace(MappingSpace):
+ MappingRepr = rdict.DictRepr
+ new_reference = dict
+ ll_getitem = staticmethod(rdict.ll_dict_getitem)
+ ll_setitem = staticmethod(rdict.ll_dict_setitem)
+ ll_delitem = staticmethod(rdict.ll_dict_delitem)
+ ll_len = staticmethod(rdict.ll_dict_len)
+ ll_contains = staticmethod(rdict.ll_contains)
+ ll_copy = staticmethod(rdict.ll_copy)
+ ll_clear = staticmethod(rdict.ll_clear)
+
+ def newdict(self, repr):
+ return rdict.ll_newdict(repr.DICT)
+
+class DictSM(MappingSM):
+ Space = DictSpace
+
def test_hypothesis():
- run_state_machine_as_test(StressTest, settings(max_examples=500,
stateful_step_count=100))
+ run_state_machine_as_test(
+ DictSM, settings(max_examples=500, stateful_step_count=100))
diff --git a/rpython/rtyper/test/test_rordereddict.py
b/rpython/rtyper/test/test_rordereddict.py
--- a/rpython/rtyper/test/test_rordereddict.py
+++ b/rpython/rtyper/test/test_rordereddict.py
@@ -1,14 +1,18 @@
-
import py
from collections import OrderedDict
+from hypothesis import settings
+from hypothesis.stateful import run_state_machine_as_test
+
from rpython.rtyper.lltypesystem import lltype, rffi
from rpython.rtyper.lltypesystem import rordereddict, rstr
from rpython.rlib.rarithmetic import intmask
from rpython.rtyper.annlowlevel import llstr, hlstr
-from rpython.rtyper.test.test_rdict import BaseTestRDict
+from rpython.rtyper.test.test_rdict import (
+ BaseTestRDict, MappingSpace, MappingSM)
from rpython.rlib import objectmodel
+rodct = rordereddict
def get_indexes(ll_d):
return ll_d.indexes._obj.container._as_ptr()
@@ -330,124 +334,48 @@
assert res == 6
-class TestStress:
+class ODictSpace(MappingSpace):
+ MappingRepr = rodct.OrderedDictRepr
+ new_reference = OrderedDict
+ ll_getitem = staticmethod(rodct.ll_dict_getitem)
+ ll_setitem = staticmethod(rodct.ll_dict_setitem)
+ ll_delitem = staticmethod(rodct.ll_dict_delitem)
+ ll_len = staticmethod(rodct.ll_dict_len)
+ ll_contains = staticmethod(rodct.ll_dict_contains)
+ ll_copy = staticmethod(rodct.ll_dict_copy)
+ ll_clear = staticmethod(rodct.ll_dict_clear)
- def test_stress(self):
- from rpython.annotator.dictdef import DictKey, DictValue
- from rpython.annotator import model as annmodel
- from rpython.rtyper import rint
- from rpython.rtyper.test.test_rdict import not_really_random
- rodct = rordereddict
- dictrepr = rodct.OrderedDictRepr(
- None, rint.signed_repr, rint.signed_repr,
- DictKey(None, annmodel.SomeInteger()),
- DictValue(None, annmodel.SomeInteger()))
- dictrepr.setup()
- l_dict = rodct.ll_newdict(dictrepr.DICT)
- referencetable = [None] * 400
- referencelength = 0
- value = 0
+ def newdict(self, repr):
+ return rodct.ll_newdict(repr.DICT)
- def complete_check():
- for n, refvalue in zip(range(len(referencetable)), referencetable):
- try:
- gotvalue = rodct.ll_dict_getitem(l_dict, n)
- except KeyError:
- assert refvalue is None
- else:
- assert gotvalue == refvalue
+ def get_keys(self):
+ DICT = lltype.typeOf(self.l_dict).TO
+ ITER = rordereddict.get_ll_dictiter(lltype.Ptr(DICT))
+ ll_iter = rordereddict.ll_dictiter(ITER, self.l_dict)
+ ll_dictnext = rordereddict._ll_dictnext
+ keys_ll = []
+ while True:
+ try:
+ num = ll_dictnext(ll_iter)
+ keys_ll.append(self.l_dict.entries[num].key)
+ except StopIteration:
+ break
+ return keys_ll
- for x in not_really_random():
- n = int(x*100.0) # 0 <= x < 400
- op = repr(x)[-1]
- if op <= '2' and referencetable[n] is not None:
- rodct.ll_dict_delitem(l_dict, n)
- referencetable[n] = None
- referencelength -= 1
- elif op <= '6':
- rodct.ll_dict_setitem(l_dict, n, value)
- if referencetable[n] is None:
- referencelength += 1
- referencetable[n] = value
- value += 1
- else:
- try:
- gotvalue = rodct.ll_dict_getitem(l_dict, n)
- except KeyError:
- assert referencetable[n] is None
- else:
- assert gotvalue == referencetable[n]
- if 1.38 <= x <= 1.39:
- complete_check()
- print 'current dict length:', referencelength
- assert l_dict.num_live_items == referencelength
- complete_check()
+ def fullcheck(self):
+ # overridden to also check key order
+ assert self.ll_len(self.l_dict) == len(self.reference)
+ keys_ll = self.get_keys()
+ assert len(keys_ll) == len(self.reference)
+ for key, ll_key in zip(self.reference, keys_ll):
+ assert self.ll_key(key) == ll_key
+ assert (self.ll_getitem(self.l_dict, self.ll_key(key)) ==
+ self.ll_value(self.reference[key]))
- def test_stress_2(self):
- yield self.stress_combination, True, False
- yield self.stress_combination, False, True
- yield self.stress_combination, False, False
- yield self.stress_combination, True, True
- def stress_combination(self, key_can_be_none, value_can_be_none):
- from rpython.rtyper.lltypesystem.rstr import string_repr
- from rpython.annotator.dictdef import DictKey, DictValue
- from rpython.annotator import model as annmodel
- from rpython.rtyper.test.test_rdict import not_really_random
- rodct = rordereddict
+class ODictSM(MappingSM):
+ Space = ODictSpace
- print
- print "Testing combination with can_be_None: keys %s, values %s" % (
- key_can_be_none, value_can_be_none)
-
- class PseudoRTyper:
- cache_dummy_values = {}
- dictrepr = rodct.OrderedDictRepr(
- PseudoRTyper(), string_repr, string_repr,
- DictKey(None, annmodel.SomeString(key_can_be_none)),
- DictValue(None, annmodel.SomeString(value_can_be_none)))
- dictrepr.setup()
- print dictrepr.lowleveltype
- #for key, value in dictrepr.DICTENTRY._adtmeths.items():
- # print ' %s = %s' % (key, value)
- l_dict = rodct.ll_newdict(dictrepr.DICT)
- referencetable = [None] * 400
- referencelength = 0
- values = not_really_random()
- keytable = [string_repr.convert_const("foo%d" % n)
- for n in range(len(referencetable))]
-
- def complete_check():
- for n, refvalue in zip(range(len(referencetable)), referencetable):
- try:
- gotvalue = rodct.ll_dict_getitem(l_dict, keytable[n])
- except KeyError:
- assert refvalue is None
- else:
- assert gotvalue == refvalue
-
- for x in not_really_random():
- n = int(x*100.0) # 0 <= x < 400
- op = repr(x)[-1]
- if op <= '2' and referencetable[n] is not None:
- rodct.ll_dict_delitem(l_dict, keytable[n])
- referencetable[n] = None
- referencelength -= 1
- elif op <= '6':
- ll_value = string_repr.convert_const(str(values.next()))
- rodct.ll_dict_setitem(l_dict, keytable[n], ll_value)
- if referencetable[n] is None:
- referencelength += 1
- referencetable[n] = ll_value
- else:
- try:
- gotvalue = rodct.ll_dict_getitem(l_dict, keytable[n])
- except KeyError:
- assert referencetable[n] is None
- else:
- assert gotvalue == referencetable[n]
- if 1.38 <= x <= 1.39:
- complete_check()
- print 'current dict length:', referencelength
- assert l_dict.num_live_items == referencelength
- complete_check()
+def test_hypothesis():
+ run_state_machine_as_test(
+ ODictSM, settings(max_examples=500, stateful_step_count=100))
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
