← Back to branch summary

~ubuntu-branches/ubuntu/karmic/pypy/karmic

« back to all changes in this revision

Viewing changes to lib-python/2.4.1/bsddb/test/test_associate.py

  • Committer: Bazaar Package Importer
  • Author(s): Alexandre Fayolle
  • Date: 2007-04-13 09:33:09 UTC
  • Revision ID: james.westby@ubuntu.com-20070413093309-yoojh4jcoocu2krz
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib-python/2.4.1/bsddb/test/test_associate.py
 
1
"""
 
2
TestCases for DB.associate.
 
3
"""
 
4
 
 
5
import sys, os, string
 
6
import tempfile
 
7
import time
 
8
from pprint import pprint
 
9
 
 
10
try:
 
11
    from threading import Thread, currentThread
 
12
    have_threads = 1
 
13
except ImportError:
 
14
    have_threads = 0
 
15
 
 
16
import unittest
 
17
from test_all import verbose
 
18
 
 
19
try:
 
20
    # For Pythons w/distutils pybsddb
 
21
    from bsddb3 import db, dbshelve
 
22
except ImportError:
 
23
    # For Python 2.3
 
24
    from bsddb import db, dbshelve
 
25
 
 
26
 
 
27
#----------------------------------------------------------------------
 
28
 
 
29
 
 
30
musicdata = {
 
31
1 : ("Bad English", "The Price Of Love", "Rock"),
 
32
2 : ("DNA featuring Suzanne Vega", "Tom's Diner", "Rock"),
 
33
3 : ("George Michael", "Praying For Time", "Rock"),
 
34
4 : ("Gloria Estefan", "Here We Are", "Rock"),
 
35
5 : ("Linda Ronstadt", "Don't Know Much", "Rock"),
 
36
6 : ("Michael Bolton", "How Am I Supposed To Live Without You", "Blues"),
 
37
7 : ("Paul Young", "Oh Girl", "Rock"),
 
38
8 : ("Paula Abdul", "Opposites Attract", "Rock"),
 
39
9 : ("Richard Marx", "Should've Known Better", "Rock"),
 
40
10: ("Rod Stewart", "Forever Young", "Rock"),
 
41
11: ("Roxette", "Dangerous", "Rock"),
 
42
12: ("Sheena Easton", "The Lover In Me", "Rock"),
 
43
13: ("Sinead O'Connor", "Nothing Compares 2 U", "Rock"),
 
44
14: ("Stevie B.", "Because I Love You", "Rock"),
 
45
15: ("Taylor Dayne", "Love Will Lead You Back", "Rock"),
 
46
16: ("The Bangles", "Eternal Flame", "Rock"),
 
47
17: ("Wilson Phillips", "Release Me", "Rock"),
 
48
18: ("Billy Joel", "Blonde Over Blue", "Rock"),
 
49
19: ("Billy Joel", "Famous Last Words", "Rock"),
 
50
20: ("Billy Joel", "Lullabye (Goodnight, My Angel)", "Rock"),
 
51
21: ("Billy Joel", "The River Of Dreams", "Rock"),
 
52
22: ("Billy Joel", "Two Thousand Years", "Rock"),
 
53
23: ("Janet Jackson", "Alright", "Rock"),
 
54
24: ("Janet Jackson", "Black Cat", "Rock"),
 
55
25: ("Janet Jackson", "Come Back To Me", "Rock"),
 
56
26: ("Janet Jackson", "Escapade", "Rock"),
 
57
27: ("Janet Jackson", "Love Will Never Do (Without You)", "Rock"),
 
58
28: ("Janet Jackson", "Miss You Much", "Rock"),
 
59
29: ("Janet Jackson", "Rhythm Nation", "Rock"),
 
60
30: ("Janet Jackson", "State Of The World", "Rock"),
 
61
31: ("Janet Jackson", "The Knowledge", "Rock"),
 
62
32: ("Spyro Gyra", "End of Romanticism", "Jazz"),
 
63
33: ("Spyro Gyra", "Heliopolis", "Jazz"),
 
64
34: ("Spyro Gyra", "Jubilee", "Jazz"),
 
65
35: ("Spyro Gyra", "Little Linda", "Jazz"),
 
66
36: ("Spyro Gyra", "Morning Dance", "Jazz"),
 
67
37: ("Spyro Gyra", "Song for Lorraine", "Jazz"),
 
68
38: ("Yes", "Owner Of A Lonely Heart", "Rock"),
 
69
39: ("Yes", "Rhythm Of Love", "Rock"),
 
70
40: ("Cusco", "Dream Catcher", "New Age"),
 
71
41: ("Cusco", "Geronimos Laughter", "New Age"),
 
72
42: ("Cusco", "Ghost Dance", "New Age"),
 
73
43: ("Blue Man Group", "Drumbone", "New Age"),
 
74
44: ("Blue Man Group", "Endless Column", "New Age"),
 
75
45: ("Blue Man Group", "Klein Mandelbrot", "New Age"),
 
76
46: ("Kenny G", "Silhouette", "Jazz"),
 
77
47: ("Sade", "Smooth Operator", "Jazz"),
 
78
48: ("David Arkenstone", "Papillon (On The Wings Of The Butterfly)",
 
79
     "New Age"),
 
80
49: ("David Arkenstone", "Stepping Stars", "New Age"),
 
81
50: ("David Arkenstone", "Carnation Lily Lily Rose", "New Age"),
 
82
51: ("David Lanz", "Behind The Waterfall", "New Age"),
 
83
52: ("David Lanz", "Cristofori's Dream", "New Age"),
 
84
53: ("David Lanz", "Heartsounds", "New Age"),
 
85
54: ("David Lanz", "Leaves on the Seine", "New Age"),
 
86
99: ("unknown artist", "Unnamed song", "Unknown"),
 
87
}
 
