Author: tchemit Date: 2011-01-29 08:20:31 +0100 (Sat, 29 Jan 2011) New Revision: 1041 Url: http://nuiton.org/repositories/revision/eugene/1041 Log: Evolution #1268: Improve importManager pass to debug level some tests Modified: trunk/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java trunk/eugene/src/main/java/org/nuiton/eugene/java/extension/ImportsManager.java trunk/eugene/src/main/java/org/nuiton/eugene/java/extension/ImportsManagerExtension.java trunk/eugene/src/test/java/org/nuiton/eugene/GeneratorUtilTest.java trunk/eugene/src/test/java/org/nuiton/eugene/java/extension/ImportsManagerTest.java Modified: trunk/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java 2011-01-27 08:53:21 UTC (rev 1040) +++ trunk/eugene/src/main/java/org/nuiton/eugene/GeneratorUtil.java 2011-01-29 07:20:31 UTC (rev 1041) @@ -667,6 +667,48 @@ } /** + * + * @param str the string to parse + * @return the string without any + * @since 2.3.2 + */ + public static String[] splitGenericDefinition(String str) { + + // always trim the string + String result = str.trim(); + + if (!result.startsWith("<")) { + + // not starting by a generics definition, no treatment to do + return new String[]{str}; + } + + int i = 0; + for (int length = result.length(), count = 0; i < length; i++) { + char c = result.charAt(i); + if ('<' == c) { + count++; + } else if ('>' == c) { + count--; + } + if (count == 0) { + break; + } + } + + // the i position was on the last closing caracter, can safely + // remove until this position + 1 + String prefix = result.substring(0,i+1); + String end = result.substring(i + 1); + + // remove any starting spaces + while (end.startsWith(" ")) { + end = end.substring(1); + } + return new String[]{prefix, end}; + } + + /** * Parse a fully qualified generic java type, and extract each * imbricated types. * Modified: trunk/eugene/src/main/java/org/nuiton/eugene/java/extension/ImportsManager.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/java/extension/ImportsManager.java 2011-01-27 08:53:21 UTC (rev 1040) +++ trunk/eugene/src/main/java/org/nuiton/eugene/java/extension/ImportsManager.java 2011-01-29 07:20:31 UTC (rev 1041) @@ -25,6 +25,9 @@ package org.nuiton.eugene.java.extension; +import org.apache.commons.lang.StringUtils; +import org.nuiton.eugene.GeneratorUtil; + import java.util.ArrayList; import java.util.Collections; import java.util.HashMap; @@ -37,10 +40,10 @@ * Class used in generators that allows to manage easily imports. A first-pass * allow to register imports, and in a second-pass, returns the type to use in * generated code. - * - * @author thimel, chemit - * @version $Revision$ * + * @author athimel <thimle@codelutin.com> + * @author tchemit <chemit@codelutin.com> + * @version $Id$ * @since 2.0.0 */ public class ImportsManager { @@ -73,11 +76,14 @@ primitiveTypes.add("void"); } + private Map<String, String> imports = new HashMap<String, String>(); + private State state = State.FILLING; /** * From the given class, add it to the imports list. + * * @param clazz the class to import * @return true if import add was successful * @see ImportsManager#addImport(String) @@ -91,29 +97,50 @@ * If there is a conflict adding this import, will return false. * If reading of the imports has started, this method will return false, * unless type does not need to be imported. + * * @param fqn the fully qualified name to import * @return true if import add was successful */ public boolean addImport(String fqn) { + + // don't include null fqn + if (fqn == null) { + return false; + } + + int lastDotIndex = getLastDotIndex(fqn); + // if no package don't include it - if (!fqn.contains(".")) { + if (lastDotIndex == -1) { return true; } // Exclude java.lang classes - if (fqn == null || fqn.trim().isEmpty() || - fqn.startsWith("java.lang.") && fqn.lastIndexOf(".") == 9) { + + if (fqn.trim().isEmpty() || + fqn.startsWith("java.lang.") && lastDotIndex == 9) { return true; } // Exclude primitive types if (primitiveTypes.contains(fqn)) { return true; } - // Reject generics - if (fqn.contains("<") || fqn.contains(">")) { + if (containsGenerics(fqn)) { + + // Generics case : + String[] parts = splitGeneric(fqn); + for (String part : parts) { + if (addImport(part)) { + return true; + } + } return false; } - String name = fqn.substring(fqn.lastIndexOf(".") + 1); +// // Reject generics +// if (fqn.contains("<") || fqn.contains(">")) { +// return false; +// } + String name = fqn.substring(lastDotIndex + 1); String inPlaceFqn = imports.get(name); if (inPlaceFqn == null) { // Someone has started to read imports, impossible to add some more @@ -132,37 +159,78 @@ * Accorging to the already added types, returns the type to write in file. * If there is a conflict, returns the fully qualified name, otherwise * returns the simple name + * * @param fqn the fully qualified name to add * @return the fqn or simple name according to in-place imports */ public String getType(String fqn) { boolean importResult = addImport(fqn); if (!importResult) { + // There is a conflict, do not use simple name return fqn; + } + if (containsGenerics(fqn)) { + + String[] parts = splitGeneric(fqn); + for (int i = 0; i < parts.length; i++) { + String part = parts[i]; + parts[i] = getType(part); + } + return joinGeneric(parts); + } + // No conflict, use simple name + int packageEndIndex = getLastDotIndex(fqn); + if (packageEndIndex == -1) { + return fqn; } else { - // No conflict, use simple name - int packageEndIndex = fqn.lastIndexOf("."); - if (packageEndIndex == -1) { - return fqn; - } else { - return fqn.substring(packageEndIndex + 1); + return fqn.substring(packageEndIndex + 1); + } + } + + public String getReturnType(String returnType) { + if (StringUtils.isBlank(returnType)) { + return null; + } + if (containsGenerics(returnType)) { + + // the return type is in two parts : <...> ... + String[] parts = + GeneratorUtil.splitGenericDefinition(returnType); + if (parts.length == 1) { + + // no generic definition + return getType(returnType); } + String genericDef = parts[0]; + String strictReturnType = parts[1]; + if (StringUtils.isNotBlank(genericDef)) { + genericDef += " "; + } + return genericDef + getType(strictReturnType); + } else { + return getType(returnType); } } /** * List the imports. This method will remove the useless imports according * to the given packageName (no need to import a class in the same package) + * * @param packageName the current package name (to avoid useless imports) * @return the imports alphabeticaly sorted */ public List<String> getImports(String packageName) { state = State.READING; List<String> result = new ArrayList<String>(); + int packageLength = packageName.length(); + String packagePrefix = packageName + "."; for (String fqn : imports.values()) { - if (!(fqn.lastIndexOf(".") == packageName.length() && - fqn.startsWith(packageName + "."))) { + int lastDotIndex = getLastDotIndex(fqn); + + // only keep sub package of given package + if (!(lastDotIndex == packageLength && + fqn.startsWith(packagePrefix))) { result.add(fqn); } } @@ -183,4 +251,148 @@ FILLING, READING } + + /** + * Split the given fqn which contains a generic declaration into his parts. + * <p/> + * Example : + * <pre> + * java.util.List<Integer> : [java.util.List, Integer] + * java.util.List<java.util.List<Integer>> : [java.util.List, java.util.List<Integer>] + * java.util.Map<Integer, Integer> : [java.util.Map, Integer, Integer] + * java.util.Map<Integer, java.util.List<Integer>> : [java.util.Map, Integer, java.util.List<Integer>] + * <p/> + * </pre> + * <strong>Note:</strong> We only deal with one level of generics here in + * order to be able easly to rebuild after all the fqn with simple names... + * + * @param fqn the fqn to split + * @return the array of all parts of the fqn. + * @since 2.3.2 + */ + public String[] splitGeneric(String fqn) { + if (fqn == null) { + return null; + } + + int firstPartIndex = fqn.indexOf('<'); + if (firstPartIndex == -1) { + + // no generics, just return the fqn + return new String[]{fqn}; + } + + List<String> parts = new ArrayList<String>(); + parts.add(fqn.substring(0, firstPartIndex)); + String rest = fqn.substring(firstPartIndex + 1, + fqn.lastIndexOf('>')); + + if (containsGenerics(rest) && rest.contains(",")) { + + // there is others generics in generics, worse case... + int begin = 0; + int count = 0; + int max = rest.length(); + for (int i = 0; i < max; i++) { + char c = rest.charAt(i); + if (c == '<') { + + count++; + } else if (c == '>') { + + count--; + } else if (c == ',') { + + // arrives on a possible split + if (count == 0) { + + // can safely add this part + String part = rest.substring(begin, i); + parts.add(part.trim()); + begin = i + 1; + } + } + } + + // there is a last part to add ? + if (begin < max) { + String part = rest.substring(begin, max); + parts.add(part.trim()); + } + + } else { + + // simple case : each part of the generics has no other generics + String[] split = rest.split(","); + for (String part : split) { + parts.add(part.trim()); + } + } + + return parts.toArray(new String[parts.size()]); + } + + /** + * Join generics parts of a fqn into aparts. + * <p/> + * Example : + * <pre> + * [java.util.List, Integer] : java.util.List<Integer> + * [java.util.List, java.util.List<Integer>] : java.util.List<java.util.List<Integer>> + * [java.util.Map, Integer, Integer] : java.util.Map<Integer, Integer> + * [java.util.Map, Integer, java.util.List<Integer>] : java.util.Map<Integer, java.util.List<Integer>> + * </pre> + * + * @param genericParts the parts of fqn + * @return the fqn from his parts + * @since 2.3.2 + */ + public String joinGeneric(String... genericParts) { + + if (genericParts == null || genericParts.length == 0) { + + // this case should never happen ? + return null; + } + + if (genericParts.length == 1) { + + // in fact, no generics + return genericParts[0]; + } + + StringBuilder sb = new StringBuilder(genericParts[0]); + + sb.append("<").append(genericParts[1]); + + for (int i = 2, max = genericParts.length; i < max; i++) { + String genericPart = genericParts[i]; + sb.append(", ").append(genericPart); + } + sb.append('>'); + return sb.toString(); + } + + /** + * Tells if the given fqn contains a generic declaration (says contains a + * {@code <} caracter). + * + * @param fqn the fqn to test + * @return {@code true} if given fqn contains a generic declaration + * @since 2.3.2 + */ + public boolean containsGenerics(String fqn) { + return fqn.contains("<"); + } + + /** + * Obtains the last dot index in the given fqn. + * + * @param fqn the fqn to test + * @return the last index of a dot in given fqn + * @since 2.3.2 + */ + public int getLastDotIndex(String fqn) { + return fqn.lastIndexOf("."); + } } Modified: trunk/eugene/src/main/java/org/nuiton/eugene/java/extension/ImportsManagerExtension.java =================================================================== --- trunk/eugene/src/main/java/org/nuiton/eugene/java/extension/ImportsManagerExtension.java 2011-01-27 08:53:21 UTC (rev 1040) +++ trunk/eugene/src/main/java/org/nuiton/eugene/java/extension/ImportsManagerExtension.java 2011-01-29 07:20:31 UTC (rev 1041) @@ -34,39 +34,56 @@ import java.util.Map; /** - * ImportsManagerExtension - * + * Extension for ObjectModel to manage imports for all classifiers in the model. + * <p/> * Created: 2 nov. 2009 * - * @author fdesbois - * @version $Revision$ - * - * Extension for ObjectModel to manage imports for all classifiers in the model. + * @author fdesbois <desbois@codelutin.com> + * @author tchemit <chemit@codelutin.com> + * @version $Id$ */ public class ImportsManagerExtension { - private static final Log log = LogFactory.getLog(ImportsManagerExtension.class); - /** - * Extension static used to identify ImportsManagerExtension in ObjectModel + * Logger. */ + private static final Log log = + LogFactory.getLog(ImportsManagerExtension.class); + + /** Extension static used to identify ImportsManagerExtension in ObjectModel */ public static final String OBJECTMODEL_EXTENSION = "imports"; /** - * Map of ImportsManager with key equals to the classifier qualified name associated to - * the ImportsManager + * Map of ImportsManager with key equals to the classifier qualified name + * associated to the ImportsManager. */ protected Map<String, ImportsManager> managers; /** - * Get the ImportsManager associated to the classifier. If not exist, it will be created. - * + * Get the ImportsManager associated to the classifier. + * <p/> + * <strong>Note:</strong> if not exist, it will be created. + * * @param classifier reference for the ImportsManager * @return the importsManager associated to the classifier (never null) */ public ImportsManager getManager(ObjectModelClassifier classifier) { + String fqn = classifier.getQualifiedName(); + ImportsManager manager = getManager(fqn); + return manager; + } + + /** + * Get the ImportsManager associated to the given {@code fqn}. + * <p/> + * <strong>Note:</strong> if not exist, it will be created. + * + * @param fqn reference for the ImportsManager + * @return the importsManager associated to the classifier (never null) + * @since 2.3.2 + */ + public ImportsManager getManager(String fqn) { Map<String, ImportsManager> managers = getManagers(); - String fqn = classifier.getQualifiedName(); ImportsManager manager = managers.get(fqn); if (manager == null) { manager = new ImportsManager(); @@ -85,10 +102,27 @@ * @return a List of String which contains all imports for the classifier */ public List<String> getImports(ObjectModelClassifier classifier) { - ImportsManager manager = getManager(classifier); - return manager.getImports(classifier.getPackageName()); + List<String> imports = getImports(classifier.getQualifiedName(), + classifier.getPackageName() + ); + return imports; } + /** + * Get imports for a classifier. + * <p/> + * The ImportsManager must be defined in the model. + * + * @param fqn reference for the imports + * @param packageName package name of the fqn + * @return a List of String which contains all imports for the classifier + * @since 2.3.2 + */ + public List<String> getImports(String fqn, String packageName) { + ImportsManager manager = getManager(fqn); + return manager.getImports(packageName); + } + protected Map<String, ImportsManager> getManagers() { if (managers == null) { managers = new HashMap<String, ImportsManager>(); Modified: trunk/eugene/src/test/java/org/nuiton/eugene/GeneratorUtilTest.java =================================================================== --- trunk/eugene/src/test/java/org/nuiton/eugene/GeneratorUtilTest.java 2011-01-27 08:53:21 UTC (rev 1040) +++ trunk/eugene/src/test/java/org/nuiton/eugene/GeneratorUtilTest.java 2011-01-29 07:20:31 UTC (rev 1041) @@ -42,7 +42,9 @@ @Test public void testGetOperationParametersListName() { - log.debug("getOperationParametersListName"); + if (log.isDebugEnabled()) { + log.debug("getOperationParametersListName"); + } ObjectModelOperationImpl op = new ObjectModelOperationImpl(); @@ -69,7 +71,9 @@ @Test public void testGetOperationParametersListDeclaration() { - log.debug("getOperationParametersListDeclaration"); + if (log.isDebugEnabled()) { + log.debug("getOperationParametersListDeclaration"); + } ObjectModelOperationImpl op = new ObjectModelOperationImpl(); @@ -100,97 +104,129 @@ /** Test of getSimpleName method, of class GeneratorUtil. */ @Test public void testGetSimpleName() { - log.debug("getSimpleName"); + if (log.isDebugEnabled()) { + log.debug("getSimpleName"); + } String str = "List"; String expResult = "List"; String result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.Regex"; expResult = "Regex"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "<T> java.util.List<T>"; expResult = "<T> List<T>"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.List<? extends org.chorem.bonzoms.Bonzoms>"; expResult = "List<? extends Bonzoms>"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.List<org.chorem.jtimer.Jtimer>"; expResult = "List<Jtimer>"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.Set<java.util.Collection<java.util.Collection<java.util.Collection" + "<java.lang.String>>>>"; expResult = "Set<Collection<Collection<Collection<String>>>>"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.Map<org.chorem.jtimer.Jtimer, java.util.Collection<java.lang.String>>"; expResult = "Map<Jtimer, Collection<String>>"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "new java.util.HashMap<org.chorem.jtimer.Jtimer, T extends java.lang.String>()"; expResult = "new HashMap<Jtimer, T extends String>()"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "Class<O>"; expResult = "Class<O>"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "2.0"; expResult = "2.0"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "\"eric.chatellier\""; expResult = "\"eric.chatellier\""; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "<T extends org.nuiton.topia.TopiaEntity, D extends org.nuiton.topia.TopiaDAO<? super T>> D"; expResult = "<T extends TopiaEntity, D extends TopiaDAO<? super T>> D"; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "Object..."; expResult = "Object..."; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "Class<A>..."; expResult = "Class<A>..."; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.lang.Class<A>..."; expResult = "Class<A>..."; result = GeneratorUtil.getSimpleName(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); } @@ -200,97 +236,129 @@ */ @Test public void testGetSimpleNameAndRemoveGenericsDefinition() { - log.debug("getSimpleName"); + if (log.isDebugEnabled()) { + log.debug("getSimpleName"); + } String str = "List"; String expResult = "List"; String result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.Regex"; expResult = "Regex"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "<T> java.util.List<T>"; expResult = "List<T>"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.List<? extends org.chorem.bonzoms.Bonzoms>"; expResult = "List<? extends Bonzoms>"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.List<org.chorem.jtimer.Jtimer>"; expResult = "List<Jtimer>"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.Set<java.util.Collection<java.util.Collection<java.util.Collection" + "<java.lang.String>>>>"; expResult = "Set<Collection<Collection<Collection<String>>>>"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.Map<org.chorem.jtimer.Jtimer, java.util.Collection<java.lang.String>>"; expResult = "Map<Jtimer, Collection<String>>"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "new java.util.HashMap<org.chorem.jtimer.Jtimer, T extends java.lang.String>()"; expResult = "new HashMap<Jtimer, T extends String>()"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "Class<O>"; expResult = "Class<O>"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "2.0"; expResult = "2.0"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "\"eric.chatellier\""; expResult = "\"eric.chatellier\""; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "<T extends org.nuiton.topia.TopiaEntity, D extends org.nuiton.topia.TopiaDAO<? super T>> D"; expResult = "D"; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "Object..."; expResult = "Object..."; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "Class<A>..."; expResult = "Class<A>..."; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.lang.Class<A>..."; expResult = "Class<A>..."; result = GeneratorUtil.getSimpleName(str, true); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); } @@ -298,86 +366,113 @@ /** Test of removeGenericDefinition method, of class GeneratorUtil. */ @Test public void testRemoveGenericDefinition() { - log.debug("removeGenericDefinition"); + if (log.isDebugEnabled()) { + log.debug("removeGenericDefinition"); + } String str = "List"; String expResult = "List"; String result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.Regex"; expResult = "java.util.Regex"; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "<T> java.util.List<T>"; expResult = "java.util.List<T>"; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); - str = " <T> java.util.List<T> "; expResult = "java.util.List<T>"; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.List<? extends org.chorem.bonzoms.Bonzoms>"; expResult = "java.util.List<? extends org.chorem.bonzoms.Bonzoms>"; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.util.List<org.chorem.jtimer.Jtimer>"; expResult = "java.util.List<org.chorem.jtimer.Jtimer>"; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "Class<O>"; expResult = "Class<O>"; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "2.0"; expResult = "2.0"; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "\"eric.chatellier\""; expResult = "\"eric.chatellier\""; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "<T extends org.nuiton.topia.TopiaEntity, D extends org.nuiton.topia.TopiaDAO<? super T>> D"; expResult = "D"; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "Object..."; expResult = "Object..."; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "Class<A>..."; expResult = "Class<A>..."; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); str = "java.lang.Class<A>..."; expResult = "java.lang.Class<A>..."; result = GeneratorUtil.removeGenericDefinition(str); - log.info(str + " -> " + result); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + result); + } Assert.assertEquals(expResult, result); } @@ -385,63 +480,85 @@ public void testGetTypesList() { String str = "List"; Set<String> results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(1, results.size()); str = "java.util.Regex"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(1, results.size()); str = "java.util.List<? extends org.chorem.bonzoms.Bonzoms>"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(2, results.size()); str = "java.util.List<org.chorem.jtimer.Jtimer>"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(2, results.size()); str = "java.util.Set<java.util.Collection<java.util.Collection<java.util.Collection" + "<java.lang.String>>>>"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(3, results.size()); str = "java.util.Map<org.chorem.jtimer.Jtimer, java.util.Collection<java.lang.String>>"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(4, results.size()); str = "new java.util.HashMap<org.chorem.jtimer.Jtimer, T extends java.lang.String>()"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(3, results.size()); str = "java.util.Map<org.chorem.jtimer.Jtimer, java.util.Collection<String>>"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(4, results.size()); str = "java.util.List<java.util.Map<java.util.Date, java.lang.Integer>>"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(4, results.size()); str = "java.util.List<java.util.Map<java.util.Date, java.lang.Integer>>"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(4, results.size()); str = "java.util.TreeMap<java.util.ArrayList<java.util.Date>, java.util.SortedSet<java.lang.Number, java.lang.Double>>"; results = GeneratorUtil.getTypesList(str); - log.info(str + " -> " + results); + if (log.isDebugEnabled()) { + log.debug(str + " -> " + results); + } Assert.assertEquals(6, results.size()); // str = "<T extends org.nuiton.topia.TopiaEntity> T"; // results = GeneratorUtil.getTypesList(str); -// log.info(str + " -> " + results); +// log.debug(str + " -> " + results); // assertEquals(results.size(), 1); } Modified: trunk/eugene/src/test/java/org/nuiton/eugene/java/extension/ImportsManagerTest.java =================================================================== --- trunk/eugene/src/test/java/org/nuiton/eugene/java/extension/ImportsManagerTest.java 2011-01-27 08:53:21 UTC (rev 1040) +++ trunk/eugene/src/test/java/org/nuiton/eugene/java/extension/ImportsManagerTest.java 2011-01-29 07:20:31 UTC (rev 1041) @@ -25,9 +25,11 @@ package org.nuiton.eugene.java.extension; +import org.junit.After; import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.nuiton.util.StringUtil; import java.io.Serializable; import java.util.List; @@ -41,8 +43,136 @@ mgr = new ImportsManager(); } + @After + public void tearDown() throws Exception { + mgr.clearImports(); + mgr = null; + } + @Test + public void splitGeneric() throws Exception { + + String[] actual; + String[] expected; + + expected = null; + actual = mgr.splitGeneric(null); + Assert.assertArrayEquals(expected, actual); + + expected = new String[]{"java.util.List"}; + actual = mgr.splitGeneric("java.util.List"); + Assert.assertArrayEquals(expected, actual); + + expected = new String[]{"java.util.List", "Integer"}; + actual = mgr.splitGeneric("java.util.List<Integer>"); + Assert.assertArrayEquals(expected, actual); + + expected = new String[]{"java.util.List", "java.util.List<Integer>"}; + actual = mgr.splitGeneric("java.util.List<java.util.List<Integer>>"); + Assert.assertArrayEquals(expected, actual); + + expected = new String[]{"java.util.Map", "Integer", "Integer"}; + actual = mgr.splitGeneric("java.util.Map<Integer, Integer>"); + Assert.assertArrayEquals(expected, actual); + + expected = new String[]{"java.util.Map", "Integer", "java.util.List<Integer>"}; + actual = mgr.splitGeneric("java.util.Map<Integer, java.util.List<Integer>>"); + Assert.assertArrayEquals(expected, actual); + + expected = new String[]{"java.util.Map", "Integer", "java.util.Map<Integer, Integer>"}; + actual = mgr.splitGeneric("java.util.Map<Integer, java.util.Map<Integer, Integer>>"); + Assert.assertArrayEquals(expected, actual); + + expected = new String[]{"java.util.Map", "Integer", "java.util.Map<Integer, Integer, Toto<A, B, C>>", "X", "Y<X>"}; + actual = mgr.splitGeneric("java.util.Map<Integer, java.util.Map<Integer, Integer, Toto<A, B, C>>, X, Y<X>>"); + Assert.assertArrayEquals(expected, actual); + + expected = new String[]{"java.util.Map", "X<Y<Z>>", "java.util.Map<Integer, Integer, Toto<A, B, C>>", "X", "Y<X>"}; + actual = mgr.splitGeneric("java.util.Map< X<Y<Z>>, java.util.Map<Integer, Integer, Toto<A, B, C>>, X, Y<X>>"); + Assert.assertArrayEquals(expected, actual); + } + + + @Test + public void joinGeneric() throws Exception { + String actual; + String expected; + + expected = null; + actual = mgr.joinGeneric((String) null); + Assert.assertEquals(expected, actual); + + expected = null; + actual = mgr.joinGeneric(StringUtil.EMPTY_STRING_ARRAY); + Assert.assertEquals(expected, actual); + + expected = "java.util.List"; + actual = mgr.joinGeneric("java.util.List"); + Assert.assertEquals(expected, actual); + + expected = "java.util.List<Integer>"; + actual = mgr.joinGeneric("java.util.List", "Integer"); + Assert.assertEquals(expected, actual); + + + expected = "java.util.List<java.util.List<Integer>>"; + actual = mgr.joinGeneric("java.util.List", "java.util.List<Integer>"); + Assert.assertEquals(expected, actual); + + expected = "java.util.Map<Integer, Integer>"; + actual = mgr.joinGeneric("java.util.Map", "Integer", "Integer"); + Assert.assertEquals(expected, actual); + + expected = "java.util.Map<Integer, java.util.List<Integer>>"; + actual = mgr.joinGeneric("java.util.Map", "Integer", "java.util.List<Integer>"); + Assert.assertEquals(expected, actual); + } + + @Test + public void getReturnType() throws Exception { + String actual; + String expected; + + expected = null; + actual = mgr.getReturnType(null); + Assert.assertEquals(expected, actual); + + expected = "List"; + actual = mgr.getReturnType("java.util.List"); + Assert.assertEquals(expected, actual); + + expected = "List<Integer>"; + actual = mgr.getReturnType("java.util.List<Integer>"); + Assert.assertEquals(expected, actual); + + + expected = "List<List<Integer>>"; + actual = mgr.getReturnType("java.util.List<java.util.List<Integer>>"); + Assert.assertEquals(expected, actual); + + expected = "Map<Integer, Integer>"; + actual = mgr.getReturnType("java.util.Map< Integer,Integer>"); + Assert.assertEquals(expected, actual); + + expected = "Map<Integer, List<Integer>>"; + actual = mgr.getReturnType("java.util.Map<Integer,java.util.List<Integer>>"); + Assert.assertEquals(expected, actual); + + expected = "<O> Map<O, List<Integer>>"; + actual = mgr.getReturnType("<O> java.util.Map<O, java.util.List<Integer>>"); + Assert.assertEquals(expected, actual); + + expected = "<O extends java.util.List> Map<O, List<Toto>>"; + actual = mgr.getReturnType("<O extends java.util.List> java.util.Map<O, java.util.List<a.b.Toto>>"); + Assert.assertEquals(expected, actual); + + } + + @Test public void testAddImport() throws Exception { + + Assert.assertFalse(mgr.addImport((String) null)); // Not accept null value + Assert.assertTrue(mgr.addImport("org.nuiton.eugene.Toto")); Assert.assertTrue(mgr.addImport("org.nuiton.eugene.Toto")); //Repeat to test acceptance Assert.assertTrue(mgr.addImport("org.nuiton.eugene.Tutu")); @@ -63,13 +193,15 @@ Assert.assertEquals("Toto", mgr.getType("org.nuiton.eugene.Toto")); Assert.assertEquals("Toto", mgr.getType("org.nuiton.eugene.Toto")); //Repeat to test acceptance Assert.assertEquals("Tutu", mgr.getType("org.nuiton.eugene.Tutu")); + Assert.assertEquals("Tutu<Toto>", mgr.getType("org.nuiton.eugene.Tutu<org.nuiton.eugene.Toto>")); + Assert.assertEquals("org.chorem.eugene.Tutu", mgr.getType("org.chorem.eugene.Tutu")); //Conflict, package differs Assert.assertEquals("void", mgr.getType("void")); Assert.assertEquals("boolean", mgr.getType("boolean")); Assert.assertEquals("Byte", mgr.getType("Byte")); Assert.assertEquals("Toto", mgr.getType("java.lang.Toto")); - Assert.assertEquals("java.lang.sub.Toto", mgr.getType("java.lang.sub.Toto")); + Assert.assertEquals("java.lang.sub.Toto", mgr.getType("java.lang.sub.Toto")); // Conflict, package differs } @Test