From 54df2afaa61c6a03cbb4a33c9b90fa572b6d07b8 Mon Sep 17 00:00:00 2001 From: Jesse Morgan Date: Sat, 17 Dec 2016 21:28:53 -0800 Subject: Berkeley DB 4.8 with rust build script for linux. --- db-4.8.30/test/test119.tcl | 258 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 258 insertions(+) create mode 100644 db-4.8.30/test/test119.tcl (limited to 'db-4.8.30/test/test119.tcl') diff --git a/db-4.8.30/test/test119.tcl b/db-4.8.30/test/test119.tcl new file mode 100644 index 0000000..8ab5154 --- /dev/null +++ b/db-4.8.30/test/test119.tcl @@ -0,0 +1,258 @@ +# See the file LICENSE for redistribution information. +# +# Copyright (c) 2003-2009 Oracle. All rights reserved. +# +# $Id$ +# +# TEST test119 +# TEST Test behavior when Berkeley DB returns DB_BUFFER_SMALL on a cursor. +# TEST +# TEST If the user-supplied buffer is not large enough to contain +# TEST the returned value, DB returns BUFFER_SMALL. If it does, +# TEST check that the cursor does not move -- if it moves, it will +# TEST skip items. [#13815] + +proc test119 { method {tnum "119"} args} { + source ./include.tcl + global alphabet + global errorCode + + set args [convert_args $method $args] + set omethod [convert_method $method] + puts "Test$tnum: $method ($args) Test of DB_BUFFER_SMALL." + + # Skip for queue; it has fixed-length records, so overflowing + # the buffer isn't possible with an ordinary get. + if { [is_queue $method] == 1 } { + puts "Skipping test$tnum for method $method" + return + } + + # If we are using an env, then testfile should just be the db name. + # Otherwise it is the test directory and the name. + set txnenv 0 + set txn "" + set eindex [lsearch -exact $args "-env"] + if { $eindex == -1 } { + set testfile $testdir/test$tnum.db + set env NULL + } else { + set testfile test$tnum.db + incr eindex + set env [lindex $args $eindex] + set txnenv [is_txnenv $env] + if { $txnenv == 1 } { + append args " -auto_commit " + } + set testdir [get_home $env] + } + + cleanup $testdir $env + + puts "\tTest$tnum.a: Set up database." + set db [eval \ + {berkdb_open_noerr -create -mode 0644} $args $omethod $testfile] + error_check_good dbopen [is_valid_db $db] TRUE + + # Test -data_buf_size with db->get. + puts "\tTest$tnum.b: Test db get with -data_buf_size." + set datalength 20 + set data [repeat "a" $datalength] + set key 1 + + if { $txnenv == 1 } { + set t [$env txn] + error_check_good txn [is_valid_txn $t $env] TRUE + set txn "-txn $t" + } + + error_check_good db_put \ + [eval {$db put} $txn {$key [chop_data $method $data]}] 0 + + # A get with data_buf_size equal to the data size should work. + set ret [eval {$db get} $txn -data_buf_size $datalength $key] + error_check_good db_get_key [lindex [lindex $ret 0] 0] $key + error_check_good db_get_data [lindex [lindex $ret 0] 1] $data + + # A get with a data_buf_size decreased by one should fail. + catch {eval {$db get}\ + $txn -data_buf_size [expr $datalength - 1] $key} res + error_check_good buffer_small_error [is_substr $res DB_BUFFER_SMALL] 1 + + # Delete the item so it won't get in the way of the cursor test. + error_check_good db_del [eval {$db del} $txn $key] 0 + if { $txnenv == 1 } { + error_check_good txn_commit [$t commit] 0 + } + + # Test -data_buf_size and -key_buf_size with dbc->get. + # + # Set up a database that includes large and small keys and + # large and small data in various combinations. + # + # Create small buffer equal to the largest page size. This will + # get DB_BUFFER_SMALL errors. + # Create big buffer large enough to never get DB_BUFFER_SMALL + # errors with this data set. + + puts "\tTest$tnum.c:\ + Test cursor get with -data_buf_size and -key_buf_size." + set key $alphabet + set data $alphabet + set nentries 100 + set start 100 + set bigkey [repeat $key 8192] + set bigdata [repeat $data 8192] + set buffer [expr 64 * 1024] + set bigbuf [expr $buffer * 8] + + puts "\tTest$tnum.c1: Populate database." + if { $txnenv == 1 } { + set t [$env txn] + error_check_good txn [is_valid_txn $t $env] TRUE + set txn "-txn $t" + } + + # Put in a big key every X data items, and big data every + # Y data items. X and Y should be small enough that we + # hit the case where both X and Y are big. + set x 5 + set y 7 + for { set i $start } { $i < [expr $nentries + $start] } { incr i } { + # If we have a record-based method, we can't have big keys. + # Just use the count. + if { [is_record_based $method] == 1 } { + set k $i + } else { + if { [expr $i % $x] == 1 } { + set k $i.$bigkey + } else { + set k $i.$key + } + } + + # We can have big data on any method. + if { [expr $i % $y] == 1 } { + set d $i.$bigdata + } else { + set d $i.$data + } + error_check_good db_put \ + [eval {$db put} $txn {$k [chop_data $method $d]}] 0 + } + if { $txnenv == 1 } { + error_check_good txn_commit [$t commit] 0 + } + + # Walk the database with a cursor. When we hit DB_BUFFER_SMALL, + # make sure DB returns the appropriate key/data pair. + puts "\tTest$tnum.c2: Walk the database with a cursor." + if { $txnenv == 1 } { + set t [$env txn] + error_check_good txn [is_valid_txn $t $env] TRUE + set txn "-txn $t" + } + set curs [eval {$db cursor} $txn] + error_check_good cursor [is_valid_cursor $curs $db] TRUE + + # Since hash is not sorted, we'll test that no items are + # skipped by keeping a list of all items retrieved, and + # making sure it is complete and that each item is unique + # at the end of the test. + set hashitems {} + + set count $start + for { set kd [catch {eval $curs get \ + -key_buf_size $buffer -data_buf_size $buffer -first} res] } \ + { $count < [expr $nentries + $start] } \ + { set kd [catch {eval $curs get \ + -key_buf_size $buffer -data_buf_size $buffer -next} res] } { + if { $kd == 1 } { + # Make sure we have the expected error. + error_check_good buffer_small_error \ + [is_substr $errorCode DB_BUFFER_SMALL] 1 + + # Adjust the buffer sizes to fit the big key or data. + if { [expr $count % $x] == 1 } { + set key_buf $bigbuf + } else { + set key_buf $buffer + } + if { [expr $count % $y] == 1 } { + set data_buf $bigbuf + } else { + set data_buf $buffer + } + + # Hash is not sorted, so just make sure we can get + # the item with a large buffer and check it later. + # Likewise for partition callback. + if { [is_hash $method] == 1 || \ + [is_partition_callback $args] == 1} { + set data_buf $bigbuf + set key_buf $bigbuf + } + + # Retrieve with big buffer; there should be no error. + # This also walks the cursor forward. + set nextbig [catch {eval $curs get -key_buf_size \ + $key_buf -data_buf_size $data_buf -next} res] + error_check_good data_big_buffer_get $nextbig 0 + + # Extract the item number. + set key [lindex [lindex $res 0] 0] + set data [lindex [lindex $res 0] 1] + if { [string first . $key] != -1 } { + set keyindex [string first . $key] + set keynumber \ + [string range $key 0 [expr $keyindex - 1]] + } else { + set keynumber $key + } + set dataindex [string first . $data] + set datanumber \ + [string range $data 0 [expr $dataindex - 1]] + + # If not hash, check that item number is correct. + # If hash, save the number for later verification. + if { [is_hash $method] == 0 \ + && [is_partition_callback $args] == 0 } { + error_check_good key_number $keynumber $count + error_check_good data_number $datanumber $count + } else { + lappend hashitems $keynumber + } + } else { + # For hash, save the item numbers of all items + # retrieved, not just those returning DB_BUFFER_SMALL. + if { [is_hash $method] == 1 || \ + [is_partition_callback $args] == 1} { + set key [lindex [lindex $res 0] 0] + set keyindex [string first . $key] + set keynumber \ + [string range $key 0 [expr $keyindex - 1]] + lappend hashitems $keynumber + } + } + incr count + set errorCode NONE + } + error_check_good curs_close [$curs close] 0 + if { $txnenv == 1 } { + error_check_good txn [$t commit] 0 + } + + # Now check the list of items retrieved from hash. + if { [is_hash $method] == 1 || \ + [is_partition_callback $args] == 1} { + set sortedhashitems [lsort $hashitems] + for { set i $start } \ + { $i < [expr $nentries + $start] } { incr i } { + set hashitem \ + [lindex $sortedhashitems [expr $i - $start]] + error_check_good hash_check $hashitem $i + } + } + error_check_good db_close [$db close] 0 +} + -- cgit v1.2.3