88
 
 
89
#----------------------------------------------------------------------
 
90
 
 
91
 
 
92
class AssociateTestCase(unittest.TestCase):
 
93
    keytype = ''
 
94
 
 
95
    def setUp(self):
 
96
        self.filename = self.__class__.__name__ + '.db'
 
97
        homeDir = os.path.join(os.path.dirname(sys.argv[0]), 'db_home')
 
98
        self.homeDir = homeDir
 
99
        try: os.mkdir(homeDir)
 
100
        except os.error: pass
 
101
        self.env = db.DBEnv()
 
102
        self.env.open(homeDir, db.DB_CREATE | db.DB_INIT_MPOOL |
 
103
                               db.DB_INIT_LOCK | db.DB_THREAD)
 
104
 
 
105
    def tearDown(self):
 
106
        self.closeDB()
 
107
        self.env.close()
 
108
        import glob
 
109
        files = glob.glob(os.path.join(self.homeDir, '*'))
 
110
        for file in files:
 
111
            os.remove(file)
 
112
 
 
113
    def addDataToDB(self, d):
 
114
        for key, value in musicdata.items():
 
115
            if type(self.keytype) == type(''):
 
116
                key = "%02d" % key
 
117
            d.put(key, string.join(value, '|'))
 
118
 
 
119
    def createDB(self):
 
120
        self.primary = db.DB(self.env)
 
121
        self.primary.set_get_returns_none(2)
 
122
        self.primary.open(self.filename, "primary", self.dbtype,
 
123
                          db.DB_CREATE | db.DB_THREAD)
 
124
 
 
125
    def closeDB(self):
 
126
        self.primary.close()
 
127
 
 
128
    def getDB(self):
 
129
        return self.primary
 
130
 
 
131
    def test01_associateWithDB(self):
 
132
        if verbose:
 
133
            print '\n', '-=' * 30
 
134
            print "Running %s.test01_associateWithDB..." % \
 
135
                  self.__class__.__name__
 
136
 
 
137
        self.createDB()
 
138
 
 
139
        secDB = db.DB(self.env)
 
140
        secDB.set_flags(db.DB_DUP)
 
141
        secDB.set_get_returns_none(2)
 
142
        secDB.open(self.filename, "secondary", db.DB_BTREE,
 
143
                   db.DB_CREATE | db.DB_THREAD)
 
144
        self.getDB().associate(secDB, self.getGenre)
 
145
 
 
146
        self.addDataToDB(self.getDB())
 
147
 
 
148
        self.finish_test(secDB)
 
