nilm/nilmdb
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
nilmdb-1.6.0
nilmdb/tests/test_threadsafety.py

97 lines
2.7 KiB
Python
Raw Permalink Normal View History

Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
import nilmdb
from nilmdb.utils.printf import *
import nose
from nose.tools import *
from nose.tools import assert_raises
from testutil.helpers import *
import threading
class Thread(threading.Thread):
def __init__(self, target):
self.target = target
threading.Thread.__init__(self)
def run(self):
try:
self.target()
except AssertionError as e:
self.error = e
else:
self.error = None
class Test():
def __init__(self):
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
self.test = 1234
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
@classmethod
def asdf(cls):
pass
def foo(self, exception = False, reenter = False):
if exception:
raise Exception()
self.bar(reenter)
def bar(self, reenter):
if reenter:
self.foo()
Improve serializer_proxy and verify_thread_proxy These functions can now take an object or a type (class). If given an object, they will wrap subsequent calls to that object. If given a type, they will return an object that can be instantiated to create a new object, and all calls including __init__ will be covered by the serialization or thread verification.
2013-02-23 14:26:18 -05:00
return 123
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
def baz_threaded(self, target):
t = Thread(target)
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
t.start()
t.join()
return t
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
def baz(self, target):
target()
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
class TestThreadSafety(object):
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
def tryit(self, c, threading_ok, concurrent_ok):
eq_(c.test, 1234)
c.foo()
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
t = Thread(c.foo)
t.start()
t.join()
if threading_ok and t.error:
raise Exception("got unexpected error: " + str(t.error))
if not threading_ok and not t.error:
raise Exception("failed to get expected error")
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
try:
c.baz(c.foo)
except AssertionError as e:
if concurrent_ok:
raise Exception("got unexpected error: " + str(e))
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
else:
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
if not concurrent_ok:
raise Exception("failed to get expected error")
t = c.baz_threaded(c.foo)
if (concurrent_ok and threading_ok) and t.error:
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
raise Exception("got unexpected error: " + str(t.error))
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
if not (concurrent_ok and threading_ok) and not t.error:
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
raise Exception("failed to get expected error")
def test(self):
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
proxy = nilmdb.utils.threadsafety.verify_proxy
Improve serializer_proxy and verify_thread_proxy These functions can now take an object or a type (class). If given an object, they will wrap subsequent calls to that object. If given a type, they will return an object that can be instantiated to create a new object, and all calls including __init__ will be covered by the serialization or thread verification.
2013-02-23 14:26:18 -05:00
self.tryit(Test(), True, True)
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
self.tryit(proxy(Test(), True, True, True), False, False)
self.tryit(proxy(Test(), True, True, False), False, True)
self.tryit(proxy(Test(), True, False, True), True, False)
self.tryit(proxy(Test(), True, False, False), True, True)
Improve serializer_proxy and verify_thread_proxy These functions can now take an object or a type (class). If given an object, they will wrap subsequent calls to that object. If given a type, they will return an object that can be instantiated to create a new object, and all calls including __init__ will be covered by the serialization or thread verification.
2013-02-23 14:26:18 -05:00
self.tryit(proxy(Test, True, True, True)(), False, False)
self.tryit(proxy(Test, True, True, False)(), False, True)
self.tryit(proxy(Test, True, False, True)(), True, False)
self.tryit(proxy(Test, True, False, False)(), True, True)
proxy(proxy(proxy(Test))()).foo()
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
Replace threadsafety class decorator version, add explicit proxy version Like the serializer changes, the class decorator was too fragile.
2013-02-23 10:27:23 -05:00
c = proxy(Test())
Implement verify_thread_safety to check for unsafe access patterns Occasional segfaults may be the result of performing thread-unsafe operations. This class decorator verifies that all of its methods are called in a thread-safe manner. It can separately warn about: - two threads calling methods in a function (the kind of thing sqlite doesn't like) - recursion - concurrency (two different threads functions at the same time)
2013-02-21 18:04:21 -05:00
c.foo()
try:
c.foo(exception = True)
except Exception:
pass
c.foo()
Reference in New Issue Copy Permalink