[pypy-svn] r74712 - pypy/branch/blackhole-improvement/pypy/jit/metainterp/test
arigo at codespeak.net
arigo at codespeak.net
Mon May 24 17:22:26 CEST 2010
Author: arigo
Date: Mon May 24 17:22:25 2010
New Revision: 74712
Modified:
pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_resume.py
Log:
Skip some tests, fix others. XXX rewrite...
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_resume.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_resume.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_resume.py Mon May 24 17:22:25 2010
@@ -51,16 +51,14 @@
class MyMetaInterp:
_already_allocated_resume_virtuals = None
- def __init__(self, cpu=None):
- if cpu is None:
- cpu = LLtypeMixin.cpu
+ def __init__(self, cpu):
self.cpu = cpu
self.trace = []
self.framestack = []
self.resboxes = []
def newframe(self, jitcode):
- frame = FakeFrame(jitcode, -1, -1)
+ frame = FakeFrame(jitcode, -1)
self.framestack.append(frame)
return frame
@@ -96,21 +94,29 @@
class MyBlackholeInterp:
def __init__(self):
- self.written_i = {}
- self.written_r = {}
- self.written_f = {}
+ self.written_i = []
+ self.written_r = []
+ self.written_f = []
def setarg_i(self, index, value):
- assert index not in self.written_i
- self.written_i[index] = value
+ assert index == len(self.written_i)
+ self.written_i.append(value)
def setarg_r(self, index, value):
- assert index not in self.written_r
- self.written_r[index] = value
+ assert index == len(self.written_r)
+ self.written_r.append(value)
def setarg_f(self, index, value):
- assert index not in self.written_f
- self.written_f[index] = value
+ assert index == len(self.written_f)
+ self.written_f.append(value)
+
+def _next_section(reader, *expected):
+ bh = MyBlackholeInterp()
+ reader.consume_one_section(bh)
+ lst_i = bh.written_i
+ lst_r = bh.written_r
+ lst_f = bh.written_f
+ assert lst_i + lst_r + lst_f == list(expected)
def test_simple_read():
@@ -131,27 +137,9 @@
#
cpu = MyCPU([42, gcref1, -66])
reader = ResumeDataDirectReader(cpu, storage)
- bh = MyBlackholeInterp()
- reader.consume_one_section(bh)
- assert bh.written_i == {0: 42,
- 1: 111,
- 2: 42,
- }
- assert bh.written_r == {0: gcrefnull,
- 1: gcref1,
- }
- bh = MyBlackholeInterp()
- reader.consume_one_section(bh)
- assert bh.written_i == {0: 222,
- 1: 333,
- }
- assert bh.written_r == {}
- bh = MyBlackholeInterp()
- reader.consume_one_section(bh)
- assert bh.written_i == {0: 42,
- 1: -66,
- }
- assert bh.written_r == {0: gcref1}
+ _next_section(reader, 42, 111, 42, gcrefnull, gcref1)
+ _next_section(reader, 222, 333)
+ _next_section(reader, 42, -66, gcref1)
#
metainterp = MyMetaInterp(cpu)
reader = ResumeDataBoxReader(storage, metainterp)
@@ -172,32 +160,21 @@
#
def test_simple_read_tagged_ints():
- b1, b2, b3 = [BoxInt(), BoxPtr(), BoxInt()]
storage = Storage()
storage.rd_consts = []
- numb = Numbering(None, [tag(0, TAGBOX), tag(1, TAGBOX), tag(2, TAGBOX)])
- numb = Numbering(numb, [tag(2, TAGINT), tag(3, TAGINT)])
- numb = Numbering(numb, [tag(0, TAGBOX),
- tag(1, TAGINT),
- tag(0, TAGBOX),
- tag(1, TAGBOX)])
+ numb = Numbering(None, [tag(100, TAGINT), TYPEBARRIER])
storage.rd_numb = numb
- b1s, b2s, b3s = [BoxInt(), BoxPtr(), BoxInt()]
- assert b1s != b3s
- reader = ResumeDataReader(storage, [b1s, b2s, b3s], MyMetaInterp())
- lst = reader.consume_boxes()
- assert lst == [b1s, ConstInt(1), b1s, b2s]
- lst = reader.consume_boxes()
- assert lst == [ConstInt(2), ConstInt(3)]
- lst = reader.consume_boxes()
- assert lst == [b1s, b2s, b3s]
+ #
+ cpu = MyCPU([])
+ reader = ResumeDataDirectReader(cpu, storage)
+ _next_section(reader, 100)
def test_prepare_virtuals():
class FakeVinfo(object):
- def allocate(self, metainterp):
+ def allocate(self, decoder):
return "allocated"
- def setfields(self, metainterp, virtual, func):
+ def setfields(self, decoder, virtual):
assert virtual == "allocated"
class FakeStorage(object):
rd_virtuals = [FakeVinfo(), None]
@@ -207,7 +184,7 @@
class FakeMetainterp(object):
_already_allocated_resume_virtuals = None
cpu = None
- reader = ResumeDataReader(FakeStorage(), [], FakeMetainterp())
+ reader = ResumeDataDirectReader(None, FakeStorage())
assert reader.virtuals == ["allocated", None]
# ____________________________________________________________
@@ -218,11 +195,13 @@
parent_resumedata_snapshot = None
parent_resumedata_frame_info_list = None
- def __init__(self, code, pc, exc_target, *boxes):
+ def __init__(self, code, pc, *boxes):
self.jitcode = code
self.pc = pc
- self.exception_target = exc_target
- self.env = list(boxes)
+ self._env = list(boxes)
+
+ def get_list_of_active_boxes(self, flag):
+ return self._env
def setup_resume_at_op(self, pc, exception_target, env):
self.__init__(self.jitcode, pc, exception_target, *env)
@@ -232,8 +211,7 @@
def __ne__(self, other):
return self.__dict__ != other.__dict__
def __repr__(self):
- return "<FF %s %s %s %s>" % (self.jitcode, self.pc,
- self.exception_target, self.env)
+ return "<FF %s %s %s>" % (self.jitcode, self.pc, self._env)
def test_Snapshot_create():
l = ['b0', 'b1']
@@ -248,20 +226,16 @@
def test_FrameInfo_create():
jitcode = "JITCODE"
- frame = FakeFrame(jitcode, 1, 2)
- fi = FrameInfo(None, frame)
+ fi = FrameInfo(None, jitcode, 1)
assert fi.prev is None
assert fi.jitcode is jitcode
assert fi.pc == 1
- assert fi.exception_target == 2
jitcode1 = "JITCODE1"
- frame1 = FakeFrame(jitcode, 3, 4)
- fi1 = FrameInfo(fi, frame1)
+ fi1 = FrameInfo(fi, jitcode1, 3)
assert fi1.prev is fi
- assert fi1.jitcode is jitcode
+ assert fi1.jitcode is jitcode1
assert fi1.pc == 3
- assert fi1.exception_target == 4
def test_Numbering_create():
l = [1, 2]
@@ -277,7 +251,7 @@
def test_capture_resumedata():
b1, b2, b3 = [BoxInt(), BoxPtr(), BoxInt()]
c1, c2, c3 = [ConstInt(1), ConstInt(2), ConstInt(3)]
- fs = [FakeFrame("code0", 0, -1, b1, c1, b2)]
+ fs = [FakeFrame("code0", 0, b1, c1, b2)]
storage = Storage()
capture_resumedata(fs, None, [], storage)
@@ -290,13 +264,12 @@
assert storage.rd_snapshot.boxes == [] # for virtualrefs
snapshot = storage.rd_snapshot.prev
assert snapshot.prev is None
- assert snapshot.boxes == fs[0].env
- assert snapshot.boxes is not fs[0].env
+ assert snapshot.boxes == fs[0]._env
storage = Storage()
- fs = [FakeFrame("code0", 0, -1, b1, c1, b2),
- FakeFrame("code1", 3, 7, b3, c2, b1),
- FakeFrame("code2", 9, -1, c3, b2)]
+ fs = [FakeFrame("code0", 0, b1, c1, b2),
+ FakeFrame("code1", 3, b3, c2, b1),
+ FakeFrame("code2", 9, c3, b2)]
capture_resumedata(fs, None, [], storage)
frame_info_list = storage.rd_frame_info_list
@@ -307,26 +280,23 @@
assert storage.rd_snapshot.boxes == [] # for virtualrefs
snapshot = storage.rd_snapshot.prev
assert snapshot.prev is fs[2].parent_resumedata_snapshot
- assert snapshot.boxes == fs[2].env
- assert snapshot.boxes is not fs[2].env
+ assert snapshot.boxes == fs[2]._env
frame_info_list = frame_info_list.prev
assert frame_info_list.prev is fs[1].parent_resumedata_frame_info_list
assert frame_info_list.jitcode == 'code1'
snapshot = snapshot.prev
assert snapshot.prev is fs[1].parent_resumedata_snapshot
- assert snapshot.boxes == fs[1].env
- assert snapshot.boxes is not fs[1].env
+ assert snapshot.boxes == fs[1]._env
frame_info_list = frame_info_list.prev
assert frame_info_list.prev is None
assert frame_info_list.jitcode == 'code0'
snapshot = snapshot.prev
assert snapshot.prev is None
- assert snapshot.boxes == fs[0].env
- assert snapshot.boxes is not fs[0].env
+ assert snapshot.boxes == fs[0]._env
- fs[2].env = [b2, b3]
+ fs[2]._env = [b2, b3]
fs[2].pc = 15
vbs = [b1, b2]
vrs = [b3]
@@ -347,7 +317,7 @@
snapshot = snapshot.prev
assert snapshot.prev is fs[2].parent_resumedata_snapshot
- assert snapshot.boxes == fs[2].env
+ assert snapshot.boxes == fs[2]._env
class FakeMetaInterpStaticData:
@@ -357,12 +327,13 @@
failargs_limit = 100
def test_rebuild_from_resumedata():
+ py.test.skip("XXX rewrite")
b1, b2, b3 = [BoxInt(), BoxPtr(), BoxInt()]
c1, c2, c3 = [ConstInt(1), ConstInt(2), ConstInt(3)]
storage = Storage()
- fs = [FakeFrame("code0", 0, -1, b1, c1, b2),
- FakeFrame("code1", 3, 7, b3, c2, b1),
- FakeFrame("code2", 9, -1, c3, b2)]
+ fs = [FakeFrame("code0", 0, b1, c1, b2),
+ FakeFrame("code1", 3, b3, c2, b1),
+ FakeFrame("code2", 9, c3, b2)]
capture_resumedata(fs, None, [], storage)
memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
modifier = ResumeDataVirtualAdder(storage, memo)
@@ -372,21 +343,21 @@
b1t, b2t, b3t = [BoxInt(), BoxPtr(), BoxInt()]
newboxes = _resume_remap(liveboxes, [b1, b2, b3], b1t, b2t, b3t)
- result = rebuild_from_resumedata(metainterp, newboxes, storage,
- False)
+ result = rebuild_from_resumedata(metainterp, storage, False)
assert result == (None, [])
- fs2 = [FakeFrame("code0", 0, -1, b1t, c1, b2t),
- FakeFrame("code1", 3, 7, b3t, c2, b1t),
- FakeFrame("code2", 9, -1, c3, b2t)]
+ fs2 = [FakeFrame("code0", 0, b1t, c1, b2t),
+ FakeFrame("code1", 3, b3t, c2, b1t),
+ FakeFrame("code2", 9, c3, b2t)]
assert metainterp.framestack == fs2
def test_rebuild_from_resumedata_with_virtualizable():
+ py.test.skip("XXX rewrite")
b1, b2, b3, b4 = [BoxInt(), BoxPtr(), BoxInt(), BoxPtr()]
c1, c2, c3 = [ConstInt(1), ConstInt(2), ConstInt(3)]
storage = Storage()
- fs = [FakeFrame("code0", 0, -1, b1, c1, b2),
- FakeFrame("code1", 3, 7, b3, c2, b1),
- FakeFrame("code2", 9, -1, c3, b2)]
+ fs = [FakeFrame("code0", 0, b1, c1, b2),
+ FakeFrame("code1", 3, b3, c2, b1),
+ FakeFrame("code2", 9, c3, b2)]
capture_resumedata(fs, [b4], [], storage)
memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
modifier = ResumeDataVirtualAdder(storage, memo)
@@ -399,21 +370,22 @@
result = rebuild_from_resumedata(metainterp, newboxes, storage,
True)
assert result == ([b4t], [])
- fs2 = [FakeFrame("code0", 0, -1, b1t, c1, b2t),
- FakeFrame("code1", 3, 7, b3t, c2, b1t),
- FakeFrame("code2", 9, -1, c3, b2t)]
+ fs2 = [FakeFrame("code0", 0, b1t, c1, b2t),
+ FakeFrame("code1", 3, b3t, c2, b1t),
+ FakeFrame("code2", 9, c3, b2t)]
assert metainterp.framestack == fs2
def test_rebuild_from_resumedata_two_guards():
+ py.test.skip("XXX rewrite")
b1, b2, b3, b4 = [BoxInt(), BoxPtr(), BoxInt(), BoxInt()]
c1, c2, c3 = [ConstInt(1), ConstInt(2), ConstInt(3)]
storage = Storage()
- fs = [FakeFrame("code0", 0, -1, b1, c1, b2),
- FakeFrame("code1", 3, 7, b3, c2, b1),
- FakeFrame("code2", 9, -1, c3, b2)]
+ fs = [FakeFrame("code0", 0, b1, c1, b2),
+ FakeFrame("code1", 3, b3, c2, b1),
+ FakeFrame("code2", 9, c3, b2)]
capture_resumedata(fs, None, [], storage)
storage2 = Storage()
- fs = fs[:-1] + [FakeFrame("code2", 10, -1, c3, b2, b4)]
+ fs = fs[:-1] + [FakeFrame("code2", 10, c3, b2, b4)]
capture_resumedata(fs, None, [], storage2)
memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
@@ -431,9 +403,9 @@
result = rebuild_from_resumedata(metainterp, newboxes, storage,
False)
assert result == (None, [])
- fs2 = [FakeFrame("code0", 0, -1, b1t, c1, b2t),
- FakeFrame("code1", 3, 7, b3t, c2, b1t),
- FakeFrame("code2", 9, -1, c3, b2t)]
+ fs2 = [FakeFrame("code0", 0, b1t, c1, b2t),
+ FakeFrame("code1", 3, b3t, c2, b1t),
+ FakeFrame("code2", 9, c3, b2t)]
assert metainterp.framestack == fs2
newboxes = _resume_remap(liveboxes2, [b1, b2, b3, b4], b1t, b2t, b3t, b4t)
@@ -442,7 +414,7 @@
result = rebuild_from_resumedata(metainterp, newboxes, storage2,
False)
assert result == (None, [])
- fs2 = fs2[:-1] + [FakeFrame("code2", 10, -1, c3, b2t, b4t)]
+ fs2 = fs2[:-1] + [FakeFrame("code2", 10, c3, b2t, b4t)]
assert metainterp.framestack == fs2
@@ -464,17 +436,18 @@
return vv
def test_rebuild_from_resumedata_two_guards_w_virtuals():
+ py.test.skip("XXX rewrite")
b1, b2, b3, b4, b5 = [BoxInt(), BoxPtr(), BoxInt(), BoxInt(), BoxInt()]
c1, c2, c3, c4 = [ConstInt(1), ConstInt(2), ConstInt(3),
LLtypeMixin.nodebox.constbox()]
storage = Storage()
- fs = [FakeFrame("code0", 0, -1, b1, c1, b2),
- FakeFrame("code1", 3, 7, b3, c2, b1),
- FakeFrame("code2", 9, -1, c3, b2)]
+ fs = [FakeFrame("code0", 0, b1, c1, b2),
+ FakeFrame("code1", 3, b3, c2, b1),
+ FakeFrame("code2", 9, c3, b2)]
capture_resumedata(fs, None, [], storage)
storage2 = Storage()
- fs = fs[:-1] + [FakeFrame("code2", 10, -1, c3, b2, b4)]
+ fs = fs[:-1] + [FakeFrame("code2", 10, c3, b2, b4)]
capture_resumedata(fs, None, [], storage2)
memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
@@ -508,9 +481,9 @@
False)
b2t = metainterp.resboxes[0]
- fs2 = [FakeFrame("code0", 0, -1, b1t, c1, b2t),
- FakeFrame("code1", 3, 7, b3t, c2, b1t),
- FakeFrame("code2", 9, -1, c3, b2t)]
+ fs2 = [FakeFrame("code0", 0, b1t, c1, b2t),
+ FakeFrame("code1", 3, b3t, c2, b1t),
+ FakeFrame("code2", 9, c3, b2t)]
assert metainterp.framestack == fs2
newboxes = _resume_remap(liveboxes2, [b1, b3, b4], b1t, b3t, b4t)
@@ -520,17 +493,18 @@
False)
b2t = metainterp.resboxes[0]
assert len(metainterp.resboxes) == 2
- fs2 = [FakeFrame("code0", 0, -1, b1t, c1, b2t),
- FakeFrame("code1", 3, 7, b3t, c2, b1t),
- FakeFrame("code2", 10, -1, c3, b2t, b4t)]
+ fs2 = [FakeFrame("code0", 0, b1t, c1, b2t),
+ FakeFrame("code1", 3, b3t, c2, b1t),
+ FakeFrame("code2", 10, c3, b2t, b4t)]
assert metainterp.framestack == fs2
def test_rebuild_from_resumedata_two_guards_w_shared_virtuals():
+ py.test.skip("XXX rewrite")
b1, b2, b3, b4, b5, b6 = [BoxPtr(), BoxPtr(), BoxInt(), BoxPtr(), BoxInt(), BoxInt()]
c1, c2, c3, c4 = [ConstInt(1), ConstInt(2), ConstInt(3),
LLtypeMixin.nodebox.constbox()]
storage = Storage()
- fs = [FakeFrame("code0", 0, -1, c1, b2, b3)]
+ fs = [FakeFrame("code0", 0, c1, b2, b3)]
capture_resumedata(fs, None, [], storage)
memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
@@ -542,7 +516,7 @@
tag(0, TAGCONST)]
storage2 = Storage()
- fs = [FakeFrame("code0", 0, -1, b1, b4, b2)]
+ fs = [FakeFrame("code0", 0, b1, b4, b2)]
capture_resumedata(fs, None, [], storage2)
values[b4] = virtual_value(b4, b6, c4)
modifier = ResumeDataVirtualAdder(storage2, memo)
@@ -553,9 +527,10 @@
def test_resumedata_top_recursive_virtuals():
+ py.test.skip("XXX rewrite")
b1, b2, b3 = [BoxPtr(), BoxPtr(), BoxInt()]
storage = Storage()
- fs = [FakeFrame("code0", 0, -1, b1, b2)]
+ fs = [FakeFrame("code0", 0, b1, b2)]
capture_resumedata(fs, None, [], storage)
memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
@@ -643,9 +618,9 @@
assert liveboxes == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
b3: tag(2, TAGBOX)}
assert numb.nums == [tag(3, TAGINT), tag(2, TAGBOX), tag(0, TAGBOX),
- tag(1, TAGINT)]
+ tag(1, TAGINT), TYPEBARRIER]
assert numb.prev.nums == [tag(0, TAGBOX), tag(1, TAGINT), tag(1, TAGBOX),
- tag(0, TAGBOX), tag(2, TAGINT)]
+ tag(0, TAGBOX), tag(2, TAGINT), TYPEBARRIER]
assert numb.prev.prev is None
numb2, liveboxes2, v = memo.number({}, snap2)
@@ -655,7 +630,7 @@
b3: tag(2, TAGBOX)}
assert liveboxes2 is not liveboxes
assert numb2.nums == [tag(3, TAGINT), tag(2, TAGBOX), tag(0, TAGBOX),
- tag(3, TAGINT)]
+ tag(3, TAGINT), TYPEBARRIER]
assert numb2.prev is numb.prev
env3 = [c3, b3, b1, c3]
@@ -678,11 +653,11 @@
assert liveboxes3 == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX)}
assert numb3.nums == [tag(3, TAGINT), tag(4, TAGINT), tag(0, TAGBOX),
- tag(3, TAGINT)]
+ tag(3, TAGINT), TYPEBARRIER]
assert numb3.prev is numb.prev
# virtual
- env4 = [c3, b4, b1, c3]
+ env4 = [c3, b1, c3, b4]
snap4 = Snapshot(snap, env4)
numb4, liveboxes4, v = memo.number({b4: FakeValue(True, b4)}, snap4)
@@ -690,8 +665,8 @@
assert liveboxes4 == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
b4: tag(0, TAGVIRTUAL)}
- assert numb4.nums == [tag(3, TAGINT), tag(0, TAGVIRTUAL), tag(0, TAGBOX),
- tag(3, TAGINT)]
+ assert numb4.nums == [tag(3, TAGINT), tag(0, TAGBOX),
+ tag(3, TAGINT), TYPEBARRIER, tag(0, TAGVIRTUAL)]
assert numb4.prev is numb.prev
env5 = [b1, b4, b5]
@@ -703,8 +678,8 @@
assert liveboxes5 == {b1: tag(0, TAGBOX), b2: tag(1, TAGBOX),
b4: tag(0, TAGVIRTUAL), b5: tag(1, TAGVIRTUAL)}
- assert numb5.nums == [tag(0, TAGBOX), tag(0, TAGVIRTUAL),
- tag(1, TAGVIRTUAL)]
+ assert numb5.nums == [tag(0, TAGBOX), TYPEBARRIER,
+ tag(0, TAGVIRTUAL), tag(1, TAGVIRTUAL)]
assert numb5.prev is numb4
def test_ResumeDataLoopMemo_number_boxes():
@@ -802,16 +777,11 @@
modifier = ResumeDataVirtualAdder(storage, memo)
liveboxes = modifier.finish({})
assert storage.rd_snapshot is None
- metainterp = MyMetaInterp()
- reader = ResumeDataReader(storage, [], metainterp)
- lst = reader.consume_boxes()
- assert lst == [b1s, b2s, b3s]
- lst = reader.consume_boxes()
- assert lst == [ConstInt(2), ConstInt(3)]
- lst = reader.consume_boxes()
- assert lst == [ConstInt(sys.maxint), ConstInt(1), ConstInt(sys.maxint),
- ConstInt(2**16)]
- assert metainterp.trace == []
+ cpu = MyCPU([])
+ reader = ResumeDataDirectReader(cpu, storage)
+ _next_section(reader, sys.maxint, 2**16, -65)
+ _next_section(reader, 2, 3)
+ _next_section(reader, sys.maxint, 1, sys.maxint, 2**16)
def test_virtual_adder_memo_const_sharing():
@@ -832,6 +802,7 @@
def test_virtual_adder_no_op_renaming():
+ py.test.skip("XXX rewrite")
b1s, b2s, b3s = [BoxInt(1), BoxInt(2), BoxInt(3)]
storage = make_storage(b1s, b2s, b3s)
memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
@@ -863,6 +834,7 @@
def test_virtual_adder_make_constant():
+ py.test.skip("XXX rewrite")
b1s, b2s, b3s = [BoxInt(1), BoxPtr(), BoxInt(3)]
b1s = ConstInt(111)
storage = make_storage(b1s, b2s, b3s)
@@ -884,6 +856,7 @@
def test_virtual_adder_make_virtual():
+ py.test.skip("XXX rewrite")
b2s, b3s, b4s, b5s = [BoxPtr(), BoxInt(3), BoxPtr(), BoxPtr()]
c1s = ConstInt(111)
storage = Storage()
@@ -957,6 +930,7 @@
assert ptr2.parent.next == ptr
def test_virtual_adder_make_varray():
+ py.test.skip("XXX rewrite")
b2s, b4s = [BoxPtr(), BoxInt(4)]
c1s = ConstInt(111)
storage = Storage()
@@ -1009,6 +983,7 @@
def test_virtual_adder_make_vstruct():
+ py.test.skip("XXX rewrite")
b2s, b4s = [BoxPtr(), BoxPtr()]
c1s = ConstInt(111)
storage = Storage()
@@ -1052,6 +1027,7 @@
def test_virtual_adder_pending_fields():
+ py.test.skip("XXX rewrite")
b2s, b4s = [BoxPtr(), BoxPtr()]
storage = Storage()
memo = ResumeDataLoopMemo(FakeMetaInterpStaticData())
More information about the Pypy-commit
mailing list