/*
|
* CDDL HEADER START
|
*
|
* The contents of this file are subject to the terms of the
|
* Common Development and Distribution License, Version 1.0 only
|
* (the "License"). You may not use this file except in compliance
|
* with the License.
|
*
|
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
|
* or http://forgerock.org/license/CDDLv1.0.html.
|
* See the License for the specific language governing permissions
|
* and limitations under the License.
|
*
|
* When distributing Covered Code, include this CDDL HEADER in each
|
* file and include the License file at legal-notices/CDDLv1_0.txt.
|
* If applicable, add the following below this CDDL HEADER, with the
|
* fields enclosed by brackets "[]" replaced with your own identifying
|
* information:
|
* Portions Copyright [yyyy] [name of copyright owner]
|
*
|
* CDDL HEADER END
|
*
|
*
|
* Portions copyright 2013 ForgeRock AS.
|
*/
|
|
package com.forgerock.opendj.util;
|
|
import static org.fest.assertions.Assertions.assertThat;
|
import static org.mockito.Mockito.mock;
|
import static org.mockito.Mockito.never;
|
import static org.mockito.Mockito.verify;
|
import static org.mockito.Mockito.verifyNoMoreInteractions;
|
import static org.mockito.Mockito.when;
|
|
import org.testng.annotations.Test;
|
|
/**
|
* This Test Class tests {@link ReferenceCountedObject}.
|
*/
|
@SuppressWarnings("javadoc")
|
public class ReferenceCountedObjectTestCase extends UtilTestCase {
|
|
private interface Impl {
|
void destroyInstance(Object instance);
|
|
Object newInstance();
|
}
|
|
private final Object object = "Test Object";
|
|
@Test
|
public void testAcquire() throws Exception {
|
final Impl impl = mock(Impl.class);
|
when(impl.newInstance()).thenReturn(object);
|
final ReferenceCountedObject<Object> rco = rco(impl);
|
|
// First acquisition should create new instance.
|
final ReferenceCountedObject<Object>.Reference ref1 = rco.acquire();
|
assertThat(ref1.get()).isSameAs(object);
|
verify(impl).newInstance();
|
verifyNoMoreInteractions(impl);
|
|
// Second acquisition should just bump the ref count.
|
final ReferenceCountedObject<Object>.Reference ref2 = rco.acquire();
|
assertThat(ref2.get()).isSameAs(object);
|
verifyNoMoreInteractions(impl);
|
|
// First dereference should just decrease the ref count.
|
ref1.release();
|
verifyNoMoreInteractions(impl);
|
|
// Second dereference should destroy the instance.
|
ref2.release();
|
verify(impl).destroyInstance(object);
|
verifyNoMoreInteractions(impl);
|
}
|
|
@Test
|
public void testAcquireIfNull() throws Exception {
|
final Object otherObject = "Other object";
|
final Impl impl = mock(Impl.class);
|
when(impl.newInstance()).thenReturn(object);
|
final ReferenceCountedObject<Object> rco = rco(impl);
|
final ReferenceCountedObject<Object>.Reference ref = rco.acquireIfNull(otherObject);
|
|
verify(impl, never()).newInstance();
|
assertThat(ref.get()).isSameAs(otherObject);
|
ref.release();
|
verifyNoMoreInteractions(impl);
|
}
|
|
/**
|
* This test attempts to test that finalization works. It loops at most 100
|
* times performing GCs and checking to see if the finalizer was called.
|
* Usually objects are finalized after 2 GCs, so the loop should complete
|
* quite quickly.
|
*
|
* @throws Exception
|
* If an unexpected error occurred.
|
*/
|
@Test
|
public void testFinalization() throws Exception {
|
final Impl impl = mock(Impl.class);
|
when(impl.newInstance()).thenReturn(object);
|
final ReferenceCountedObject<Object> rco = rco(impl);
|
ReferenceCountedObject<Object>.Reference ref = rco.acquire();
|
System.gc();
|
System.gc();
|
verify(impl, never()).destroyInstance(object);
|
// Read in order to prevent optimization.
|
if (ref != null) {
|
ref = null;
|
}
|
for (int i = 0; i < 100; i++) {
|
System.gc();
|
try {
|
verify(impl).destroyInstance(object);
|
break; // Finalized so stop.
|
} catch (final Throwable t) {
|
// Retry.
|
}
|
}
|
verify(impl).destroyInstance(object);
|
}
|
|
@Test(expectedExceptions = NullPointerException.class)
|
public void testStaleReference() throws Exception {
|
final Impl impl = mock(Impl.class);
|
when(impl.newInstance()).thenReturn(object);
|
final ReferenceCountedObject<Object> rco = rco(impl);
|
final ReferenceCountedObject<Object>.Reference ref = rco.acquire();
|
ref.release();
|
ref.get();
|
}
|
|
private ReferenceCountedObject<Object> rco(final Impl impl) {
|
return new ReferenceCountedObject<Object>() {
|
|
@Override
|
protected void destroyInstance(final Object instance) {
|
impl.destroyInstance(instance);
|
}
|
|
@Override
|
protected Object newInstance() {
|
return impl.newInstance();
|
}
|
};
|
}
|
}
|
