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 ByteHandlerUpdateTestCase extends
028: HandlerUpdateTestCaseBase {
029:
030: public static class Item {
031: public byte _typedPrimitive;
032:
033: public Byte _typedWrapper;
034:
035: public Object _untyped;
036: }
037:
038: public static class ItemArrays {
039: public byte[] _typedPrimitiveArray;
040:
041: public Byte[] _typedWrapperArray;
042:
043: public Object[] _untypedObjectArray;
044:
045: public Object _primitiveArrayInObject;
046:
047: public Object _wrapperArrayInObject;
048: }
049:
050: public static final byte[] data = new byte[] { Byte.MIN_VALUE,
051: Byte.MIN_VALUE + 1, (byte) 0xFB, (byte) 0xFF, 0, 1, 5,
052: Byte.MAX_VALUE - 1, Byte.MAX_VALUE, };
053:
054: public static void main(String[] args) {
055: new TestRunner(ByteHandlerUpdateTestCase.class).run();
056: }
057:
058: protected void assertArrays(Object obj) {
059: ItemArrays itemArrays = (ItemArrays) obj;
060:
061: assertPrimitiveArray(itemArrays._typedPrimitiveArray);
062:
063: if (_db4oHeaderVersion == VersionServices.HEADER_30_40) {
064: // Bug in the oldest format: It accidentally byte[] arrays to Byte[]
065: // arrays.
066: assertWrapperArray((Byte[]) itemArrays._primitiveArrayInObject);
067: } else {
068: // FIXME: Bug of store/retrieve byte[] as object.
069: // assertPrimitiveArray((byte[])
070: // itemArrays._primitiveArrayInObject);
071: }
072: assertWrapperArray(itemArrays._typedWrapperArray);
073: assertUntypedObjectArray(itemArrays);
074: assertWrapperArray((Byte[]) itemArrays._wrapperArrayInObject);
075: }
076:
077: /**
078: * @sharpen.remove Cannot convert 'object[]' to 'Byte[]' in .net
079: */
080: private void assertUntypedObjectArray(ItemArrays itemArrays) {
081: assertWrapperArray((Byte[]) itemArrays._untypedObjectArray);
082: }
083:
084: private void assertPrimitiveArray(byte[] primitiveArray) {
085: for (int i = 0; i < data.length; i++) {
086: assertAreEqual(data[i], primitiveArray[i]);
087: }
088: }
089:
090: /**
091: * FIXME: The byte optimization format change, COR-884 also hits .NET for the
092: * wrapper array. Convert to Dotnet again after we install special handlers
093: * for byte[]
094: *
095: * @sharpen.remove
096: */
097: private void assertWrapperArray(Byte[] wrapperArray) {
098: for (int i = 0; i < data.length; i++) {
099: assertAreEqual(new Byte(data[i]), wrapperArray[i]);
100: }
101: // FIXME: Arrays should also get a null Bitmap to fix.
102: // Assert.isNull(wrapperArray[wrapperArray.length - 1]);
103: }
104:
105: protected void assertValues(Object[] values) {
106: for (int i = 0; i < data.length; i++) {
107: Item item = (Item) values[i];
108: assertAreEqual(data[i], item._typedPrimitive);
109: assertAreEqual(new Byte(data[i]), item._typedWrapper);
110: assertAreEqual(new Byte(data[i]), item._untyped);
111: }
112:
113: Item nullItem = (Item) values[values.length - 1];
114: assertAreEqual((byte) 0, nullItem._typedPrimitive);
115: assertByteWrapperIsNullJavaOnly(nullItem._typedWrapper);
116: Assert.isNull(nullItem._untyped);
117: }
118:
119: private void assertAreEqual(byte expected, byte actual) {
120: Assert.areEqual(expected, actual);
121: }
122:
123: private void assertAreEqual(Object expected, Object actual) {
124: Assert.areEqual(expected, actual);
125: }
126:
127: protected Object createArrays() {
128: ItemArrays itemArrays = new ItemArrays();
129: itemArrays._typedPrimitiveArray = new byte[data.length];
130: System.arraycopy(data, 0, itemArrays._typedPrimitiveArray, 0,
131: data.length);
132:
133: Byte[] dataWrapper = new Byte[data.length];
134: for (int i = 0; i < data.length; i++) {
135: dataWrapper[i] = new Byte(data[i]);
136: }
137:
138: itemArrays._typedWrapperArray = new Byte[data.length + 1];
139: System.arraycopy(dataWrapper, 0, itemArrays._typedWrapperArray,
140: 0, dataWrapper.length);
141:
142: initializeUntypedObjectArray(itemArrays, dataWrapper);
143:
144: byte[] primitiveArray = new byte[data.length];
145: System.arraycopy(data, 0, primitiveArray, 0, data.length);
146: itemArrays._primitiveArrayInObject = primitiveArray;
147:
148: Byte[] wrapperArray = new Byte[data.length + 1];
149: System.arraycopy(dataWrapper, 0, wrapperArray, 0,
150: dataWrapper.length);
151: itemArrays._wrapperArrayInObject = wrapperArray;
152: return itemArrays;
153: }
154:
155: /**
156: * @sharpen.remove Cannot convert 'Byte[]' to 'object[]'
157: */
158: private void initializeUntypedObjectArray(ItemArrays itemArrays,
159: Byte[] dataWrapper) {
160: itemArrays._untypedObjectArray = new Byte[data.length + 1];
161: System.arraycopy(dataWrapper, 0,
162: itemArrays._untypedObjectArray, 0, dataWrapper.length);
163: }
164:
165: protected Object[] createValues() {
166: Item[] values = new Item[data.length + 1];
167: for (int i = 0; i < data.length; i++) {
168: Item item = new Item();
169: item._typedPrimitive = data[i];
170: item._typedWrapper = new Byte(data[i]);
171: item._untyped = new Byte(data[i]);
172: values[i] = item;
173: }
174: values[values.length - 1] = new Item();
175: return values;
176: }
177:
178: /**
179: * @sharpen.remove
180: */
181: private void assertByteWrapperIsNullJavaOnly(Object obj) {
182: if (_handlerVersion == 0) {
183:
184: // Bug when reading old format:
185: // Null wrappers are converted to 0
186:
187: Assert.areEqual(new Byte((byte) 0), obj);
188: } else {
189: Assert.isNull(obj);
190: }
191: }
192:
193: protected String typeName() {
194: return "byte";
195: }
196: }
|