2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.config.manager.impl.dynamicmbean;
10 import static org.junit.Assert.assertEquals;
11 import static org.junit.Assert.assertNotNull;
12 import static org.junit.Assert.assertNull;
13 import static org.junit.Assert.assertTrue;
14 import static org.junit.Assert.fail;
16 import java.lang.reflect.Method;
17 import java.util.Arrays;
18 import java.util.Collections;
19 import java.util.HashSet;
21 import java.util.concurrent.Executor;
22 import java.util.concurrent.ExecutorService;
24 import javax.management.ObjectName;
26 import org.junit.Test;
27 import org.opendaylight.controller.config.api.annotations.AbstractServiceInterface;
28 import org.opendaylight.controller.config.api.annotations.Description;
29 import org.opendaylight.controller.config.api.annotations.RequireInterface;
30 import org.opendaylight.controller.config.api.annotations.ServiceInterfaceAnnotation;
32 import com.google.common.base.Throwables;
33 import com.google.common.collect.Sets;
35 public class AnnotationsTest {
37 private final String setSomethingString = "setSomething";
39 private void assertRequireInterfaceAnnotationHasCorrectValue(
40 Class<?> clazz, String methodName,
41 Set<Class<?>> inspectedInterfaces,
42 Class<? extends AbstractServiceInterface> expectedValue) {
43 Method setter = findMethod(clazz, methodName);
44 RequireInterface found = AttributeHolder
45 .findRequireInterfaceAnnotation(setter, inspectedInterfaces);
46 if (expectedValue == null) {
50 assertEquals(expectedValue, found.value());
54 private Method findMethod(Class<?> clazz, String methodName) {
57 setter = clazz.getMethod(methodName,
58 new Class[] { ObjectName.class });
59 } catch (Exception e) {
60 throw Throwables.propagate(e);
65 private void assertDescription(Class<?> clazz, String methodName,
66 Set<Class<?>> exportedInterfaces, String expectedValue) {
67 Method setter = findMethod(clazz, methodName);
68 String found = AttributeHolder.findDescription(setter,
70 if (expectedValue == null) {
74 assertEquals(expectedValue, found);
78 private void assertDescriptionOnClass(Class<?> clazz,
79 Set<Class<?>> jmxInterfaces, String expectedValue) {
80 String found = AbstractDynamicWrapper.findDescription(clazz,
82 if (expectedValue == null) {
86 assertEquals(expectedValue, found);
90 private void assertNoDescriptionOnClass(Class<?> clazz,
91 Set<Class<?>> jmxInterfaces) {
92 String found = AbstractDynamicWrapper.findDescription(clazz,
94 assertTrue(found.isEmpty());
97 static final String SIMPLE = "simple";
98 static final String SUBCLASS2 = "subclass2";
100 @ServiceInterfaceAnnotation(value = SIMPLE, osgiRegistrationType = Executor.class)
101 static interface SimpleSI extends AbstractServiceInterface {
105 @Description("class")
106 public static class SuperClass {
107 @RequireInterface(SimpleSI.class)
108 @Description("descr")
109 public void setSomething(ObjectName objectName) {
114 private static Set<Class<?>> emptySetOfInterfaces() {
115 return Collections.emptySet();
119 public void testFindAnnotation_directly() throws Exception {
120 assertRequireInterfaceAnnotationHasCorrectValue(SuperClass.class,
121 setSomethingString, emptySetOfInterfaces(), SimpleSI.class);
122 assertDescription(SuperClass.class, setSomethingString,
123 emptySetOfInterfaces(), "descr");
124 assertDescriptionOnClass(SuperClass.class, emptySetOfInterfaces(),
128 public static class SubClassWithout extends SuperClass {
133 public void testFindAnnotation_subclassWithout() throws Exception {
134 assertRequireInterfaceAnnotationHasCorrectValue(SubClassWithout.class,
135 setSomethingString, emptySetOfInterfaces(), SimpleSI.class);
136 assertDescription(SubClassWithout.class, setSomethingString,
137 emptySetOfInterfaces(), "descr");
138 assertDescriptionOnClass(SuperClass.class, emptySetOfInterfaces(),
142 public static class SubClassWithEmptyMethod extends SuperClass {
144 public void setSomething(ObjectName objectName) {
150 public void testOverridingWithoutAnnotation() throws Exception {
151 assertRequireInterfaceAnnotationHasCorrectValue(
152 SubClassWithEmptyMethod.class, setSomethingString,
153 emptySetOfInterfaces(), SimpleSI.class);
154 assertDescription(SubClassWithEmptyMethod.class, setSomethingString,
155 emptySetOfInterfaces(), "descr");
156 assertDescriptionOnClass(SubClassWithEmptyMethod.class,
157 emptySetOfInterfaces(), "class");
160 static interface SubSI extends SimpleSI {
164 @ServiceInterfaceAnnotation(value = SUBCLASS2, osgiRegistrationType = ExecutorService.class)
165 static interface SubSI2 extends SubSI {
169 public static class SubClassWithAnnotation extends SuperClass {
171 @RequireInterface(SubSI2.class)
172 @Description("descr2")
173 public void setSomething(ObjectName objectName) {
179 public void testFindAnnotation_SubClassWithAnnotation() throws Exception {
180 assertDescription(SubClassWithAnnotation.class, setSomethingString,
181 emptySetOfInterfaces(), "descr2\ndescr");
183 assertRequireInterfaceAnnotationHasCorrectValue(
184 SubClassWithAnnotation.class, setSomethingString,
185 emptySetOfInterfaces(), SubSI2.class);
187 } catch (IllegalStateException e) {
191 .startsWith("Error finding @RequireInterface. More than one value specified"));
195 public static interface HasSomeMethod {
196 void setSomething(ObjectName objectName);
199 public static class SubClassWithoutMethodWithInterface extends SuperClass
200 implements HasSomeMethod {
205 public void testFindAnnotation_SubClassWithoutMethodWithInterface()
207 assertRequireInterfaceAnnotationHasCorrectValue(
208 SubClassWithoutMethodWithInterface.class, setSomethingString,
209 emptySetOfInterfaces(), SimpleSI.class);
210 assertDescription(SubClassWithoutMethodWithInterface.class,
211 setSomethingString, emptySetOfInterfaces(), "descr");
214 static abstract class SuperClassWithInterface implements HasSomeMethod {
216 @RequireInterface(SubSI2.class)
217 @Description("descr")
218 public void setSomething(ObjectName objectName) {
223 @Description("class")
224 public static class SubClassOfSuperClassWithInterface extends
225 SuperClassWithInterface {
230 public void testFindAnnotation_SubClassOfSuperClassWithInterface()
232 assertRequireInterfaceAnnotationHasCorrectValue(
233 SubClassOfSuperClassWithInterface.class, setSomethingString,
234 emptySetOfInterfaces(), SubSI2.class);
235 assertDescription(SubClassOfSuperClassWithInterface.class,
236 setSomethingString, emptySetOfInterfaces(), "descr");
237 assertDescriptionOnClass(SubClassOfSuperClassWithInterface.class,
238 emptySetOfInterfaces(), "class");
242 public void testFindAnnotation2() throws Exception {
243 assertNoDescriptionOnClass(SuperClassWithInterface.class,
244 emptySetOfInterfaces());
247 @Description("class")
248 static interface HasSomeMethodWithAnnotations {
250 @RequireInterface(SubSI2.class)
251 @Description("descr")
252 void setSomething(ObjectName objectName);
255 static class HasSomeMethodWithAnnotationsImpl implements
256 HasSomeMethodWithAnnotations {
258 public void setSomething(ObjectName objectName) {
264 public void testHasSomeMethodWithAnnotationsImpl() {
265 HashSet<Class<?>> exportedInterfaces = Sets
266 .<Class<?>> newHashSet(HasSomeMethodWithAnnotations.class);
267 assertRequireInterfaceAnnotationHasCorrectValue(
268 HasSomeMethodWithAnnotationsImpl.class, setSomethingString,
269 exportedInterfaces, SubSI2.class);
271 assertDescription(HasSomeMethodWithAnnotationsImpl.class,
272 setSomethingString, exportedInterfaces, "descr");
274 assertDescriptionOnClass(
275 HasSomeMethodWithAnnotationsImpl.class,
276 new HashSet<Class<?>>(Arrays
277 .asList(HasSomeMethodWithAnnotations.class)), "class");