IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 29, 2005, 4:35:06 PM (21 years ago)
Author:
jhoblitt
Message:

rename PS::IPP::IData -> Nebulous

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/Nebulous-Server/t/14_client_lock.t

    r2872 r4440  
    33# Copryight (C) 2004-2005  Joshua Hoblitt
    44#
    5 # $Id: 14_client_lock.t,v 1.3 2005-01-03 23:55:29 jhoblitt Exp $
     5# $Id: 14_client_lock.t,v 1.4 2005-06-30 02:35:06 jhoblitt Exp $
    66
    77use strict;
    … …  
    1414use lib qw( ./t ./lib );
    1515
    16 use PS::IPP::IData::Client;
    17 use PS::IPP::IData::Util qw( :standard );
    18 use Test::IData;
     16use Nebulous::Client;
     17use Nebulous::Util qw( :standard );
     18use Test::Nebulous;
    1919
    2020my $hostport = Apache::Test->config->{ 'hostport' };
    2121
    22 Test::IData->setup;
     22Test::Nebulous->setup;
    2323
    2424{
    2525    # key, type
    26     my $idata = PS::IPP::IData::Client->new(
    27         proxy => "http://$hostport/idata",
    28     );
    29     $idata->create( "foo" );
    30 
    31     ok( $idata->lock( "foo", "read" ), "read lock" );
    32 }
    33 
    34 Test::IData->setup;
    35 
    36 {
    37     # key, type, timeout
    38     my $idata = PS::IPP::IData::Client->new(
    39         proxy => "http://$hostport/idata",
    40     );
    41     $idata->create( "foo" );
    42 
    43     ok( $idata->lock( "foo", "read", 10 ), "read lock" );
    44 }
    45 
    46 Test::IData->setup;
    47 
    48 {
    49     my $idata = PS::IPP::IData::Client->new(
    50         proxy => "http://$hostport/idata",
    51     );
    52     $idata->create( "foo" );
    53 
    54     ok( $idata->lock( "foo", "read" ), "read lock" );
    55     ok( $idata->lock( "foo", "read" ), "read lock" );
    56 }
    57 
    58 Test::IData->setup;
     26    my $neb = Nebulous::Client->new(
     27        proxy => "http://$hostport/nebulous",
     28    );
     29    $neb->create( "foo" );
     30
     31    ok( $neb->lock( "foo", "read" ), "read lock" );
     32}
     33
     34Test::Nebulous->setup;
     35
     36{
     37    # key, type, timeout
     38    my $neb = Nebulous::Client->new(
     39        proxy => "http://$hostport/nebulous",
     40    );
     41    $neb->create( "foo" );
     42
     43    ok( $neb->lock( "foo", "read", 10 ), "read lock" );
     44}
     45
     46Test::Nebulous->setup;
     47
     48{
     49    my $neb = Nebulous::Client->new(
     50        proxy => "http://$hostport/nebulous",
     51    );
     52    $neb->create( "foo" );
     53
     54    ok( $neb->lock( "foo", "read" ), "read lock" );
     55    ok( $neb->lock( "foo", "read" ), "read lock" );
     56}
     57
     58Test::Nebulous->setup;
    5959
    6060{
    6161    # key, type
    62     my $idata = PS::IPP::IData::Client->new(
    63         proxy => "http://$hostport/idata",
    64     );
    65     $idata->create( "foo" );
    66 
    67     ok( $idata->lock( "foo", "write" ), "write lock" );
    68 }
    69 
    70 Test::IData->setup;
    71 
    72 {
    73     # key, type, timeout
    74     my $idata = PS::IPP::IData::Client->new(
    75         proxy => "http://$hostport/idata",
    76     );
    77     $idata->create( "foo" );
    78 
    79     ok( $idata->lock( "foo", "write", 10 ), "write lock" );
    80 }
    81 
    82 Test::IData->setup;
    83 
    84 {
    85     my $idata = PS::IPP::IData::Client->new(
    86         proxy => "http://$hostport/idata",
    87     );
    88 
    89     is( $idata->lock( "foo", "read" ), undef, "storage object does not exist" );
    90 }
    91 
    92 Test::IData->setup;
    93 
    94 {
    95     my $idata = PS::IPP::IData::Client->new(
    96         proxy => "http://$hostport/idata",
    97     );
    98 
    99     is( $idata->lock( "foo", "write" ), undef, "storage object does not exist" );
    100 }
    101 
    102 Test::IData->setup;
     62    my $neb = Nebulous::Client->new(
     63        proxy => "http://$hostport/nebulous",
     64    );
     65    $neb->create( "foo" );
     66
     67    ok( $neb->lock( "foo", "write" ), "write lock" );
     68}
     69
     70Test::Nebulous->setup;
     71
     72{
     73    # key, type, timeout
     74    my $neb = Nebulous::Client->new(
     75        proxy => "http://$hostport/nebulous",
     76    );
     77    $neb->create( "foo" );
     78
     79    ok( $neb->lock( "foo", "write", 10 ), "write lock" );
     80}
     81
     82Test::Nebulous->setup;
     83
     84{
     85    my $neb = Nebulous::Client->new(
     86        proxy => "http://$hostport/nebulous",
     87    );
     88
     89    is( $neb->lock( "foo", "read" ), undef, "storage object does not exist" );
     90}
     91
     92Test::Nebulous->setup;
     93
     94{
     95    my $neb = Nebulous::Client->new(
     96        proxy => "http://$hostport/nebulous",
     97    );
     98
     99    is( $neb->lock( "foo", "write" ), undef, "storage object does not exist" );
     100}
     101
     102Test::Nebulous->setup;
    103103
    104104diag "testing a spinlock, this will be a litle slow...";
    … …  
    109109
    110110    # key, type, timeout
    111     my $idata = PS::IPP::IData::Client->new(
    112         proxy => "http://$hostport/idata",
    113     );
    114     $idata->create( "foo" );
    115 
    116     $idata->lock( "foo", "read" );
    117     $idata->lock( "foo", "write" );
     111    my $neb = Nebulous::Client->new(
     112        proxy => "http://$hostport/nebulous",
     113    );
     114    $neb->create( "foo" );
     115
     116    $neb->lock( "foo", "read" );
     117    $neb->lock( "foo", "write" );
    118118
    119119    alarm 0;
    … …  
    121121like( $@, qr/timeout/, "default spinlock" );
    122122
    123 Test::IData->setup;
     123Test::Nebulous->setup;
    124124
    125125diag "testing a spinlock, this will be a litle slow...";
    … …  
    130130
    131131    # key, type, timeout
    132     my $idata = PS::IPP::IData::Client->new(
    133         proxy => "http://$hostport/idata",
    134     );
    135     $idata->create( "foo" );
    136 
    137     $idata->lock( "foo", "read" );
    138     unless ( $idata->lock( "foo", "write" ) ) {
     132    my $neb = Nebulous::Client->new(
     133        proxy => "http://$hostport/nebulous",
     134    );
     135    $neb->create( "foo" );
     136
     137    $neb->lock( "foo", "read" );
     138    unless ( $neb->lock( "foo", "write" ) ) {
    139139        alarm 0;
    140140        die "gaveup";
    … …  
    145145like( $@, qr/gaveup/, "default spinlock" );
    146146
    147 Test::IData->setup;
     147Test::Nebulous->setup;
    148148
    149149diag "testing a spinlock, this will be a litle slow...";
    … …  
    154154
    155155    # key, type, timeout
    156     my $idata = PS::IPP::IData::Client->new(
    157         proxy => "http://$hostport/idata",
    158     );
    159     $idata->create( "foo" );
    160 
    161     $idata->lock( "foo", "read" );
    162     $idata->lock( "foo", "write", 5 );
     156    my $neb = Nebulous::Client->new(
     157        proxy => "http://$hostport/nebulous",
     158    );
     159    $neb->create( "foo" );
     160
     161    $neb->lock( "foo", "read" );
     162    $neb->lock( "foo", "write", 5 );
    163163
    164164    alarm 0;
    … …  
    166166like( $@, qr/timeout/, "specified spinlock" );
    167167
    168 Test::IData->setup;
     168Test::Nebulous->setup;
    169169
    170170diag "testing a spinlock, this will be a litle slow...";
    … …  
    175175
    176176    # key, type, timeout
    177     my $idata = PS::IPP::IData::Client->new(
    178         proxy => "http://$hostport/idata",
    179     );
    180     $idata->create( "foo" );
    181 
    182     $idata->lock( "foo", "read" );
    183     unless ( $idata->lock( "foo", "write", 5 ) ) {
     177    my $neb = Nebulous::Client->new(
     178        proxy => "http://$hostport/nebulous",
     179    );
     180    $neb->create( "foo" );
     181
     182    $neb->lock( "foo", "read" );
     183    unless ( $neb->lock( "foo", "write", 5 ) ) {
    184184        alarm 0;
    185185        die "gaveup";
    … …  
    191191like( $@, qr/gaveup/, "specified spinlock" );
    192192
    193 Test::IData->setup;
    194 
    195 {
    196     my $idata = PS::IPP::IData::Client->new(
    197         proxy => "http://$hostport/idata",
    198     );
    199     $idata->create( "foo" );
    200 
    201     $idata->lock( "foo", "write" );
    202     is( $idata->lock( "foo", "write", 1 ), undef, "can not write lock twice" );
    203 }
    204 
    205 Test::IData->setup;
    206 
    207 {
    208     my $idata = PS::IPP::IData::Client->new(
    209         proxy => "http://$hostport/idata",
    210     );
    211     $idata->create( "foo" );
    212 
    213     $idata->lock( "foo", "read" );
    214     is( $idata->lock( "foo", "write", 1 ), undef, "can not write lock after read lock" );
    215 }
    216 
    217 Test::IData->setup;
    218 
    219 {
    220     my $idata = PS::IPP::IData::Client->new(
    221         proxy => "http://$hostport/idata",
    222     );
    223     $idata->create( "foo" );
    224 
    225     $idata->lock( "foo", "write" );
    226     is( $idata->lock( "foo", "read", 1 ), undef, "can not read lock after write lock" );
    227 }
    228 
    229 Test::IData->setup;
    230 
    231 eval {
    232     my $idata = PS::IPP::IData::Client->new(
    233         proxy => "http://$hostport/idata",
    234     );
    235 
    236     $idata->lock();
     193Test::Nebulous->setup;
     194
     195{
     196    my $neb = Nebulous::Client->new(
     197        proxy => "http://$hostport/nebulous",
     198    );
     199    $neb->create( "foo" );
     200
     201    $neb->lock( "foo", "write" );
     202    is( $neb->lock( "foo", "write", 1 ), undef, "can not write lock twice" );
     203}
     204
     205Test::Nebulous->setup;
     206
     207{
     208    my $neb = Nebulous::Client->new(
     209        proxy => "http://$hostport/nebulous",
     210    );
     211    $neb->create( "foo" );
     212
     213    $neb->lock( "foo", "read" );
     214    is( $neb->lock( "foo", "write", 1 ), undef, "can not write lock after read lock" );
     215}
     216
     217Test::Nebulous->setup;
     218
     219{
     220    my $neb = Nebulous::Client->new(
     221        proxy => "http://$hostport/nebulous",
     222    );
     223    $neb->create( "foo" );
     224
     225    $neb->lock( "foo", "write" );
     226    is( $neb->lock( "foo", "read", 1 ), undef, "can not read lock after write lock" );
     227}
     228
     229Test::Nebulous->setup;
     230
     231eval {
     232    my $neb = Nebulous::Client->new(
     233        proxy => "http://$hostport/nebulous",
     234    );
     235
     236    $neb->lock();
    237237};
    238238like( $@, qr/2 - 3 were expected/, "no params" );
    239239
    240 Test::IData->setup;
    241 
    242 eval {
    243     my $idata = PS::IPP::IData::Client->new(
    244         proxy => "http://$hostport/idata",
    245     );
    246 
    247     $idata->lock( "foo" );
     240Test::Nebulous->setup;
     241
     242eval {
     243    my $neb = Nebulous::Client->new(
     244        proxy => "http://$hostport/nebulous",
     245    );
     246
     247    $neb->lock( "foo" );
    248248};
    249249like( $@, qr/2 - 3 were expected/, "not enough params" );
    250250
    251 Test::IData->setup;
    252 
    253 eval {
    254     my $idata = PS::IPP::IData::Client->new(
    255         proxy => "http://$hostport/idata",
    256     );
    257 
    258     $idata->lock( "foo", "both" );
     251Test::Nebulous->setup;
     252
     253eval {
     254    my $neb = Nebulous::Client->new(
     255        proxy => "http://$hostport/nebulous",
     256    );
     257
     258    $neb->lock( "foo", "both" );
    259259};
    260260like( $@, qr/is read or write/, "not read or write" );
    261261
    262 Test::IData->setup;
    263 
    264 eval {
    265     my $idata = PS::IPP::IData::Client->new(
    266         proxy => "http://$hostport/idata",
    267     );
    268 
    269     $idata->lock( "foo", 'read', 3, "bar" );
     262Test::Nebulous->setup;
     263
     264eval {
     265    my $neb = Nebulous::Client->new(
     266        proxy => "http://$hostport/nebulous",
     267    );
     268
     269    $neb->lock( "foo", 'read', 3, "bar" );
    270270};
    271271like( $@, qr/2 - 3 were expected/, "too many params" );
    272272
    273 Test::IData->cleanup;
     273Test::Nebulous->cleanup;
Note: See TracChangeset for help on using the changeset viewer.