prompt
large_stringlengths
72
9.34k
completion
large_stringlengths
0
7.61k
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): <|fim_middle|> def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
try: os.remove(self.filename) except os.error: pass
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): <|fim_middle|> def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
self.do_bthash_test(btopen, 'btopen')
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): <|fim_middle|> def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
self.do_bthash_test(hashopen, 'hashopen')
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): <|fim_middle|> def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close()
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): <|fim_middle|> self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
rec = f[15]
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): <|fim_middle|> self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
rec = f['a string']
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): <|fim_middle|> def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
f = hashopen(self.filename, 'n') f.close()
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): <|fim_middle|> #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close()
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): <|fim_middle|> self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
rec = f['no such key']
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): <|fim_middle|> self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
rec = f[15]
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): <|fim_middle|> if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
return unittest.makeSuite(CompatibilityTestCase)
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: <|fim_middle|> f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print "\nTesting: rnopen"
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: <|fim_middle|> assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print '%s %s %s' % getTest
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: <|fim_middle|> try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print rec
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: <|fim_middle|> f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print '\nTesting: ', what
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: <|fim_middle|> # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print 'creation...'
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: <|fim_middle|> else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
if verbose: print "truth test: true"
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: <|fim_middle|> else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print "truth test: true"
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: <|fim_middle|> f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
if verbose: print "truth test: false"
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: <|fim_middle|> f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print "truth test: false"
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: <|fim_middle|> if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print '%s %s %s' % (f['a'], f['b'], f['c'])
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: <|fim_middle|> f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print 'key ordering...'
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: <|fim_middle|> assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print rec
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: <|fim_middle|> else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
if verbose: print "truth test: true"
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: <|fim_middle|> else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print "truth test: true"
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: <|fim_middle|> except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
if verbose: print "truth test: false"
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: <|fim_middle|> except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print "truth test: false"
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: <|fim_middle|> del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
self.fail("Exception expected")
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: <|fim_middle|> f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print 'modification...'
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: <|fim_middle|> for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print 'access...'
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: <|fim_middle|> def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
print word
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': <|fim_middle|> <|fim▁end|>
unittest.main(defaultTest='test_suite')
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def <|fim_middle|>(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
setUp
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def <|fim_middle|>(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
tearDown
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def <|fim_middle|>(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
test01_btopen
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def <|fim_middle|>(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
test02_hashopen
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def <|fim_middle|>(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
test03_rnopen
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def <|fim_middle|>(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
noRec
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def <|fim_middle|>(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
badKey
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def <|fim_middle|>(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
test04_n_flag
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def <|fim_middle|>(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
do_bthash_test
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def <|fim_middle|>(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
noRec
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def <|fim_middle|>(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def test_suite(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
badKey
<|file_name|>test_compat.py<|end_file_name|><|fim▁begin|>""" Test cases adapted from the test_bsddb.py module in Python's regression test suite. """ import sys, os, string import unittest import tempfile from test_all import verbose try: # For Python 2.3 from bsddb import db, hashopen, btopen, rnopen except ImportError: # For earlier Pythons w/distutils pybsddb from bsddb3 import db, hashopen, btopen, rnopen class CompatibilityTestCase(unittest.TestCase): def setUp(self): self.filename = tempfile.mktemp() def tearDown(self): try: os.remove(self.filename) except os.error: pass def test01_btopen(self): self.do_bthash_test(btopen, 'btopen') def test02_hashopen(self): self.do_bthash_test(hashopen, 'hashopen') def test03_rnopen(self): data = string.split("The quick brown fox jumped over the lazy dog.") if verbose: print "\nTesting: rnopen" f = rnopen(self.filename, 'c') for x in range(len(data)): f[x+1] = data[x] getTest = (f[1], f[2], f[3]) if verbose: print '%s %s %s' % getTest assert getTest[1] == 'quick', 'data mismatch!' f[25] = 'twenty-five' f.close() del f f = rnopen(self.filename, 'w') f[20] = 'twenty' def noRec(f): rec = f[15] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f['a string'] self.assertRaises(TypeError, badKey, f) del f[3] rec = f.first() while rec: if verbose: print rec try: rec = f.next() except KeyError: break f.close() def test04_n_flag(self): f = hashopen(self.filename, 'n') f.close() def do_bthash_test(self, factory, what): if verbose: print '\nTesting: ', what f = factory(self.filename, 'c') if verbose: print 'creation...' # truth test if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" f['0'] = '' f['a'] = 'Guido' f['b'] = 'van' f['c'] = 'Rossum' f['d'] = 'invented' f['f'] = 'Python' if verbose: print '%s %s %s' % (f['a'], f['b'], f['c']) if verbose: print 'key ordering...' f.set_location(f.first()[0]) while 1: try: rec = f.next() except KeyError: assert rec == f.last(), 'Error, last <> last!' f.previous() break if verbose: print rec assert f.has_key('f'), 'Error, missing key!' f.sync() f.close() # truth test try: if f: if verbose: print "truth test: true" else: if verbose: print "truth test: false" except db.DBError: pass else: self.fail("Exception expected") del f if verbose: print 'modification...' f = factory(self.filename, 'w') f['d'] = 'discovered' if verbose: print 'access...' for key in f.keys(): word = f[key] if verbose: print word def noRec(f): rec = f['no such key'] self.assertRaises(KeyError, noRec, f) def badKey(f): rec = f[15] self.assertRaises(TypeError, badKey, f) f.close() #---------------------------------------------------------------------- def <|fim_middle|>(): return unittest.makeSuite(CompatibilityTestCase) if __name__ == '__main__': unittest.main(defaultTest='test_suite') <|fim▁end|>
test_suite
<|file_name|>choices.py<|end_file_name|><|fim▁begin|># Add your own choices here! <|fim▁hole|>situations = {"fruit":fruit, "lunch":lunch}<|fim▁end|>
fruit = ["apples", "oranges", "pears", "grapes", "blueberries"] lunch = ["pho", "timmies", "thai", "burgers", "buffet!", "indian", "montanas"]
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass<|fim▁hole|> if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test()<|fim▁end|>
def f(v, i, j, k):
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): <|fim_middle|> def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
if x == 0: return 0 return 1
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): <|fim_middle|> def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
if x == 0: pass
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): <|fim_middle|> def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): <|fim_middle|> @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
if code == 0: return f(r1, r2, r3, r4) return 0
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): <|fim_middle|> test() <|fim▁end|>
assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0)
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: <|fim_middle|> return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
return 0
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: <|fim_middle|> def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
pass
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: <|fim_middle|> elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
return v
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: <|fim_middle|> elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
return v
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: <|fim_middle|> elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
h(g(j) + g(k)) return v
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: <|fim_middle|> else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
for m in range(j): v += 2 return v
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: <|fim_middle|> def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
for n in range(i): v += 1 return v
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: <|fim_middle|> return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
return f(r1, r2, r3, r4)
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def <|fim_middle|>(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
g
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def <|fim_middle|>(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
h
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def <|fim_middle|>(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
f
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def <|fim_middle|>(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def test(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
if28
<|file_name|>if28.py<|end_file_name|><|fim▁begin|>from polyphony import testbench def g(x): if x == 0: return 0 return 1 def h(x): if x == 0: pass def f(v, i, j, k): if i == 0: return v elif i == 1: return v elif i == 2: h(g(j) + g(k)) return v elif i == 3: for m in range(j): v += 2 return v else: for n in range(i): v += 1 return v def if28(code, r1, r2, r3, r4): if code == 0: return f(r1, r2, r3, r4) return 0 @testbench def <|fim_middle|>(): assert 1 == if28(0, 1, 1, 0, 0) assert 2 == if28(0, 2, 0, 0, 0) assert 3 == if28(0, 3, 1, 0, 0) assert 4 == if28(0, 4, 2, 0, 0) assert 5 == if28(0, 5, 2, 1, 1) assert 6 == if28(0, 6, 2, 2, 2) assert 7 == if28(0, 7, 3, 0, 0) assert 10 == if28(0, 8, 3, 1, 1) assert 13 == if28(0, 9, 3, 2, 2) assert 14 == if28(0, 10, 4, 0, 0) test() <|fim▁end|>
test
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object):<|fim▁hole|> def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b)<|fim▁end|>
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): <|fim_middle|> @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
def get_devices(self): return psutil.net_io_counters(pernic=True).keys()
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): <|fim_middle|> @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
return psutil.net_io_counters(pernic=True).keys()
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): <|fim_middle|> @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): <|fim_middle|> def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
return self.interfaces.values()
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): <|fim_middle|> def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
pass
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): <|fim_middle|> @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
pass
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): <|fim_middle|> @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
def apply(self): pass
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): <|fim_middle|> @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
pass
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): <|fim_middle|> class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
cls = 'unknown' iface = None title = 'Unknown' typeid = 'box'
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): <|fim_middle|> <|fim▁end|>
def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b)
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): <|fim_middle|> def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): <|fim_middle|> def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
if idx in self.params: return self.params[idx] else: return ''
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): <|fim_middle|> def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
self.params[idx] = val
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): <|fim_middle|> <|fim▁end|>
for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b)
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: <|fim_middle|> else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
return self.params[idx]
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: <|fim_middle|> def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
return ''
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: <|fim_middle|> <|fim▁end|>
b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b)
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def <|fim_middle|>(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
get_devices
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def <|fim_middle|>(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
interface_list
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def <|fim_middle|>(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
rescan
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def <|fim_middle|>(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
save
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def <|fim_middle|>(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
apply
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def <|fim_middle|>(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
__init__
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def <|fim_middle|>(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
__getitem__
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def <|fim_middle|>(self, idx, val): self.params[idx] = val def add_bits(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
__setitem__
<|file_name|>api.py<|end_file_name|><|fim▁begin|>import psutil from ajenti.api import * from ajenti.ui import * @plugin class NetworkManager (BasePlugin): def get_devices(self): return psutil.net_io_counters(pernic=True).keys() @interface class INetworkConfig (object): interfaces = {} @property def interface_list(self): return self.interfaces.values() def rescan(self): pass def save(self): pass @interface class INetworkConfigBit (object): def apply(self): pass @plugin class NetworkConfigBit (UIElement, INetworkConfigBit): cls = 'unknown' iface = None title = 'Unknown' typeid = 'box' class NetworkInterface(object): def __init__(self): self.up = False self.auto = False self.name = '' self.devclass = '' self.addressing = 'static' self.bits = [] self.params = {'address': '0.0.0.0'} self.type = '' self.editable = True def __getitem__(self, idx): if idx in self.params: return self.params[idx] else: return '' def __setitem__(self, idx, val): self.params[idx] = val def <|fim_middle|>(self, ui): for cls in INetworkConfigBit.get_classes(): if cls.cls in self.bit_classes: b = cls.new(ui) b.iface = self b.refresh() self.bits.append(b) <|fim▁end|>
add_bits
<|file_name|>ipc_lista4.01.py<|end_file_name|><|fim▁begin|># #Programa Lista 4, questão 1; #Felipe Henrique Bastos Costa - 1615310032; # # # # <|fim▁hole|>cont1 = 0#contador do indice; cont2 = 1#contador da posição do numero, se é o primeiro, segundo etc; v = 5#representaria o len da lista; while(cont1 < v): x = int(input("Informe o %dº numero inteiro para colocar em sua lista:\n"%cont2))#x e a variavel que recebe #o numero do usuario lista.append(x)#o numero informado para x e colocado dentro da lista; cont1+=1#Os contadores estao cont2+=1#sendo incrementados; print("A lista de informada foi:\n%s"%lista)<|fim▁end|>
lista = []#lista vazia;
<|file_name|>bolly.py<|end_file_name|><|fim▁begin|>#! /usr/bin/env python3 from bollinger import bands, plot, strategies import argparse parser = argparse.ArgumentParser(description="plots bollinger bands or suggests investments", epilog="example: bolly.py plot AMZN FB") parser.add_argument("action", metavar="ACTION", choices=["plot", "suggest"], help="either plot or suggest") parser.add_argument("symbols", metavar="SYMBOL", nargs="+", help="stock symbols") parser.add_argument("-s", "--strategy", choices=["uponce", "downonce", "moreup", "moredown"], default="moredown", help="selects invesment strategy") args = parser.parse_args() if args.action == "plot": for symbol in args.symbols: print("plot [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: p = plot.Plot(b) p.save()<|fim▁hole|> print("FAIL: (%s)"%(ex)) if args.action == "suggest": for symbol in args.symbols: print("suggest [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: if args.strategy == "uponce": s = strategies.UpOnce(b) elif args.strategy == "downonce": s = strategies.DownOnce(b) elif args.strategy == "moreup": s = strategies.MoreUp(b) elif args.strategy == "moredown": s = strategies.MoreDown(b) print("YES" if s.invest() else "NO") except Exception as ex: print("FAIL: (%s)"%(ex))<|fim▁end|>
print("OK") except Exception as ex:
<|file_name|>bolly.py<|end_file_name|><|fim▁begin|>#! /usr/bin/env python3 from bollinger import bands, plot, strategies import argparse parser = argparse.ArgumentParser(description="plots bollinger bands or suggests investments", epilog="example: bolly.py plot AMZN FB") parser.add_argument("action", metavar="ACTION", choices=["plot", "suggest"], help="either plot or suggest") parser.add_argument("symbols", metavar="SYMBOL", nargs="+", help="stock symbols") parser.add_argument("-s", "--strategy", choices=["uponce", "downonce", "moreup", "moredown"], default="moredown", help="selects invesment strategy") args = parser.parse_args() if args.action == "plot": <|fim_middle|> if args.action == "suggest": for symbol in args.symbols: print("suggest [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: if args.strategy == "uponce": s = strategies.UpOnce(b) elif args.strategy == "downonce": s = strategies.DownOnce(b) elif args.strategy == "moreup": s = strategies.MoreUp(b) elif args.strategy == "moredown": s = strategies.MoreDown(b) print("YES" if s.invest() else "NO") except Exception as ex: print("FAIL: (%s)"%(ex)) <|fim▁end|>
for symbol in args.symbols: print("plot [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: p = plot.Plot(b) p.save() print("OK") except Exception as ex: print("FAIL: (%s)"%(ex))
<|file_name|>bolly.py<|end_file_name|><|fim▁begin|>#! /usr/bin/env python3 from bollinger import bands, plot, strategies import argparse parser = argparse.ArgumentParser(description="plots bollinger bands or suggests investments", epilog="example: bolly.py plot AMZN FB") parser.add_argument("action", metavar="ACTION", choices=["plot", "suggest"], help="either plot or suggest") parser.add_argument("symbols", metavar="SYMBOL", nargs="+", help="stock symbols") parser.add_argument("-s", "--strategy", choices=["uponce", "downonce", "moreup", "moredown"], default="moredown", help="selects invesment strategy") args = parser.parse_args() if args.action == "plot": for symbol in args.symbols: print("plot [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: p = plot.Plot(b) p.save() print("OK") except Exception as ex: print("FAIL: (%s)"%(ex)) if args.action == "suggest": <|fim_middle|> <|fim▁end|>
for symbol in args.symbols: print("suggest [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: if args.strategy == "uponce": s = strategies.UpOnce(b) elif args.strategy == "downonce": s = strategies.DownOnce(b) elif args.strategy == "moreup": s = strategies.MoreUp(b) elif args.strategy == "moredown": s = strategies.MoreDown(b) print("YES" if s.invest() else "NO") except Exception as ex: print("FAIL: (%s)"%(ex))
<|file_name|>bolly.py<|end_file_name|><|fim▁begin|>#! /usr/bin/env python3 from bollinger import bands, plot, strategies import argparse parser = argparse.ArgumentParser(description="plots bollinger bands or suggests investments", epilog="example: bolly.py plot AMZN FB") parser.add_argument("action", metavar="ACTION", choices=["plot", "suggest"], help="either plot or suggest") parser.add_argument("symbols", metavar="SYMBOL", nargs="+", help="stock symbols") parser.add_argument("-s", "--strategy", choices=["uponce", "downonce", "moreup", "moredown"], default="moredown", help="selects invesment strategy") args = parser.parse_args() if args.action == "plot": for symbol in args.symbols: print("plot [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: p = plot.Plot(b) p.save() print("OK") except Exception as ex: print("FAIL: (%s)"%(ex)) if args.action == "suggest": for symbol in args.symbols: print("suggest [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: if args.strategy == "uponce": <|fim_middle|> elif args.strategy == "downonce": s = strategies.DownOnce(b) elif args.strategy == "moreup": s = strategies.MoreUp(b) elif args.strategy == "moredown": s = strategies.MoreDown(b) print("YES" if s.invest() else "NO") except Exception as ex: print("FAIL: (%s)"%(ex)) <|fim▁end|>
s = strategies.UpOnce(b)
<|file_name|>bolly.py<|end_file_name|><|fim▁begin|>#! /usr/bin/env python3 from bollinger import bands, plot, strategies import argparse parser = argparse.ArgumentParser(description="plots bollinger bands or suggests investments", epilog="example: bolly.py plot AMZN FB") parser.add_argument("action", metavar="ACTION", choices=["plot", "suggest"], help="either plot or suggest") parser.add_argument("symbols", metavar="SYMBOL", nargs="+", help="stock symbols") parser.add_argument("-s", "--strategy", choices=["uponce", "downonce", "moreup", "moredown"], default="moredown", help="selects invesment strategy") args = parser.parse_args() if args.action == "plot": for symbol in args.symbols: print("plot [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: p = plot.Plot(b) p.save() print("OK") except Exception as ex: print("FAIL: (%s)"%(ex)) if args.action == "suggest": for symbol in args.symbols: print("suggest [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: if args.strategy == "uponce": s = strategies.UpOnce(b) elif args.strategy == "downonce": <|fim_middle|> elif args.strategy == "moreup": s = strategies.MoreUp(b) elif args.strategy == "moredown": s = strategies.MoreDown(b) print("YES" if s.invest() else "NO") except Exception as ex: print("FAIL: (%s)"%(ex)) <|fim▁end|>
s = strategies.DownOnce(b)
<|file_name|>bolly.py<|end_file_name|><|fim▁begin|>#! /usr/bin/env python3 from bollinger import bands, plot, strategies import argparse parser = argparse.ArgumentParser(description="plots bollinger bands or suggests investments", epilog="example: bolly.py plot AMZN FB") parser.add_argument("action", metavar="ACTION", choices=["plot", "suggest"], help="either plot or suggest") parser.add_argument("symbols", metavar="SYMBOL", nargs="+", help="stock symbols") parser.add_argument("-s", "--strategy", choices=["uponce", "downonce", "moreup", "moredown"], default="moredown", help="selects invesment strategy") args = parser.parse_args() if args.action == "plot": for symbol in args.symbols: print("plot [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: p = plot.Plot(b) p.save() print("OK") except Exception as ex: print("FAIL: (%s)"%(ex)) if args.action == "suggest": for symbol in args.symbols: print("suggest [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: if args.strategy == "uponce": s = strategies.UpOnce(b) elif args.strategy == "downonce": s = strategies.DownOnce(b) elif args.strategy == "moreup": <|fim_middle|> elif args.strategy == "moredown": s = strategies.MoreDown(b) print("YES" if s.invest() else "NO") except Exception as ex: print("FAIL: (%s)"%(ex)) <|fim▁end|>
s = strategies.MoreUp(b)
<|file_name|>bolly.py<|end_file_name|><|fim▁begin|>#! /usr/bin/env python3 from bollinger import bands, plot, strategies import argparse parser = argparse.ArgumentParser(description="plots bollinger bands or suggests investments", epilog="example: bolly.py plot AMZN FB") parser.add_argument("action", metavar="ACTION", choices=["plot", "suggest"], help="either plot or suggest") parser.add_argument("symbols", metavar="SYMBOL", nargs="+", help="stock symbols") parser.add_argument("-s", "--strategy", choices=["uponce", "downonce", "moreup", "moredown"], default="moredown", help="selects invesment strategy") args = parser.parse_args() if args.action == "plot": for symbol in args.symbols: print("plot [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: p = plot.Plot(b) p.save() print("OK") except Exception as ex: print("FAIL: (%s)"%(ex)) if args.action == "suggest": for symbol in args.symbols: print("suggest [ %s ]: " %(symbol), end="") b = bands.Bands(symbol) b.fetch() try: if args.strategy == "uponce": s = strategies.UpOnce(b) elif args.strategy == "downonce": s = strategies.DownOnce(b) elif args.strategy == "moreup": s = strategies.MoreUp(b) elif args.strategy == "moredown": <|fim_middle|> print("YES" if s.invest() else "NO") except Exception as ex: print("FAIL: (%s)"%(ex)) <|fim▁end|>
s = strategies.MoreDown(b)
<|file_name|>is_near_arterial.py<|end_file_name|><|fim▁begin|># Opus/UrbanSim urban simulation software. # Copyright (C) 2005-2009 University of Washington # See opus_core/LICENSE from opus_core.variables.variable import Variable from variable_functions import my_attribute_label from urbansim.length_constants import UrbanSimLength, UrbanSimLengthConstants from numpy import array class is_near_arterial(Variable): """Boolean indicating if this gridcell is near an arterial, as specified by the arterial threshold (a constant). Distance is assumed to be measured from the "border" of the gridcell.""" distance_to_arterial = "distance_to_arterial" def dependencies(self): return [my_attribute_label(self.distance_to_arterial)] def compute(self, dataset_pool): return get_is_near_arterial(self.get_dataset().get_attribute(self.distance_to_arterial), dataset_pool.get_dataset('urbansim_constant')) def post_check(self, values, dataset_pool): self.do_check("x == False or x == True", values) def get_is_near_arterial(distance, urbansim_constant): length = UrbanSimLength(distance, urbansim_constant["gridcell_width"].units) return length.less_than(urbansim_constant["near_arterial_threshold_unit"]) from opus_core.tests import opus_unittest from opus_core.tests.utils.variable_tester import VariableTester from numpy import array class Tests(opus_unittest.OpusTestCase): def test_my_inputs( self ): # Assumes distance is measured from the gridcell border to the arterial. tester = VariableTester( __file__, package_order=['urbansim'], test_data={ 'gridcell':{ 'grid_id': array([1,2,3,4,5,6]), 'distance_to_arterial': array([0.0, 50.0, 99.0, 100.0, 101.0, 200.0]), }, 'urbansim_constant':{ 'cell_size': array([150]), 'near_arterial_threshold': array([100]), 'units': array(['meters']), } } ) should_be = array( [True, True, True, False, False, False] ) tester.test_is_equal_for_variable_defined_by_this_module(self, should_be) <|fim▁hole|> if __name__=='__main__': opus_unittest.main()<|fim▁end|>