queue.t

berkeleyDB,强大的嵌入式数据,多个数据库的内核

#!./perl -w

# ID: %I%, %G%   

use strict ;

BEGIN {
    unless(grep /blib/, @INC) {
        chdir 't' if -d 't';
        @INC = '../lib' if -d '../lib';
    }
}

use BerkeleyDB; 
use t::util ;

BEGIN 
{
    if ($BerkeleyDB::db_version < 3.3) {
	print "1..0 # Skip: Queue needs Berkeley DB 3.3.x or better\n" ;
	exit 0 ;
    }
}    

print "1..200\n";

my $Dfile = "dbhash.tmp";
my $Dfile2 = "dbhash2.tmp";
my $Dfile3 = "dbhash3.tmp";
unlink $Dfile;

umask(0) ;


# Check for invalid parameters
{
    # Check for invalid parameters
    my $db ;
    eval ' $db = new BerkeleyDB::Queue  -Stupid => 3 ; ' ;
    ok 1, $@ =~ /unknown key value\(s\) Stupid/  ;

    eval ' $db = new BerkeleyDB::Queue -Bad => 2, -Mode => 0345, -Stupid => 3; ' ;
    ok 2, $@ =~ /unknown key value\(s\) /  ;

    eval ' $db = new BerkeleyDB::Queue -Env => 2 ' ;
    ok 3, $@ =~ /^Env not of type BerkeleyDB::Env/ ;

    eval ' $db = new BerkeleyDB::Queue -Txn => "x" ' ;
    ok 4, $@ =~ /^Txn not of type BerkeleyDB::Txn/ ;

    my $obj = bless [], "main" ;
    eval ' $db = new BerkeleyDB::Queue -Env => $obj ' ;
    ok 5, $@ =~ /^Env not of type BerkeleyDB::Env/ ;
}

# Now check the interface to Queue

{
    my $lex = new LexFile $Dfile ;
    my $rec_len = 10 ;
    my $pad = "x" ;

    ok 6, my $db = new BerkeleyDB::Queue -Filename => $Dfile, 
				    -Flags    => DB_CREATE,
				    -Len      => $rec_len,
				    -Pad      => $pad;

    # Add a k/v pair
    my $value ;
    my $status ;
    ok 7, $db->db_put(1, "some value") == 0  ;
    ok 8, $db->status() == 0 ;
    ok 9, $db->db_get(1, $value) == 0 ;
    ok 10, $value eq fillout("some value", $rec_len, $pad) ;
    ok 11, $db->db_put(2, "value") == 0  ;
    ok 12, $db->db_get(2, $value) == 0 ;
    ok 13, $value eq fillout("value", $rec_len, $pad) ;
    ok 14, $db->db_put(3, "value") == 0  ;
    ok 15, $db->db_get(3, $value) == 0 ;
    ok 16, $value eq fillout("value", $rec_len, $pad) ;
    ok 17, $db->db_del(2) == 0 ;
    ok 18, ($status = $db->db_get(2, $value)) == DB_KEYEMPTY ;
    ok 19, $db->status() == DB_KEYEMPTY ;
    ok 20, $db->status() eq $DB_errors{'DB_KEYEMPTY'} ;

    ok 21, ($status = $db->db_get(7, $value)) == DB_NOTFOUND ;
    ok 22, $db->status() == DB_NOTFOUND ;
    ok 23, $db->status() eq $DB_errors{'DB_NOTFOUND'} ;

    ok 24, $db->db_sync() == 0 ;

    # Check NOOVERWRITE will make put fail when attempting to overwrite
    # an existing record.

    ok 25, $db->db_put( 1, 'x', DB_NOOVERWRITE) == DB_KEYEXIST ;
    ok 26, $db->status() eq $DB_errors{'DB_KEYEXIST'} ;
    ok 27, $db->status() == DB_KEYEXIST ;


    # check that the value of the key  has not been changed by the
    # previous test
    ok 28, $db->db_get(1, $value) == 0 ;
    ok 29, $value eq fillout("some value", $rec_len, $pad) ;


}


