/**
* 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.cxf.resource;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class DefaultResourceManagerTest extends Assert {
private DefaultResourceManager manager;
private DummyResolver[] resolvers;
@Before
public void setUp() {
AtomicInteger ordering = new AtomicInteger(0);
resolvers = new DummyResolver[4];
for (int i = 0; i < resolvers.length; i++) {
resolvers[i] = new DummyResolver(ordering);
}
manager = new DefaultResourceManager(resolvers[resolvers.length - 1]);
for (int i = resolvers.length - 2; i >= 0; i--) {
manager.addResourceResolver(resolvers[i]);
}
}
@After
public void tearDown() {
manager = null;
resolvers = null;
}
@Test
public void testResolverOrder() {
assertArrayEquals(resolvers, getResolvers(manager));
checkCallOrder(resolvers);
}
@Test
public void testCopiedResolverOrder() {
ResourceManager newManager = new DefaultResourceManager(manager.getResourceResolvers());
assertArrayEquals(resolvers, getResolvers(newManager));
checkCallOrder(resolvers);
}
@Test
public void testAddResolverList() {
List<ResourceResolver> addedResolvers = new ArrayList<>();
for (int i = 0; i < 4; i++) {
addedResolvers.add(new DummyResolver(resolvers[0].source));
}
manager.addResourceResolvers(addedResolvers);
DummyResolver[] expected = new DummyResolver[addedResolvers.size() + resolvers.length];
addedResolvers.toArray(expected);
System.arraycopy(resolvers, 0, expected, addedResolvers.size(), resolvers.length);
assertArrayEquals(expected, getResolvers(manager));
checkCallOrder(expected);
}
@Test
public void testAddDuplicateResolver() {
manager.addResourceResolver(resolvers[1]);
assertArrayEquals(resolvers, getResolvers(manager));
checkCallOrder(resolvers);
}
@Test
public void testAddDuplicateResolverList() {
manager.addResourceResolvers(new ArrayList<>(manager.getResourceResolvers()));
assertArrayEquals(resolvers, getResolvers(manager));
checkCallOrder(resolvers);
}
@Test
public void testRemoveResolver() {
manager.removeResourceResolver(resolvers[1]);
DummyResolver[] expected = new DummyResolver[resolvers.length - 1];
expected[0] = resolvers[0];
System.arraycopy(resolvers, 2, expected, 1, expected.length - 1);
assertArrayEquals(expected, getResolvers(manager));
checkCallOrder(expected);
assertEquals(-1, resolvers[1].order);
}
@Test
public void testLiveResolverList() {
List<ResourceResolver> currentResolvers = manager.getResourceResolvers();
DummyResolver newResolver = new DummyResolver(resolvers[0].source);
assertFalse(currentResolvers.contains(newResolver));
manager.addResourceResolver(newResolver);
assertTrue(currentResolvers.contains(newResolver));
assertTrue(currentResolvers.contains(resolvers[1]));
manager.removeResourceResolver(resolvers[1]);
assertFalse(currentResolvers.contains(resolvers[1]));
}
private ResourceResolver[] getResolvers(ResourceManager resourceManager) {
List<ResourceResolver> list = resourceManager.getResourceResolvers();
ResourceResolver[] actual = new ResourceResolver[list.size()];
return list.toArray(actual);
}
private void checkCallOrder(DummyResolver[] usedResolvers) {
manager.resolveResource(null, Void.class);
int[] expected = new int[usedResolvers.length];
int[] actual = new int[usedResolvers.length];
for (int i = 0; i < usedResolvers.length; i++) {
expected[i] = i;
actual[i] = usedResolvers[i].order;
}
assertArrayEquals(expected, actual);
}
private static class DummyResolver implements ResourceResolver {
AtomicInteger source;
int order = -1;
DummyResolver(AtomicInteger source) {
this.source = source;
}
@Override
public <T> T resolve(String resourceName, Class<T> resourceType) {
order = source.getAndIncrement();
return null;
}
@Override
public InputStream getAsStream(String name) {
return null;
}
}
}