FILEMOVER/test/mapping_manager.py


import os
import sys
import sets
import time
import unittest
import threading
import ConfigParser

if os.path.exists("src"):
    sys.path.append("src")
if os.path.exists('../src'):
    sys.path.append('../src')

from CmsFileServer.MappingManager import MappingManager

class BlockingMappingManager(MappingManager):
    """
    A mapping manager which can be made to block on acquire and release
    (so we can test thread-safety a bit).
    """
    
    def __init__(self):
        super(BlockingMappingManager, self).__init__()
        self._acquire_cond = None
        self._release_cond = None
        self._acquire_count = 0
        self._release_count = 0
        
    def blockOnAcquire(self, cond):
        self._acquire_cond = cond
        
    def _lookup(self, key):
        if self._acquire_cond:
            self._acquire_cond.acquire()
            self._acquire_cond.wait()
            self._acquire_cond.release()
        self._acquire_count += 1
        return key**2

    def blockOnRelease(self, cond):
        self._acquire_cond = cond
        
    def _release(self, key):
        if self._release_cond:
            self._release_cond.acquire()
            self._release_cond.wait()
            self._release_cond.release()
        self._release_count += 1
            
class TestMappingManager(unittest.TestCase):
    """
    A test case for the MappingManager
    """
    
    def setUp(self):
        self.manager = BlockingMappingManager()
    
    def test_acquire_release_serial(self):
        value = self.manager.acquireValue(3)
        self.failUnless(value==9, "Returned the incorrect value.")
        self.manager.releaseKey(3)
        value = self.manager.acquireValue(3)
        self.failUnless(value==9, "Returned the incorrect value.")
        self.manager.releaseKey(3)
        self.failUnless(self.manager._acquire_count == 2)
        self.failUnless(self.manager._release_count == 2)
        
    def test_acquire_release_overlapping(self):
        value = self.manager.acquireValue(3)
        self.failUnless(value==9, "Returned the incorrect value.")
        self.failUnless(self.manager._keys_refcount[3] == 1)
        value = self.manager.acquireValue(3)
        self.failUnless(self.manager._keys_refcount[3] == 2)
        self.manager.releaseKey(3)
        self.failUnless(self.manager._keys_refcount[3] == 1)
        self.failUnless(value==9, "Returned the incorrect value.")
        self.manager.releaseKey(3)
        self.failUnless(3 not in self.manager._keys_refcount)
        self.failUnless(self.manager._acquire_count == 1)
        self.failUnless(self.manager._release_count == 2)
     
    def _acquire_key_3(self):
        self.manager.acquireValue(3)
     
    def test_acquire_release_blocking(self):
        cond = threading.Condition()
        self.manager.blockOnAcquire(cond)
        t1 = threading.Thread(target=self._acquire_key_3)
        t2 = threading.Thread(target=self._acquire_key_3)
        self.failUnless(3 not in self.manager._lookup_attempts)
        self.failUnless(3 not in self.manager._keys_refcount)
        t1.start()
        self.failUnless(3 in self.manager._lookup_attempts)
        self.failUnless(3 not in self.manager._keys_refcount)
        t2.start()
        time.sleep(.2)
        cond.acquire()
        cond.notifyAll()
        cond.release()
        cond.acquire()
        cond.notifyAll()
        cond.release()
        t1.join()
        t2.join()
        self.failUnless(self.manager._acquire_count == 1)
        self.failUnless(self.manager._keys_refcount[3] == 2)
        self.manager.releaseKey(3)
        self.manager.releaseKey(3)
        self.failUnless(3 not in self.manager._keys_refcount)
        
if __name__ == '__main__':
    unittest.main()
Revision:	1.1
Committed:	Wed Jan 14 00:52:15 2009 UTC (16 years, 3 months ago) by bbockelm
Content type:	text/x-python
Branch:	MAIN
Log Message:	Mapping manager implementation of resources allocation. Added test cases for basic functionality.
#	User	Rev	Content
1	bbockelm	1.1
2			import os
3			import sys
4			import sets
5			import time
6			import unittest
7			import threading
8			import ConfigParser
9
10			if os.path.exists("src"):
11			sys.path.append("src")
12			if os.path.exists('../src'):
13			sys.path.append('../src')
14
15			from CmsFileServer.MappingManager import MappingManager
16
17			class BlockingMappingManager(MappingManager):
18			"""
19			A mapping manager which can be made to block on acquire and release
20			(so we can test thread-safety a bit).
21			"""
22
23			def __init__(self):
24			super(BlockingMappingManager, self).__init__()
25			self._acquire_cond = None
26			self._release_cond = None
27			self._acquire_count = 0
28			self._release_count = 0
29
30			def blockOnAcquire(self, cond):
31			self._acquire_cond = cond
32
33			def _lookup(self, key):
34			if self._acquire_cond:
35			self._acquire_cond.acquire()
36			self._acquire_cond.wait()
37			self._acquire_cond.release()
38			self._acquire_count += 1
39			return key**2
40
41			def blockOnRelease(self, cond):
42			self._acquire_cond = cond
43
44			def _release(self, key):
45			if self._release_cond:
46			self._release_cond.acquire()
47			self._release_cond.wait()
48			self._release_cond.release()
49			self._release_count += 1
50
51			class TestMappingManager(unittest.TestCase):
52			"""
53			A test case for the MappingManager
54			"""
55
56			def setUp(self):
57			self.manager = BlockingMappingManager()
58
59			def test_acquire_release_serial(self):
60			value = self.manager.acquireValue(3)
61			self.failUnless(value==9, "Returned the incorrect value.")
62			self.manager.releaseKey(3)
63			value = self.manager.acquireValue(3)
64			self.failUnless(value==9, "Returned the incorrect value.")
65			self.manager.releaseKey(3)
66			self.failUnless(self.manager._acquire_count == 2)
67			self.failUnless(self.manager._release_count == 2)
68
69			def test_acquire_release_overlapping(self):
70			value = self.manager.acquireValue(3)
71			self.failUnless(value==9, "Returned the incorrect value.")
72			self.failUnless(self.manager._keys_refcount[3] == 1)
73			value = self.manager.acquireValue(3)
74			self.failUnless(self.manager._keys_refcount[3] == 2)
75			self.manager.releaseKey(3)
76			self.failUnless(self.manager._keys_refcount[3] == 1)
77			self.failUnless(value==9, "Returned the incorrect value.")
78			self.manager.releaseKey(3)
79			self.failUnless(3 not in self.manager._keys_refcount)
80			self.failUnless(self.manager._acquire_count == 1)
81			self.failUnless(self.manager._release_count == 2)
82
83			def _acquire_key_3(self):
84			self.manager.acquireValue(3)
85
86			def test_acquire_release_blocking(self):
87			cond = threading.Condition()
88			self.manager.blockOnAcquire(cond)
89			t1 = threading.Thread(target=self._acquire_key_3)
90			t2 = threading.Thread(target=self._acquire_key_3)
91			self.failUnless(3 not in self.manager._lookup_attempts)
92			self.failUnless(3 not in self.manager._keys_refcount)
93			t1.start()
94			self.failUnless(3 in self.manager._lookup_attempts)
95			self.failUnless(3 not in self.manager._keys_refcount)
96			t2.start()
97			time.sleep(.2)
98			cond.acquire()
99			cond.notifyAll()
100			cond.release()
101			cond.acquire()
102			cond.notifyAll()
103			cond.release()
104			t1.join()
105			t2.join()
106			self.failUnless(self.manager._acquire_count == 1)
107			self.failUnless(self.manager._keys_refcount[3] == 2)
108			self.manager.releaseKey(3)
109			self.manager.releaseKey(3)
110			self.failUnless(3 not in self.manager._keys_refcount)
111
112			if __name__ == '__main__':
113			unittest.main()