Classes

Class	Line #	Total Statements	% Filtered	Complexity	Uncovered Elements	TOTAL Coverage	Actions
ConcurrencyUtil	24	10	0%	5	17	0.00%	Show methods

Class ConcurrencyUtil

Class ConcurrencyUtil	Line # 24	Total Statements 10	% Filtered 0%	Complexity 5	Uncovered Elements 17	TOTAL Coverage 0.00%
ConcurrencyUtil()   ConcurrencyUtil()	3535	0.00	-1.0 -	1.01	0.00	-1.0 -1.0 -
hash(Object) : int   hash(Object) : int	4949	3.03	0.00%	1.01	3.03	0.0 0.00%
selectLock(Object,int) : int   selectLock(Object,int) : int	6161	7.07	0.00%	3.03	11.011	0.0 0.00%

 

Contributing tests

Source view

1		/**
2		* Copyright Terracotta, Inc.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package info.magnolia.cache.concurrent;
17
18		/**
19		* Various bits of black magic garnered from experts on the concurrency-interest@cs.oswego.edu mailing list.
20		*
21		* @author Greg Luck
22		* @version $Id: ConcurrencyUtil.java 7833 2013-07-25 01:00:20Z cschanck $
23		*/
		0% Uncovered Elements: 17 (17) Complexity: 5 Complexity Density: 0.5
24		public final class ConcurrencyUtil {
25
26		private static final int DOUG_LEA_BLACK_MAGIC_OPERAND_1 = 20;
27		private static final int DOUG_LEA_BLACK_MAGIC_OPERAND_2 = 12;
28		private static final int DOUG_LEA_BLACK_MAGIC_OPERAND_3 = 7;
29		private static final int DOUG_LEA_BLACK_MAGIC_OPERAND_4 = 4;
30
31
32		/**
33		* Utility class therefore precent construction.
34		*/
		- Uncovered Elements: 0 (0) Complexity: 1 Complexity Density: -
35	0	private ConcurrencyUtil() {...
36		//noop;
37		}
38
39		/**
40		* Returns a hash code for non-null Object x.
41		* <p/>
42		* This function ensures that hashCodes that differ only by
43		* constant multiples at each bit position have a bounded
44		* number of collisions. (Doug Lea)
45		*
46		* @param object the object serving as a key
47		* @return the hash code
48		*/
		0% Uncovered Elements: 3 (3) Complexity: 1 Complexity Density: 0.33
49	0	public static int hash(Object object) {...
50	0	int h = object.hashCode();
51	0	h ^= (h >>> DOUG_LEA_BLACK_MAGIC_OPERAND_1) ^ (h >>> DOUG_LEA_BLACK_MAGIC_OPERAND_2);
52	0	return h ^ (h >>> DOUG_LEA_BLACK_MAGIC_OPERAND_3) ^ (h >>> DOUG_LEA_BLACK_MAGIC_OPERAND_4);
53		}
54
55		/**
56		* Selects a lock for a key. The same lock is always used for a given key.
57		*
58		* @param key
59		* @return the selected lock index
60		*/
		0% Uncovered Elements: 11 (11) Complexity: 3 Complexity Density: 0.43
61	0	public static int selectLock(final Object key, int numberOfLocks) {...
62	0	int number = numberOfLocks & (numberOfLocks - 1);
63	0	if (number != 0) {
64	0	throw new IllegalStateException("Lock number must be a power of two: " + numberOfLocks);
65		}
66	0	if (key == null) {
67	0	return 0;
68		} else {
69	0	int hash = hash(key) & (numberOfLocks - 1);
70	0	return hash;
71		}
72
73		}
74		}