1 /***
2 * Copyright 2003-2010 Terracotta, Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package net.sf.ehcache.config.generator.xsom;
18
19 import net.sf.ehcache.config.MemoryUnit;
20
21 import java.util.Iterator;
22 import java.util.Random;
23
24 import com.sun.xml.xsom.XSAttributeDecl;
25 import com.sun.xml.xsom.XSFacet;
26 import com.sun.xml.xsom.XSRestrictionSimpleType;
27 import com.sun.xml.xsom.XSSimpleType;
28
29 public abstract class XSDAttributeValueType {
30
31 protected static final Random RANDOM = new Random(System.currentTimeMillis());
32 protected String pattern;
33 public enum XsdType {
34 BOOLEAN, INTEGER, POSITIVE_INTEGER, NON_NEGATIVE_INTEGER, STRING, ANY_SIMPLE_TYPE, ENUMERATION;
35 }
36 protected String maxValue;
37 protected String minValue;
38 protected String length;
39 protected String maxLength;
40 protected String minLength;
41
42 protected String totalDigits;
43
44 private final XsdType type;
45
46 public XSDAttributeValueType(XsdType type) {
47 this.type = type;
48 }
49
50 public abstract String getRandomAllowedValue();
51
52 protected void fillUpRestrictions(XSAttributeDecl attributeDecl) {
53 XSSimpleType localType = attributeDecl.getType();
54 XSRestrictionSimpleType restriction = localType.asRestriction();
55 if (restriction != null) {
56 Iterator<? extends XSFacet> i = restriction.getDeclaredFacets().iterator();
57 while (i.hasNext()) {
58 XSFacet facet = i.next();
59 if (facet.getName().equals(XSFacet.FACET_MAXINCLUSIVE)) {
60 maxValue = facet.getValue().value;
61 }
62 if (facet.getName().equals(XSFacet.FACET_MININCLUSIVE)) {
63 minValue = facet.getValue().value;
64 }
65 if (facet.getName().equals(XSFacet.FACET_MAXEXCLUSIVE)) {
66 maxValue = String.valueOf(Integer.parseInt(facet.getValue().value) - 1);
67 }
68 if (facet.getName().equals(XSFacet.FACET_MINEXCLUSIVE)) {
69 minValue = String.valueOf(Integer.parseInt(facet.getValue().value) + 1);
70 }
71 if (facet.getName().equals(XSFacet.FACET_LENGTH)) {
72 length = facet.getValue().value;
73 }
74 if (facet.getName().equals(XSFacet.FACET_MAXLENGTH)) {
75 maxLength = facet.getValue().value;
76 }
77 if (facet.getName().equals(XSFacet.FACET_MINLENGTH)) {
78 minLength = facet.getValue().value;
79 }
80 if (facet.getName().equals(XSFacet.FACET_PATTERN)) {
81 pattern = facet.getValue().value;
82 }
83 if (facet.getName().equals(XSFacet.FACET_TOTALDIGITS)) {
84 totalDigits = facet.getValue().value;
85 }
86 }
87 }
88 }
89
90 public static class XSDAttributeValueBooleanType extends XSDAttributeValueType {
91
92 public XSDAttributeValueBooleanType() {
93 super(XsdType.BOOLEAN);
94 }
95
96 @Override
97 public String getRandomAllowedValue() {
98 return RANDOM.nextInt() % 2 == 0 ? getTrue() : getFalse();
99 }
100
101 public String getTrue() {
102 return String.valueOf(true);
103 }
104
105 public String getFalse() {
106 return String.valueOf(false);
107 }
108
109 }
110
111 public static class XSDAttributeValueIntegerType extends XSDAttributeValueType {
112
113 public XSDAttributeValueIntegerType() {
114 super(XsdType.INTEGER);
115 }
116
117 @Override
118 public String getRandomAllowedValue() {
119 return String.valueOf(RANDOM.nextInt());
120 }
121
122 }
123
124 public static class XSDAttributeValuePositiveIntegerType extends XSDAttributeValueType {
125
126 public XSDAttributeValuePositiveIntegerType() {
127 super(XsdType.POSITIVE_INTEGER);
128 }
129
130 @Override
131 public String getRandomAllowedValue() {
132 return String.valueOf(Math.abs(RANDOM.nextInt() + 1));
133 }
134
135 }
136
137 public static class XSDAttributeValueNonNegativeIntegerType extends XSDAttributeValueType {
138
139 public XSDAttributeValueNonNegativeIntegerType() {
140 super(XsdType.NON_NEGATIVE_INTEGER);
141 }
142
143 @Override
144 public String getRandomAllowedValue() {
145 return String.valueOf(Math.abs(RANDOM.nextInt()));
146 }
147
148 }
149
150 public static class XSDAttributeValueMemoryUnitType extends XSDAttributeValueType {
151
152 public static final char[] unitChars;
153
154 static {
155 MemoryUnit[] values = MemoryUnit.values();
156 char [] chars = new char[values.length * 2];
157 int i = 0;
158 for (MemoryUnit memoryUnit : values) {
159 chars[i++] = Character.toLowerCase(memoryUnit.getUnit());
160 chars[i++] = Character.toUpperCase(memoryUnit.getUnit());
161 }
162 unitChars = chars;
163 }
164
165 public XSDAttributeValueMemoryUnitType() {
166 super(XsdType.NON_NEGATIVE_INTEGER);
167 }
168
169 @Override
170 public String getRandomAllowedValue() {
171 int index = RANDOM.nextInt(unitChars.length + 1);
172 if(index < unitChars.length) {
173 return String.valueOf(Math.abs(RANDOM.nextInt())) + unitChars[index];
174 }
175 return String.valueOf(Math.abs(RANDOM.nextInt()));
176 }
177
178 }
179
180 public static class XSDAttributeValueMemoryUnitOrPercentageType extends XSDAttributeValueType {
181
182 public static final char[] unitChars;
183
184 static {
185 MemoryUnit[] values = MemoryUnit.values();
186 char [] chars = new char[values.length * 2 + 1];
187 int i = 0;
188 for (MemoryUnit memoryUnit : values) {
189 chars[i++] = Character.toLowerCase(memoryUnit.getUnit());
190 chars[i++] = Character.toUpperCase(memoryUnit.getUnit());
191 }
192 chars[i] = '%';
193 unitChars = chars;
194 }
195
196 public XSDAttributeValueMemoryUnitOrPercentageType() {
197 super(XsdType.NON_NEGATIVE_INTEGER);
198 }
199
200 @Override
201 public String getRandomAllowedValue() {
202 int index = RANDOM.nextInt(unitChars.length + 1);
203 if(index < unitChars.length) {
204 switch (unitChars[index]) {
205 case '%' :
206 return String.valueOf(Math.abs(RANDOM.nextInt(100) + 1)) + unitChars[index];
207 default:
208 return String.valueOf(Math.abs(RANDOM.nextInt())) + unitChars[index];
209 }
210 }
211 return String.valueOf(Math.abs(RANDOM.nextInt()));
212 }
213
214 }
215
216 public static class XSDAttributeValueStringType extends XSDAttributeValueType {
217
218 private static final String[] RANDOM_VALUES = {"random_string_one", "random_string_two", "random_string_three", "random_string_four",
219 "random_string_five", };
220
221 public XSDAttributeValueStringType() {
222 super(XsdType.STRING);
223 }
224
225 @Override
226 public String getRandomAllowedValue() {
227 return RANDOM_VALUES[RANDOM.nextInt(RANDOM_VALUES.length)];
228 }
229
230 }
231
232 public static class XSDAttributeValueAnySimpleType extends XSDAttributeValueType {
233
234 private static final String[] RANDOM_VALUES = {"any_simple_type_random_one", "any_simple_type_random_two",
235 "any_simple_type_random_three", "any_simple_type_random_four", "any_simple_type_random_five", };
236
237 public XSDAttributeValueAnySimpleType() {
238 super(XsdType.ANY_SIMPLE_TYPE);
239 }
240
241 @Override
242 public String getRandomAllowedValue() {
243 return RANDOM_VALUES[RANDOM.nextInt(RANDOM_VALUES.length)];
244 }
245
246 }
247
248 public static class XSDAttributeValueEnumerationType extends XSDAttributeValueType {
249
250 private final String[] enumeration;
251
252 public XSDAttributeValueEnumerationType(String[] enumeration) {
253 super(XsdType.ENUMERATION);
254 this.enumeration = enumeration;
255 }
256
257 @Override
258 public String getRandomAllowedValue() {
259 return enumeration[RANDOM.nextInt(enumeration.length)];
260 }
261
262 }
263
264 }