{
    # Check simple env works with a array.
    # and pad defaults to space
    my $lex = new LexFile $Dfile ;

    my $home = "./fred" ;
    my $rec_len = 11 ;
    ok 30, my $lexD = new LexDir($home);

    ok 31, my $env = new BerkeleyDB::Env -Flags => DB_CREATE|DB_INIT_MPOOL,@StdErrFile,
    					 -Home => $home ;
    ok 32, my $db = new BerkeleyDB::Queue -Filename => $Dfile, 
				    -Env      => $env,
				    -Flags    => DB_CREATE,
				    -Len      => $rec_len;

    # Add a k/v pair
    my $value ;
    ok 33, $db->db_put(1, "some value") == 0 ;
    ok 34, $db->db_get(1, $value) == 0 ;
    ok 35, $value eq fillout("some value", $rec_len)  ;
    undef $db ;
    undef $env ;
}

 
{
    # cursors

    my $lex = new LexFile $Dfile ;
    my @array ;
    my ($k, $v) ;
    my $rec_len = 5 ;
    ok 36, my $db = new BerkeleyDB::Queue -Filename  => $Dfile, 
				    	  -ArrayBase => 0,
				    	  -Flags     => DB_CREATE ,
				    	  -Len       => $rec_len;

    # create some data
    my @data =  (
		"red"	,
		"green"	,
		"blue"	,
		) ;

    my $i ;
    my %data ;
    my $ret = 0 ;
    for ($i = 0 ; $i < @data ; ++$i) {
        $ret += $db->db_put($i, $data[$i]) ;
	$data{$i} = $data[$i] ;
    }
    ok 37, $ret == 0 ;

    # create the cursor
    ok 38, my $cursor = $db->db_cursor() ;

    $k = 0 ; $v = "" ;
    my %copy = %data;
    my $extras = 0 ;
    # sequence forwards
    while ($cursor->c_get($k, $v, DB_NEXT) == 0) 
    {
        if ( fillout($copy{$k}, $rec_len) eq $v ) 
            { delete $copy{$k} }
	else
	    { ++ $extras }
    }

    ok 39, $cursor->status() == DB_NOTFOUND ;
    ok 40, $cursor->status() eq $DB_errors{'DB_NOTFOUND'} ;
    ok 41, keys %copy == 0 ;
    ok 42, $extras == 0 ;

    # sequence backwards
    %copy = %data ;
    $extras = 0 ;
    my $status ;
    for ( $status = $cursor->c_get($k, $v, DB_LAST) ;
	  $status == 0 ;
    	  $status = $cursor->c_get($k, $v, DB_PREV)) {
        if ( fillout($copy{$k}, $rec_len) eq $v ) 
            { delete $copy{$k} }
	else
	    { ++ $extras }
    }
    ok 43, $status == DB_NOTFOUND ;
    ok 44, $status eq $DB_errors{'DB_NOTFOUND'} ;
    ok 45, $cursor->status() == $status ;
    ok 46, $cursor->status() eq $status ;
    ok 47, keys %copy == 0 ;
    ok 48, $extras == 0 ;
}
 
