1   package com.atlassian.util.concurrent;
2   
3   import static org.junit.Assert.assertNotNull;
4   
5   import org.junit.Test;
6   
7   import java.util.concurrent.locks.Lock;
8   import java.util.concurrent.locks.ReadWriteLock;
9   
10  public class ManagedLocksTest {
11      @Test(expected = IllegalArgumentException.class)
12      public void weakManagedLockFactoryNullStripe() throws Exception {
13          ManagedLocks.weakManagedLockFactory(null);
14      }
15  
16      @Test(expected = IllegalArgumentException.class)
17      public void weakManagedLockFactoryNullLockSupplier() throws Exception {
18          ManagedLocks.weakManagedLockFactory(new Function<Object, Object>() {
19              public Object get(final Object input) {
20                  return new Object();
21              }
22          }, null);
23      }
24  
25      @Test
26      public void weakManagedLockFactory() throws Exception {
27          ManagedLocks.weakManagedLockFactory();
28      }
29  
30      @Test(expected = IllegalArgumentException.class)
31      public void weakRWManagedLockFactoryNullStripe() throws Exception {
32          ManagedLocks.weakReadWriteManagedLockFactory(null);
33      }
34  
35      @Test(expected = IllegalArgumentException.class)
36      public void weakRWManagedLockFactoryNullLockSupplier() throws Exception {
37          ManagedLocks.weakReadWriteManagedLockFactory(new Function<Object, Object>() {
38              public Object get(final Object input) {
39                  return new Object();
40              }
41          }, null);
42      }
43  
44      @Test
45      public void weakRWManagedLockFactory() throws Exception {
46          assertNotNull(ManagedLocks.weakReadWriteManagedLockFactory());
47      }
48  
49      @Test
50      public void lockFactory() throws Exception {
51          final Supplier<Lock> lockFactory = ManagedLocks.lockFactory();
52          assertNotNull(lockFactory);
53          assertNotNull(lockFactory.get());
54      }
55  
56      @Test
57      public void readWriteLockFactory() throws Exception {
58          final Supplier<ReadWriteLock> lockFactory = ManagedLocks.readWriteLockFactory();
59          assertNotNull(lockFactory);
60          assertNotNull(lockFactory.get());
61      }
62  
63      @Test
64      public void manage() throws Exception {
65          final Supplier<ManagedLock> lockFactory = ManagedLocks.managedLockFactory(ManagedLocks.lockFactory());
66          assertNotNull(lockFactory);
67          assertNotNull(lockFactory.get());
68      }
69  
70      @Test
71      public void manageReadWrite() throws Exception {
72          final Supplier<ManagedLock.ReadWrite> lockFactory = ManagedLocks.managedReadWriteLockFactory(ManagedLocks.readWriteLockFactory());
73          assertNotNull(lockFactory);
74          assertNotNull(lockFactory.get());
75      }
76  
77      @Test(expected = IllegalArgumentException.class)
78      public void manageNull() throws Exception {
79          ManagedLocks.managedLockFactory(null);
80      }
81  
82      @Test(expected = IllegalArgumentException.class)
83      public void manageReadWriteNull() throws Exception {
84          ManagedLocks.managedReadWriteLockFactory(null);
85      }
86  
87      @Test
88      public void managedFactory() throws Exception {
89          final Function<Integer, ManagedLock> lockFactory = ManagedLocks.weakManagedLockFactory();
90          assertNotNull(lockFactory.get(1));
91      }
92  
93      @Test
94      public void managedReadWriteFactory() throws Exception {
95          final Function<Integer, ManagedLock.ReadWrite> lockFactory = ManagedLocks.weakReadWriteManagedLockFactory();
96          assertNotNull(lockFactory.get(1));
97      }
98  }