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
|
<?php
/**
* This class will test BagOStuff.
*
* @author Matthias Mullie <mmullie@wikimedia.org>
*/
class BagOStuffTest extends MediaWikiTestCase {
private $cache;
protected function setUp() {
parent::setUp();
// type defined through parameter
if ( $this->getCliArg( 'use-bagostuff' ) ) {
$name = $this->getCliArg( 'use-bagostuff' );
$this->cache = ObjectCache::newFromId( $name );
} else {
// no type defined - use simple hash
$this->cache = new HashBagOStuff;
}
$this->cache->delete( wfMemcKey( 'test' ) );
}
public function testMerge() {
$key = wfMemcKey( 'test' );
$usleep = 0;
/**
* Callback method: append "merged" to whatever is in cache.
*
* @param BagOStuff $cache
* @param string $key
* @param int $existingValue
* @use int $usleep
* @return int
*/
$callback = function ( BagOStuff $cache, $key, $existingValue ) use ( &$usleep ) {
// let's pretend this is an expensive callback to test concurrent merge attempts
usleep( $usleep );
if ( $existingValue === false ) {
return 'merged';
}
return $existingValue . 'merged';
};
// merge on non-existing value
$merged = $this->cache->merge( $key, $callback, 0 );
$this->assertTrue( $merged );
$this->assertEquals( $this->cache->get( $key ), 'merged' );
// merge on existing value
$merged = $this->cache->merge( $key, $callback, 0 );
$this->assertTrue( $merged );
$this->assertEquals( $this->cache->get( $key ), 'mergedmerged' );
/*
* Test concurrent merges by forking this process, if:
* - not manually called with --use-bagostuff
* - pcntl_fork is supported by the system
* - cache type will correctly support calls over forks
*/
$fork = (bool)$this->getCliArg( 'use-bagostuff' );
$fork &= function_exists( 'pcntl_fork' );
$fork &= !$this->cache instanceof HashBagOStuff;
$fork &= !$this->cache instanceof EmptyBagOStuff;
$fork &= !$this->cache instanceof MultiWriteBagOStuff;
if ( $fork ) {
// callback should take awhile now so that we can test concurrent merge attempts
$pid = pcntl_fork();
if ( $pid == -1 ) {
// can't fork, ignore this test...
} elseif ( $pid ) {
// wait a little, making sure that the child process is calling merge
usleep( 3000 );
// attempt a merge - this should fail
$merged = $this->cache->merge( $key, $callback, 0, 1 );
// merge has failed because child process was merging (and we only attempted once)
$this->assertFalse( $merged );
// make sure the child's merge is completed and verify
usleep( 3000 );
$this->assertEquals( $this->cache->get( $key ), 'mergedmergedmerged' );
} else {
$this->cache->merge( $key, $callback, 0, 1 );
// Note: I'm not even going to check if the merge worked, I'll
// compare values in the parent process to test if this merge worked.
// I'm just going to exit this child process, since I don't want the
// child to output any test results (would be rather confusing to
// have test output twice)
exit;
}
}
}
public function testAdd() {
$key = wfMemcKey( 'test' );
$this->assertTrue( $this->cache->add( $key, 'test' ) );
}
public function testGet() {
$value = array( 'this' => 'is', 'a' => 'test' );
$key = wfMemcKey( 'test' );
$this->cache->add( $key, $value );
$this->assertEquals( $this->cache->get( $key ), $value );
}
/**
* @covers BagOStuff::incr
*/
public function testIncr() {
$key = wfMemcKey( 'test' );
$this->cache->add( $key, 0 );
$this->cache->incr( $key );
$expectedValue = 1;
$actualValue = $this->cache->get( $key );
$this->assertEquals( $expectedValue, $actualValue, 'Value should be 1 after incrementing' );
}
public function testGetMulti() {
$value1 = array( 'this' => 'is', 'a' => 'test' );
$value2 = array( 'this' => 'is', 'another' => 'test' );
$key1 = wfMemcKey( 'test1' );
$key2 = wfMemcKey( 'test2' );
$this->cache->add( $key1, $value1 );
$this->cache->add( $key2, $value2 );
$this->assertEquals(
$this->cache->getMulti( array( $key1, $key2 ) ),
array( $key1 => $value1, $key2 => $value2 )
);
// cleanup
$this->cache->delete( $key1 );
$this->cache->delete( $key2 );
}
}
|