{
    # Tied Array interface

    my $lex = new LexFile $Dfile ;
    my @array ;
    my $db ;
    my $rec_len = 10 ;
    ok 49, $db = tie @array, 'BerkeleyDB::Queue', -Filename  => $Dfile,
				    	    -ArrayBase => 0,
                                            -Flags     => DB_CREATE ,
				    	    -Len       => $rec_len;

    ok 50, my $cursor = (tied @array)->db_cursor() ;
    # check the database is empty
    my $count = 0 ;
    my ($k, $v) = (0,"") ;
    while ($cursor->c_get($k, $v, DB_NEXT) == 0) {
	++ $count ;
    }
    ok 51, $cursor->status() == DB_NOTFOUND ;
    ok 52, $count == 0 ;

    ok 53, @array == 0 ;

    # Add a k/v pair
    my $value ;
    $array[1] = "some value";
    ok 54, (tied @array)->status() == 0 ;
    ok 55, $array[1] eq fillout("some value", $rec_len);
    ok 56, defined $array[1];
    ok 57, (tied @array)->status() == 0 ;
    ok 58, !defined $array[3];
    ok 59, (tied @array)->status() == DB_NOTFOUND ;

    $array[1] = 2 ;
    $array[10] = 20 ;
    $array[1000] = 2000 ;

    my ($keys, $values) = (0,0);
    $count = 0 ;
    for ( my $status = $cursor->c_get($k, $v, DB_FIRST) ;
	  $status == 0 ;
    	  $status = $cursor->c_get($k, $v, DB_NEXT)) {
        $keys += $k ;
	$values += $v ;
	++ $count ;
    }
    ok 60, $count == 3 ;
    ok 61, $keys == 1011 ;
    ok 62, $values == 2022 ;

    # unshift isn't allowed
#    eval {
#    	$FA ? unshift @array, "red", "green", "blue" 
#        : $db->unshift("red", "green", "blue" ) ;
#	} ;
#    ok 64, $@ =~ /^unshift is unsupported with Queue databases/ ;	
    $array[0] = "red" ;
    $array[1] = "green" ;
    $array[2] = "blue" ;
    $array[4] = 2 ;
    ok 63, $array[0] eq fillout("red", $rec_len) ;
    ok 64, $cursor->c_get($k, $v, DB_FIRST) == 0 ;
    ok 65, $k == 0 ;
    ok 66, $v eq fillout("red", $rec_len) ;
    ok 67, $array[1] eq fillout("green", $rec_len) ;
    ok 68, $cursor->c_get($k, $v, DB_NEXT) == 0 ;
    ok 69, $k == 1 ;
    ok 70, $v eq fillout("green", $rec_len) ;
    ok 71, $array[2] eq fillout("blue", $rec_len) ;
    ok 72, $cursor->c_get($k, $v, DB_NEXT) == 0 ;
    ok 73, $k == 2 ;
    ok 74, $v eq fillout("blue", $rec_len) ;
    ok 75, $array[4] == 2 ;
    ok 76, $cursor->c_get($k, $v, DB_NEXT) == 0 ;
    ok 77, $k == 4 ;
    ok 78, $v == 2 ;

    # shift
    ok 79, ($FA ? shift @array : $db->shift()) eq fillout("red", $rec_len) ;
    ok 80, ($FA ? shift @array : $db->shift()) eq fillout("green", $rec_len) ;
    ok 81, ($FA ? shift @array : $db->shift()) eq fillout("blue", $rec_len) ;
    ok 82, ($FA ? shift @array : $db->shift()) == 2 ;

    # push
    $FA ? push @array, "the", "end" 
        : $db->push("the", "end") ;
    ok 83, $cursor->c_get($k, $v, DB_LAST) == 0 ;
    ok 84, $k == 1002 ;
    ok 85, $v eq fillout("end", $rec_len) ;
    ok 86, $cursor->c_get($k, $v, DB_PREV) == 0 ;
    ok 87, $k == 1001 ;
    ok 88, $v eq fillout("the", $rec_len) ;
    ok 89, $cursor->c_get($k, $v, DB_PREV) == 0 ;
    ok 90, $k == 1000 ;
    ok 91, $v == 2000 ;

    # pop
    ok 92, ( $FA ? pop @array : $db->pop ) eq fillout("end", $rec_len) ;
    ok 93, ( $FA ? pop @array : $db->pop ) eq fillout("the", $rec_len) ;
    ok 94, ( $FA ? pop @array : $db->pop ) == 2000  ;

    # now clear the array 
    $FA ? @array = () 
        : $db->clear() ;
    ok 95, $cursor->c_get($k, $v, DB_FIRST) == DB_NOTFOUND ;

    undef $cursor ;
    undef $db ;
    untie @array ;
}

{
    # in-memory file

    my @array ;
    my $fd ;
    my $value ;
    my $rec_len = 15 ;
    ok 96, my $db = tie @array, 'BerkeleyDB::Queue',
				    	    -Len       => $rec_len;

    ok 97, $db->db_put(1, "some value") == 0  ;
    ok 98, $db->db_get(1, $value) == 0 ;
    ok 99, $value eq fillout("some value", $rec_len) ;

}
 
{
    # partial
    # check works via API

    my $lex = new LexFile $Dfile ;
    my $value ;
    my $rec_len = 8 ;
    ok 100, my $db = new BerkeleyDB::Queue  -Filename => $Dfile,
                                      	    -Flags    => DB_CREATE ,
				    	    -Len      => $rec_len,
				    	    -Pad      => " " ;

    # create some data
    my @data =  (
		"",
		"boat",
		"house",
		"sea",
		) ;

    my $ret = 0 ;
    my $i ;
    for ($i = 0 ; $i < @data ; ++$i) {
        my $r = $db->db_put($i, $data[$i]) ;
        $ret += $r ;
    }
    ok 101, $ret == 0 ;

    # do a partial get
    my ($pon, $off, $len) = $db->partial_set(0,2) ;
    ok 102, ! $pon && $off == 0 && $len == 0 ;
    ok 103, $db->db_get(1, $value) == 0 && $value eq "bo" ;
    ok 104, $db->db_get(2, $value) == 0 && $value eq "ho" ;
    ok 105, $db->db_get(3, $value) == 0 && $value eq "se" ;

    # do a partial get, off end of data
    ($pon, $off, $len) = $db->partial_set(3,2) ;
    ok 106, $pon ;
    ok 107, $off == 0 ;
    ok 108, $len == 2 ;
    ok 109, $db->db_get(1, $value) == 0 && $value eq fillout("t", 2) ;
    ok 110, $db->db_get(2, $value) == 0 && $value eq "se" ;
    ok 111, $db->db_get(3, $value) == 0 && $value eq "  " ;

    # switch of partial mode
    ($pon, $off, $len) = $db->partial_clear() ;