~pythonregexp2.7/python/issue2636-09-01+10

« back to all changes in this revision

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

• browse files at revision 39075
• compare with another revision
• download diff
• download tarball
• view history from revision 39075

Show diffs side-by-side

added

removed

Lib/bsddb/test/test_basics.py

10

10

import unittest

11

11

import time

12

12

 

13

 

try:

14

 

    # For Pythons w/distutils pybsddb

15

 

    from bsddb3 import db

16

 

except ImportError:

17

 

    # For Python 2.3

18

 

    from bsddb import db

19

 

 

20

 

try:

21

 

    from bsddb3 import test_support

22

 

except ImportError:

23

 

    from test import test_support

24

 

 

25

 

from test_all import verbose, get_new_environment_path, get_new_database_path

 

13

from test_all import db, test_support, verbose, get_new_environment_path, \

 

14

        get_new_database_path

26

15

 

27

16

DASH = '-'

28

17

 

101

90

    def populateDB(self, _txn=None):

102

91

        d = self.d

103

92

 

104

 

        for x in range(self._numKeys/2):

 

93

        for x in range(self._numKeys//2):

105

94

            key = '%04d' % (self._numKeys - x)  # insert keys in reverse order

106

95

            data = self.makeData(key)

107

96

            d.put(key, data, _txn)

108

97

 

109

98

        d.put('empty value', '', _txn)

110

99

 

111

 

        for x in range(self._numKeys/2-1):

 

100

        for x in range(self._numKeys//2-1):

112

101

            key = '%04d' % x  # and now some in forward order

113

102

            data = self.makeData(key)

114

103

            d.put(key, data, _txn)

150

139

        try:

151

140

            d.delete('abcd')

152

141

        except db.DBNotFoundError, val:

153

 

            self.assertEqual(val[0], db.DB_NOTFOUND)

 

142

            import sys

 

143

            if sys.version_info[0] < 3 :

 

144

                self.assertEqual(val[0], db.DB_NOTFOUND)

 

145

            else :

 

146

                self.assertEqual(val.args[0], db.DB_NOTFOUND)

154

147

            if verbose: print val

155

148

        else:

156

149

            self.fail("expected exception")

169

162

        try:

170

163

            d.put('abcd', 'this should fail', flags=db.DB_NOOVERWRITE)

171

164

        except db.DBKeyExistError, val:

172

 

            self.assertEqual(val[0], db.DB_KEYEXIST)

 

165

            import sys

 

166

            if sys.version_info[0] < 3 :

 

167

                self.assertEqual(val[0], db.DB_KEYEXIST)

 

168

            else :

 

169

                self.assertEqual(val.args[0], db.DB_KEYEXIST)

173

170

            if verbose: print val

174

171

        else:

175

172

            self.fail("expected exception")

255

252

 

256

253

        self.assertEqual(d['new record'], 'a replacement record')

257

254

 

258

 

        self.assertEqual(d.has_key('0001'), 1)

259

 

        self.assertEqual(d.has_key('spam'), 0)

 

255

# We check also the positional parameter

 

256

        self.assertEqual(d.has_key('0001', None), 1)

 

257

# We check also the keyword parameter

 

258

        self.assertEqual(d.has_key('spam', txn=None), 0)

260

259

 

261

260

        items = d.items()

262

261

        self.assertEqual(len(items), self._numKeys+1)

302

301

                rec = c.next()

303

302

            except db.DBNotFoundError, val:

304

303

                if get_raises_error:

305

 

                    self.assertEqual(val[0], db.DB_NOTFOUND)

 

304

                    import sys

 

305

                    if sys.version_info[0] < 3 :

 

306

                        self.assertEqual(val[0], db.DB_NOTFOUND)

 

307

                    else :

 

308

                        self.assertEqual(val.args[0], db.DB_NOTFOUND)

306

309

                    if verbose: print val

307

310

                    rec = None

308

311

                else:

323

326

                rec = c.prev()

324

327

            except db.DBNotFoundError, val:

325

328

                if get_raises_error:

326

 

                    self.assertEqual(val[0], db.DB_NOTFOUND)

 

329

                    import sys

 

330

                    if sys.version_info[0] < 3 :

 

331

                        self.assertEqual(val[0], db.DB_NOTFOUND)

 

332

                    else :

 

333

                        self.assertEqual(val.args[0], db.DB_NOTFOUND)

327

334

                    if verbose: print val

328

335

                    rec = None

329

336

                else:

346

353

        try:

347

354

            n = c.set('bad key')

348

355

        except db.DBNotFoundError, val:

349

 

            self.assertEqual(val[0], db.DB_NOTFOUND)

 

356

            import sys

 

357

            if sys.version_info[0] < 3 :

 

358

                self.assertEqual(val[0], db.DB_NOTFOUND)

 

359

            else :

 

360

                self.assertEqual(val.args[0], db.DB_NOTFOUND)

350

361

            if verbose: print val

351

362

        else:

352

363

            if set_raises_error:

360

371

        try:

361

372

            n = c.get_both('0404', 'bad data')

362

373

        except db.DBNotFoundError, val:

363

 

            self.assertEqual(val[0], db.DB_NOTFOUND)

 

374

            import sys

 

375

            if sys.version_info[0] < 3 :

 

376

                self.assertEqual(val[0], db.DB_NOTFOUND)

 

377

            else :

 

378

                self.assertEqual(val.args[0], db.DB_NOTFOUND)

364

379

            if verbose: print val

365

380

        else:

366

381

            if get_raises_error:

389

404

            rec = c.current()

390

405

        except db.DBKeyEmptyError, val:

391

406

            if get_raises_error:

392

 

                self.assertEqual(val[0], db.DB_KEYEMPTY)

 

407

                import sys

 

408

                if sys.version_info[0] < 3 :

 

409

                    self.assertEqual(val[0], db.DB_KEYEMPTY)

 

410

                else :

 

411

                    self.assertEqual(val.args[0], db.DB_KEYEMPTY)

393

412

                if verbose: print val

394

413

            else:

395

414

                self.fail("unexpected DBKeyEmptyError")

434

453

                # a bug may cause a NULL pointer dereference...

435

454

                apply(getattr(c, method), args)

436

455

            except db.DBError, val:

437

 

                self.assertEqual(val[0], 0)

 

456

                import sys

 

457

                if sys.version_info[0] < 3 :

 

458

                    self.assertEqual(val[0], 0)

 

459

                else :

 

460

                    self.assertEqual(val.args[0], 0)

438

461

                if verbose: print val

439

462

            else:

440

463

                self.fail("no exception raised when using a buggy cursor's"

536

559

    #----------------------------------------

537

560

 

538

561

    def test06_Truncate(self):

539

 

        if db.version() < (3,3):

540

 

            # truncate is a feature of Berkeley DB 3.3 and above

541

 

            return

542

 

 

543

562

        d = self.d

544

563

        if verbose:

545

564

            print '\n', '-=' * 30

681

700

        except db.DBIncompleteError:

682

701

            pass

683

702

 

684

 

        if db.version() >= (4,0):

685

 

            statDict = self.env.log_stat(0);

686

 

            self.assert_(statDict.has_key('magic'))

687

 

            self.assert_(statDict.has_key('version'))

688

 

            self.assert_(statDict.has_key('cur_file'))

689

 

            self.assert_(statDict.has_key('region_nowait'))

 

703

        statDict = self.env.log_stat(0);

 

704

        self.assert_(statDict.has_key('magic'))

 

705

        self.assert_(statDict.has_key('version'))

 

706

        self.assert_(statDict.has_key('cur_file'))

 

707

        self.assert_(statDict.has_key('region_nowait'))

690

708

 

691

709

        # must have at least one log file present:

692

710

        logs = self.env.log_archive(db.DB_ARCH_ABS | db.DB_ARCH_LOG)

703

721

    #----------------------------------------

704

722

 

705

723

    def test07_TxnTruncate(self):

706

 

        if db.version() < (3,3):

707

 

            # truncate is a feature of Berkeley DB 3.3 and above

708

 

            return

709

 

 

710

724

        d = self.d

711

725

        if verbose:

712

726

            print '\n', '-=' * 30

812

826

        rec = c.set("dup1")

813

827

        self.assertEqual(rec, ('dup1', 'The'))

814

828

 

815

 

        next = c.next()

816

 

        self.assertEqual(next, ('dup1', 'quick'))

 

829

        next_reg = c.next()

 

830

        self.assertEqual(next_reg, ('dup1', 'quick'))

817

831

 

818

832

        rec = c.set("dup1")

819

833

        count = c.count()

928

942

            if verbose:

929

943

                print rec

930

944

            rec = c3.next()

931

 

        self.assertEqual(count, 52)

 

945

        self.assertEqual(count, len(string.letters))

932

946

 

933

947

 

934

948

        c1.close()

956

970

    envflags = db.DB_THREAD | db.DB_INIT_MPOOL | db.DB_INIT_LOCK

957

971

 

958

972

 

 

973

class PrivateObject(unittest.TestCase) :

 

974

    import sys

 

975

    if sys.version_info[:3] < (2, 4, 0):

 

976

        def assertTrue(self, expr, msg=None):

 

977

            self.failUnless(expr,msg=msg)

 

978

 

 

979

    def tearDown(self) :

 

980

        del self.obj

 

981

 

 

982

    def test01_DefaultIsNone(self) :

 

983

        self.assertEqual(self.obj.get_private(), None)

 

984

 

 

985

    def test02_assignment(self) :

 

986

        a = "example of private object"

 

987

        self.obj.set_private(a)

 

988

        b = self.obj.get_private()

 

989

        self.assertTrue(a is b)  # Object identity

 

990

 

 

991

    def test03_leak_assignment(self) :

 

992

        import sys

 

993

        a = "example of private object"

 

994

        refcount = sys.getrefcount(a)

 

995

        self.obj.set_private(a)

 

996

        self.assertEqual(refcount+1, sys.getrefcount(a))

 

997

        self.obj.set_private(None)

 

998

        self.assertEqual(refcount, sys.getrefcount(a))

 

999

 

 

1000

    def test04_leak_GC(self) :

 

1001

        import sys

 

1002

        a = "example of private object"

 

1003

        refcount = sys.getrefcount(a)

 

1004

        self.obj.set_private(a)

 

1005

        self.obj = None

 

1006

        self.assertEqual(refcount, sys.getrefcount(a))

 

1007

 

 

1008

class DBEnvPrivateObject(PrivateObject) :

 

1009

    def setUp(self) :

 

1010

        self.obj = db.DBEnv()

 

1011

 

 

1012

class DBPrivateObject(PrivateObject) :

 

1013

    def setUp(self) :

 

1014

        self.obj = db.DB()

 

1015

 

 

1016

class CrashAndBurn(unittest.TestCase) :

 

1017

    def test01_OpenCrash(self) :

 

1018

        # See http://bugs.python.org/issue3307

 

1019

        self.assertRaises(db.DBInvalidArgError, db.DB, None, 65535)

 

1020

 

 

1021

 

959

1022

#----------------------------------------------------------------------

960

1023

#----------------------------------------------------------------------

961

1024

 

979

1042

    suite.addTest(unittest.makeSuite(HashDUPWithThreadTestCase))

980

1043

    suite.addTest(unittest.makeSuite(BTreeMultiDBTestCase))

981

1044

    suite.addTest(unittest.makeSuite(HashMultiDBTestCase))

 

1045

    suite.addTest(unittest.makeSuite(DBEnvPrivateObject))

 

1046

    suite.addTest(unittest.makeSuite(DBPrivateObject))

 

1047

    #suite.addTest(unittest.makeSuite(CrashAndBurn))

982

1048

 

983

1049

    return suite

984

1050

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1