149
 
 
150
 
 
151
    def test02_associateAfterDB(self):
 
152
        if verbose:
 
153
            print '\n', '-=' * 30
 
154
            print "Running %s.test02_associateAfterDB..." % \
 
155
                  self.__class__.__name__
 
156
 
 
157
        self.createDB()
 
158
        self.addDataToDB(self.getDB())
 
159
 
 
160
        secDB = db.DB(self.env)
 
161
        secDB.set_flags(db.DB_DUP)
 
162
        secDB.open(self.filename, "secondary", db.DB_BTREE,
 
163
                   db.DB_CREATE | db.DB_THREAD)
 
164
 
 
165
        # adding the DB_CREATE flag will cause it to index existing records
 
166
        self.getDB().associate(secDB, self.getGenre, db.DB_CREATE)
 
167
 
 
168
        self.finish_test(secDB)
 
169
 
 
170
 
 
171
    def finish_test(self, secDB):
 
172
        # 'Blues' should not be in the secondary database
 
173
        vals = secDB.pget('Blues')
 
174
        assert vals == None, vals
 
175
 
 
176
        vals = secDB.pget('Unknown')
 
177
        assert vals[0] == 99 or vals[0] == '99', vals
 
178
        vals[1].index('Unknown')
 
179
        vals[1].index('Unnamed')
 
180
        vals[1].index('unknown')
 
181
 
 
182
        if verbose:
 
183
            print "Primary key traversal:"
 
184
        c = self.getDB().cursor()
 
185
        count = 0
 
186
        rec = c.first()
 
187
        while rec is not None:
 
188
            if type(self.keytype) == type(''):
 
189
                assert string.atoi(rec[0])  # for primary db, key is a number
 
190
            else:
 
191
                assert rec[0] and type(rec[0]) == type(0)
 
192
            count = count + 1
 
193
            if verbose:
 
194
                print rec
 
195
            rec = c.next()
 
196
        assert count == len(musicdata) # all items accounted for
 
197
 
 
198
 
 
199
        if verbose:
 
200
            print "Secondary key traversal:"
 
201
        c = secDB.cursor()
 
202
        count = 0
 
203
 
 
204
        # test cursor pget
 
205
        vals = c.pget('Unknown', flags=db.DB_LAST)
 
206
        assert vals[1] == 99 or vals[1] == '99', vals
 
207
        assert vals[0] == 'Unknown'
 
208
        vals[2].index('Unknown')
 
209
        vals[2].index('Unnamed')
 
210
        vals[2].index('unknown')
 
211
 
 
212
        vals = c.pget('Unknown', data='wrong value', flags=db.DB_GET_BOTH)
 
213
        assert vals == None, vals
 
214
 
 
215
        rec = c.first()
 
216
        assert rec[0] == "Jazz"
 
217
        while rec is not None:
 
218
            count = count + 1
 
219
            if verbose:
 
220
                print rec
 
221
            rec = c.next()
 
222
        # all items accounted for EXCEPT for 1 with "Blues" genre
 
223
        assert count == len(musicdata)-1
 
224
 
 
225
    def getGenre(self, priKey, priData):
 
226
        assert type(priData) == type("")
 
227
        if verbose:
 
228
            print 'getGenre key: %r data: %r' % (priKey, priData)
 
229
        genre = string.split(priData, '|')[2]
 
230
        if genre == 'Blues':
 
231
            return db.DB_DONOTINDEX
 
232
        else:
 
233
            return genre
 
234
 
 
235
 
 
236
#----------------------------------------------------------------------
 
237
 
 
238
 
 
239
class AssociateHashTestCase(AssociateTestCase):
 
240
    dbtype = db.DB_HASH
 
241
 
 
242
class AssociateBTreeTestCase(AssociateTestCase):
 
243
    dbtype = db.DB_BTREE
 
244
 
 
245
class AssociateRecnoTestCase(AssociateTestCase):
 
246
    dbtype = db.DB_RECNO
 
247
    keytype = 0
 
248
 
 
249
 
 
250
#----------------------------------------------------------------------
 
251
 
 
252
class ShelveAssociateTestCase(AssociateTestCase):
 
253
 
 
254
    def createDB(self):
 
