LockingProvider::testReleaseAll() - Code Metrics - Inspection of "Locking: Limit key length in Shared Storage #25376..." - owncloud/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — stable8.2 ( e00fe4...971a4b )

by Thomas

created 2016-07-12 16:00 UTC

LockingProvider::testReleaseAll() A

↳ Parent: LockingProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	12
Code Lines	9

Duplication

Lines	12
Ratio	100 %

Importance

Changes

Metric	Value
cc	1
eloc	9
nc	1
nop	0
dl	12
loc	12
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * @author Robin Appelman <[email protected]>
 *
 * @copyright Copyright (c) 2015, ownCloud, Inc.
 * @license AGPL-3.0
 *
 * This code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License, version 3,
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License, version 3,
 * along with this program.  If not, see <http://www.gnu.org/licenses/>
 *
 */

namespace Test\Lock;

use OCP\Lock\ILockingProvider;
use OCP\Lock\LockedException;
use Test\TestCase;

abstract class LockingProvider extends TestCase {
	/**
	 * @var \OCP\Lock\ILockingProvider
	 */
	protected $instance;

	/**
	 * @return \OCP\Lock\ILockingProvider
	 */
	abstract protected function getInstance();

	protected function setUp() {
		parent::setUp();
		$this->instance = $this->getInstance();
	}

	public function testExclusiveLock() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
	}

	public function testSharedLock() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
	}

	public function testDoubleSharedLock() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
	}

	public function testReleaseSharedLock() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->instance->releaseLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->instance->releaseLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
	}

	/**
	 * @expectedException \OCP\Lock\LockedException
	 */
	public function testDoubleExclusiveLock() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
	}

	public function testReleaseExclusiveLock() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
		$this->instance->releaseLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
	}

	/**
	 * @expectedException \OCP\Lock\LockedException
	 */
	public function testExclusiveLockAfterShared() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
	}

	public function testExclusiveLockAfterSharedReleased() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->instance->releaseLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
	}

	public function testReleaseAll() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('bar', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('asd', ILockingProvider::LOCK_EXCLUSIVE);

		$this->instance->releaseAll();

		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->assertFalse($this->instance->isLocked('bar', ILockingProvider::LOCK_SHARED));
		$this->assertFalse($this->instance->isLocked('asd', ILockingProvider::LOCK_EXCLUSIVE));
	}

	public function testReleaseAllAfterChange() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('bar', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('asd', ILockingProvider::LOCK_EXCLUSIVE);

		$this->instance->changeLock('bar', ILockingProvider::LOCK_EXCLUSIVE);

		$this->instance->releaseAll();

		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->assertFalse($this->instance->isLocked('bar', ILockingProvider::LOCK_SHARED));
		$this->assertFalse($this->instance->isLocked('bar', ILockingProvider::LOCK_EXCLUSIVE));
		$this->assertFalse($this->instance->isLocked('asd', ILockingProvider::LOCK_EXCLUSIVE));
	}

	public function testReleaseAllAfterUnlock() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('bar', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('asd', ILockingProvider::LOCK_EXCLUSIVE);

		$this->instance->releaseLock('bar', ILockingProvider::LOCK_SHARED);

		$this->instance->releaseAll();

		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->assertFalse($this->instance->isLocked('asd', ILockingProvider::LOCK_EXCLUSIVE));
	}

	public function testReleaseAfterReleaseAll() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);

		$this->instance->releaseAll();

		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));

		$this->instance->releaseLock('foo', ILockingProvider::LOCK_SHARED);
	}


	/**
	 * @expectedException \OCP\Lock\LockedException
	 */
	public function testSharedLockAfterExclusive() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
	}

	public function testLockedExceptionHasPathForShared() {
		try {
			$this->testSharedLockAfterExclusive();
			$this->fail('Expected locked exception');
		} catch (LockedException $e) {
			$this->assertEquals('foo', $e->getPath());
		}
	}

	public function testLockedExceptionHasPathForExclusive() {
		try {
			$this->testExclusiveLockAfterShared();
			$this->fail('Expected locked exception');
		} catch (LockedException $e) {
			$this->assertEquals('foo', $e->getPath());
		}
	}

	public function testChangeLockToExclusive() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->changeLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
	}

	public function testChangeLockToShared() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
		$this->instance->changeLock('foo', ILockingProvider::LOCK_SHARED);
		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
	}

	/**
	 * @expectedException \OCP\Lock\LockedException
	 */
	public function testChangeLockToExclusiveDoubleShared() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->changeLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
	}

	/**
	 * @expectedException \OCP\Lock\LockedException
	 */
	public function testChangeLockToExclusiveNoShared() {
		$this->instance->changeLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
	}

	/**
	 * @expectedException \OCP\Lock\LockedException
	 */
	public function testChangeLockToExclusiveFromExclusive() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
		$this->instance->changeLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
	}

	/**
	 * @expectedException \OCP\Lock\LockedException
	 */
	public function testChangeLockToSharedNoExclusive() {
		$this->instance->changeLock('foo', ILockingProvider::LOCK_SHARED);
	}

	/**
	 * @expectedException \OCP\Lock\LockedException
	 */
	public function testChangeLockToSharedFromShared() {
		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
		$this->instance->changeLock('foo', ILockingProvider::LOCK_SHARED);
	}

	/**
	 * @expectedException \InvalidArgumentException
	*/
	public function testTooLongLockName() {
	   $this->instance->acquireLock(str_repeat("x",250), ILockingProvider::LOCK_EXCLUSIVE);
	}
}


