| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| <<<<<<< Updated upstream |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| ======= |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| >>>>>>> Stashed changes |
| * limitations under the License. |
| */ |
| |
| package org.apache.jdo.tck.models.fieldtypes; |
| |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.util.Date; |
| import java.util.Locale; |
| import java.util.Set; |
| import java.util.Vector; |
| import org.apache.jdo.tck.pc.fieldtypes.AllTypes; |
| import org.apache.jdo.tck.pc.fieldtypes.SimpleClass; |
| import org.apache.jdo.tck.pc.fieldtypes.SimpleEnum; |
| |
| public class TestUtil { |
| |
| public TestUtil() {} |
| |
| // gets the value type for fields of a collection class |
| public static String getFieldSpecs(String field) { |
| // sample field =public Collection CollectionOfObject0 |
| // look for last space and get the String before the numbers |
| String valueType = ""; |
| |
| int indexOfLastSpace = field.lastIndexOf(" "); |
| String fieldName = field.substring(indexOfLastSpace); |
| int indexOfValueType = fieldName.indexOf("Of") + 2; |
| String valueTypeWithNumber = fieldName.substring(indexOfValueType); |
| int lastIndexOfValueType = 0; |
| for (int i = valueTypeWithNumber.length() - 1; i >= 0; i--) { |
| if (Character.isDigit(valueTypeWithNumber.charAt(i))) { |
| continue; |
| } else { |
| lastIndexOfValueType = i; |
| break; |
| } |
| } |
| valueType = valueTypeWithNumber.substring(0, lastIndexOfValueType + 1); |
| |
| return valueType; |
| } |
| |
| // gets the key type and value type for fields of a Map class |
| public static Vector<String> getFieldSpecsForMap(String field) { |
| // sample field =public HashMap HashMapOfObject_Object0 |
| // fieldType -- look for the last space and get the value between Of and _ |
| // valueType -- look for last _ and get the String before the numbers |
| String fieldType = ""; |
| String valueType = ""; |
| |
| int indexOfLastSpace = field.lastIndexOf(" "); |
| String fieldName = field.substring(indexOfLastSpace); |
| int indexOfFieldType = fieldName.indexOf("Of") + 2; |
| String fieldTypeWithValueType = fieldName.substring(indexOfFieldType); |
| int indexOfUnderScore = fieldTypeWithValueType.indexOf("_"); |
| fieldType = fieldTypeWithValueType.substring(0, indexOfUnderScore); |
| |
| String valueTypeWithNumber = fieldTypeWithValueType.substring(indexOfUnderScore + 1); |
| int lastIndexOfValueType = 0; |
| for (int i = valueTypeWithNumber.length() - 1; i >= 0; i--) { |
| if (Character.isDigit(valueTypeWithNumber.charAt(i))) { |
| continue; |
| } else { |
| lastIndexOfValueType = i; |
| break; |
| } |
| } |
| valueType = valueTypeWithNumber.substring(0, lastIndexOfValueType + 1); |
| |
| Vector<String> fieldSpecs = new Vector<>(); |
| fieldSpecs.add(fieldType); |
| fieldSpecs.add(valueType); |
| |
| return fieldSpecs; |
| } |
| |
| public static final String[] elementTypes = |
| new String[] { |
| "Object", |
| "SimpleClass", |
| "SimpleInterface", |
| "String", |
| "Date", |
| "Locale", |
| "BigDecimal", |
| "BigInteger", |
| "Byte", |
| "Double", |
| "Float", |
| "Integer", |
| "Long", |
| "Short", |
| "SimpleEnum" |
| }; |
| |
| private static int getIndexOf(String type) { |
| for (int i = 0; i < elementTypes.length; i++) { |
| if (type.equals(elementTypes[i])) return i; |
| } |
| return 9999; |
| } |
| |
| @SuppressWarnings("rawtypes") |
| public static Vector makeNewVectorInstance(String type, int order) { |
| |
| Vector<Object> vec = new Vector<>(); |
| |
| switch (order) { |
| case (1): |
| switch (getIndexOf(type)) { |
| case (0): |
| vec.add(0, new SimpleClass(1, "Hello World")); |
| vec.add(1, new SimpleClass(2, "Java Data Objects")); |
| vec.add(2, new SimpleClass(2, "Java")); |
| vec.add(3, new SimpleClass(4, "Origami")); |
| vec.add(4, new SimpleClass(5, "watch")); |
| break; |
| case (1): |
| case (2): |
| vec.add(0, new SimpleClass(1, "Welcome")); |
| vec.add(1, new SimpleClass(2, "To")); |
| vec.add(2, new SimpleClass(3, "The")); |
| vec.add(3, new SimpleClass(4, "Beautiful")); |
| vec.add(4, new SimpleClass(5, "World")); |
| break; |
| case (3): |
| vec.add(0, "Hello"); |
| vec.add(1, "Welcome"); |
| vec.add(2, "To The"); |
| vec.add(3, "Beautiful"); |
| vec.add(4, "World"); |
| break; |
| case (4): |
| vec.add(0, new Date(2007908)); |
| vec.add(1, new Date(89067382l)); |
| vec.add(2, new Date(890673822)); |
| vec.add(3, new Date(890673823)); |
| vec.add(4, new Date(890673824)); |
| break; |
| case (5): |
| vec.add(0, Locale.CHINA); |
| vec.add(1, Locale.FRANCE); |
| vec.add(2, Locale.GERMANY); |
| vec.add(3, Locale.JAPAN); |
| vec.add(4, Locale.ITALY); |
| break; |
| case (6): |
| vec.add(0, new BigDecimal("2007908.54548")); |
| vec.add(1, new BigDecimal("0.544")); |
| vec.add(2, new BigDecimal("3002323232.545454")); |
| vec.add(3, new BigDecimal("64564645656.78657")); |
| vec.add(4, new BigDecimal("4564565465.2342")); |
| break; |
| case (7): |
| vec.add(0, new BigInteger("2007908")); |
| vec.add(1, new BigInteger("767575")); |
| vec.add(2, new BigInteger("3002323232")); |
| vec.add(3, new BigInteger("64564645656")); |
| vec.add(4, new BigInteger("456445645")); |
| break; |
| case (8): |
| vec.add(0, Byte.valueOf(Byte.MIN_VALUE)); |
| vec.add(1, Byte.valueOf(Byte.MAX_VALUE)); |
| vec.add(2, Byte.valueOf((byte) (Byte.MAX_VALUE - 20))); |
| vec.add(3, Byte.valueOf((byte) (Byte.MAX_VALUE - 50))); |
| vec.add(4, Byte.valueOf((byte) (Byte.MAX_VALUE - 75))); |
| break; |
| case (9): |
| vec.add(0, Double.valueOf(AllTypes.DOUBLE_SMALLEST)); |
| vec.add(1, Double.valueOf(AllTypes.DOUBLE_LARGEST)); |
| vec.add(2, Double.valueOf(AllTypes.DOUBLE_LARGEST - 20000)); |
| vec.add(3, Double.valueOf(AllTypes.DOUBLE_LARGEST - 454545.436664)); |
| vec.add(4, Double.valueOf(AllTypes.DOUBLE_LARGEST - 2323235.76764677)); |
| break; |
| case (10): |
| vec.add(0, Float.valueOf(AllTypes.FLOAT_SMALLEST)); |
| vec.add(1, Float.valueOf(AllTypes.FLOAT_LARGEST)); |
| vec.add(2, Float.valueOf(AllTypes.FLOAT_LARGEST - 20000)); |
| vec.add(3, Float.valueOf((float) (AllTypes.FLOAT_LARGEST - 454545.434))); |
| vec.add(4, Float.valueOf((float) (AllTypes.FLOAT_LARGEST - 565656.43434))); |
| break; |
| case (11): |
| vec.add(0, Integer.valueOf(Integer.MIN_VALUE)); |
| vec.add(1, Integer.valueOf(Integer.MAX_VALUE)); |
| vec.add(2, Integer.valueOf(Integer.MAX_VALUE - 20000)); |
| vec.add(3, Integer.valueOf(Integer.MAX_VALUE - 343434343)); |
| vec.add(4, Integer.valueOf(Integer.MAX_VALUE - 565656)); |
| break; |
| case (12): |
| vec.add(0, Long.valueOf(Long.MIN_VALUE)); |
| vec.add(1, Long.valueOf(Long.MAX_VALUE)); |
| vec.add(2, Long.valueOf(Long.MAX_VALUE - 20000)); |
| vec.add(3, Long.valueOf(Long.MAX_VALUE - 343434343)); |
| vec.add(4, Long.valueOf(Long.MAX_VALUE - 565656)); |
| break; |
| case (13): |
| vec.add(0, Short.valueOf(Short.MIN_VALUE)); |
| vec.add(1, Short.valueOf(Short.MAX_VALUE)); |
| vec.add(2, Short.valueOf((short) (Short.MAX_VALUE - 20000))); |
| vec.add(3, Short.valueOf((short) (Short.MAX_VALUE - 343))); |
| vec.add(4, Short.valueOf((short) (Short.MAX_VALUE - 5656))); |
| break; |
| case (14): |
| vec.add(0, SimpleEnum.AK); |
| vec.add(1, SimpleEnum.FM); |
| vec.add(2, SimpleEnum.KS); |
| vec.add(3, SimpleEnum.NJ); |
| vec.add(4, SimpleEnum.WI); |
| break; |
| default: |
| throw new IndexOutOfBoundsException(); |
| } |
| return vec; |
| case (2): |
| switch (getIndexOf(type)) { |
| case (0): |
| vec.add(0, new SimpleClass(1, "Hi There")); |
| vec.add(1, new SimpleClass(1, "Hi")); |
| vec.add(2, new SimpleClass(2, "Object")); |
| vec.add(3, new SimpleClass(0, "Relational")); |
| vec.add(4, new SimpleClass(3, "Hi There")); |
| break; |
| case (1): |
| case (2): |
| vec.add(0, new SimpleClass(1, "Peaches")); |
| vec.add(1, new SimpleClass(2, "Oranges")); |
| vec.add(2, new SimpleClass(3, "Blue Berries")); |
| vec.add(3, new SimpleClass(4, "Apples")); |
| vec.add(4, new SimpleClass(5, "Strawberries")); |
| break; |
| case (3): |
| vec.add(0, "Peaches"); |
| vec.add(1, "Oranges"); |
| vec.add(2, "Blue Berries"); |
| vec.add(3, "Apples"); |
| vec.add(4, "Strawberries"); |
| break; |
| case (4): |
| vec.add(0, new Date(54545)); |
| vec.add(1, new Date(8905454l)); |
| vec.add(2, new Date(323545445)); |
| vec.add(3, new Date(890748967382l)); |
| vec.add(4, new Date(954545)); |
| break; |
| case (5): |
| vec.add(0, Locale.ENGLISH); |
| vec.add(1, Locale.JAPANESE); |
| vec.add(2, Locale.CANADA_FRENCH); |
| vec.add(3, Locale.KOREA); |
| vec.add(4, Locale.UK); |
| break; |
| case (6): |
| vec.add(0, new BigDecimal("434238.5454898989")); |
| vec.add(1, new BigDecimal("6.544")); |
| vec.add(2, new BigDecimal("55552323232.545454")); |
| vec.add(3, new BigDecimal("6456456.7543543534865785")); |
| vec.add(4, new BigDecimal("456456.4353452342")); |
| break; |
| case (7): |
| vec.add(0, new BigInteger("345345345345345345345345")); |
| vec.add(1, new BigInteger("543543543543544")); |
| vec.add(2, new BigInteger("65323423432423423")); |
| vec.add(3, new BigInteger("87845634534543")); |
| vec.add(4, new BigInteger("53452567766657567")); |
| break; |
| case (8): |
| vec.add(0, Byte.valueOf((byte) (Byte.MAX_VALUE - 34))); |
| vec.add(1, Byte.valueOf(Byte.MIN_VALUE)); |
| vec.add(2, Byte.valueOf((byte) (Byte.MAX_VALUE - 76))); |
| vec.add(3, Byte.valueOf(Byte.MAX_VALUE)); |
| vec.add(4, Byte.valueOf((byte) (Byte.MAX_VALUE - 12))); |
| break; |
| case (9): |
| vec.add(0, Double.valueOf(AllTypes.DOUBLE_LARGEST - 343434)); |
| vec.add(1, Double.valueOf(AllTypes.DOUBLE_SMALLEST)); |
| vec.add(2, Double.valueOf(AllTypes.DOUBLE_LARGEST)); |
| vec.add(3, Double.valueOf(AllTypes.DOUBLE_LARGEST - 65423445.436664)); |
| vec.add(4, Double.valueOf(AllTypes.DOUBLE_LARGEST - 7235.236764677)); |
| break; |
| case (10): |
| vec.add(0, Float.valueOf(AllTypes.FLOAT_LARGEST - 5452)); |
| vec.add(1, Float.valueOf(AllTypes.FLOAT_SMALLEST)); |
| vec.add(2, Float.valueOf((float) (AllTypes.FLOAT_LARGEST - 6564560.54))); |
| vec.add(3, Float.valueOf(AllTypes.FLOAT_LARGEST)); |
| vec.add(4, Float.valueOf((float) (AllTypes.FLOAT_LARGEST - 9756.634))); |
| break; |
| case (11): |
| vec.add(0, Integer.valueOf(Integer.MAX_VALUE - 54454)); |
| vec.add(1, Integer.valueOf(Integer.MIN_VALUE)); |
| vec.add(2, Integer.valueOf(Integer.MAX_VALUE)); |
| vec.add(3, Integer.valueOf(Integer.MAX_VALUE - 767234)); |
| vec.add(4, Integer.valueOf(Integer.MAX_VALUE - 23673446)); |
| break; |
| case (12): |
| vec.add(0, Long.valueOf(Long.MAX_VALUE - 545345454)); |
| vec.add(1, Long.valueOf(Long.MIN_VALUE)); |
| vec.add(2, Long.valueOf(Long.MAX_VALUE)); |
| vec.add(3, Long.valueOf(Long.MAX_VALUE - 3543343)); |
| vec.add(4, Long.valueOf(Long.MAX_VALUE - 556)); |
| break; |
| case (13): |
| vec.add(0, Short.valueOf((short) (Short.MAX_VALUE - 3434))); |
| vec.add(1, Short.valueOf(Short.MIN_VALUE)); |
| vec.add(2, Short.valueOf(Short.MAX_VALUE)); |
| vec.add(3, Short.valueOf((short) (Short.MAX_VALUE - 23344))); |
| vec.add(4, Short.valueOf((short) (Short.MAX_VALUE - 723))); |
| break; |
| case (14): |
| vec.add(0, SimpleEnum.AZ); |
| vec.add(1, SimpleEnum.SD); |
| vec.add(2, SimpleEnum.NV); |
| vec.add(3, SimpleEnum.WV); |
| vec.add(4, SimpleEnum.PA); |
| break; |
| default: |
| throw new IndexOutOfBoundsException(); |
| } |
| return vec; |
| default: |
| throw new IndexOutOfBoundsException(); |
| } |
| } |
| |
| protected static boolean containsBigDecimalKey( |
| BigDecimal keyValue, Set<BigDecimal> bigDecimalKeySet) { |
| for (BigDecimal nextVal : bigDecimalKeySet) { |
| if (keyValue.compareTo(nextVal) == 0) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| protected static BigDecimal getBigDecimalKey( |
| BigDecimal keyValue, Set<BigDecimal> bigDecimalKeySet) { |
| for (BigDecimal nextVal : bigDecimalKeySet) { |
| if (keyValue.compareTo(nextVal) == 0) { |
| return nextVal; |
| } |
| } |
| return null; |
| } |
| } |