/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.uima.internal.util;
import junit.framework.Assert;
import junit.framework.TestCase;
import org.apache.uima.UIMAFramework;
import org.apache.uima.analysis_engine.AnalysisEngine;
import org.apache.uima.analysis_engine.AnalysisEngineDescription;
import org.apache.uima.analysis_engine.impl.AnalysisEngineDescription_impl;
import org.apache.uima.resource.Resource;
import org.apache.uima.resource.metadata.ResourceMetaData;
import org.apache.uima.test.junit_extension.JUnitExtension;
import org.apache.uima.util.Level;
/**
* Tests the ResourcePool_impl class.
*
*/
public class ResourcePoolTest extends TestCase {
/**
* Constructor for ResourcePool_implTest.
*
* @param arg0
*/
public ResourcePoolTest(String arg0) {
super(arg0);
}
/**
* @see TestCase#setUp()
*/
protected void setUp() throws Exception {
try {
super.setUp();
// create resource specifier and a pool containing 3 instances
mDesc = new AnalysisEngineDescription_impl();
mDesc.setPrimitive(true);
mDesc.setAnnotatorImplementationName("org.apache.uima.analysis_engine.impl.TestAnnotator");
mDesc.getMetaData().setName("Test TAE");
mDesc.getMetaData().setDescription("This is a test.");
pool1 = new ResourcePool(3, mDesc, AnalysisEngine.class);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
/*
* Test for Resource_impl getResource()
*/
public void testGetResource() throws Exception {
try {
Assert.assertEquals(3, pool1.getFreeInstances().size());
// get two resources
Resource foo = pool1.getResource();
Assert.assertNotNull(foo);
Assert.assertEquals(2, pool1.getFreeInstances().size());
Resource bar = pool1.getResource();
Assert.assertNotNull(bar);
Assert.assertTrue(!foo.equals(bar));
Assert.assertEquals(1, pool1.getFreeInstances().size());
// get two more resources (should exhaust pool)
Resource a = pool1.getResource();
Assert.assertNotNull(a);
Assert.assertEquals(0, pool1.getFreeInstances().size());
Resource b = pool1.getResource();
Assert.assertNull(b);
Assert.assertEquals(0, pool1.getFreeInstances().size());
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
/*
* Test for Resource_impl getResource(long)
*/
public void testGetResourceJ() throws Exception {
try {
// ask for resources with timeout of 2 seconds. should respond quickly
// until resources are exhausted, then it will pause 2 seconds before
// returning null
long startTime = System.currentTimeMillis();
Resource foo = pool1.getResource(2000);
Assert.assertNotNull(foo);
Assert.assertTrue(System.currentTimeMillis() - startTime < 1000);
startTime = System.currentTimeMillis();
Resource bar = pool1.getResource(2000);
Assert.assertNotNull(bar);
Assert.assertTrue(!foo.equals(bar));
Assert.assertTrue(System.currentTimeMillis() - startTime < 1000);
startTime = System.currentTimeMillis();
Resource a = pool1.getResource(2000);
Assert.assertNotNull(a);
Assert.assertTrue(System.currentTimeMillis() - startTime < 1000);
startTime = System.currentTimeMillis();
Resource b = pool1.getResource(2000);
Assert.assertNull(b);
Assert.assertTrue(System.currentTimeMillis() - startTime >= 2000);
// Start a thread that will release "foo" in 1 second. Demonstrate that
// getResource() will not acquire a resource but getResource(2000) will.
Thread releaserThread = new ReleaserThread(foo);
releaserThread.start();
b = pool1.getResource();
Assert.assertNull(b);
b = pool1.getResource(2000);
Assert.assertNotNull(b);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testReleaseResource() throws Exception {
try {
// acquire all the resources
Assert.assertEquals(3, pool1.getFreeInstances().size());
Resource foo = pool1.getResource();
Resource bar = pool1.getResource();
Resource blah = pool1.getResource();
Assert.assertEquals(0, pool1.getFreeInstances().size());
// release one
pool1.releaseResource(foo);
Assert.assertEquals(1, pool1.getFreeInstances().size());
// try to release "foo" again - should not change the free instances count
// this will log a warning - first we log that this is expected
UIMAFramework.getLogger().log(Level.WARNING, "Unit test is expecting to log ResourcePool warning.");
pool1.releaseResource(foo);
Assert.assertEquals(1, pool1.getFreeInstances().size());
// show that we can then check out a new one
Resource test = pool1.getResource();
Assert.assertNotNull(test);
Assert.assertEquals(0, pool1.getFreeInstances().size());
// release the others
pool1.releaseResource(test);
pool1.releaseResource(bar);
pool1.releaseResource(blah);
Assert.assertEquals(3, pool1.getFreeInstances().size());
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testDestroy() throws Exception {
try {
// do some stuff
Resource foo = pool1.getResource();
Resource bar = pool1.getResource();
Resource a = pool1.getResource();
pool1.releaseResource(foo);
Resource b = pool1.getResource();
pool1.releaseResource(b);
// now some stuff should be recorded in the pool
Assert.assertTrue(!pool1.getFreeInstances().isEmpty());
// destroy the pool
pool1.destroy();
// check that everything is gone
Assert.assertTrue(pool1.getFreeInstances().isEmpty());
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
public void testGetMetaData() throws Exception {
try {
ResourceMetaData descMetaData = mDesc.getMetaData();
ResourceMetaData poolMetaData = pool1.getMetaData();
// only UUID should be different
descMetaData.setUUID(poolMetaData.getUUID());
Assert.assertEquals(descMetaData, poolMetaData);
} catch (Exception e) {
JUnitExtension.handleException(e);
}
}
private AnalysisEngineDescription mDesc;
private ResourcePool pool1;
class ReleaserThread extends Thread {
private Resource r;
ReleaserThread(Resource r) {
this.r = r;
}
public void run() {
try {
synchronized (this) {
wait(1000);
}
pool1.releaseResource(r);
} catch (Exception e) {
Assert.fail(e.getMessage());
}
}
}
}