|
1
22 package org.jboss.test.mx.mxbean.test;
23
24 import java.lang.reflect.Method  ;
25 import java.util.ArrayList ;
26 import java.util.Collection ;
27 import java.util.HashMap ;
28 import java.util.LinkedHashMap ;
29 import java.util.LinkedHashSet ;
30 import java.util.List ;
31 import java.util.Map ;
32 import java.util.Set ;
33
34 import javax.management.Attribute ;
35 import javax.management.AttributeList ;
36 import javax.management.MBeanAttributeInfo ;
37 import javax.management.MBeanServer ;
38 import javax.management.ObjectName ;
39 import javax.management.openmbean.CompositeData ;
40 import javax.management.openmbean.CompositeDataSupport ;
41 import javax.management.openmbean.CompositeType ;
42 import javax.management.openmbean.OpenMBeanAttributeInfo ;
43 import javax.management.openmbean.OpenMBeanInfo ;
44 import javax.management.openmbean.OpenType ;
45 import javax.management.openmbean.SimpleType ;
46 import javax.management.openmbean.TabularDataSupport ;
47 import javax.management.openmbean.TabularType ;
48
49 import junit.framework.Test;
50 import junit.framework.TestSuite;
51
52 import org.jboss.mx.mxbean.MXBeanUtils;
53 import org.jboss.test.mx.mxbean.support.CollectionsInterface;
54 import org.jboss.test.mx.mxbean.support.CollectionsMXBeanSupport;
55 import org.jboss.test.mx.mxbean.support.CollectionsMXBeanSupportMXBean;
56 import org.jboss.test.mx.mxbean.support.CompositeInterface;
57 import org.jboss.test.mx.mxbean.support.CompositeMXBeanSupport;
58 import org.jboss.test.mx.mxbean.support.CompositeMXBeanSupportMXBean;
59 import org.jboss.test.mx.mxbean.support.SimpleInterface;
60 import org.jboss.test.mx.mxbean.support.SimpleMXBeanSupport;
61 import org.jboss.test.mx.mxbean.support.SimpleMXBeanSupportMXBean;
62 import org.jboss.test.mx.mxbean.support.SimpleObject;
63 import org.jboss.test.mx.mxbean.support.TestEnum;
64
65
71 public class MXBeanSupportUnitTestCase extends AbstractMXBeanTest
72 {
73 private static final TabularType TABLE_STRING_TO_INTEGER = MXBeanUtils.createMapType(String .class, Integer .class);
74
75 public static Test suite()
76 {
77 return new TestSuite(MXBeanSupportUnitTestCase.class);
78 }
79
80 public MXBeanSupportUnitTestCase(String name)
81 {
82 super(name);
83 }
84
85 public void testGetSimpleAttributes() throws Exception
86 {
87 MBeanServer server = createMBeanServer();
88 SimpleMXBeanSupport support = new SimpleMXBeanSupport();
89 ObjectName objectName = SimpleMXBeanSupportMXBean.REGISTERED_OBJECT_NAME;
90 server.registerMBean(support, objectName);
91 OpenMBeanInfo info = (OpenMBeanInfo ) server.getMBeanInfo(objectName);
92 OpenType [] types = new OpenType [SimpleInterface.TYPES.length];
93 for (int i = 0; i < types.length; ++i)
94 types[i] = MXBeanUtils.getOpenType(SimpleInterface.TYPES[i]);
95 checkAttributes(server, objectName, SimpleMXBeanSupportMXBean.class, support, SimpleInterface.KEYS, types, SimpleInterface.VALUES, SimpleInterface.VALUES, info);
96 }
97
98 public void testSetSimpleAttributes() throws Exception
99 {
100 MBeanServer server = createMBeanServer();
101 SimpleMXBeanSupport support = new SimpleMXBeanSupport();
102 ObjectName objectName = SimpleMXBeanSupportMXBean.REGISTERED_OBJECT_NAME;
103 server.registerMBean(support, objectName);
104 OpenMBeanInfo info = (OpenMBeanInfo ) server.getMBeanInfo(objectName);
105 String [] keys = SimpleInterface.KEYS;
106 Object [] values = SimpleInterface.VALUES;
107 Object [] changedValues = SimpleInterface.CHANGED_VALUES;
108 AttributeList list = new AttributeList (keys.length);
109 OpenType [] types = new OpenType [SimpleInterface.TYPES.length];
110 for (int i = 0; i < types.length; ++i)
111 {
112 types[i] = MXBeanUtils.getOpenType(SimpleInterface.TYPES[i]);
113 String name = getUpperName(keys[i]);
114 server.setAttribute(objectName, new Attribute (name, changedValues[i]));
115 Attribute attribute = new Attribute (name, values[i]);
116 list.add(attribute);
117 }
118 checkAttributes(server, objectName, SimpleMXBeanSupportMXBean.class, support, keys, types, SimpleInterface.CHANGED_VALUES, SimpleInterface.CHANGED_VALUES, info);
119
120 setAttributes(server, objectName, list);
121 checkAttributes(server, objectName, SimpleMXBeanSupportMXBean.class, support, keys, types, SimpleInterface.VALUES, SimpleInterface.VALUES, info);
122 }
123
124 public void testSimpleInvoke() throws Exception
125 {
126 MBeanServer server = createMBeanServer();
127 SimpleMXBeanSupport support = new SimpleMXBeanSupport();
128 ObjectName objectName = SimpleMXBeanSupportMXBean.REGISTERED_OBJECT_NAME;
129 server.registerMBean(support, objectName);
130 assertEquals("olleH", server.invoke(objectName, "echoReverse", new Object [] { "Hello" }, new String [] { String .class.getName() }));
131 }
132
133 public void testGetCompositeAttributes() throws Exception
134 {
135 MBeanServer server = createMBeanServer();
136 SimpleObject composite = new SimpleObject();
137 CompositeMXBeanSupport support = new CompositeMXBeanSupport("Simple", composite);
138 ObjectName objectName = CompositeMXBeanSupportMXBean.REGISTERED_OBJECT_NAME;
139 server.registerMBean(support, objectName);
140 OpenMBeanInfo info = (OpenMBeanInfo ) server.getMBeanInfo(objectName);
141 CompositeData data = createCompositeData(SimpleInterface.class.getName(), SimpleInterface.KEYS, SimpleInterface.VALUES);
142 Object [] values = { "Simple", data };
143 Object [] realValues = { "Simple", composite };
144 checkAttributes(server, objectName, CompositeMXBeanSupportMXBean.class, support, CompositeInterface.KEYS, CompositeInterface.TYPES, values, realValues, info);
145 }
146
147 public void testSetCompositeAttributes() throws Exception
148 {
149 MBeanServer server = createMBeanServer();
150 SimpleObject composite = new SimpleObject();
151 CompositeMXBeanSupport support = new CompositeMXBeanSupport("Simple", composite);
152 ObjectName objectName = CompositeMXBeanSupportMXBean.REGISTERED_OBJECT_NAME;
153 server.registerMBean(support, objectName);
154 OpenMBeanInfo info = (OpenMBeanInfo ) server.getMBeanInfo(objectName);
155 String [] keys = CompositeInterface.KEYS;
156 CompositeData data = createCompositeData(SimpleInterface.class.getName(), SimpleInterface.KEYS, SimpleInterface.VALUES);
157 Object [] values = { "Simple", data };
158 data = createCompositeData(SimpleInterface.class.getName(), SimpleInterface.KEYS, SimpleInterface.CHANGED_VALUES);
159 Object [] changedValues = { "Changed", data };
160 AttributeList list = new AttributeList (keys.length);
161 for (int i = 0; i < keys.length; ++i)
162 {
163 String name = getUpperName(keys[i]);
164 server.setAttribute(objectName, new Attribute (name, changedValues[i]));
165 Attribute attribute = new Attribute (name, values[i]);
166 list.add(attribute);
167 }
168 SimpleObject changed = new SimpleObject();
169 changed.setBigDecimal(SimpleInterface.bigDecimalChangedValue);
170 changed.setBigInteger(SimpleInterface.bigIntegerChangedValue);
171 changed.setBoolean(SimpleInterface.booleanChangedValue);
172 changed.setByte(SimpleInterface.byteChangedValue);
173 changed.setCharacter(SimpleInterface.characterChangedValue);
174 changed.setDate(SimpleInterface.dateChangedValue);
175 changed.setDouble(SimpleInterface.doubleChangedValue);
176 changed.setFloat(SimpleInterface.floatChangedValue);
177 changed.setInteger(SimpleInterface.integerChangedValue);
178 changed.setLong(SimpleInterface.longChangedValue);
179 changed.setObjectName(SimpleInterface.objectNameChangedValue);
180 changed.setPrimitiveBoolean(SimpleInterface.primitiveBooleanChangedValue);
181 changed.setPrimitiveByte(SimpleInterface.primitiveByteChangedValue);
182 changed.setPrimitiveChar(SimpleInterface.primitiveCharChangedValue);
183 changed.setPrimitiveDouble(SimpleInterface.primitiveDoubleChangedValue);
184 changed.setPrimitiveFloat(SimpleInterface.primitiveFloatChangedValue);
185 changed.setPrimitiveInt(SimpleInterface.primitiveIntChangedValue);
186 changed.setPrimitiveLong(SimpleInterface.primitiveLongChangedValue);
187 changed.setPrimitiveShort(SimpleInterface.primitiveShortChangedValue);
188 changed.setShort(SimpleInterface.shortChangedValue);
189 changed.setString(SimpleInterface.stringChangedValue);
190 Object [] realChangedValues = { "Changed", changed };
191 checkAttributes(server, objectName, CompositeMXBeanSupportMXBean.class, support, CompositeInterface.KEYS, CompositeInterface.TYPES, changedValues, realChangedValues, info);
192
193 setAttributes(server, objectName, list);
194 Object [] realValues = { "Simple", composite };
195 checkAttributes(server, objectName, CompositeMXBeanSupportMXBean.class, support, keys, CompositeInterface.TYPES, values, realValues, info);
196 }
197
198 public void testCompositeInvoke() throws Exception
199 {
200 MBeanServer server = createMBeanServer();
201 SimpleObject composite = new SimpleObject();
202 CompositeMXBeanSupport support = new CompositeMXBeanSupport("Simple", composite);
203 ObjectName objectName = CompositeMXBeanSupportMXBean.REGISTERED_OBJECT_NAME;
204 server.registerMBean(support, objectName);
205 composite = new SimpleObject();
206 composite.setString("hello");
207 CompositeData data = (CompositeData ) MXBeanUtils.construct(MXBeanUtils.getOpenType(SimpleInterface.class), composite, getName());
208 Object actual = server.invoke(objectName, "echoReverse", new Object [] { data }, new String [] { SimpleInterface.class.getName() });
209 composite = new SimpleObject();
210 composite.setString("olleh");
211 CompositeData expected = (CompositeData ) MXBeanUtils.construct(MXBeanUtils.getOpenType(SimpleInterface.class), composite, getName());
212 checkValueEquals(expected, actual);
213 }
214
215 public void testGetCollectionAttributes() throws Exception
216 {
217 MBeanServer server = createMBeanServer();
218 String [] array = { "array" };
219 Collection <String > collection = new ArrayList <String >();
220 collection.add("collection");
221 Set <String > set = new LinkedHashSet <String >();
222 set.add("set");
223 List <String > list = new ArrayList <String >();
224 list.add("list");
225 Map <String , Integer > map = new LinkedHashMap <String , Integer >();
226 map.put("map", 1);
227 TestEnum enumeration = TestEnum.FIRST;
228 CollectionsMXBeanSupport support = new CollectionsMXBeanSupport(array, collection, set, list, map, enumeration);
229 ObjectName objectName = CollectionsMXBeanSupportMXBean.REGISTERED_OBJECT_NAME;
230 server.registerMBean(support, objectName);
231 OpenMBeanInfo info = (OpenMBeanInfo ) server.getMBeanInfo(objectName);
232 String [] collectionArray = collection.toArray(new String [collection.size()]);
233 String [] setArray = set.toArray(new String [set.size()]);
234 String [] listArray = list.toArray(new String [list.size()]);
235 TabularDataSupport mapData = new TabularDataSupport (TABLE_STRING_TO_INTEGER);
236 CompositeType entryType = TABLE_STRING_TO_INTEGER.getRowType();
237 mapData.put(new CompositeDataSupport (entryType, MXBeanUtils.MAP_ITEM_NAMES, new Object [] { "map", 1 }));
238
239 Object [] values = { array, collectionArray, setArray, listArray, mapData, TestEnum.FIRST.name() };
240 Object [] realValues = { array, collection, set, list, map, enumeration };
241 checkAttributes(server, objectName, CollectionsMXBeanSupportMXBean.class, support, CollectionsInterface.KEYS, CollectionsInterface.TYPES, values, realValues, info);
242 }
243
244 public void testSetCollectionAttributes() throws Exception
245 {
246 MBeanServer server = createMBeanServer();
247 String [] array = { "array" };
248 Collection <String > collection = new ArrayList <String >();
249 collection.add("collection");
250 Set <String > set = new LinkedHashSet <String >();
251 set.add("set");
252 List <String > list = new ArrayList <String >();
253 list.add("list");
254 Map <String , Integer > map = new LinkedHashMap <String , Integer >();
255 map.put("map", 1);
256 TestEnum enumeration = TestEnum.FIRST;
257 CollectionsMXBeanSupport support = new CollectionsMXBeanSupport(array, collection, set, list, map, enumeration);
258 ObjectName objectName = CollectionsMXBeanSupportMXBean.REGISTERED_OBJECT_NAME;
259 server.registerMBean(support, objectName);
260 OpenMBeanInfo info = (OpenMBeanInfo ) server.getMBeanInfo(objectName);
261
262 String [] keys = CollectionsInterface.KEYS;
263 String [] collectionArray = collection.toArray(new String [collection.size()]);
264 String [] setArray = set.toArray(new String [set.size()]);
265 String [] listArray = list.toArray(new String [list.size()]);
266 TabularDataSupport mapData = new TabularDataSupport (TABLE_STRING_TO_INTEGER);
267 CompositeType entryType = TABLE_STRING_TO_INTEGER.getRowType();
268 mapData.put(new CompositeDataSupport (entryType, MXBeanUtils.MAP_ITEM_NAMES, new Object [] { "map", 1 }));
269 Object [] values = { array, collectionArray, setArray, listArray, mapData, TestEnum.FIRST.name() };
270
271 String [] changedArray = { "arrayChanged" };
272 Collection <String > changedCollection = new ArrayList <String >();
273 changedCollection.add("collectionChanged");
274 Set <String > changedSet = new LinkedHashSet <String >();
275 changedSet.add("setChanged");
276 List <String > changedList = new ArrayList <String >();
277 changedList.add("listChanged");
278
279 String [] changedCollectionArray = changedCollection.toArray(new String [changedCollection.size()]);
280 String [] changedSetArray = changedSet.toArray(new String [changedSet.size()]);
281 String [] changedListArray = changedList.toArray(new String [changedList.size()]);
282 TabularDataSupport changedMapData = new TabularDataSupport (TABLE_STRING_TO_INTEGER);
283 changedMapData.put(new CompositeDataSupport (entryType, MXBeanUtils.MAP_ITEM_NAMES, new Object [] { "mapChanged", 2 }));
284 Object [] changedValues = { changedArray, changedCollectionArray, changedSetArray, changedListArray, changedMapData, TestEnum.SECOND.name() };
285
286 AttributeList attributeList = new AttributeList (keys.length);
287 for (int i = 0; i < keys.length; ++i)
288 {
289 String name = getUpperName(keys[i]);
290 server.setAttribute(objectName, new Attribute (name, changedValues[i]));
291 Attribute attribute = new Attribute (name, values[i]);
292 attributeList.add(attribute);
293 }
294 Map <String , Integer > changedMap = new LinkedHashMap <String , Integer >();
295 changedMap.put("mapChanged", 2);
296 Object [] realChangedValues = { changedArray, changedCollection, changedSet, changedList, changedMap, TestEnum.SECOND };
297 checkAttributes(server, objectName, CollectionsMXBeanSupportMXBean.class, support, keys, CollectionsInterface.TYPES, changedValues, realChangedValues, info);
298
299 setAttributes(server, objectName, attributeList);
300 Object [] realValues = { array, collection, set, list, map, enumeration };
301 checkAttributes(server, objectName, CollectionsMXBeanSupportMXBean.class, support, keys, CollectionsInterface.TYPES, values, realValues, info);
302 }
303
304 public void testCollectionInvoke() throws Exception
305 {
306 MBeanServer server = createMBeanServer();
307 CollectionsMXBeanSupport support = new CollectionsMXBeanSupport();
308 ObjectName objectName = CompositeMXBeanSupportMXBean.REGISTERED_OBJECT_NAME;
309 server.registerMBean(support, objectName);
310 String [] list = { "one", "two", "three" };
311 String [] expected = { "three", "two", "one" };
312 Object result = server.invoke(objectName, "echoReverse", new Object [] { list }, new String [] { List .class.getName() });
313 checkArrayEquals(expected, result);
314 }
315
316 private void checkAttributes(MBeanServer server, ObjectName objectName, Class intf, Object mxbean, String [] keys, OpenType [] types, Object [] values, Object [] realValues, OpenMBeanInfo info) throws Exception
317 {
318 MBeanAttributeInfo [] attributes = info.getAttributes();
319
320 assertEquals(keys.length, values.length);
321 assertEquals(keys.length, types.length);
322 assertEquals(keys.length, attributes.length);
323
324 Map <String , OpenMBeanAttributeInfo > mapping = new HashMap <String , OpenMBeanAttributeInfo >(attributes.length);
325 for (int i = 0; i < attributes.length; ++i)
326 {
327 OpenMBeanAttributeInfo attribute = (OpenMBeanAttributeInfo ) attributes[i];
328 String name = attribute.getName();
329 mapping.put(name, attribute);
330 }
331
332 String [] attributeNames = new String [keys.length];
333
334 for (int i = 0; i < keys.length; ++i)
335 {
336 String name = getUpperName(keys[i]);
337 OpenMBeanAttributeInfo attribute = mapping.get(name);
338 assertNotNull("Could not find key " + name + " in " + mapping.keySet(), attribute);
339 Object value = server.getAttribute(objectName, name);
340 checkValueEquals(values[i], value);
341 Method method = MXBeanUtils.getCompositeDataMethod(intf, keys[i], types[i] == SimpleType.BOOLEAN);
342 value = method.invoke(mxbean, null);
343 checkValueEquals(realValues[i], value);
344 assertEquals(types[i], attribute.getOpenType());
345 attributeNames[i] = name;
346 }
347
348 AttributeList list = server.getAttributes(objectName, attributeNames);
349 for (int i = 0; i < keys.length; ++i)
350 {
351 String name = attributeNames[i];
352 OpenMBeanAttributeInfo attribute = mapping.get(name);
353 Attribute attr = (Attribute ) list.get(i);
354 checkValueEquals(values[i], attr.getValue());
355 assertEquals(types[i], attribute.getOpenType());
356 }
357 }
358
359 private void setAttributes(MBeanServer server, ObjectName objectName, AttributeList list) throws Exception
360 {
361 AttributeList result = server.setAttributes(objectName, list);
362 for (int i = 0; i < list.size(); ++i)
363 {
364 Attribute attribute = (Attribute ) list.get(i);
365 Object expected = attribute.getValue();
366 attribute = (Attribute ) result.get(i);
367 Object actual = attribute.getValue();
368 checkValueEquals(expected, actual);
369 }
370 }
371 }
372 |
Popular Tags |
Java API By Example, From Geeks To Geeks.