← Back to branch summary

~pythonregexp2.7/python/issue2636-24

« back to all changes in this revision

Viewing changes to Lib/bsddb/test/test_thread.py

  • Committer: Jeffrey C. "The TimeHorse" Jacobs
  • Date: 2008-09-21 13:47:31 UTC
  • mfrom: (39021.1.404 Regexp-2.7)
  • Revision ID: darklord@timehorse.com-20080921134731-rudomuzeh1b2tz1y
Merged in changes from the latest python source snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/bsddb/test/test_thread.py
7
7
import errno
8
8
from random import random
9
9
 
10
 
try:
11
 
    True, False
12
 
except NameError:
13
 
    True = 1
14
 
    False = 0
15
 
 
16
10
DASH = '-'
17
11
 
18
12
try:
19
 
    from threading import Thread, currentThread
20
 
    have_threads = True
21
 
except ImportError:
22
 
    have_threads = False
23
 
 
24
 
try:
25
13
    WindowsError
26
14
except NameError:
27
15
    class WindowsError(Exception):
28
16
        pass
29
17
 
30
18
import unittest
31
 
from test_all import verbose, get_new_environment_path, get_new_database_path
32
 
 
33
 
 
34
 
try:
35
 
    # For Pythons w/distutils pybsddb
36
 
    from bsddb3 import db, dbutils
37
 
except ImportError:
38
 
    # For Python 2.3
39
 
    from bsddb import db, dbutils
40
 
 
41
 
try:
42
 
    from bsddb3 import test_support
43
 
except ImportError:
44
 
    from test import test_support
 
19
from test_all import db, dbutils, test_support, verbose, have_threads, \
 
20
        get_new_environment_path, get_new_database_path
 
21
 
 
22
if have_threads :
 
23
    from threading import Thread
 
24
    import sys
 
25
    if sys.version_info[0] < 3 :
 
26
        from threading import currentThread
 
27
    else :
 
28
        from threading import current_thread as currentThread
45
29
 
46
30
 
47
31
#----------------------------------------------------------------------
103
87
        keys=range(self.records)
104
88
        import random
105
89
        random.shuffle(keys)
106
 
        records_per_writer=self.records/self.writers
107
 
        readers_per_writer=self.readers/self.writers
 
90
        records_per_writer=self.records//self.writers
 
91
        readers_per_writer=self.readers//self.writers
108
92
        self.assertEqual(self.records,self.writers*records_per_writer)
109
93
        self.assertEqual(self.readers,self.writers*readers_per_writer)
110
94
        self.assertTrue((records_per_writer%readers_per_writer)==0)
115
99
                        args = (self.d, x),
116
100
                        name = 'reader %d' % x,
117
101
                        )#verbose = verbose)
118
 
            rt.setDaemon(True)
 
102
            import sys
 
103
            if sys.version_info[0] < 3 :
 
104
                rt.setDaemon(True)
 
105
            else :
 
106
                rt.daemon = True
119
107
            readers.append(rt)
120
108
 
121
109
        writers=[]
130
118
            writers.append(wt)
131
119
 
132
120
        for t in writers:
133
 
            t.setDaemon(True)
 
121
            import sys
 
122
            if sys.version_info[0] < 3 :
 
123
                t.setDaemon(True)
 
124
            else :
 
125
                t.daemon = True
134
126
            t.start()
135
127
 
136
128
        for t in writers:
139
131
            t.join()
140
132
 
141
133
    def writerThread(self, d, keys, readers):
142
 
        name = currentThread().getName()
 
134
        import sys
 
135
        if sys.version_info[0] < 3 :
 
136
            name = currentThread().getName()
 
137
        else :
 
138
            name = currentThread().name
 
139
 
143
140
        if verbose:
144
141
            print "%s: creating records %d - %d" % (name, start, stop)
145
142
 
146
 
        count=len(keys)/len(readers)
 
143
        count=len(keys)//len(readers)
147
144
        count2=count
148
145
        for x in keys :
149
146
            key = '%04d' % x
164
161
            print "%s: thread finished" % name
165
162
 
166
163
    def readerThread(self, d, readerNum):
167
 
        name = currentThread().getName()
 
164
        import sys
 
165
        if sys.version_info[0] < 3 :
 
166
            name = currentThread().getName()
 
167
        else :
 
168
            name = currentThread().name
168
169
 
169
170
        for i in xrange(5) :
170
171
            c = d.cursor()
218
219
        keys=range(self.records)
219
220
        import random
220
221
        random.shuffle(keys)
221
 
        records_per_writer=self.records/self.writers
222
 
        readers_per_writer=self.readers/self.writers
 
222
        records_per_writer=self.records//self.writers
 
