1 package org.apache.torque.generator.source.transform;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import static org.junit.Assert.assertEquals;
23
24 import java.io.StringReader;
25 import java.util.List;
26
27 import org.apache.torque.generator.source.transform.AttributeTransformer;
28 import org.apache.torque.generator.source.transform.SourceTransformerException;
29 import org.junit.Before;
30 import org.junit.Test;
31
32 public class AttributeTransformerTest
33 {
34 private AttributeTransformer emptyTransformer;
35
36 @Before
37 public void before() throws SourceTransformerException
38 {
39 StringReader stringReader = new StringReader("#");
40 emptyTransformer = new AttributeTransformer(stringReader);
41 }
42
43 @Test
44 public void testParsePlainText() throws SourceTransformerException
45 {
46 List<AttributeTransformer.Definition> result
47 = emptyTransformer.parse("abcxy", true);
48 assertEquals(1, result.size());
49 assertEquals(
50 AttributeTransformer.Definition.Type.PLAIN,
51 result.get(0).getType());
52 assertEquals("abcxy", result.get(0).getContent());
53 }
54
55 @Test
56 public void testParseOption() throws SourceTransformerException
57 {
58 List<AttributeTransformer.Definition> result
59 = emptyTransformer.parse("${option:torque:someOption}", true);
60 assertEquals(1, result.size());
61 assertEquals(
62 AttributeTransformer.Definition.Type.OPTION,
63 result.get(0).getType());
64 assertEquals("torque:someOption", result.get(0).getContent());
65 }
66
67 @Test
68 public void testParseAttribute() throws SourceTransformerException
69 {
70 List<AttributeTransformer.Definition> result
71 = emptyTransformer.parse(
72 "${attribute:org.apache.torque:someAttribute}",
73 true);
74 assertEquals(1, result.size());
75 assertEquals(
76 AttributeTransformer.Definition.Type.ATTRIBUTE,
77 result.get(0).getType());
78 assertEquals(
79 "org.apache.torque:someAttribute",
80 result.get(0).getContent());
81 }
82
83 @Test
84 public void testParseOverrideAttribute() throws SourceTransformerException
85 {
86 List<AttributeTransformer.Definition> result
87 = emptyTransformer.parse(
88 "${attribute(override):torque:someAttribute}",
89 false);
90 assertEquals(1, result.size());
91 assertEquals(
92 AttributeTransformer.Definition.Type.ATTRIBUTE_OVERRIDE,
93 result.get(0).getType());
94 assertEquals(
95 "torque:someAttribute",
96 result.get(0).getContent());
97 }
98
99 @Test
100 public void testParseNoOverrideAttribute() throws SourceTransformerException
101 {
102 List<AttributeTransformer.Definition> result
103 = emptyTransformer.parse(
104 "${attribute(noOverride):torque:someAttribute}",
105 false);
106 assertEquals(1, result.size());
107 assertEquals(
108 AttributeTransformer.Definition.Type.ATTRIBUTE_NO_OVERRIDE,
109 result.get(0).getType());
110 assertEquals(
111 "torque:someAttribute",
112 result.get(0).getContent());
113 }
114
115 @Test
116 public void testParseEscapingInPlain() throws SourceTransformerException
117 {
118 List<AttributeTransformer.Definition> result
119 = emptyTransformer.parse("\\:\\$\\}\\{\\\\l", true);
120 assertEquals(1, result.size());
121 assertEquals(
122 AttributeTransformer.Definition.Type.PLAIN,
123 result.get(0).getType());
124 assertEquals(
125 ":$}{\\l",
126 result.get(0).getContent());
127 }
128
129 @Test
130 public void testParseEscapingInDefinition() throws SourceTransformerException
131 {
132 List<AttributeTransformer.Definition> result
133 = emptyTransformer.parse(
134 "${attribute:\\:\\$\\}\\{l\\\\}",
135 true);
136 assertEquals(1, result.size());
137 assertEquals(
138 AttributeTransformer.Definition.Type.ATTRIBUTE,
139 result.get(0).getType());
140 assertEquals(
141 ":$}{l\\",
142 result.get(0).getContent());
143 }
144
145 @Test
146 public void testParseSeveralDefinitions() throws SourceTransformerException
147 {
148 List<AttributeTransformer.Definition> result
149 = emptyTransformer.parse(
150 "${attribute:someAttribute}"
151 + "${option:someOption}"
152 + "plainText"
153 + "${option:someOption1}"
154 + "${attribute:someAttribute1}",
155 true);
156 assertEquals(5, result.size());
157 assertEquals(
158 AttributeTransformer.Definition.Type.ATTRIBUTE,
159 result.get(0).getType());
160 assertEquals("someAttribute", result.get(0).getContent());
161 assertEquals(
162 AttributeTransformer.Definition.Type.OPTION,
163 result.get(1).getType());
164 assertEquals("someOption", result.get(1).getContent());
165 assertEquals(
166 AttributeTransformer.Definition.Type.PLAIN,
167 result.get(2).getType());
168 assertEquals("plainText", result.get(2).getContent());
169 assertEquals(
170 AttributeTransformer.Definition.Type.OPTION,
171 result.get(3).getType());
172 assertEquals("someOption1", result.get(3).getContent());
173 assertEquals(
174 AttributeTransformer.Definition.Type.ATTRIBUTE,
175 result.get(4).getType());
176 assertEquals("someAttribute1", result.get(4).getContent());
177 }
178
179 @Test(expected = SourceTransformerException.class)
180 public void testParseNotEndedDefinition() throws SourceTransformerException
181 {
182 emptyTransformer.parse(
183 "${option:torque.endlessAttribute",
184 false);
185 }
186
187 @Test(expected = SourceTransformerException.class)
188 public void testParseDefinitionInsideType()
189 throws SourceTransformerException
190 {
191 emptyTransformer.parse(
192 "${option:torque${option:torque.otherAttr}",
193 false);
194 }
195
196 @Test(expected = SourceTransformerException.class)
197 public void testParseDefinitionInsideValue()
198 throws SourceTransformerException
199 {
200 emptyTransformer.parse(
201 "${option:torque.attribute${option:torque.otherAttr}",
202 false);
203 }
204
205 @Test(expected = SourceTransformerException.class)
206 public void testUnknownDefinition() throws SourceTransformerException
207 {
208 emptyTransformer.parse(
209 "${unknownDefinition:torque.unknownDefinition}",
210 false);
211 }
212
213 @Test(expected = SourceTransformerException.class)
214 public void testParsePlainInTarget() throws SourceTransformerException
215 {
216 emptyTransformer.parse(
217 "xy",
218 false);
219 }
220
221 @Test(expected = SourceTransformerException.class)
222 public void testParseOptionInTarget() throws SourceTransformerException
223 {
224 emptyTransformer.parse(
225 "${option:torque.optionValue}",
226 false);
227 }
228
229 @Test(expected = SourceTransformerException.class)
230 public void testParseAttributeInTarget() throws SourceTransformerException
231 {
232 emptyTransformer.parse(
233 "${attribute:torque.attributeValue}",
234 false);
235 }
236
237 @Test(expected = SourceTransformerException.class)
238 public void testParseNoOverrideAttributeInSource()
239 throws SourceTransformerException
240 {
241 emptyTransformer.parse(
242 "${attribute(noOverride):torque.attributeValue}",
243 true);
244 }
245
246 @Test(expected = SourceTransformerException.class)
247 public void testParseOverrideAttributeInSource()
248 throws SourceTransformerException
249 {
250 emptyTransformer.parse(
251 "${attribute(override):torque.attributeValue}",
252 true);
253 }
254 }