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.openjpa.persistence;
020:
021: import java.util.EnumSet;
022:
023: import junit.framework.TestCase;
024: import org.apache.openjpa.kernel.ConnectionRetainModes;
025: import org.apache.openjpa.kernel.DetachState;
026: import org.apache.openjpa.kernel.RestoreState;
027: import org.apache.openjpa.kernel.AutoClear;
028: import org.apache.openjpa.kernel.AutoDetach;
029: import org.apache.openjpa.kernel.QueryOperations;
030: import org.apache.openjpa.event.CallbackModes;
031:
032: public class TestEnumToKernelConstantMappings extends TestCase {
033:
034: public void testConnectionRetainModes() {
035: assertEquals(ConnectionRetainModes.CONN_RETAIN_ALWAYS,
036: ConnectionRetainMode.ALWAYS.toKernelConstant());
037: assertEquals(
038: ConnectionRetainMode.ALWAYS,
039: ConnectionRetainMode
040: .fromKernelConstant(ConnectionRetainModes.CONN_RETAIN_ALWAYS));
041: assertEquals(ConnectionRetainMode.ALWAYS.toKernelConstant(),
042: ConnectionRetainMode.ALWAYS.ordinal());
043:
044: assertEquals(ConnectionRetainModes.CONN_RETAIN_DEMAND,
045: ConnectionRetainMode.ON_DEMAND.toKernelConstant());
046: assertEquals(
047: ConnectionRetainMode.ON_DEMAND,
048: ConnectionRetainMode
049: .fromKernelConstant(ConnectionRetainModes.CONN_RETAIN_DEMAND));
050: assertEquals(ConnectionRetainMode.ON_DEMAND.toKernelConstant(),
051: ConnectionRetainMode.ON_DEMAND.ordinal());
052:
053: assertEquals(ConnectionRetainModes.CONN_RETAIN_TRANS,
054: ConnectionRetainMode.TRANSACTION.toKernelConstant());
055: assertEquals(
056: ConnectionRetainMode.TRANSACTION,
057: ConnectionRetainMode
058: .fromKernelConstant(ConnectionRetainModes.CONN_RETAIN_TRANS));
059: assertEquals(ConnectionRetainMode.TRANSACTION
060: .toKernelConstant(), ConnectionRetainMode.TRANSACTION
061: .ordinal());
062:
063: assertEquals(getConstantCount(ConnectionRetainModes.class),
064: ConnectionRetainMode.values().length);
065: }
066:
067: public void testDetachState() {
068: assertEquals(DetachState.DETACH_ALL, DetachStateType.ALL
069: .toKernelConstant());
070: assertEquals(DetachStateType.ALL, DetachStateType
071: .fromKernelConstant(DetachState.DETACH_ALL));
072: assertEquals(DetachStateType.ALL.toKernelConstant(),
073: DetachStateType.ALL.ordinal());
074:
075: assertEquals(DetachState.DETACH_FETCH_GROUPS,
076: DetachStateType.FETCH_GROUPS.toKernelConstant());
077: assertEquals(DetachStateType.FETCH_GROUPS, DetachStateType
078: .fromKernelConstant(DetachState.DETACH_FETCH_GROUPS));
079: assertEquals(DetachStateType.FETCH_GROUPS.toKernelConstant(),
080: DetachStateType.FETCH_GROUPS.ordinal());
081:
082: assertEquals(DetachState.DETACH_LOADED, DetachStateType.LOADED
083: .toKernelConstant());
084: assertEquals(DetachStateType.LOADED, DetachStateType
085: .fromKernelConstant(DetachState.DETACH_LOADED));
086: assertEquals(DetachStateType.LOADED.toKernelConstant(),
087: DetachStateType.LOADED.ordinal());
088:
089: // subtract 1 for DetachState.DETACH_FGS, which is deprecated
090: assertEquals(getConstantCount(DetachState.class) - 1,
091: DetachStateType.values().length);
092: }
093:
094: public void testRestoreState() {
095: assertEquals(RestoreState.RESTORE_ALL, RestoreStateType.ALL
096: .toKernelConstant());
097: assertEquals(RestoreStateType.ALL, RestoreStateType
098: .fromKernelConstant(RestoreState.RESTORE_ALL));
099: assertEquals(RestoreStateType.ALL.toKernelConstant(),
100: RestoreStateType.ALL.ordinal());
101:
102: assertEquals(RestoreState.RESTORE_IMMUTABLE,
103: RestoreStateType.IMMUTABLE.toKernelConstant());
104: assertEquals(RestoreStateType.IMMUTABLE, RestoreStateType
105: .fromKernelConstant(RestoreState.RESTORE_IMMUTABLE));
106: assertEquals(RestoreStateType.IMMUTABLE.toKernelConstant(),
107: RestoreStateType.IMMUTABLE.ordinal());
108:
109: assertEquals(RestoreState.RESTORE_NONE, RestoreStateType.NONE
110: .toKernelConstant());
111: assertEquals(RestoreStateType.NONE, RestoreStateType
112: .fromKernelConstant(RestoreState.RESTORE_NONE));
113: assertEquals(RestoreStateType.NONE.toKernelConstant(),
114: RestoreStateType.NONE.ordinal());
115:
116: assertEquals(getConstantCount(RestoreState.class),
117: RestoreStateType.values().length);
118: }
119:
120: public void testAutoClear() {
121: assertEquals(AutoClear.CLEAR_ALL, AutoClearType.ALL
122: .toKernelConstant());
123: assertEquals(AutoClearType.ALL, AutoClearType
124: .fromKernelConstant(AutoClear.CLEAR_ALL));
125: assertEquals(AutoClearType.ALL.toKernelConstant(),
126: AutoClearType.ALL.ordinal());
127:
128: assertEquals(AutoClear.CLEAR_DATASTORE, AutoClearType.DATASTORE
129: .toKernelConstant());
130: assertEquals(AutoClearType.DATASTORE, AutoClearType
131: .fromKernelConstant(AutoClear.CLEAR_DATASTORE));
132: assertEquals(AutoClearType.DATASTORE.toKernelConstant(),
133: AutoClearType.DATASTORE.ordinal());
134:
135: assertEquals(getConstantCount(AutoClear.class), AutoClearType
136: .values().length);
137: }
138:
139: public void testAutoDetach() {
140: assertEquals(getConstantCount(AutoDetach.class), AutoDetachType
141: .values().length);
142:
143: assertEquals(EnumSet.of(AutoDetachType.CLOSE), AutoDetachType
144: .toEnumSet(AutoDetach.DETACH_CLOSE));
145: assertEquals(AutoDetach.DETACH_CLOSE, AutoDetachType
146: .fromEnumSet(EnumSet.of(AutoDetachType.CLOSE)));
147:
148: assertEquals(EnumSet.of(AutoDetachType.COMMIT), AutoDetachType
149: .toEnumSet(AutoDetach.DETACH_COMMIT));
150: assertEquals(AutoDetach.DETACH_COMMIT, AutoDetachType
151: .fromEnumSet(EnumSet.of(AutoDetachType.COMMIT)));
152:
153: assertEquals(EnumSet.of(AutoDetachType.NON_TRANSACTIONAL_READ),
154: AutoDetachType.toEnumSet(AutoDetach.DETACH_NONTXREAD));
155: assertEquals(AutoDetach.DETACH_NONTXREAD, AutoDetachType
156: .fromEnumSet(EnumSet
157: .of(AutoDetachType.NON_TRANSACTIONAL_READ)));
158:
159: assertEquals(EnumSet.of(AutoDetachType.ROLLBACK),
160: AutoDetachType.toEnumSet(AutoDetach.DETACH_ROLLBACK));
161: assertEquals(AutoDetach.DETACH_ROLLBACK, AutoDetachType
162: .fromEnumSet(EnumSet.of(AutoDetachType.ROLLBACK)));
163:
164: assertEquals(EnumSet.of(AutoDetachType.CLOSE,
165: AutoDetachType.COMMIT), AutoDetachType
166: .toEnumSet(AutoDetach.DETACH_CLOSE
167: | AutoDetach.DETACH_COMMIT));
168: assertEquals(AutoDetach.DETACH_ROLLBACK
169: | AutoDetach.DETACH_CLOSE, AutoDetachType
170: .fromEnumSet(EnumSet.of(AutoDetachType.ROLLBACK,
171: AutoDetachType.CLOSE)));
172:
173: assertEquals(EnumSet.allOf(AutoDetachType.class),
174: AutoDetachType.toEnumSet(AutoDetach.DETACH_CLOSE
175: | AutoDetach.DETACH_COMMIT
176: | AutoDetach.DETACH_NONTXREAD
177: | AutoDetach.DETACH_ROLLBACK));
178: assertEquals(AutoDetach.DETACH_CLOSE | AutoDetach.DETACH_COMMIT
179: | AutoDetach.DETACH_NONTXREAD
180: | AutoDetach.DETACH_ROLLBACK, AutoDetachType
181: .fromEnumSet(EnumSet.allOf(AutoDetachType.class)));
182: }
183:
184: public void testCallbackMode() {
185: assertEquals(getConstantCount(CallbackModes.class),
186: CallbackMode.values().length);
187:
188: assertEquals(EnumSet.of(CallbackMode.FAIL_FAST), CallbackMode
189: .toEnumSet(CallbackModes.CALLBACK_FAIL_FAST));
190: assertEquals(CallbackModes.CALLBACK_FAIL_FAST, CallbackMode
191: .fromEnumSet(EnumSet.of(CallbackMode.FAIL_FAST)));
192:
193: assertEquals(EnumSet.of(CallbackMode.IGNORE), CallbackMode
194: .toEnumSet(CallbackModes.CALLBACK_IGNORE));
195: assertEquals(CallbackModes.CALLBACK_IGNORE, CallbackMode
196: .fromEnumSet(EnumSet.of(CallbackMode.IGNORE)));
197:
198: assertEquals(EnumSet.of(CallbackMode.LOG), CallbackMode
199: .toEnumSet(CallbackModes.CALLBACK_LOG));
200: assertEquals(CallbackModes.CALLBACK_LOG, CallbackMode
201: .fromEnumSet(EnumSet.of(CallbackMode.LOG)));
202:
203: assertEquals(EnumSet.of(CallbackMode.RETHROW), CallbackMode
204: .toEnumSet(CallbackModes.CALLBACK_RETHROW));
205: assertEquals(CallbackModes.CALLBACK_RETHROW, CallbackMode
206: .fromEnumSet(EnumSet.of(CallbackMode.RETHROW)));
207:
208: assertEquals(EnumSet.of(CallbackMode.ROLLBACK), CallbackMode
209: .toEnumSet(CallbackModes.CALLBACK_ROLLBACK));
210: assertEquals(CallbackModes.CALLBACK_ROLLBACK, CallbackMode
211: .fromEnumSet(EnumSet.of(CallbackMode.ROLLBACK)));
212:
213: assertEquals(EnumSet.of(CallbackMode.ROLLBACK,
214: CallbackMode.IGNORE), CallbackMode
215: .toEnumSet(CallbackModes.CALLBACK_ROLLBACK
216: | CallbackModes.CALLBACK_IGNORE));
217: assertEquals(CallbackModes.CALLBACK_ROLLBACK
218: | CallbackModes.CALLBACK_IGNORE, CallbackMode
219: .fromEnumSet(EnumSet.of(CallbackMode.ROLLBACK,
220: CallbackMode.IGNORE)));
221:
222: assertEquals(EnumSet.allOf(CallbackMode.class), CallbackMode
223: .toEnumSet(CallbackModes.CALLBACK_FAIL_FAST
224: | CallbackModes.CALLBACK_IGNORE
225: | CallbackModes.CALLBACK_LOG
226: | CallbackModes.CALLBACK_RETHROW
227: | CallbackModes.CALLBACK_ROLLBACK));
228: assertEquals(CallbackModes.CALLBACK_FAIL_FAST
229: | CallbackModes.CALLBACK_IGNORE
230: | CallbackModes.CALLBACK_LOG
231: | CallbackModes.CALLBACK_RETHROW
232: | CallbackModes.CALLBACK_ROLLBACK, CallbackMode
233: .fromEnumSet(EnumSet.allOf(CallbackMode.class)));
234: }
235:
236: public void testQueryOperationTypes() {
237: assertEquals(QueryOperations.OP_SELECT,
238: QueryOperationType.SELECT.toKernelConstant());
239: assertEquals(QueryOperationType.SELECT, QueryOperationType
240: .fromKernelConstant(QueryOperations.OP_SELECT));
241: assertEquals(QueryOperationType.SELECT.toKernelConstant(),
242: QueryOperationType.SELECT.ordinal() + 1);
243:
244: assertEquals(QueryOperations.OP_UPDATE,
245: QueryOperationType.UPDATE.toKernelConstant());
246: assertEquals(QueryOperationType.UPDATE, QueryOperationType
247: .fromKernelConstant(QueryOperations.OP_UPDATE));
248: assertEquals(QueryOperationType.UPDATE.toKernelConstant(),
249: QueryOperationType.UPDATE.ordinal() + 1);
250:
251: assertEquals(QueryOperations.OP_DELETE,
252: QueryOperationType.DELETE.toKernelConstant());
253: assertEquals(QueryOperationType.DELETE, QueryOperationType
254: .fromKernelConstant(QueryOperations.OP_DELETE));
255: assertEquals(QueryOperationType.DELETE.toKernelConstant(),
256: QueryOperationType.DELETE.ordinal() + 1);
257:
258: assertEquals(getConstantCount(QueryOperations.class),
259: QueryOperationType.values().length);
260: }
261:
262: private int getConstantCount(Class cls) {
263: return cls.getDeclaredFields().length;
264: }
265: }
|