255
        self.primary = dbshelve.open(self.filename,
 
256
                                     dbname="primary",
 
257
                                     dbenv=self.env,
 
258
                                     filetype=self.dbtype)
 
259
 
 
260
    def addDataToDB(self, d):
 
261
        for key, value in musicdata.items():
 
262
            if type(self.keytype) == type(''):
 
263
                key = "%02d" % key
 
264
            d.put(key, value)    # save the value as is this time
 
265
 
 
266
 
 
267
    def getGenre(self, priKey, priData):
 
268
        assert type(priData) == type(())
 
269
        if verbose:
 
270
            print 'getGenre key: %r data: %r' % (priKey, priData)
 
271
        genre = priData[2]
 
272
        if genre == 'Blues':
 
273
            return db.DB_DONOTINDEX
 
274
        else:
 
275
            return genre
 
276
 
 
277
 
 
278
class ShelveAssociateHashTestCase(ShelveAssociateTestCase):
 
279
    dbtype = db.DB_HASH
 
280
 
 
281
class ShelveAssociateBTreeTestCase(ShelveAssociateTestCase):
 
282
    dbtype = db.DB_BTREE
 
283
 
 
284
class ShelveAssociateRecnoTestCase(ShelveAssociateTestCase):
 
285
    dbtype = db.DB_RECNO
 
286
    keytype = 0
 
287
 
 
288
 
 
289
#----------------------------------------------------------------------
 
290
 
 
291
class ThreadedAssociateTestCase(AssociateTestCase):
 
292
 
 
293
    def addDataToDB(self, d):
 
294
        t1 = Thread(target = self.writer1,
 
295
                    args = (d, ))
 
296
        t2 = Thread(target = self.writer2,
 
297
                    args = (d, ))
 
298
 
 
299
        t1.start()
 
300
        t2.start()
 
301
        t1.join()
 
302
        t2.join()
 
303
 
 
304
    def writer1(self, d):
 
305
        for key, value in musicdata.items():
 
306
            if type(self.keytype) == type(''):
 
307
                key = "%02d" % key
 
308
            d.put(key, string.join(value, '|'))
 
309
 
 
310
    def writer2(self, d):
 
311
        for x in range(100, 600):
 
312
            key = 'z%2d' % x
 
313
            value = [key] * 4
 
314
            d.put(key, string.join(value, '|'))
 
315
 
 
316
 
 
317
class ThreadedAssociateHashTestCase(ShelveAssociateTestCase):
 
318
    dbtype = db.DB_HASH
 
319
 
 
320
class ThreadedAssociateBTreeTestCase(ShelveAssociateTestCase):
 
321
    dbtype = db.DB_BTREE
 
322
 
 
323
class ThreadedAssociateRecnoTestCase(ShelveAssociateTestCase):
 
324
    dbtype = db.DB_RECNO
 
325
    keytype = 0
 
326
 
 
327
 
 
328
#----------------------------------------------------------------------
 
329
 
 
330
def test_suite():
 
331
    suite = unittest.TestSuite()
 
332
 
 
333
    if db.version() >= (3, 3, 11):
 
334
        suite.addTest(unittest.makeSuite(AssociateHashTestCase))
 
335
        suite.addTest(unittest.makeSuite(AssociateBTreeTestCase))
 
336
        suite.addTest(unittest.makeSuite(AssociateRecnoTestCase))
 
337
 
 
338
        suite.addTest(unittest.makeSuite(ShelveAssociateHashTestCase))
 
339
        suite.addTest(unittest.makeSuite(ShelveAssociateBTreeTestCase))
 
340
        suite.addTest(unittest.makeSuite(ShelveAssociateRecnoTestCase))
 
341
 
 
342
        if have_threads:
 
343
            suite.addTest(unittest.makeSuite(ThreadedAssociateHashTestCase))
 
344
            suite.addTest(unittest.makeSuite(ThreadedAssociateBTreeTestCase))
 
345
            suite.addTest(unittest.makeSuite(ThreadedAssociateRecnoTestCase))
 
346
 
 
347
    return suite
 
348
 
 
349
 
 
350
if __name__ == '__main__':
 
351
    unittest.main(defaultTest='test_suite')