223
        readers_per_writer=self.readers//self.writers
223
224
        self.assertEqual(self.records,self.writers*records_per_writer)
224
225
        self.assertEqual(self.readers,self.writers*readers_per_writer)
225
226
        self.assertTrue((records_per_writer%readers_per_writer)==0)
230
231
                        args = (self.d, x),
231
232
                        name = 'reader %d' % x,
232
233
                        )#verbose = verbose)
233
 
            rt.setDaemon(True)
 
234
            import sys
 
235
            if sys.version_info[0] < 3 :
 
236
                rt.setDaemon(True)
 
237
            else :
 
238
                rt.daemon = True
234
239
            readers.append(rt)
235
240
 
236
241
        writers = []
245
250
            writers.append(wt)
246
251
 
247
252
        for t in writers:
248
 
            t.setDaemon(True)
 
253
            import sys
 
254
            if sys.version_info[0] < 3 :
 
255
                t.setDaemon(True)
 
256
            else :
 
257
                t.daemon = True
249
258
            t.start()
250
259
 
251
260
        for t in writers:
254
263
            t.join()
255
264
 
256
265
    def writerThread(self, d, keys, readers):
257
 
        name = currentThread().getName()
 
266
        import sys
 
267
        if sys.version_info[0] < 3 :
 
268
            name = currentThread().getName()
 
269
        else :
 
270
            name = currentThread().name
258
271
        if verbose:
259
272
            print "%s: creating records %d - %d" % (name, start, stop)
260
273
 
261
 
        count=len(keys)/len(readers)
 
274
        count=len(keys)//len(readers)
262
275
        count2=count
263
276
        for x in keys :
264
277
            key = '%04d' % x
277
290
            print "%s: thread finished" % name
278
291
 
279
292
    def readerThread(self, d, readerNum):
280
 
        name = currentThread().getName()
 
293
        import sys
 
294
        if sys.version_info[0] < 3 :
 
295
            name = currentThread().getName()
 
296
        else :
 
297
            name = currentThread().name
281
298
 
282
299
        c = d.cursor()
283
300
        count = 0
332
349
        keys=range(self.records)
333
350
        import random
334
351
        random.shuffle(keys)
335
 
        records_per_writer=self.records/self.writers
336
 
        readers_per_writer=self.readers/self.writers
 
352
        records_per_writer=self.records//self.writers
 
353
        readers_per_writer=self.readers//self.writers
337
354
        self.assertEqual(self.records,self.writers*records_per_writer)
338
355
        self.assertEqual(self.readers,self.writers*readers_per_writer)
339
356
        self.assertTrue((records_per_writer%readers_per_writer)==0)
344
361
                        args = (self.d, x),
345
362
                        name = 'reader %d' % x,
346
363
                        )#verbose = verbose)
347
 
            rt.setDaemon(True)
 
364
            import sys
 
365
            if sys.version_info[0] < 3 :
 
366
                rt.setDaemon(True)
 
367
            else :
 
368
                rt.daemon = True
348
369
            readers.append(rt)
349
370
 
350
371
        writers = []
358
379
            writers.append(wt)
359
380
 
360
381
        dt = Thread(target = self.deadlockThread)
361
 
        dt.setDaemon(True)
 
382
        import sys
 
383
        if sys.version_info[0] < 3 :
 
384
            dt.setDaemon(True)
 
385
        else :
 
386
            dt.daemon = True
362
387
        dt.start()
363
388
 
364
389
        for t in writers:
365
 
            t.setDaemon(True)
 
390
            import sys
 
391
            if sys.version_info[0] < 3 :
 
392
                t.setDaemon(True)
 
393
            else :
 
394
                t.daemon = True
366
395
            t.start()
367
396
 
368
397
        for t in writers:
374
403
        dt.join()
375
404
 
376
405
    def writerThread(self, d, keys, readers):
377
 
        name = currentThread().getName()
378
 
        count=len(keys)/len(readers)
 
406
        import sys
 
407
        if sys.version_info[0] < 3 :
 
408
            name = currentThread().getName()
 
409
        else :
 
410
            name = currentThread().name
 
411
 
 
412
        count=len(keys)//len(readers)
379
413
        while len(keys):
380
414
            try:
381
415
                txn = self.env.txn_begin(None, self.txnFlag)
397
431
            print "%s: thread finished" % name
398
432
 
399
433
    def readerThread(self, d, readerNum):
400
 
        name = currentThread().getName()
 
434
        import sys
 
435
        if sys.version_info[0] < 3 :
 
436
            name = currentThread().getName()
 
437
        else :
 
438
            name = currentThread().name
401
439
 
402
440
        finished = False
403
441
        while not finished: