1
2
3
4
5
6
7
8
9
10 package org.mule.transformer;
11
12 import org.mule.api.transformer.DiscoverableTransformer;
13 import org.mule.api.transformer.Transformer;
14 import org.mule.api.transformer.TransformerException;
15 import org.mule.tck.AbstractMuleTestCase;
16 import org.mule.tck.testmodels.fruit.BloodOrange;
17 import org.mule.tck.testmodels.fruit.Fruit;
18 import org.mule.tck.testmodels.fruit.FruitBowl;
19 import org.mule.tck.testmodels.fruit.Orange;
20 import org.mule.transformer.simple.ObjectToByteArray;
21 import org.mule.transformer.simple.SerializableToByteArray;
22 import org.mule.transformer.types.DataTypeFactory;
23 import org.mule.transformer.types.SimpleDataType;
24
25 import java.io.FilterInputStream;
26 import java.io.IOException;
27 import java.util.Iterator;
28 import java.util.List;
29
30 public class TransformerWeightingTestCase extends AbstractMuleTestCase
31 {
32
33 public void testExactMatch() throws Exception
34 {
35 DummyTransformer trans = new DummyTransformer();
36 trans.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
37 trans.registerSourceType(DataTypeFactory.create(IOException.class));
38
39 TransformerWeighting weighting = new TransformerWeighting(IOException.class, byte[].class, trans);
40
41 assertFalse(weighting.isNotMatch());
42 assertTrue(weighting.isExactMatch());
43 }
44
45 public void testNearMatch() throws Exception
46 {
47 ObjectToByteArray trans = new ObjectToByteArray();
48
49 TransformerWeighting weighting = new TransformerWeighting(FilterInputStream.class, byte[].class, trans);
50
51 assertFalse(weighting.isNotMatch());
52 assertFalse(weighting.isExactMatch());
53 assertEquals(1, weighting.getInputWeighting());
54 assertEquals(0, weighting.getOutputWeighting());
55
56 }
57
58 public void testNoMatchWeighting() throws Exception
59 {
60 SerializableToByteArray trans = new SerializableToByteArray();
61
62 TransformerWeighting weighting = new TransformerWeighting(FruitBowl.class, byte[].class, trans);
63
64 assertTrue(weighting.isNotMatch());
65 assertEquals(-1, weighting.getInputWeighting());
66 assertEquals(0, weighting.getOutputWeighting());
67
68 }
69
70 public void testCompareWeightingWithNearMatches() throws Exception
71 {
72 ObjectToByteArray trans1 = new ObjectToByteArray();
73
74 DummyTransformer trans2 = new DummyTransformer();
75 trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
76 trans2.registerSourceType(DataTypeFactory.create(Exception.class));
77
78 TransformerWeighting weighting1 =
79 new TransformerWeighting(IOException.class, byte[].class, trans1);
80 TransformerWeighting weighting2 =
81 new TransformerWeighting(IOException.class, byte[].class, trans2);
82
83 assertFalse(weighting1.isNotMatch());
84 assertFalse(weighting2.isNotMatch());
85 assertFalse(weighting1.isExactMatch());
86 assertFalse(weighting2.isExactMatch());
87
88 assertEquals(1, weighting2.compareTo(weighting1));
89
90 assertEquals(3, weighting1.getInputWeighting());
91 assertEquals(1, weighting2.getInputWeighting());
92 assertEquals(0, weighting1.getOutputWeighting());
93 assertEquals(0, weighting2.getOutputWeighting());
94
95 }
96
97 public void testCompareWeightingWithExactMatch() throws Exception
98 {
99 ObjectToByteArray trans1 = new ObjectToByteArray();
100
101 DummyTransformer trans2 = new DummyTransformer();
102 trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
103 trans2.registerSourceType(DataTypeFactory.create(IOException.class));
104
105 TransformerWeighting weighting1 =
106 new TransformerWeighting(IOException.class, byte[].class, trans1);
107 TransformerWeighting weighting2 =
108 new TransformerWeighting(IOException.class, byte[].class, trans2);
109
110 assertFalse(weighting1.isNotMatch());
111 assertFalse(weighting2.isNotMatch());
112 assertFalse(weighting1.isExactMatch());
113 assertTrue(weighting2.isExactMatch());
114
115 assertEquals(1, weighting2.compareTo(weighting1));
116
117 assertEquals(3, weighting1.getInputWeighting());
118 assertEquals(0, weighting2.getInputWeighting());
119 assertEquals(0, weighting1.getOutputWeighting());
120 assertEquals(0, weighting2.getOutputWeighting());
121
122 }
123
124 public void testCompareWeightingWithNoMatch() throws Exception
125 {
126 ObjectToByteArray trans1 = new ObjectToByteArray();
127
128 DummyTransformer trans2 = new DummyTransformer();
129 trans2.setReturnDataType(DataTypeFactory.BYTE_ARRAY);
130 trans2.registerSourceType(DataTypeFactory.create(FruitBowl.class));
131
132 TransformerWeighting weighting1 =
133 new TransformerWeighting(IOException.class, byte[].class, trans1);
134 TransformerWeighting weighting2 =
135 new TransformerWeighting(IOException.class, byte[].class, trans2);
136
137 assertFalse(weighting1.isNotMatch());
138 assertTrue(weighting2.isNotMatch());
139 assertFalse(weighting1.isExactMatch());
140 assertFalse(weighting2.isExactMatch());
141
142 assertEquals(-1, weighting2.compareTo(weighting1));
143
144 assertEquals(3, weighting1.getInputWeighting());
145 assertEquals(-1, weighting2.getInputWeighting());
146 assertEquals(0, weighting1.getOutputWeighting());
147 assertEquals(0, weighting2.getOutputWeighting());
148
149 }
150
151 public void testPriorityMatching() throws Exception
152 {
153 DummyTransformer t1 = new DummyTransformer();
154 t1.setName("--t1");
155 t1.registerSourceType(DataTypeFactory.create(Orange.class));
156 t1.setReturnDataType(DataTypeFactory.create(Fruit.class));
157 muleContext.getRegistry().registerTransformer(t1);
158
159 DummyTransformer t2 = new DummyTransformer();
160 t2.setName("--t2");
161 t2.registerSourceType(DataTypeFactory.OBJECT);
162 t2.setReturnDataType(DataTypeFactory.create(Fruit.class));
163 muleContext.getRegistry().registerTransformer(t2);
164
165 List trans = muleContext.getRegistry().lookupTransformers(new SimpleDataType(BloodOrange.class), new SimpleDataType(Fruit.class));
166 assertEquals(2, trans.size());
167 for (Iterator iterator = trans.iterator(); iterator.hasNext();)
168 {
169 Transformer transformer = (Transformer) iterator.next();
170 assertTrue(transformer.getName().startsWith("--"));
171 }
172
173 Transformer result = muleContext.getRegistry().lookupTransformer(new SimpleDataType(BloodOrange.class), new SimpleDataType(Fruit.class));
174 assertNotNull(result);
175 assertEquals("--t1", result.getName());
176 }
177
178 private static class DummyTransformer extends AbstractTransformer implements DiscoverableTransformer
179 {
180 private int weighting;
181
182 public DummyTransformer()
183 {
184 super();
185 }
186
187 public int getPriorityWeighting()
188 {
189 return weighting;
190 }
191
192
193 public void setPriorityWeighting(int weighting)
194 {
195 this.weighting = weighting;
196 }
197
198 @Override
199 protected Object doTransform(Object src, String encoding) throws TransformerException
200 {
201 return src;
202 }
203 }
204 }