001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one
003: * or more contributor license agreements. See the NOTICE file
004: * distributed with this work for additional information
005: * regarding copyright ownership. The ASF licenses this file
006: * to you under the Apache License, Version 2.0 (the
007: * "License"); you may not use this file except in compliance
008: * with the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing,
013: * software distributed under the License is distributed on an
014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015: * KIND, either express or implied. See the License for the
016: * specific language governing permissions and limitations
017: * under the License.
018: */
019: package org.apache.axis2.schema.testsuite;
020:
021: import org.apache.axiom.om.OMAbstractFactory;
022: import org.apache.axiom.om.OMElement;
023: import org.apache.axiom.om.util.StAXUtils;
024: import services.echo.types.*;
025:
026: import javax.xml.stream.XMLStreamReader;
027: import java.io.ByteArrayInputStream;
028: import java.util.Arrays;
029:
030: public class IntElementsTest extends AbstractTest {
031:
032: public static final int MIN_EQUALS_ZERO_NILLABLE_TRUE_TEST = 1;
033: public static final int MIN_EQUALS_ZERO_NILLABLE_FALSE_TEST = 2;
034: public static final int MIN_EQUALS_ONE_NILLABLE_TRUE_TEST = 3;
035: public static final int MIN_EQUALS_ONE_NILLABLE_FALSE_TEST = 4;
036:
037: public void testIntArray() {
038: int[] returnObject;
039: System.out.println("minOccurs = 0 nillable true");
040: try {
041: returnObject = testIntArray(null,
042: MIN_EQUALS_ZERO_NILLABLE_TRUE_TEST);
043: assertTrue(Arrays.equals(returnObject,
044: new int[] { Integer.MIN_VALUE }));
045: returnObject = testIntArray(new int[] { 5 },
046: MIN_EQUALS_ZERO_NILLABLE_TRUE_TEST);
047: assertTrue(Arrays.equals(returnObject, new int[] { 5 }));
048: returnObject = testIntArray(
049: new int[] { Integer.MIN_VALUE },
050: MIN_EQUALS_ZERO_NILLABLE_TRUE_TEST);
051: assertTrue(Arrays.equals(returnObject,
052: new int[] { Integer.MIN_VALUE }));
053: returnObject = testIntArray(new int[] { Integer.MIN_VALUE,
054: 5 }, MIN_EQUALS_ZERO_NILLABLE_TRUE_TEST);
055: assertTrue(Arrays.equals(returnObject, new int[] {
056: Integer.MIN_VALUE, 5 }));
057: } catch (Exception e) {
058: fail();
059: }
060: System.out.println("minOccurs = 0 nillable false");
061: try {
062: returnObject = testIntArray(null,
063: MIN_EQUALS_ZERO_NILLABLE_FALSE_TEST);
064: assertTrue(Arrays.equals(returnObject, null));
065: returnObject = testIntArray(new int[] { 5 },
066: MIN_EQUALS_ZERO_NILLABLE_FALSE_TEST);
067: assertTrue(Arrays.equals(returnObject, new int[] { 5 }));
068: returnObject = testIntArray(
069: new int[] { Integer.MIN_VALUE },
070: MIN_EQUALS_ZERO_NILLABLE_FALSE_TEST);
071: assertTrue(Arrays.equals(returnObject, null));
072: } catch (Exception e) {
073: fail();
074: }
075: System.out.println("minOccurs = 1 nillable true");
076: try {
077: returnObject = testIntArray(null,
078: MIN_EQUALS_ONE_NILLABLE_TRUE_TEST);
079: assertTrue(Arrays.equals(returnObject,
080: new int[] { Integer.MIN_VALUE }));
081: returnObject = testIntArray(new int[] { 5 },
082: MIN_EQUALS_ONE_NILLABLE_TRUE_TEST);
083: assertTrue(Arrays.equals(returnObject, new int[] { 5 }));
084: returnObject = testIntArray(
085: new int[] { Integer.MIN_VALUE },
086: MIN_EQUALS_ONE_NILLABLE_TRUE_TEST);
087: assertTrue(Arrays.equals(returnObject,
088: new int[] { Integer.MIN_VALUE }));
089: } catch (Exception e) {
090: e.printStackTrace();
091: fail();
092: }
093:
094: System.out.println("minOccurs = 1 nillable false");
095: try {
096: returnObject = testIntArray(null,
097: MIN_EQUALS_ONE_NILLABLE_FALSE_TEST);
098: fail();
099: } catch (Exception e) {
100: assertTrue(true);
101: }
102:
103: try {
104: returnObject = testIntArray(
105: new int[] { Integer.MIN_VALUE },
106: MIN_EQUALS_ONE_NILLABLE_FALSE_TEST);
107: fail();
108: } catch (Exception e) {
109: assertTrue(true);
110: }
111:
112: try {
113: returnObject = testIntArray(new int[] { 5 },
114: MIN_EQUALS_ONE_NILLABLE_FALSE_TEST);
115: assertTrue(Arrays.equals(returnObject, new int[] { 5 }));
116: } catch (Exception e) {
117: fail();
118: }
119: }
120:
121: private int[] testIntArray(int[] innerElement, int type)
122: throws Exception {
123: OMElement omElement;
124: int[] returnObject = null;
125: String omElementString;
126: switch (type) {
127: case MIN_EQUALS_ZERO_NILLABLE_TRUE_TEST: {
128: TestInt1 testInt = new TestInt1();
129: testInt.setTestValue(innerElement);
130: omElement = testInt.getOMElement(TestInt1.MY_QNAME,
131: OMAbstractFactory.getSOAP12Factory());
132: omElementString = omElement.toStringWithConsume();
133: System.out.println("OMElement ==> " + omElementString);
134: XMLStreamReader xmlReader = StAXUtils
135: .createXMLStreamReader(new ByteArrayInputStream(
136: omElementString.getBytes()));
137: returnObject = TestInt1.Factory.parse(xmlReader)
138: .getTestValue();
139: break;
140: }
141: case MIN_EQUALS_ZERO_NILLABLE_FALSE_TEST: {
142: TestInt3 testInt = new TestInt3();
143: testInt.setTestValue(innerElement);
144: omElement = testInt.getOMElement(TestInt3.MY_QNAME,
145: OMAbstractFactory.getSOAP12Factory());
146: omElementString = omElement.toStringWithConsume();
147: System.out.println("OMElement ==> " + omElementString);
148: XMLStreamReader xmlReader = StAXUtils
149: .createXMLStreamReader(new ByteArrayInputStream(
150: omElementString.getBytes()));
151: returnObject = TestInt3.Factory.parse(xmlReader)
152: .getTestValue();
153: break;
154: }
155: case MIN_EQUALS_ONE_NILLABLE_TRUE_TEST: {
156: TestInt5 testInt = new TestInt5();
157: testInt.setTestValue(innerElement);
158: omElement = testInt.getOMElement(TestInt5.MY_QNAME,
159: OMAbstractFactory.getSOAP12Factory());
160: omElementString = omElement.toStringWithConsume();
161: System.out.println("OMElement ==> " + omElementString);
162: XMLStreamReader xmlReader = StAXUtils
163: .createXMLStreamReader(new ByteArrayInputStream(
164: omElementString.getBytes()));
165: returnObject = TestInt5.Factory.parse(xmlReader)
166: .getTestValue();
167: break;
168: }
169: case MIN_EQUALS_ONE_NILLABLE_FALSE_TEST: {
170: TestInt7 testInt = new TestInt7();
171: testInt.setTestValue(innerElement);
172: omElement = testInt.getOMElement(TestInt7.MY_QNAME,
173: OMAbstractFactory.getSOAP12Factory());
174: omElementString = omElement.toStringWithConsume();
175: System.out.println("OMElement ==> " + omElementString);
176: XMLStreamReader xmlReader = StAXUtils
177: .createXMLStreamReader(new ByteArrayInputStream(
178: omElementString.getBytes()));
179: returnObject = TestInt7.Factory.parse(xmlReader)
180: .getTestValue();
181: break;
182: }
183: }
184: return returnObject;
185: }
186:
187: public void testInt() {
188:
189: System.out.println("min =0 and nillable true test");
190: try {
191: assertEquals(
192: testInt(1, MIN_EQUALS_ZERO_NILLABLE_TRUE_TEST), 1);
193: assertEquals(testInt(Integer.MIN_VALUE,
194: MIN_EQUALS_ZERO_NILLABLE_TRUE_TEST),
195: Integer.MIN_VALUE);
196: } catch (Exception e) {
197: fail();
198: }
199:
200: try {
201: assertEquals(
202: testInt(1, MIN_EQUALS_ZERO_NILLABLE_FALSE_TEST), 1);
203: assertEquals(testInt(Integer.MIN_VALUE,
204: MIN_EQUALS_ZERO_NILLABLE_FALSE_TEST),
205: Integer.MIN_VALUE);
206: } catch (Exception e) {
207: fail();
208: }
209:
210: try {
211: assertEquals(testInt(1, MIN_EQUALS_ONE_NILLABLE_TRUE_TEST),
212: 1);
213: assertEquals(testInt(Integer.MIN_VALUE,
214: MIN_EQUALS_ONE_NILLABLE_TRUE_TEST),
215: Integer.MIN_VALUE);
216: } catch (Exception e) {
217: fail();
218: }
219:
220: try {
221: assertEquals(
222: testInt(1, MIN_EQUALS_ONE_NILLABLE_FALSE_TEST), 1);
223: } catch (Exception e) {
224: fail();
225: }
226:
227: try {
228: assertEquals(testInt(Integer.MIN_VALUE,
229: MIN_EQUALS_ONE_NILLABLE_FALSE_TEST),
230: Integer.MIN_VALUE);
231: fail();
232: } catch (Exception e) {
233: assertTrue(true);
234: }
235:
236: }
237:
238: public int testInt(int innerElement, int type) throws Exception {
239: OMElement omElement;
240: int returnInt = 0;
241: String omElementString;
242:
243: switch (type) {
244: case MIN_EQUALS_ZERO_NILLABLE_TRUE_TEST: {
245: TestInt2 testInt = new TestInt2();
246: testInt.setTestValue(innerElement);
247: omElement = testInt.getOMElement(TestInt2.MY_QNAME,
248: OMAbstractFactory.getSOAP12Factory());
249: omElementString = omElement.toStringWithConsume();
250: System.out.println("OMElement ==> " + omElementString);
251: XMLStreamReader xmlReader = StAXUtils
252: .createXMLStreamReader(new ByteArrayInputStream(
253: omElementString.getBytes()));
254: returnInt = TestInt2.Factory.parse(xmlReader)
255: .getTestValue();
256: break;
257: }
258: case MIN_EQUALS_ZERO_NILLABLE_FALSE_TEST: {
259: TestInt4 testInt = new TestInt4();
260: testInt.setTestValue(innerElement);
261: omElement = testInt.getOMElement(TestInt4.MY_QNAME,
262: OMAbstractFactory.getSOAP12Factory());
263: omElementString = omElement.toStringWithConsume();
264: System.out.println("OMElement ==> " + omElementString);
265: XMLStreamReader xmlReader = StAXUtils
266: .createXMLStreamReader(new ByteArrayInputStream(
267: omElementString.getBytes()));
268: returnInt = TestInt4.Factory.parse(xmlReader)
269: .getTestValue();
270: break;
271: }
272: case MIN_EQUALS_ONE_NILLABLE_TRUE_TEST: {
273: TestInt6 testInt = new TestInt6();
274: testInt.setTestValue(innerElement);
275: omElement = testInt.getOMElement(TestInt6.MY_QNAME,
276: OMAbstractFactory.getSOAP12Factory());
277: omElementString = omElement.toStringWithConsume();
278: System.out.println("OMElement ==> " + omElementString);
279: XMLStreamReader xmlReader = StAXUtils
280: .createXMLStreamReader(new ByteArrayInputStream(
281: omElementString.getBytes()));
282: returnInt = TestInt6.Factory.parse(xmlReader)
283: .getTestValue();
284: break;
285: }
286: case MIN_EQUALS_ONE_NILLABLE_FALSE_TEST: {
287: TestInt8 testInt = new TestInt8();
288: testInt.setTestValue(innerElement);
289: omElement = testInt.getOMElement(TestInt8.MY_QNAME,
290: OMAbstractFactory.getSOAP12Factory());
291: omElementString = omElement.toStringWithConsume();
292: System.out.println("OMElement ==> " + omElementString);
293: XMLStreamReader xmlReader = StAXUtils
294: .createXMLStreamReader(new ByteArrayInputStream(
295: omElementString.getBytes()));
296: returnInt = TestInt6.Factory.parse(xmlReader)
297: .getTestValue();
298: break;
299: }
300: }
301: return returnInt;
302: }
303: }
|