diff options
Diffstat (limited to 'src/third_party/wiredtiger/test/suite/test_util02.py')
| -rw-r--r-- | src/third_party/wiredtiger/test/suite/test_util02.py | 224 |
1 files changed, 224 insertions, 0 deletions
diff --git a/src/third_party/wiredtiger/test/suite/test_util02.py b/src/third_party/wiredtiger/test/suite/test_util02.py new file mode 100644 index 00000000000..51e03d8d105 --- /dev/null +++ b/src/third_party/wiredtiger/test/suite/test_util02.py @@ -0,0 +1,224 @@ +#!/usr/bin/env python +# +# Public Domain 2014-2016 MongoDB, Inc. +# Public Domain 2008-2014 WiredTiger, Inc. +# +# This is free and unencumbered software released into the public domain. +# +# Anyone is free to copy, modify, publish, use, compile, sell, or +# distribute this software, either in source code form or as a compiled +# binary, for any purpose, commercial or non-commercial, and by any +# means. +# +# In jurisdictions that recognize copyright laws, the author or authors +# of this software dedicate any and all copyright interest in the +# software to the public domain. We make this dedication for the benefit +# of the public at large and to the detriment of our heirs and +# successors. We intend this dedication to be an overt act of +# relinquishment in perpetuity of all present and future rights to this +# software under copyright law. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. + +import string, os +import wiredtiger, wttest +from suite_subprocess import suite_subprocess +from wtscenario import check_scenarios +from helper import complex_populate + +# test_util02.py +# Utilities: wt load +class test_util02(wttest.WiredTigerTestCase, suite_subprocess): + """ + Test wt load + """ + + tablename = 'test_util02.a' + tablename2 = 'test_util02.b' + nentries = 1000 + stringclass = ''.__class__ + + scenarios = check_scenarios([ + ('SS', dict(key_format='S',value_format='S')), + ('rS', dict(key_format='r',value_format='S')), + ('ri', dict(key_format='r',value_format='i')), + ('ii', dict(key_format='i',value_format='i')), + ]) + + def get_string(self, i, len): + """ + Return a pseudo-random, but predictable string that uses + all characters. As a special case, key 0 returns all characters + 1-255 repeated + """ + ret = '' + if i == 0: + for j in range (0, len): + # we ensure that there are no internal nulls, that would + # truncate the string when we're using the 'S' encoding + # The last char in a string is null anyway, so that's tested. + ret += chr(j%255 + 1) + else: + for j in range(0, len / 3): + k = i + j + # no internal nulls... + ret += chr(k%255 + 1) + chr((k*3)%255 + 1) + chr((k*7)%255 + 1) + return ret + + def get_key(self, i): + if self.key_format == 'S': + return ("%0.6d" % i) + ':' + self.get_string(i, 20) + elif self.key_format == 'r': + return long(i + 1) + else: + return i + 1 + + def get_value(self, i): + if self.value_format == 'S': + return self.get_string(i, 1000) + else: + # format is 'i' for this test + # return numbers throughout the 2^64 range + if i == 0: + return 0 + else: + if i < 64: + mask = (1 << i) - 1 + else: + mask = 0xffffffffffffffff + # multiply by a large prime get pseudo random bits + n = (i * 48112959837082048697) & mask + if n & 0x8000000000000000 != 0: + n = n - 0x10000000000000000 + return n + + def dumpstr(self, obj, hexoutput): + """ + Return a key or value string formatted just as 'wt dump' would. + Most printable characters (except tab, newline,...) are printed + as is, otherwise, backslash hex is used. + """ + result = '' + if type(obj) == self.stringclass: + for c in s: + if hexoutput: + result += "%0.2x" % ord(c) + elif c == '\\': + result += '\\\\' + elif c == ' ' or \ + (c in string.printable and not c in string.whitespace): + result += c + else: + result += '\\' + "%0.2x" % ord(c) + if hexoutput: + result += '00\n' + else: + result += '\\00\n' + return result + + def table_config(self): + return 'key_format=' + \ + self.key_format + ',value_format=' + self.value_format + + def load_process(self, hexoutput): + params = self.table_config() + self.session.create('table:' + self.tablename, params) + cursor = self.session.open_cursor('table:' + self.tablename, None, None) + for i in range(0, self.nentries): + cursor[self.get_key(i)] = self.get_value(i) + cursor.close() + + dumpargs = ["dump"] + if hexoutput: + dumpargs.append("-x") + dumpargs.append(self.tablename) + self.runWt(dumpargs, outfilename="dump.out") + + # Create a placeholder for the new table. + self.session.create('table:' + self.tablename2, params) + + self.runWt(["load", "-f", "dump.out", "-r", self.tablename2]) + + cursor =\ + self.session.open_cursor('table:' + self.tablename2, None, None) + self.assertEqual(cursor.key_format, self.key_format) + self.assertEqual(cursor.value_format, self.value_format) + i = 0 + for key, val in cursor: + self.assertEqual(key, self.get_key(i)) + self.assertEqual(val, self.get_value(i)) + i += 1 + cursor.close() + + def test_load_process(self): + self.load_process(False) + + def test_load_process_hex(self): + self.load_process(True) + + +# test_load_commandline -- +# Test the command-line processing. +class test_load_commandline(wttest.WiredTigerTestCase, suite_subprocess): + uri = "table:command_line" + + def load_commandline(self, args, fail): + errfile= "errfile" + complex_populate(self, self.uri, "key_format=S,value_format=S", 20) + self.runWt(["dump", self.uri], outfilename="dump.out") + loadargs = ["load", "-f", "dump.out"] + args + self.runWt(loadargs, errfilename=errfile) + if fail: + self.check_non_empty_file(errfile) + else: + self.check_empty_file(errfile) + + # Empty arguments should suceed. + def test_load_commandline_1(self): + self.load_commandline([], 0) + + # Arguments are in pairs. + def test_load_commandline_2(self): + self.load_commandline(["table"], 1) + self.load_commandline([self.uri, "block_allocation=first", self.uri], 1) + + # You can use short-hand URIs for a single object, but cannot match multiple + # objects. + def test_load_commandline_3(self): + self.load_commandline(["table", "block_allocation=first"], 0) + self.load_commandline(["colgroup", "block_allocation=first"], 1) + + # You can't reference non-existent objects. + def test_load_commandline_4(self): + self.load_commandline([self.uri, "block_allocation=first"], 0) + self.load_commandline(["table:bar", "block_allocation=first"], 1) + + # You can specify multipleconfiguration arguments for the same object. + def test_load_commandline_5(self): + self.load_commandline([ + self.uri, "block_allocation=first", + self.uri, "block_allocation=best", + self.uri, "block_allocation=first", + self.uri, "block_allocation=best"], 0) + + # You can't modify a format. + def test_load_commandline_6(self): + self.load_commandline(["table", "key_format=d"], 1) + self.load_commandline(["table", "value_format=d"], 1) + + # You can set the source or version, but it gets stripped; confirm the + # attempt succeeds, so we know they configuration values are stripped. + def test_load_commandline_7(self): + self.load_commandline(["table", "filename=bar"], 0) + self.load_commandline(["table", "source=bar"], 0) + self.load_commandline(["table", "version=(100,200)"], 0) + + +if __name__ == '__main__': + wttest.run() |