1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
|
# See the file LICENSE for redistribution information.
#
# Copyright (c) 1996-2002
# Sleepycat Software. All rights reserved.
#
# $Id: test014.tcl,v 11.24 2002/05/22 15:42:46 sue Exp $
#
# TEST test014
# TEST Exercise partial puts on short data
# TEST Run 5 combinations of numbers of characters to replace,
# TEST and number of times to increase the size by.
# TEST
# TEST Partial put test, small data, replacing with same size. The data set
# TEST consists of the first nentries of the dictionary. We will insert them
# TEST (and retrieve them) as we do in test 1 (equal key/data pairs). Then
# TEST we'll try to perform partial puts of some characters at the beginning,
# TEST some at the end, and some at the middle.
proc test014 { method {nentries 10000} args } {
set fixed 0
set args [convert_args $method $args]
if { [is_fixed_length $method] == 1 } {
set fixed 1
}
puts "Test014: $method ($args) $nentries equal key/data pairs, put test"
# flagp indicates whether this is a postpend or a
# normal partial put
set flagp 0
eval {test014_body $method $flagp 1 1 $nentries} $args
eval {test014_body $method $flagp 1 4 $nentries} $args
eval {test014_body $method $flagp 2 4 $nentries} $args
eval {test014_body $method $flagp 1 128 $nentries} $args
eval {test014_body $method $flagp 2 16 $nentries} $args
if { $fixed == 0 } {
eval {test014_body $method $flagp 0 1 $nentries} $args
eval {test014_body $method $flagp 0 4 $nentries} $args
eval {test014_body $method $flagp 0 128 $nentries} $args
# POST-PENDS :
# partial put data after the end of the existent record
# chars: number of empty spaces that will be padded with null
# increase: is the length of the str to be appended (after pad)
#
set flagp 1
eval {test014_body $method $flagp 1 1 $nentries} $args
eval {test014_body $method $flagp 4 1 $nentries} $args
eval {test014_body $method $flagp 128 1 $nentries} $args
eval {test014_body $method $flagp 1 4 $nentries} $args
eval {test014_body $method $flagp 1 128 $nentries} $args
}
puts "Test014 complete."
}
proc test014_body { method flagp chars increase {nentries 10000} args } {
source ./include.tcl
set omethod [convert_method $method]
if { [is_fixed_length $method] == 1 && $chars != $increase } {
puts "Test014: $method: skipping replace\
$chars chars with string $increase times larger."
return
}
if { $flagp == 1} {
puts "Test014: Postpending string of len $increase with \
gap $chars."
} else {
puts "Test014: Replace $chars chars with string \
$increase times larger"
}
# Create the database and open the dictionary
set txnenv 0
set eindex [lsearch -exact $args "-env"]
#
# If we are using an env, then testfile should just be the db name.
# Otherwise it is the test directory and the name.
if { $eindex == -1 } {
set testfile $testdir/test014.db
set env NULL
} else {
set testfile test014.db
incr eindex
set env [lindex $args $eindex]
set txnenv [is_txnenv $env]
if { $txnenv == 1 } {
append args " -auto_commit "
#
# If we are using txns and running with the
# default, set the default down a bit.
#
if { $nentries == 10000 } {
set nentries 100
}
}
set testdir [get_home $env]
}
set t1 $testdir/t1
set t2 $testdir/t2
set t3 $testdir/t3
cleanup $testdir $env
set db [eval {berkdb_open \
-create -mode 0644} $args {$omethod $testfile}]
error_check_good dbopen [is_valid_db $db] TRUE
set gflags ""
set pflags ""
set txn ""
set count 0
if { [is_record_based $method] == 1 } {
append gflags " -recno"
}
puts "\tTest014.a: put/get loop"
# Here is the loop where we put and get each key/data pair
# We will do the initial put and then three Partial Puts
# for the beginning, middle and end of the string.
set did [open $dict]
while { [gets $did str] != -1 && $count < $nentries } {
if { [is_record_based $method] == 1 } {
set key [expr $count + 1]
} else {
set key $str
}
if { $flagp == 1 } {
# this is for postpend only
global dvals
# initial put
if { $txnenv == 1 } {
set t [$env txn]
error_check_good txn [is_valid_txn $t $env] TRUE
set txn "-txn $t"
}
set ret [eval {$db put} $txn {$key $str}]
if { $txnenv == 1 } {
error_check_good txn [$t commit] 0
}
error_check_good dbput $ret 0
set offset [string length $str]
# increase is the actual number of new bytes
# to be postpended (besides the null padding)
set data [repeat "P" $increase]
# chars is the amount of padding in between
# the old data and the new
set len [expr $offset + $chars + $increase]
set dvals($key) [binary format \
a[set offset]x[set chars]a[set increase] \
$str $data]
set offset [expr $offset + $chars]
if { $txnenv == 1 } {
set t [$env txn]
error_check_good txn [is_valid_txn $t $env] TRUE
set txn "-txn $t"
}
set ret [eval {$db put -partial [list $offset 0]} \
$txn {$key $data}]
error_check_good dbput:post $ret 0
if { $txnenv == 1 } {
error_check_good txn [$t commit] 0
}
} else {
if { $txnenv == 1 } {
set t [$env txn]
error_check_good txn [is_valid_txn $t $env] TRUE
set txn "-txn $t"
}
partial_put $method $db $txn \
$gflags $key $str $chars $increase
if { $txnenv == 1 } {
error_check_good txn [$t commit] 0
}
}
incr count
}
close $did
# Now make sure that everything looks OK
puts "\tTest014.b: check entire file contents"
if { $txnenv == 1 } {
set t [$env txn]
error_check_good txn [is_valid_txn $t $env] TRUE
set txn "-txn $t"
}
dump_file $db $txn $t1 test014.check
if { $txnenv == 1 } {
error_check_good txn [$t commit] 0
}
error_check_good db_close [$db close] 0
# Now compare the keys to see if they match the dictionary (or ints)
if { [is_record_based $method] == 1 } {
set oid [open $t2 w]
for {set i 1} {$i <= $nentries} {set i [incr i]} {
puts $oid $i
}
close $oid
file rename -force $t1 $t3
} else {
set q q
filehead $nentries $dict $t3
filesort $t3 $t2
filesort $t1 $t3
}
error_check_good \
Test014:diff($t3,$t2) [filecmp $t3 $t2] 0
puts "\tTest014.c: close, open, and dump file"
# Now, reopen the file and run the last test again.
open_and_dump_file $testfile $env \
$t1 test014.check dump_file_direction "-first" "-next"
if { [string compare $omethod "-recno"] != 0 } {
filesort $t2 $t3
file rename -force $t3 $t2
filesort $t1 $t3
}
error_check_good \
Test014:diff($t3,$t2) [filecmp $t3 $t2] 0
# Now, reopen the file and run the last test again in the
# reverse direction.
puts "\tTest014.d: close, open, and dump file in reverse direction"
open_and_dump_file $testfile $env $t1 \
test014.check dump_file_direction "-last" "-prev"
if { [string compare $omethod "-recno"] != 0 } {
filesort $t2 $t3
file rename -force $t3 $t2
filesort $t1 $t3
}
error_check_good \
Test014:diff($t3,$t2) [filecmp $t3 $t2] 0
}
# Check function for test014; keys and data are identical
proc test014.check { key data } {
global dvals
error_check_good key"$key"_exists [info exists dvals($key)] 1
error_check_good "data mismatch for key $key" $data $dvals($key)
}
|