1		<?php
2		/**
3		* @author Robin Appelman <[email protected]>
4		*
5		* @copyright Copyright (c) 2015, ownCloud, Inc.
6		* @license AGPL-3.0
7		*
8		* This code is free software: you can redistribute it and/or modify
9		* it under the terms of the GNU Affero General Public License, version 3,
10		* as published by the Free Software Foundation.
11		*
12		* This program is distributed in the hope that it will be useful,
13		* but WITHOUT ANY WARRANTY; without even the implied warranty of
14		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15		* GNU Affero General Public License for more details.
16		*
17		* You should have received a copy of the GNU Affero General Public License, version 3,
18		* along with this program. If not, see <http://www.gnu.org/licenses/>
19		*
20		*/
21
22		namespace Test\Lock;
23
24		use OCP\Lock\ILockingProvider;
25		use OCP\Lock\LockedException;
26		use Test\TestCase;
27
28		abstract class LockingProvider extends TestCase {
29		/**
30		* @var \OCP\Lock\ILockingProvider
31		*/
32		protected $instance;
33
34		/**
35		* @return \OCP\Lock\ILockingProvider
36		*/
37		abstract protected function getInstance();
38
39		protected function setUp() {
40		parent::setUp();
41		$this->instance = $this->getInstance();
42		}
43
44		public function testExclusiveLock() {
45		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
46		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
47		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
48		}
49
50		public function testSharedLock() {
51		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
52		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
53		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
54		}
55
56	View Code Duplication	public function testDoubleSharedLock() {
57		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
58		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
59		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
60		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
61		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
62		}
63
64	View Code Duplication	public function testReleaseSharedLock() {
65		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
66		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
67		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
68		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
69		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
70		$this->instance->releaseLock('foo', ILockingProvider::LOCK_SHARED);
71		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
72		$this->instance->releaseLock('foo', ILockingProvider::LOCK_SHARED);
73		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
74		}
75
76		/**
77		* @expectedException \OCP\Lock\LockedException
78		*/
79		public function testDoubleExclusiveLock() {
80		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
81		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
82		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
83		}
84
85	View Code Duplication	public function testReleaseExclusiveLock() {
86		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
87		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
88		$this->instance->releaseLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
89		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
90		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
91		}
92
93		/**
94		* @expectedException \OCP\Lock\LockedException
95		*/
96		public function testExclusiveLockAfterShared() {
97		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
98		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
99		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
100		}
101
102	View Code Duplication	public function testExclusiveLockAfterSharedReleased() {
103		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
104		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
105		$this->instance->releaseLock('foo', ILockingProvider::LOCK_SHARED);
106		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
107		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
108		}
109
110	View Code Duplication	public function testReleaseAll() {
111		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
112		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
113		$this->instance->acquireLock('bar', ILockingProvider::LOCK_SHARED);
114		$this->instance->acquireLock('asd', ILockingProvider::LOCK_EXCLUSIVE);
115
116		$this->instance->releaseAll();
117
118		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
119		$this->assertFalse($this->instance->isLocked('bar', ILockingProvider::LOCK_SHARED));
120		$this->assertFalse($this->instance->isLocked('asd', ILockingProvider::LOCK_EXCLUSIVE));
121		}
122
123	View Code Duplication	public function testReleaseAllAfterChange() {
124		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
125		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
126		$this->instance->acquireLock('bar', ILockingProvider::LOCK_SHARED);
127		$this->instance->acquireLock('asd', ILockingProvider::LOCK_EXCLUSIVE);
128
129		$this->instance->changeLock('bar', ILockingProvider::LOCK_EXCLUSIVE);
130
131		$this->instance->releaseAll();
132
133		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
134		$this->assertFalse($this->instance->isLocked('bar', ILockingProvider::LOCK_SHARED));
135		$this->assertFalse($this->instance->isLocked('bar', ILockingProvider::LOCK_EXCLUSIVE));
136		$this->assertFalse($this->instance->isLocked('asd', ILockingProvider::LOCK_EXCLUSIVE));
137		}
138
139	View Code Duplication	public function testReleaseAllAfterUnlock() {
140		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
141		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
142		$this->instance->acquireLock('bar', ILockingProvider::LOCK_SHARED);
143		$this->instance->acquireLock('asd', ILockingProvider::LOCK_EXCLUSIVE);
144
145		$this->instance->releaseLock('bar', ILockingProvider::LOCK_SHARED);
146
147		$this->instance->releaseAll();
148
149		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
150		$this->assertFalse($this->instance->isLocked('asd', ILockingProvider::LOCK_EXCLUSIVE));
151		}
152
153		public function testReleaseAfterReleaseAll() {
154		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
155		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
156
157		$this->instance->releaseAll();
158
159		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
160
161		$this->instance->releaseLock('foo', ILockingProvider::LOCK_SHARED);
162		}
163
164
165		/**
166		* @expectedException \OCP\Lock\LockedException
167		*/
168		public function testSharedLockAfterExclusive() {
169		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
170		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
171		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
172		}
173
174		public function testLockedExceptionHasPathForShared() {
175		try {
176		$this->testSharedLockAfterExclusive();
177		$this->fail('Expected locked exception');
178		} catch (LockedException $e) {
179		$this->assertEquals('foo', $e->getPath());
180		}
181		}
182
183		public function testLockedExceptionHasPathForExclusive() {
184		try {
185		$this->testExclusiveLockAfterShared();
186		$this->fail('Expected locked exception');
187		} catch (LockedException $e) {
188		$this->assertEquals('foo', $e->getPath());
189		}
190		}
191
192		public function testChangeLockToExclusive() {
193		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
194		$this->instance->changeLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
195		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
196		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
197		}
198
199		public function testChangeLockToShared() {
200		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
201		$this->instance->changeLock('foo', ILockingProvider::LOCK_SHARED);
202		$this->assertFalse($this->instance->isLocked('foo', ILockingProvider::LOCK_EXCLUSIVE));
203		$this->assertTrue($this->instance->isLocked('foo', ILockingProvider::LOCK_SHARED));
204		}
205
206		/**
207		* @expectedException \OCP\Lock\LockedException
208		*/
209		public function testChangeLockToExclusiveDoubleShared() {
210		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
211		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
212		$this->instance->changeLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
213		}
214
215		/**
216		* @expectedException \OCP\Lock\LockedException
217		*/
218		public function testChangeLockToExclusiveNoShared() {
219		$this->instance->changeLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
220		}
221
222		/**
223		* @expectedException \OCP\Lock\LockedException
224		*/
225		public function testChangeLockToExclusiveFromExclusive() {
226		$this->instance->acquireLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
227		$this->instance->changeLock('foo', ILockingProvider::LOCK_EXCLUSIVE);
228		}
229
230		/**
231		* @expectedException \OCP\Lock\LockedException
232		*/
233		public function testChangeLockToSharedNoExclusive() {
234		$this->instance->changeLock('foo', ILockingProvider::LOCK_SHARED);
235		}
236
237		/**
238		* @expectedException \OCP\Lock\LockedException
239		*/
240		public function testChangeLockToSharedFromShared() {
241		$this->instance->acquireLock('foo', ILockingProvider::LOCK_SHARED);
242		$this->instance->changeLock('foo', ILockingProvider::LOCK_SHARED);
243		}
244
245		/**
246		* @expectedException \InvalidArgumentException
247		*/
248		public function testTooLongLockName() {
249		$this->instance->acquireLock(str_repeat("x",250), ILockingProvider::LOCK_EXCLUSIVE);
250		}
251		}
252

owncloud / core

Push — stable8.2 ( e00fe4...971a4b )

LockingProvider::testReleaseAll() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like