001: /* Copyright (C) 2004 - 2007 db4objects Inc. http://www.db4o.com
002:
003: This file is part of the db4o open source object database.
004:
005: db4o is free software; you can redistribute it and/or modify it under
006: the terms of version 2 of the GNU General Public License as published
007: by the Free Software Foundation and as clarified by db4objects' GPL
008: interpretation policy, available at
009: http://www.db4o.com/about/company/legalpolicies/gplinterpretation/
010: Alternatively you can write to db4objects, Inc., 1900 S Norfolk Street,
011: Suite 350, San Mateo, CA 94403, USA.
012:
013: db4o is distributed in the hope that it will be useful, but WITHOUT ANY
014: WARRANTY; without even the implied warranty of MERCHANTABILITY or
015: FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
016: for more details.
017:
018: You should have received a copy of the GNU General Public License along
019: with this program; if not, write to the Free Software Foundation, Inc.,
020: 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
021: package com.db4o.db4ounit.common.handlers;
022:
023: import com.db4o.db4ounit.util.*;
024:
025: import db4ounit.*;
026:
027: public class ShortHandlerUpdateTestCase extends
028: HandlerUpdateTestCaseBase {
029:
030: public static class Item {
031: public short _typedPrimitive;
032:
033: public Short _typedWrapper;
034:
035: public Object _untyped;
036: }
037:
038: public static class ItemArrays {
039: public short[] _typedPrimitiveArray;
040:
041: public Short[] _typedWrapperArray;
042:
043: public Object[] _untypedObjectArray;
044:
045: public Object _primitiveArrayInObject;
046:
047: public Object _wrapperArrayInObject;
048: }
049:
050: private static final short[] data = new short[] { Short.MIN_VALUE,
051: Short.MIN_VALUE + 1, -5, -1, 0, 1, 5, Short.MAX_VALUE - 1,
052: Short.MAX_VALUE, };
053:
054: public static void main(String[] args) {
055: new TestRunner(ShortHandlerUpdateTestCase.class).run();
056: }
057:
058: protected void assertArrays(Object obj) {
059: ItemArrays itemArrays = (ItemArrays) obj;
060:
061: assertPrimitiveArray(itemArrays._typedPrimitiveArray);
062: if (_db4oHeaderVersion == VersionServices.HEADER_30_40) {
063: // Bug in the oldest format: It accidentally short[] arrays to Short[] arrays.
064: assertWrapperArray((Short[]) itemArrays._primitiveArrayInObject);
065: } else {
066: assertPrimitiveArray((short[]) itemArrays._primitiveArrayInObject);
067: }
068: assertWrapperArray(itemArrays._typedWrapperArray);
069: assertUntypedObjectArray(itemArrays);
070: assertWrapperArray((Short[]) itemArrays._wrapperArrayInObject);
071: }
072:
073: /**
074: * @sharpen.remove Cannot convert 'object[]' to 'Short[]' in .net
075: */
076: private void assertUntypedObjectArray(ItemArrays itemArrays) {
077: assertWrapperArray((Short[]) itemArrays._untypedObjectArray);
078: }
079:
080: private void assertPrimitiveArray(short[] primitiveArray) {
081: for (int i = 0; i < data.length; i++) {
082: assertAreEqual(data[i], primitiveArray[i]);
083: }
084: }
085:
086: private void assertWrapperArray(Short[] wrapperArray) {
087: for (int i = 0; i < data.length; i++) {
088: assertAreEqual(new Short(data[i]), wrapperArray[i]);
089: }
090: //FIXME: Arrays should also get a null Bitmap to fix.
091: //Assert.isNull(wrapperArray[wrapperArray.length - 1]);
092: }
093:
094: protected void assertValues(Object[] values) {
095: for (int i = 0; i < data.length; i++) {
096: Item item = (Item) values[i];
097: assertAreEqual(data[i], item._typedPrimitive);
098: assertAreEqual(new Short(data[i]), item._typedWrapper);
099: assertAreEqual(new Short(data[i]), item._untyped);
100: }
101:
102: Item nullItem = (Item) values[values.length - 1];
103: assertAreEqual((short) 0, nullItem._typedPrimitive);
104: assertPrimitiveWrapperIsNullJavaOnly(nullItem._typedWrapper);
105: Assert.isNull(nullItem._untyped);
106: }
107:
108: private void assertAreEqual(short expected, short actual) {
109: if (expected == Short.MAX_VALUE && _handlerVersion == 0) {
110: // Bug in the oldest format: It treats Short.MAX_VALUE as null.
111: expected = 0;
112: }
113: Assert.areEqual(expected, actual);
114: }
115:
116: private void assertAreEqual(Object expected, Object actual) {
117: if (new Short(Short.MAX_VALUE).equals(expected)
118: && _handlerVersion == 0) {
119: // Bug in the oldest format: It treats Short.MAX_VALUE as null.
120: expected = null;
121: }
122: Assert.areEqual(expected, actual);
123: }
124:
125: protected Object createArrays() {
126: ItemArrays itemArrays = new ItemArrays();
127: itemArrays._typedPrimitiveArray = new short[data.length];
128: System.arraycopy(data, 0, itemArrays._typedPrimitiveArray, 0,
129: data.length);
130:
131: Short[] dataWrapper = new Short[data.length];
132: for (int i = 0; i < data.length; i++) {
133: dataWrapper[i] = new Short(data[i]);
134: }
135:
136: itemArrays._typedWrapperArray = new Short[data.length + 1];
137: System.arraycopy(dataWrapper, 0, itemArrays._typedWrapperArray,
138: 0, dataWrapper.length);
139:
140: initializeUntypedObjectArray(itemArrays, dataWrapper);
141:
142: short[] primitiveArray = new short[data.length];
143: System.arraycopy(data, 0, primitiveArray, 0, data.length);
144: itemArrays._primitiveArrayInObject = primitiveArray;
145:
146: Short[] wrapperArray = new Short[data.length + 1];
147: System.arraycopy(dataWrapper, 0, wrapperArray, 0,
148: dataWrapper.length);
149: itemArrays._wrapperArrayInObject = wrapperArray;
150: return itemArrays;
151: }
152:
153: /**
154: * @sharpen.remove Cannot convert 'Short[]' to 'object[]'
155: */
156: private void initializeUntypedObjectArray(ItemArrays itemArrays,
157: Short[] dataWrapper) {
158: itemArrays._untypedObjectArray = new Short[data.length + 1];
159: System.arraycopy(dataWrapper, 0,
160: itemArrays._untypedObjectArray, 0, dataWrapper.length);
161: }
162:
163: protected Object[] createValues() {
164: Item[] values = new Item[data.length + 1];
165: for (int i = 0; i < data.length; i++) {
166: Item item = new Item();
167: item._typedPrimitive = data[i];
168: item._typedWrapper = new Short(data[i]);
169: item._untyped = new Short(data[i]);
170: values[i] = item;
171: }
172: values[values.length - 1] = new Item();
173: return values;
174: }
175:
176: protected String typeName() {
177: return "short";
178: }
179:
180: }
|