false otherwise
*/
public boolean isConnected( final String label )
{
final Vertex vertex = getVertex( label );
final boolean retValue = vertex.isConnected();
return retValue;
}
/**
* Return the list of labels of successor in order decided by topological sort
*
* @param label The label of the vertex whose predessors are serched
*
* @return The list of labels. Returned list contains also
* the label passed as parameter to this method. This label should
* always be the last item in the list.
*/
public List getSuccessorLabels( final String label )
{
final Vertex vertex = getVertex( label );
final List retValue;
//optimization.
if ( vertex.isLeaf() )
{
retValue = new ArrayList( 1 );
retValue.add( label );
}
else
{
retValue = TopologicalSorter.sort( vertex );
}
return retValue;
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/dag/TopologicalSorter.java 0000664 0000000 0000000 00000006312 11660305702 0030644 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.dag;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* @author Michal Maczka
* @version $Id: TopologicalSorter.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class TopologicalSorter
{
private final static Integer NOT_VISTITED = new Integer( 0 );
private final static Integer VISITING = new Integer( 1 );
private final static Integer VISITED = new Integer( 2 );
/**
* @param graph
* @return List of String (vertex labels)
*/
public static List sort( final DAG graph )
{
return dfs( graph );
}
public static List sort( final Vertex vertex )
{
// we need to use addFirst method so we will use LinkedList explicitly
final LinkedList retValue = new LinkedList();
final Map vertexStateMap = new HashMap();
dfsVisit( vertex, vertexStateMap, retValue );
return retValue;
}
private static List dfs( final DAG graph )
{
final List verticies = graph.getVerticies();
// we need to use addFirst method so we will use LinkedList explicitly
final LinkedList retValue = new LinkedList();
final Map vertexStateMap = new HashMap();
for ( final Iterator iter = verticies.iterator(); iter.hasNext(); )
{
final Vertex vertex = ( Vertex ) iter.next();
if ( isNotVisited( vertex, vertexStateMap ) )
{
dfsVisit( vertex, vertexStateMap, retValue );
}
}
return retValue;
}
/**
* @param vertex
* @param vertexStateMap
* @return
*/
private static boolean isNotVisited( final Vertex vertex, final Map vertexStateMap )
{
if ( !vertexStateMap.containsKey( vertex ) )
{
return true;
}
final Integer state = ( Integer ) vertexStateMap.get( vertex );
return NOT_VISTITED.equals( state );
}
private static void dfsVisit( final Vertex vertex, final Map vertexStateMap, final LinkedList list )
{
vertexStateMap.put( vertex, VISITING );
final List verticies = vertex.getChildren();
for ( final Iterator iter = verticies.iterator(); iter.hasNext(); )
{
final Vertex v = ( Vertex ) iter.next();
if ( isNotVisited( v, vertexStateMap ) )
{
dfsVisit( v, vertexStateMap, list );
}
}
vertexStateMap.put( vertex, VISITED );
list.add( vertex.getLabel() );
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/dag/Vertex.java 0000664 0000000 0000000 00000010625 11660305702 0026450 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.dag;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* @author Michal Maczka
* @version $Id: Vertex.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class Vertex implements Cloneable, Serializable
{
//------------------------------------------------------------
//Fields
//------------------------------------------------------------
private String label = null;
List children = new ArrayList();
List parents = new ArrayList();
// ------------------------------------------------------------
// Constructors
// ------------------------------------------------------------
/**
*
*/
public Vertex( final String label )
{
this.label = label;
}
// ------------------------------------------------------------
// Accessors
// ------------------------------------------------------------
/**
* @return
*/
public String getLabel()
{
return label;
}
/**
* @param vertex
*/
public void addEdgeTo( final Vertex vertex )
{
children.add( vertex );
}
/**
* @param vertex
*/
public void removeEdgeTo( final Vertex vertex )
{
children.remove( vertex );
}
/**
* @param vertex
*/
public void addEdgeFrom( final Vertex vertex )
{
parents.add( vertex );
}
public void removeEdgeFrom( final Vertex vertex )
{
parents.remove( vertex );
}
public List getChildren()
{
return children;
}
/**
* Get the labels used by the most direct children.
*
* @return the labels used by the most direct children.
*/
public List getChildLabels()
{
final List retValue = new ArrayList( children.size() );
for ( final Iterator iter = children.iterator(); iter.hasNext(); )
{
final Vertex vertex = ( Vertex ) iter.next();
retValue.add( vertex.getLabel() );
}
return retValue;
}
/**
* Get the list the most direct ancestors (parents).
*
* @return list of parents
*/
public List getParents()
{
return parents;
}
/**
* Get the labels used by the most direct ancestors (parents).
*
* @return the labels used parents
*/
public List getParentLabels()
{
final List retValue = new ArrayList( parents.size() );
for ( final Iterator iter = parents.iterator(); iter.hasNext(); )
{
final Vertex vertex = ( Vertex ) iter.next();
retValue.add( vertex.getLabel() );
}
return retValue;
}
/**
* Indicates if given vertex has no child
*
* @return true if this vertex has no child, false otherwise
*/
public boolean isLeaf()
{
return children.size() == 0;
}
/**
* Indicates if given vertex has no parent
*
* @return true if this vertex has no parent, false otherwise
*/
public boolean isRoot()
{
return parents.size() == 0;
}
/**
* Indicates if there is at least one edee leading to or from given vertex
*
* @return true if this vertex is connected with other vertex,false otherwise
*/
public boolean isConnected()
{
return isRoot() || isLeaf();
}
public Object clone() throws CloneNotSupportedException
{
// this is what's failing..
final Object retValue = super.clone();
return retValue;
}
public String toString()
{
return "Vertex{" +
"label='" + label + "'" +
"}";
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/introspection/ 0000775 0000000 0000000 00000000000 11660305702 0026471 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/introspection/ClassMap.java 0000664 0000000 0000000 00000035622 11660305702 0031047 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.introspection;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Hashtable;
import java.util.Map;
/**
* A cache of introspection information for a specific class instance.
* Keys {@link java.lang.Method} objects by a concatenation of the
* method name and the names of classes that make up the parameters.
*
* @author Jason van Zyl
* @author Bob McWhirter
* @author Attila Szegedi
* @author Geir Magnusson Jr.
* @version $Id: ClassMap.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class ClassMap
{
private static final class CacheMiss
{
}
private static final CacheMiss CACHE_MISS = new CacheMiss();
private static final Object OBJECT = new Object();
/**
* Class passed into the constructor used to as
* the basis for the Method map.
*/
private Class clazz;
/**
* Cache of Methods, or CACHE_MISS, keyed by method
* name and actual arguments used to find it.
*/
private Map methodCache = new Hashtable();
private MethodMap methodMap = new MethodMap();
/**
* Standard constructor
*/
public ClassMap( Class clazz )
{
this.clazz = clazz;
populateMethodCache();
}
/**
* @return the class object whose methods are cached by this map.
*/
Class getCachedClass()
{
return clazz;
}
/**
* Find a Method using the methodKey
* provided.
*
* Look in the methodMap for an entry. If found,
* it'll either be a CACHE_MISS, in which case we
* simply give up, or it'll be a Method, in which
* case, we return it.
*
* If nothing is found, then we must actually go
* and introspect the method from the MethodMap.
*/
public Method findMethod( String name, Object[] params )
throws MethodMap.AmbiguousException
{
String methodKey = makeMethodKey( name, params );
Object cacheEntry = methodCache.get( methodKey );
if ( cacheEntry == CACHE_MISS )
{
return null;
}
if ( cacheEntry == null )
{
try
{
cacheEntry = methodMap.find( name,
params );
}
catch ( MethodMap.AmbiguousException ae )
{
/*
* that's a miss :)
*/
methodCache.put( methodKey,
CACHE_MISS );
throw ae;
}
if ( cacheEntry == null )
{
methodCache.put( methodKey,
CACHE_MISS );
}
else
{
methodCache.put( methodKey,
cacheEntry );
}
}
// Yes, this might just be null.
return (Method) cacheEntry;
}
/**
* Populate the Map of direct hits. These
* are taken from all the public methods
* that our class provides.
*/
private void populateMethodCache()
{
StringBuffer methodKey;
/*
* get all publicly accessible methods
*/
Method[] methods = getAccessibleMethods( clazz );
/*
* map and cache them
*/
for ( int i = 0; i < methods.length; i++ )
{
Method method = methods[i];
/*
* now get the 'public method', the method declared by a
* public interface or class. (because the actual implementing
* class may be a facade...
*/
Method publicMethod = getPublicMethod( method );
/*
* it is entirely possible that there is no public method for
* the methods of this class (i.e. in the facade, a method
* that isn't on any of the interfaces or superclass
* in which case, ignore it. Otherwise, map and cache
*/
if ( publicMethod != null )
{
methodMap.add( publicMethod );
methodCache.put( makeMethodKey( publicMethod ), publicMethod );
}
}
}
/**
* Make a methodKey for the given method using
* the concatenation of the name and the
* types of the method parameters.
*/
private String makeMethodKey( Method method )
{
Class[] parameterTypes = method.getParameterTypes();
StringBuffer methodKey = new StringBuffer( method.getName() );
for ( int j = 0; j < parameterTypes.length; j++ )
{
/*
* If the argument type is primitive then we want
* to convert our primitive type signature to the
* corresponding Object type so introspection for
* methods with primitive types will work correctly.
*/
if ( parameterTypes[j].isPrimitive() )
{
if ( parameterTypes[j].equals( Boolean.TYPE ) )
methodKey.append( "java.lang.Boolean" );
else if ( parameterTypes[j].equals( Byte.TYPE ) )
methodKey.append( "java.lang.Byte" );
else if ( parameterTypes[j].equals( Character.TYPE ) )
methodKey.append( "java.lang.Character" );
else if ( parameterTypes[j].equals( Double.TYPE ) )
methodKey.append( "java.lang.Double" );
else if ( parameterTypes[j].equals( Float.TYPE ) )
methodKey.append( "java.lang.Float" );
else if ( parameterTypes[j].equals( Integer.TYPE ) )
methodKey.append( "java.lang.Integer" );
else if ( parameterTypes[j].equals( Long.TYPE ) )
methodKey.append( "java.lang.Long" );
else if ( parameterTypes[j].equals( Short.TYPE ) )
methodKey.append( "java.lang.Short" );
}
else
{
methodKey.append( parameterTypes[j].getName() );
}
}
return methodKey.toString();
}
private static String makeMethodKey( String method, Object[] params )
{
StringBuffer methodKey = new StringBuffer().append( method );
for ( int j = 0; j < params.length; j++ )
{
Object arg = params[j];
if ( arg == null )
{
arg = OBJECT;
}
methodKey.append( arg.getClass().getName() );
}
return methodKey.toString();
}
/**
* Retrieves public methods for a class. In case the class is not
* public, retrieves methods with same signature as its public methods
* from public superclasses and interfaces (if they exist). Basically
* upcasts every method to the nearest acccessible method.
*/
private static Method[] getAccessibleMethods( Class clazz )
{
Method[] methods = clazz.getMethods();
/*
* Short circuit for the (hopefully) majority of cases where the
* clazz is public
*/
if ( Modifier.isPublic( clazz.getModifiers() ) )
{
return methods;
}
/*
* No luck - the class is not public, so we're going the longer way.
*/
MethodInfo[] methodInfos = new MethodInfo[methods.length];
for ( int i = methods.length; i-- > 0; )
{
methodInfos[i] = new MethodInfo( methods[i] );
}
int upcastCount = getAccessibleMethods( clazz, methodInfos, 0 );
/*
* Reallocate array in case some method had no accessible counterpart.
*/
if ( upcastCount < methods.length )
{
methods = new Method[upcastCount];
}
int j = 0;
for ( int i = 0; i < methodInfos.length; ++i )
{
MethodInfo methodInfo = methodInfos[i];
if ( methodInfo.upcast )
{
methods[j++] = methodInfo.method;
}
}
return methods;
}
/**
* Recursively finds a match for each method, starting with the class, and then
* searching the superclass and interfaces.
*
* @param clazz Class to check
* @param methodInfos array of methods we are searching to match
* @param upcastCount current number of methods we have matched
* @return count of matched methods
*/
private static int getAccessibleMethods( Class clazz, MethodInfo[] methodInfos, int upcastCount )
{
int l = methodInfos.length;
/*
* if this class is public, then check each of the currently
* 'non-upcasted' methods to see if we have a match
*/
if ( Modifier.isPublic( clazz.getModifiers() ) )
{
for ( int i = 0; i < l && upcastCount < l; ++i )
{
try
{
MethodInfo methodInfo = methodInfos[i];
if ( !methodInfo.upcast )
{
methodInfo.tryUpcasting( clazz );
upcastCount++;
}
}
catch ( NoSuchMethodException e )
{
/*
* Intentionally ignored - it means
* it wasn't found in the current class
*/
}
}
/*
* Short circuit if all methods were upcast
*/
if ( upcastCount == l )
{
return upcastCount;
}
}
/*
* Examine superclass
*/
Class superclazz = clazz.getSuperclass();
if ( superclazz != null )
{
upcastCount = getAccessibleMethods( superclazz, methodInfos, upcastCount );
/*
* Short circuit if all methods were upcast
*/
if ( upcastCount == l )
{
return upcastCount;
}
}
/*
* Examine interfaces. Note we do it even if superclazz == null.
* This is redundant as currently java.lang.Object does not implement
* any interfaces, however nothing guarantees it will not in future.
*/
Class[] interfaces = clazz.getInterfaces();
for ( int i = interfaces.length; i-- > 0; )
{
upcastCount = getAccessibleMethods( interfaces[i], methodInfos, upcastCount );
/*
* Short circuit if all methods were upcast
*/
if ( upcastCount == l )
{
return upcastCount;
}
}
return upcastCount;
}
/**
* For a given method, retrieves its publicly accessible counterpart.
* This method will look for a method with same name
* and signature declared in a public superclass or implemented interface of this
* method's declaring class. This counterpart method is publicly callable.
*
* @param method a method whose publicly callable counterpart is requested.
* @return the publicly callable counterpart method. Note that if the parameter
* method is itself declared by a public class, this method is an identity
* function.
*/
public static Method getPublicMethod( Method method )
{
Class clazz = method.getDeclaringClass();
/*
* Short circuit for (hopefully the majority of) cases where the declaring
* class is public.
*/
if ( ( clazz.getModifiers() & Modifier.PUBLIC ) != 0 )
{
return method;
}
return getPublicMethod( clazz, method.getName(), method.getParameterTypes() );
}
/**
* Looks up the method with specified name and signature in the first public
* superclass or implemented interface of the class.
*
* @param class the class whose method is sought
* @param name the name of the method
* @param paramTypes the classes of method parameters
*/
private static Method getPublicMethod( Class clazz, String name, Class[] paramTypes )
{
/*
* if this class is public, then try to get it
*/
if ( ( clazz.getModifiers() & Modifier.PUBLIC ) != 0 )
{
try
{
return clazz.getMethod( name, paramTypes );
}
catch ( NoSuchMethodException e )
{
/*
* If the class does not have the method, then neither its
* superclass nor any of its interfaces has it so quickly return
* null.
*/
return null;
}
}
/*
* try the superclass
*/
Class superclazz = clazz.getSuperclass();
if ( superclazz != null )
{
Method superclazzMethod = getPublicMethod( superclazz, name, paramTypes );
if ( superclazzMethod != null )
{
return superclazzMethod;
}
}
/*
* and interfaces
*/
Class[] interfaces = clazz.getInterfaces();
for ( int i = 0; i < interfaces.length; ++i )
{
Method interfaceMethod = getPublicMethod( interfaces[i], name, paramTypes );
if ( interfaceMethod != null )
{
return interfaceMethod;
}
}
return null;
}
/**
* Used for the iterative discovery process for public methods.
*/
private static final class MethodInfo
{
Method method;
String name;
Class[] parameterTypes;
boolean upcast;
MethodInfo( Method method )
{
this.method = null;
name = method.getName();
parameterTypes = method.getParameterTypes();
upcast = false;
}
void tryUpcasting( Class clazz )
throws NoSuchMethodException
{
method = clazz.getMethod( name, parameterTypes );
name = null;
parameterTypes = null;
upcast = true;
}
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/introspection/MethodMap.java 0000664 0000000 0000000 00000034760 11660305702 0031224 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.introspection;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
*
* @author Jason van Zyl
* @author Bob McWhirter
* @author Christoph Reck
* @author Geir Magnusson Jr.
* @author Attila Szegedi
* @version $Id: MethodMap.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class MethodMap
{
private static final int MORE_SPECIFIC = 0;
private static final int LESS_SPECIFIC = 1;
private static final int INCOMPARABLE = 2;
/**
* Keep track of all methods with the same name.
*/
Map methodByNameMap = new Hashtable();
/**
* Add a method to a list of methods by name.
* For a particular class we are keeping track
* of all the methods with the same name.
*/
public void add(Method method)
{
String methodName = method.getName();
List l = get( methodName );
if ( l == null)
{
l = new ArrayList();
methodByNameMap.put(methodName, l);
}
l.add(method);
return;
}
/**
* Return a list of methods with the same name.
*
* @param key The name of the method.
* @return List list of methods
*/
public List get(String key)
{
return (List) methodByNameMap.get(key);
}
/**
*
* Find a method. Attempts to find the
* most specific applicable method using the
* algorithm described in the JLS section
* 15.12.2 (with the exception that it can't
* distinguish a primitive type argument from
* an object type argument, since in reflection
* primitive type arguments are represented by
* their object counterparts, so for an argument of
* type (say) java.lang.Integer, it will not be able
* to decide between a method that takes int and a
* method that takes java.lang.Integer as a parameter.
*
*
*
* This turns out to be a relatively rare case
* where this is needed - however, functionality
* like this is needed.
*
*
* @param methodName name of method
* @param args the actual arguments with which the method is called
* @return the most specific applicable method, or null if no
* method is applicable.
* @throws AmbiguousException if there is more than one maximally
* specific applicable method
*/
public Method find(String methodName, Object[] args)
throws AmbiguousException
{
List methodList = get(methodName);
if (methodList == null)
{
return null;
}
int l = args.length;
Class[] classes = new Class[l];
for(int i = 0; i < l; ++i)
{
Object arg = args[i];
/*
* if we are careful down below, a null argument goes in there
* so we can know that the null was passed to the method
*/
classes[i] =
arg == null ? null : arg.getClass();
}
return getMostSpecific(methodList, classes);
}
/**
* simple distinguishable exception, used when
* we run across ambiguous overloading
*/
public static class AmbiguousException extends Exception
{
}
private static Method getMostSpecific(List methods, Class[] classes)
throws AmbiguousException
{
LinkedList applicables = getApplicables(methods, classes);
if(applicables.isEmpty())
{
return null;
}
if(applicables.size() == 1)
{
return (Method)applicables.getFirst();
}
/*
* This list will contain the maximally specific methods. Hopefully at
* the end of the below loop, the list will contain exactly one method,
* (the most specific method) otherwise we have ambiguity.
*/
LinkedList maximals = new LinkedList();
for (Iterator applicable = applicables.iterator();
applicable.hasNext();)
{
Method app = (Method) applicable.next();
Class[] appArgs = app.getParameterTypes();
boolean lessSpecific = false;
for (Iterator maximal = maximals.iterator();
!lessSpecific && maximal.hasNext();)
{
Method max = (Method) maximal.next();
switch(moreSpecific(appArgs, max.getParameterTypes()))
{
case MORE_SPECIFIC:
{
/*
* This method is more specific than the previously
* known maximally specific, so remove the old maximum.
*/
maximal.remove();
break;
}
case LESS_SPECIFIC:
{
/*
* This method is less specific than some of the
* currently known maximally specific methods, so we
* won't add it into the set of maximally specific
* methods
*/
lessSpecific = true;
break;
}
}
}
if(!lessSpecific)
{
maximals.addLast(app);
}
}
if(maximals.size() > 1)
{
// We have more than one maximally specific method
throw new AmbiguousException();
}
return (Method)maximals.getFirst();
}
/**
* Determines which method signature (represented by a class array) is more
* specific. This defines a partial ordering on the method signatures.
* @param c1 first signature to compare
* @param c2 second signature to compare
* @return MORE_SPECIFIC if c1 is more specific than c2, LESS_SPECIFIC if
* c1 is less specific than c2, INCOMPARABLE if they are incomparable.
*/
private static int moreSpecific(Class[] c1, Class[] c2)
{
boolean c1MoreSpecific = false;
boolean c2MoreSpecific = false;
for(int i = 0; i < c1.length; ++i)
{
if(c1[i] != c2[i])
{
c1MoreSpecific =
c1MoreSpecific ||
isStrictMethodInvocationConvertible(c2[i], c1[i]);
c2MoreSpecific =
c2MoreSpecific ||
isStrictMethodInvocationConvertible(c1[i], c2[i]);
}
}
if(c1MoreSpecific)
{
if(c2MoreSpecific)
{
/*
* Incomparable due to cross-assignable arguments (i.e.
* foo(String, Object) vs. foo(Object, String))
*/
return INCOMPARABLE;
}
return MORE_SPECIFIC;
}
if(c2MoreSpecific)
{
return LESS_SPECIFIC;
}
/*
* Incomparable due to non-related arguments (i.e.
* foo(Runnable) vs. foo(Serializable))
*/
return INCOMPARABLE;
}
/**
* Returns all methods that are applicable to actual argument types.
* @param methods list of all candidate methods
* @param classes the actual types of the arguments
* @return a list that contains only applicable methods (number of
* formal and actual arguments matches, and argument types are assignable
* to formal types through a method invocation conversion).
*/
private static LinkedList getApplicables(List methods, Class[] classes)
{
LinkedList list = new LinkedList();
for (Iterator imethod = methods.iterator(); imethod.hasNext();)
{
Method method = (Method) imethod.next();
if(isApplicable(method, classes))
{
list.add(method);
}
}
return list;
}
/**
* Returns true if the supplied method is applicable to actual
* argument types.
*/
private static boolean isApplicable(Method method, Class[] classes)
{
Class[] methodArgs = method.getParameterTypes();
if(methodArgs.length != classes.length)
{
return false;
}
for(int i = 0; i < classes.length; ++i)
{
if(!isMethodInvocationConvertible(methodArgs[i], classes[i]))
{
return false;
}
}
return true;
}
/**
* Determines whether a type represented by a class object is
* convertible to another type represented by a class object using a
* method invocation conversion, treating object types of primitive
* types as if they were primitive types (that is, a Boolean actual
* parameter type matches boolean primitive formal type). This behavior
* is because this method is used to determine applicable methods for
* an actual parameter list, and primitive types are represented by
* their object duals in reflective method calls.
*
* @param formal the formal parameter type to which the actual
* parameter type should be convertible
* @param actual the actual parameter type.
* @return true if either formal type is assignable from actual type,
* or formal is a primitive type and actual is its corresponding object
* type or an object type of a primitive type that can be converted to
* the formal type.
*/
private static boolean isMethodInvocationConvertible(Class formal,
Class actual)
{
/*
* if it's a null, it means the arg was null
*/
if (actual == null && !formal.isPrimitive())
{
return true;
}
/*
* Check for identity or widening reference conversion
*/
if (actual != null && formal.isAssignableFrom(actual))
{
return true;
}
/*
* Check for boxing with widening primitive conversion. Note that
* actual parameters are never primitives.
*/
if (formal.isPrimitive())
{
if(formal == Boolean.TYPE && actual == Boolean.class)
return true;
if(formal == Character.TYPE && actual == Character.class)
return true;
if(formal == Byte.TYPE && actual == Byte.class)
return true;
if(formal == Short.TYPE &&
(actual == Short.class || actual == Byte.class))
return true;
if(formal == Integer.TYPE &&
(actual == Integer.class || actual == Short.class ||
actual == Byte.class))
return true;
if(formal == Long.TYPE &&
(actual == Long.class || actual == Integer.class ||
actual == Short.class || actual == Byte.class))
return true;
if(formal == Float.TYPE &&
(actual == Float.class || actual == Long.class ||
actual == Integer.class || actual == Short.class ||
actual == Byte.class))
return true;
if(formal == Double.TYPE &&
(actual == Double.class || actual == Float.class ||
actual == Long.class || actual == Integer.class ||
actual == Short.class || actual == Byte.class))
return true;
}
return false;
}
/**
* Determines whether a type represented by a class object is
* convertible to another type represented by a class object using a
* method invocation conversion, without matching object and primitive
* types. This method is used to determine the more specific type when
* comparing signatures of methods.
*
* @param formal the formal parameter type to which the actual
* parameter type should be convertible
* @param actual the actual parameter type.
* @return true if either formal type is assignable from actual type,
* or formal and actual are both primitive types and actual can be
* subject to widening conversion to formal.
*/
private static boolean isStrictMethodInvocationConvertible(Class formal,
Class actual)
{
/*
* we shouldn't get a null into, but if so
*/
if (actual == null && !formal.isPrimitive())
{
return true;
}
/*
* Check for identity or widening reference conversion
*/
if(formal.isAssignableFrom(actual))
{
return true;
}
/*
* Check for widening primitive conversion.
*/
if(formal.isPrimitive())
{
if(formal == Short.TYPE && (actual == Byte.TYPE))
return true;
if(formal == Integer.TYPE &&
(actual == Short.TYPE || actual == Byte.TYPE))
return true;
if(formal == Long.TYPE &&
(actual == Integer.TYPE || actual == Short.TYPE ||
actual == Byte.TYPE))
return true;
if(formal == Float.TYPE &&
(actual == Long.TYPE || actual == Integer.TYPE ||
actual == Short.TYPE || actual == Byte.TYPE))
return true;
if(formal == Double.TYPE &&
(actual == Float.TYPE || actual == Long.TYPE ||
actual == Integer.TYPE || actual == Short.TYPE ||
actual == Byte.TYPE))
return true;
}
return false;
}
}
ReflectionValueExtractor.java 0000664 0000000 0000000 00000021673 11660305702 0034251 0 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/introspection package org.codehaus.plexus.util.introspection;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.WeakHashMap;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.codehaus.plexus.util.StringUtils;
/**
* Using simple dotted expressions to extract the values from an Object instance,
* For example we might want to extract a value like: project.build.sourceDirectory
*
* The implementation supports indexed, nested and mapped properties similar to the JSP way.
*
* @author Jason van Zyl
* @author Vincent Siveton
* @version $Id: ReflectionValueExtractor.java 8010 2009-01-07 12:59:50Z vsiveton $
* @see http://struts.apache.org/1.x/struts-taglib/indexedprops.html
*/
public class ReflectionValueExtractor
{
private static final Class[] CLASS_ARGS = new Class[0];
private static final Object[] OBJECT_ARGS = new Object[0];
/**
* Use a WeakHashMap here, so the keys (Class objects) can be garbage collected.
* This approach prevents permgen space overflows due to retention of discarded
* classloaders.
*/
private static final Map classMaps = new WeakHashMap();
/**
* Indexed properties pattern, ie (\\w+)\\[(\\d+)\\]
*/
private static final Pattern INDEXED_PROPS = Pattern.compile( "(\\w+)\\[(\\d+)\\]" );
/**
* Indexed properties pattern, ie (\\w+)\\((.+)\\)
*/
private static final Pattern MAPPED_PROPS = Pattern.compile( "(\\w+)\\((.+)\\)" );
private ReflectionValueExtractor()
{
}
/**
* The implementation supports indexed, nested and mapped properties.
*
*
* - nested properties should be defined by a dot, i.e. "user.address.street"
* - indexed properties (java.util.List or array instance) should be contains
(\\w+)\\[(\\d+)\\]
* pattern, i.e. "user.addresses[1].street"
* - mapped properties should be contains
(\\w+)\\((.+)\\) pattern, i.e. "user.addresses(myAddress).street"
*
*
* @param expression not null expression
* @param root not null object
* @return the object defined by the expression
* @throws Exception if any
*/
public static Object evaluate( String expression, Object root )
throws Exception
{
return evaluate( expression, root, true );
}
/**
* The implementation supports indexed, nested and mapped properties.
*
*
* - nested properties should be defined by a dot, i.e. "user.address.street"
* - indexed properties (java.util.List or array instance) should be contains
(\\w+)\\[(\\d+)\\]
* pattern, i.e. "user.addresses[1].street"
* - mapped properties should be contains
(\\w+)\\((.+)\\) pattern, i.e. "user.addresses(myAddress).street"
*
*
* @param expression not null expression
* @param root not null object
* @return the object defined by the expression
* @throws Exception if any
*/
// TODO: don't throw Exception
public static Object evaluate( String expression, Object root, boolean trimRootToken )
throws Exception
{
// if the root token refers to the supplied root object parameter, remove it.
if ( trimRootToken )
{
expression = expression.substring( expression.indexOf( '.' ) + 1 );
}
Object value = root;
// ----------------------------------------------------------------------
// Walk the dots and retrieve the ultimate value desired from the
// MavenProject instance.
// ----------------------------------------------------------------------
StringTokenizer parser = new StringTokenizer( expression, "." );
while ( parser.hasMoreTokens() )
{
// if we have nothing, stop now
if ( value == null )
{
return null;
}
String token = parser.nextToken();
ClassMap classMap = getClassMap( value.getClass() );
Method method;
Object[] localParams = OBJECT_ARGS;
// do we have an indexed property?
Matcher matcher = INDEXED_PROPS.matcher( token );
if ( matcher.find() )
{
String methodBase = StringUtils.capitalizeFirstLetter( matcher.group( 1 ) );
String methodName = "get" + methodBase;
method = classMap.findMethod( methodName, CLASS_ARGS );
value = method.invoke( value, OBJECT_ARGS );
classMap = getClassMap( value.getClass() );
if ( classMap.getCachedClass().isArray() )
{
value = Arrays.asList( (Object[]) value );
classMap = getClassMap( value.getClass() );
}
if ( value instanceof List )
{
// use get method on List interface
localParams = new Object[1];
localParams[0] = Integer.valueOf( matcher.group( 2 ) );
method = classMap.findMethod( "get", localParams );
}
else
{
throw new Exception( "The token '" + token
+ "' refers to a java.util.List or an array, but the value seems is an instance of '"
+ value.getClass() + "'." );
}
}
else
{
// do we have a mapped property?
matcher = MAPPED_PROPS.matcher( token );
if ( matcher.find() )
{
String methodBase = StringUtils.capitalizeFirstLetter( matcher.group( 1 ) );
String methodName = "get" + methodBase;
method = classMap.findMethod( methodName, CLASS_ARGS );
value = method.invoke( value, OBJECT_ARGS );
classMap = getClassMap( value.getClass() );
if ( value instanceof Map )
{
// use get method on List interface
localParams = new Object[1];
localParams[0] = matcher.group( 2 );
method = classMap.findMethod( "get", localParams );
}
else
{
throw new Exception( "The token '" + token
+ "' refers to a java.util.Map, but the value seems is an instance of '"
+ value.getClass() + "'." );
}
}
else
{
String methodBase = StringUtils.capitalizeFirstLetter( token );
String methodName = "get" + methodBase;
method = classMap.findMethod( methodName, CLASS_ARGS );
if ( method == null )
{
// perhaps this is a boolean property??
methodName = "is" + methodBase;
method = classMap.findMethod( methodName, CLASS_ARGS );
}
}
}
if ( method == null )
{
return null;
}
try
{
value = method.invoke( value, localParams );
}
catch ( InvocationTargetException e )
{
// catch array index issues gracefully, otherwise release
if ( e.getCause() instanceof IndexOutOfBoundsException )
{
return null;
}
throw e;
}
}
return value;
}
private static ClassMap getClassMap( Class clazz )
{
ClassMap classMap = (ClassMap) classMaps.get( clazz );
if ( classMap == null )
{
classMap = new ClassMap( clazz );
classMaps.put( clazz, classMap );
}
return classMap;
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/io/ 0000775 0000000 0000000 00000000000 11660305702 0024200 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/io/FileInputStreamFacade.java 0000664 0000000 0000000 00000002211 11660305702 0031176 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.io;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* Implementation of {@link InputStreamFacade} for files.
*/
public class FileInputStreamFacade implements InputStreamFacade {
private final File file;
/**
* Creates a new instance.
*/
public FileInputStreamFacade( File file )
{
this.file = file;
}
public InputStream getInputStream() throws IOException {
return new FileInputStream( file );
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/io/InputStreamFacade.java 0000664 0000000 0000000 00000002075 11660305702 0030406 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.io;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.IOException;
import java.io.InputStream;
/**
* Interface of a wrapper for input streams. This facade is used
* by methods, which are being implemented for files, URL's, or
* input streams.
*/
public interface InputStreamFacade {
/**
* Retrieves the actual {@link InputStream}. The caller must assume,
* that this method may be invoked only once.
*/
InputStream getInputStream() throws IOException;
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/io/RawInputStreamFacade.java 0000664 0000000 0000000 00000002125 11660305702 0031054 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.io;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.IOException;
import java.io.InputStream;
/**
* Implementation of {@link InputStreamFacade} for raw input streams.
*/
public class RawInputStreamFacade implements InputStreamFacade {
final InputStream stream;
/**
* Creates a new instance.
*/
public RawInputStreamFacade( InputStream stream )
{
this.stream = stream;
}
public InputStream getInputStream() throws IOException {
return stream;
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/io/URLInputStreamFacade.java 0000664 0000000 0000000 00000002124 11660305702 0030764 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.io;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
/**
* Implementation of {@link InputStreamFacade} for URL's.
*/
public class URLInputStreamFacade implements InputStreamFacade {
private final URL url;
/**
* Creates a new instance.
*/
public URLInputStreamFacade( URL url )
{
this.url = url;
}
public InputStream getInputStream() throws IOException {
return url.openStream();
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/reflection/ 0000775 0000000 0000000 00000000000 11660305702 0025723 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/reflection/Reflector.java 0000664 0000000 0000000 00000047607 11660305702 0030531 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.reflection;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
/**
* Utility class used to instantiate an object using reflection. This utility
* hides many of the gory details needed to do this.
*
* @author John Casey
*/
public final class Reflector
{
private static final String CONSTRUCTOR_METHOD_NAME = "$$CONSTRUCTOR$$";
private static final String GET_INSTANCE_METHOD_NAME = "getInstance";
private HashMap classMaps = new HashMap();
/** Ensure no instances of Reflector are created...this is a utility. */
public Reflector()
{
}
/**
* Create a new instance of a class, given the array of parameters... Uses
* constructor caching to find a constructor that matches the parameter
* types, either specifically (first choice) or abstractly...
*
* @param theClass
* The class to instantiate
* @param params
* The parameters to pass to the constructor
* @return The instantiated object
* @throws ReflectorException
* In case anything goes wrong here...
*/
public Object newInstance( Class theClass, Object[] params )
throws ReflectorException
{
if ( params == null )
{
params = new Object[0];
}
Class[] paramTypes = new Class[params.length];
for ( int i = 0, len = params.length; i < len; i++ )
{
paramTypes[i] = params[i].getClass();
}
try
{
Constructor con = getConstructor( theClass, paramTypes );
if ( con == null )
{
StringBuffer buffer = new StringBuffer();
buffer.append( "Constructor not found for class: " );
buffer.append( theClass.getName() );
buffer.append( " with specified or ancestor parameter classes: " );
for ( int i = 0; i < paramTypes.length; i++ )
{
buffer.append( paramTypes[i].getName() );
buffer.append( ',' );
}
buffer.setLength( buffer.length() - 1 );
throw new ReflectorException( buffer.toString() );
}
return con.newInstance( params );
}
catch ( InstantiationException ex )
{
throw new ReflectorException( ex );
}
catch ( InvocationTargetException ex )
{
throw new ReflectorException( ex );
}
catch ( IllegalAccessException ex )
{
throw new ReflectorException( ex );
}
}
/**
* Retrieve the singleton instance of a class, given the array of
* parameters... Uses constructor caching to find a constructor that matches
* the parameter types, either specifically (first choice) or abstractly...
*
* @param theClass
* The class to retrieve the singleton of
* @param initParams
* The parameters to pass to the constructor
* @return The singleton object
* @throws ReflectorException
* In case anything goes wrong here...
*/
public Object getSingleton( Class theClass, Object[] initParams )
throws ReflectorException
{
Class[] paramTypes = new Class[initParams.length];
for ( int i = 0, len = initParams.length; i < len; i++ )
{
paramTypes[i] = initParams[i].getClass();
}
try
{
Method method = getMethod( theClass, GET_INSTANCE_METHOD_NAME, paramTypes );
return method.invoke( null, initParams );
}
catch ( InvocationTargetException ex )
{
throw new ReflectorException( ex );
}
catch ( IllegalAccessException ex )
{
throw new ReflectorException( ex );
}
}
/**
* Invoke the specified method on the specified target with the specified
* params...
*
* @param target
* The target of the invocation
* @param methodName
* The method name to invoke
* @param params
* The parameters to pass to the method invocation
* @return The result of the method call
* @throws ReflectorException
* In case of an error looking up or invoking the method.
*/
public Object invoke( Object target, String methodName, Object[] params )
throws ReflectorException
{
if ( params == null )
{
params = new Object[0];
}
Class[] paramTypes = new Class[params.length];
for ( int i = 0, len = params.length; i < len; i++ )
{
paramTypes[i] = params[i].getClass();
}
try
{
Method method = getMethod( target.getClass(), methodName, paramTypes );
if ( method == null )
{
StringBuffer buffer = new StringBuffer();
buffer.append( "Singleton-producing method named '" ).append( methodName )
.append( "' not found with specified parameter classes: " );
for ( int i = 0; i < paramTypes.length; i++ )
{
buffer.append( paramTypes[i].getName() );
buffer.append( ',' );
}
buffer.setLength( buffer.length() - 1 );
throw new ReflectorException( buffer.toString() );
}
return method.invoke( target, params );
}
catch ( InvocationTargetException ex )
{
throw new ReflectorException( ex );
}
catch ( IllegalAccessException ex )
{
throw new ReflectorException( ex );
}
}
public Object getStaticField( Class targetClass, String fieldName )
throws ReflectorException
{
try
{
Field field = targetClass.getField( fieldName );
return field.get( null );
}
catch ( SecurityException e )
{
throw new ReflectorException( e );
}
catch ( NoSuchFieldException e )
{
throw new ReflectorException( e );
}
catch ( IllegalArgumentException e )
{
throw new ReflectorException( e );
}
catch ( IllegalAccessException e )
{
throw new ReflectorException( e );
}
}
public Object getField( Object target, String fieldName )
throws ReflectorException
{
return getField( target, fieldName, false );
}
public Object getField( Object target, String fieldName, boolean breakAccessibility )
throws ReflectorException
{
Class targetClass = target.getClass();
while ( targetClass != null )
{
try
{
Field field = targetClass.getDeclaredField( fieldName );
boolean accessibilityBroken = false;
if ( !field.isAccessible() && breakAccessibility )
{
field.setAccessible( true );
accessibilityBroken = true;
}
Object result = field.get( target );
if ( accessibilityBroken )
{
field.setAccessible( false );
}
return result;
}
catch ( SecurityException e )
{
throw new ReflectorException( e );
}
catch ( NoSuchFieldException e )
{
if ( targetClass == Object.class )
throw new ReflectorException( e );
targetClass = targetClass.getSuperclass();
}
catch ( IllegalAccessException e )
{
throw new ReflectorException( e );
}
}
// Never reached, but needed to satisfy compiler
return null;
}
/**
* Invoke the specified static method with the specified params...
*
* @param targetClass
* The target class of the invocation
* @param methodName
* The method name to invoke
* @param params
* The parameters to pass to the method invocation
* @return The result of the method call
* @throws ReflectorException
* In case of an error looking up or invoking the method.
*/
public Object invokeStatic( Class targetClass, String methodName, Object[] params )
throws ReflectorException
{
if ( params == null )
{
params = new Object[0];
}
Class[] paramTypes = new Class[params.length];
for ( int i = 0, len = params.length; i < len; i++ )
{
paramTypes[i] = params[i].getClass();
}
try
{
Method method = getMethod( targetClass, methodName, paramTypes );
if ( method == null )
{
StringBuffer buffer = new StringBuffer();
buffer.append( "Singleton-producing method named \'" + methodName
+ "\' not found with specified parameter classes: " );
for ( int i = 0; i < paramTypes.length; i++ )
{
buffer.append( paramTypes[i].getName() );
buffer.append( ',' );
}
buffer.setLength( buffer.length() - 1 );
throw new ReflectorException( buffer.toString() );
}
return method.invoke( null, params );
}
catch ( InvocationTargetException ex )
{
throw new ReflectorException( ex );
}
catch ( IllegalAccessException ex )
{
throw new ReflectorException( ex );
}
}
/**
* Return the constructor, checking the cache first and storing in cache if
* not already there..
*
* @param targetClass
* The class to get the constructor from
* @param params
* The classes of the parameters which the constructor should
* match.
* @return the Constructor object that matches.
* @throws ReflectorException
* In case we can't retrieve the proper constructor.
*/
public Constructor getConstructor( Class targetClass, Class[] params )
throws ReflectorException
{
Map constructorMap = getConstructorMap( targetClass );
StringBuffer key = new StringBuffer( 200 );
key.append( "(" );
for ( int i = 0, len = params.length; i < len; i++ )
{
key.append( params[i].getName() );
key.append( "," );
}
if ( params.length > 0 )
{
key.setLength( key.length() - 1 );
}
key.append( ")" );
Constructor constructor = null;
String paramKey = key.toString();
synchronized ( paramKey.intern() )
{
constructor = (Constructor) constructorMap.get( paramKey );
if ( constructor == null )
{
Constructor[] cands = targetClass.getConstructors();
for ( int i = 0, len = cands.length; i < len; i++ )
{
Class[] types = cands[i].getParameterTypes();
if ( params.length != types.length )
{
continue;
}
for ( int j = 0, len2 = params.length; j < len2; j++ )
{
if ( !types[j].isAssignableFrom( params[j] ) )
{
continue;
}
}
// we got it, so store it!
constructor = cands[i];
constructorMap.put( paramKey, constructor );
}
}
}
if ( constructor == null )
{
throw new ReflectorException( "Error retrieving constructor object for: " + targetClass.getName()
+ paramKey );
}
return constructor;
}
public Object getObjectProperty( Object target, String propertyName )
throws ReflectorException
{
Object returnValue = null;
if ( propertyName == null || propertyName.trim().length() < 1 )
{
throw new ReflectorException( "Cannot retrieve value for empty property." );
}
String beanAccessor = "get" + Character.toUpperCase( propertyName.charAt( 0 ) );
if ( propertyName.trim().length() > 1 )
{
beanAccessor += propertyName.substring( 1 ).trim();
}
Class targetClass = target.getClass();
Class[] emptyParams = {};
Method method = _getMethod( targetClass, beanAccessor, emptyParams );
if ( method == null )
{
method = _getMethod( targetClass, propertyName, emptyParams );
}
if ( method != null )
{
try
{
returnValue = method.invoke( target, new Object[] {} );
}
catch ( IllegalAccessException e )
{
throw new ReflectorException( "Error retrieving property \'" + propertyName + "\' from \'"
+ targetClass + "\'", e );
}
catch ( InvocationTargetException e )
{
throw new ReflectorException( "Error retrieving property \'" + propertyName + "\' from \'"
+ targetClass + "\'", e );
}
}
if ( method != null )
{
try
{
returnValue = method.invoke( target, new Object[] {} );
}
catch ( IllegalAccessException e )
{
throw new ReflectorException( "Error retrieving property \'" + propertyName + "\' from \'"
+ targetClass + "\'", e );
}
catch ( InvocationTargetException e )
{
throw new ReflectorException( "Error retrieving property \'" + propertyName + "\' from \'"
+ targetClass + "\'", e );
}
}
else
{
returnValue = getField( target, propertyName, true );
if ( method == null && returnValue == null )
{
// TODO: Check if exception is the right action! Field exists, but contains null
throw new ReflectorException( "Neither method: \'" + propertyName + "\' nor bean accessor: \'"
+ beanAccessor + "\' can be found for class: \'" + targetClass
+ "\', and retrieval of field: \'" + propertyName + "\' returned null as value." );
}
}
return returnValue;
}
/**
* Return the method, checking the cache first and storing in cache if not
* already there..
*
* @param targetClass
* The class to get the method from
* @param params
* The classes of the parameters which the method should match.
* @return the Method object that matches.
* @throws ReflectorException
* In case we can't retrieve the proper method.
*/
public Method getMethod( Class targetClass, String methodName, Class[] params )
throws ReflectorException
{
Method method = _getMethod( targetClass, methodName, params );
if ( method == null )
{
throw new ReflectorException( "Method: \'" + methodName + "\' not found in class: \'" + targetClass
+ "\'" );
}
return method;
}
private Method _getMethod( Class targetClass, String methodName, Class[] params )
throws ReflectorException
{
Map methodMap = getMethodMap( targetClass, methodName );
StringBuffer key = new StringBuffer( 200 );
key.append( "(" );
for ( int i = 0, len = params.length; i < len; i++ )
{
key.append( params[i].getName() );
key.append( "," );
}
key.append( ")" );
Method method = null;
String paramKey = key.toString();
synchronized ( paramKey.intern() )
{
method = (Method) methodMap.get( paramKey );
if ( method == null )
{
Method[] cands = targetClass.getMethods();
for ( int i = 0, len = cands.length; i < len; i++ )
{
String name = cands[i].getName();
if ( !methodName.equals( name ) )
{
continue;
}
Class[] types = cands[i].getParameterTypes();
if ( params.length != types.length )
{
continue;
}
for ( int j = 0, len2 = params.length; j < len2; j++ )
{
if ( !types[j].isAssignableFrom( params[j] ) )
{
continue;
}
}
// we got it, so store it!
method = cands[i];
methodMap.put( paramKey, method );
}
}
}
return method;
}
/**
* Retrieve the cache of constructors for the specified class.
*
* @param theClass
* the class to lookup.
* @return The cache of constructors.
* @throws ReflectorException
* in case of a lookup error.
*/
private Map getConstructorMap( Class theClass )
throws ReflectorException
{
return getMethodMap( theClass, CONSTRUCTOR_METHOD_NAME );
}
/**
* Retrieve the cache of methods for the specified class and method name.
*
* @param theClass
* the class to lookup.
* @param methodName
* The name of the method to lookup.
* @return The cache of constructors.
* @throws ReflectorException
* in case of a lookup error.
*/
private Map getMethodMap( Class theClass, String methodName )
throws ReflectorException
{
Map methodMap = null;
if ( theClass == null )
{
return null;
}
String className = theClass.getName();
synchronized ( className.intern() )
{
Map classMethods = (Map) classMaps.get( className );
if ( classMethods == null )
{
classMethods = new HashMap();
methodMap = new HashMap();
classMethods.put( methodName, methodMap );
classMaps.put( className, classMethods );
}
else
{
String key = className + "::" + methodName;
synchronized ( key.intern() )
{
methodMap = (Map) classMethods.get( methodName );
if ( methodMap == null )
{
methodMap = new HashMap();
classMethods.put( methodName, methodMap );
}
}
}
}
return methodMap;
}
} plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/reflection/ReflectorException.java 0000664 0000000 0000000 00000003464 11660305702 0032401 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.reflection;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
/**
* Exception indicating that an error has occurred while instantiating a class
* with the Reflector class. This exception is meant to put a more user-friendly
* face on the myriad other exceptions throws during reflective object creation.
*
* @author John Casey
*/
public class ReflectorException
extends Exception
{
/**
* Create a new ReflectorException.
*/
public ReflectorException()
{
}
/**
* Create a new ReflectorException with the specified message.
*
* @param msg
* The message.
*/
public ReflectorException( String msg )
{
super( msg );
}
/**
* Create a new ReflectorException with the specified root cause.
*
* @param root
* The root cause.
*/
public ReflectorException( Throwable root )
{
super( root );
}
/**
* Create a new ReflectorException with the specified message and root
* cause.
*
* @param msg
* The message.
* @param root
* The root cause.
*/
public ReflectorException( String msg, Throwable root )
{
super( msg, root );
}
} plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/ 0000775 0000000 0000000 00000000000 11660305702 0024371 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/CompactXMLWriter.java 0000664 0000000 0000000 00000002145 11660305702 0030402 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.PrintWriter;
import java.io.Writer;
/**
* @version $Id: CompactXMLWriter.java 8660 2010-03-05 21:50:36Z hboutemy $
*/
public class CompactXMLWriter
extends PrettyPrintXMLWriter
{
public CompactXMLWriter( PrintWriter writer )
{
super( writer );
}
public CompactXMLWriter( Writer writer )
{
super( writer );
}
protected void endOfLine()
{
// override parent: don't write anything at end of line
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/PrettyPrintXMLWriter.java 0000664 0000000 0000000 00000025134 11660305702 0031323 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.PrintWriter;
import java.io.Writer;
import java.util.LinkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.codehaus.plexus.util.StringUtils;
/**
* Implementation of XMLWriter which emits nicely formatted documents.
*
* @version $Id: PrettyPrintXMLWriter.java 8660 2010-03-05 21:50:36Z hboutemy $
*/
public class PrettyPrintXMLWriter
implements XMLWriter
{
/** Line separator ("\n" on UNIX) */
protected static final String LS = System.getProperty( "line.separator" );
private PrintWriter writer;
private LinkedList elementStack = new LinkedList();
private boolean tagInProgress;
private int depth;
private String lineIndenter;
private String lineSeparator;
private String encoding;
private String docType;
private boolean readyForNewLine;
private boolean tagIsEmpty;
/**
* @param writer not null
* @param lineIndenter could be null, but the normal way is some spaces.
*/
public PrettyPrintXMLWriter( PrintWriter writer, String lineIndenter )
{
this( writer, lineIndenter, null, null );
}
/**
* @param writer not null
* @param lineIndenter could be null, but the normal way is some spaces.
*/
public PrettyPrintXMLWriter( Writer writer, String lineIndenter )
{
this( new PrintWriter( writer ), lineIndenter );
}
/**
* @param writer not null
*/
public PrettyPrintXMLWriter( PrintWriter writer )
{
this( writer, null, null );
}
/**
* @param writer not null
*/
public PrettyPrintXMLWriter( Writer writer )
{
this( new PrintWriter( writer ) );
}
/**
* @param writer not null
* @param lineIndenter could be null, but the normal way is some spaces.
* @param encoding could be null or invalid.
* @param doctype could be null.
*/
public PrettyPrintXMLWriter( PrintWriter writer, String lineIndenter, String encoding, String doctype )
{
this( writer, lineIndenter, LS, encoding, doctype );
}
/**
* @param writer not null
* @param lineIndenter could be null, but the normal way is some spaces.
* @param encoding could be null or invalid.
* @param doctype could be null.
*/
public PrettyPrintXMLWriter( Writer writer, String lineIndenter, String encoding, String doctype )
{
this( new PrintWriter( writer ), lineIndenter, encoding, doctype );
}
/**
* @param writer not null
* @param encoding could be null or invalid.
* @param doctype could be null.
*/
public PrettyPrintXMLWriter( PrintWriter writer, String encoding, String doctype )
{
this( writer, " ", encoding, doctype );
}
/**
* @param writer not null
* @param encoding could be null or invalid.
* @param doctype could be null.
*/
public PrettyPrintXMLWriter( Writer writer, String encoding, String doctype )
{
this( new PrintWriter( writer ), encoding, doctype );
}
/**
* @param writer not null
* @param lineIndenter could be null, but the normal way is some spaces.
* @param lineSeparator could be null, but the normal way is valid line separator ("\n" on UNIX).
* @param encoding could be null or invalid.
* @param doctype could be null.
*/
public PrettyPrintXMLWriter( PrintWriter writer, String lineIndenter, String lineSeparator, String encoding, String doctype )
{
setWriter( writer );
setLineIndenter( lineIndenter );
setLineSeparator( lineSeparator );
setEncoding( encoding );
setDocType( doctype );
if ( doctype != null || encoding != null )
{
writeDocumentHeaders();
}
}
/** {@inheritDoc} */
public void startElement( String name )
{
tagIsEmpty = false;
finishTag();
write( "<" );
write( name );
elementStack.addLast( name );
tagInProgress = true;
setDepth( getDepth() + 1 );
readyForNewLine = true;
tagIsEmpty = true;
}
/** {@inheritDoc} */
public void writeText( String text )
{
writeText( text, true );
}
/** {@inheritDoc} */
public void writeMarkup( String text )
{
writeText( text, false );
}
private void writeText( String text, boolean escapeXml )
{
readyForNewLine = false;
tagIsEmpty = false;
finishTag();
if ( escapeXml )
{
text = escapeXml( text );
}
write( StringUtils.unifyLineSeparators( text, lineSeparator ) );
}
private static String escapeXml( String text )
{
text = text.replaceAll( "&", "&" );
text = text.replaceAll( "<", "<" );
text = text.replaceAll( ">", ">" );
text = text.replaceAll( "\"", """ );
text = text.replaceAll( "\'", "'" );
return text;
}
private static String escapeXmlAttribute( String text )
{
text = escapeXml( text );
// Windows
text = text.replaceAll( "\r\n", "
" );
Pattern pattern = Pattern.compile( "([\000-\037])" );
Matcher m = pattern.matcher( text );
StringBuffer b = new StringBuffer();
while ( m.find() )
{
m = m.appendReplacement( b, "&#" + Integer.toString( m.group( 1 ).charAt( 0 ) ) + ";" );
}
m.appendTail( b );
return b.toString();
}
/** {@inheritDoc} */
public void addAttribute( String key, String value )
{
write( " " );
write( key );
write( "=\"" );
write( escapeXmlAttribute( value ) );
write( "\"" );
}
/** {@inheritDoc} */
public void endElement()
{
setDepth( getDepth() - 1 );
if ( tagIsEmpty )
{
write( "/" );
readyForNewLine = false;
finishTag();
elementStack.removeLast();
}
else
{
finishTag();
write( "" );
}
readyForNewLine = true;
}
/**
* Write a string to the underlying writer
* @param str
*/
private void write( String str )
{
getWriter().write( str );
}
private void finishTag()
{
if ( tagInProgress )
{
write( ">" );
}
tagInProgress = false;
if ( readyForNewLine )
{
endOfLine();
}
readyForNewLine = false;
tagIsEmpty = false;
}
/**
* Get the string used as line indenter
*
* @return the line indenter
*/
protected String getLineIndenter()
{
return lineIndenter;
}
/**
* Set the string used as line indenter
*
* @param lineIndenter new line indenter, could be null, but the normal way is some spaces.
*/
protected void setLineIndenter( String lineIndenter )
{
this.lineIndenter = lineIndenter;
}
/**
* Get the string used as line separator or LS if not set.
*
* @return the line separator
* @see #LS
*/
protected String getLineSeparator()
{
return lineSeparator;
}
/**
* Set the string used as line separator
*
* @param lineSeparator new line separator, could be null but the normal way is valid line separator
* ("\n" on UNIX).
*/
protected void setLineSeparator( String lineSeparator )
{
this.lineSeparator = lineSeparator;
}
/**
* Write the end of line character (using specified line separator)
* and start new line with indentation
*
* @see #getLineIndenter()
* @see #getLineSeparator()
*/
protected void endOfLine()
{
write( getLineSeparator() );
for ( int i = 0; i < getDepth(); i++ )
{
write( getLineIndenter() );
}
}
private void writeDocumentHeaders()
{
write( "" );
endOfLine();
if ( getDocType() != null )
{
write( "" );
endOfLine();
}
}
/**
* Set the underlying writer
*
* @param writer not null writer
*/
protected void setWriter( PrintWriter writer )
{
if ( writer == null )
{
throw new IllegalArgumentException( "writer could not be null");
}
this.writer = writer;
}
/**
* Get the underlying writer
*
* @return the underlying writer
*/
protected PrintWriter getWriter()
{
return writer;
}
/**
* Set the depth in the xml indentation
*
* @param depth new depth
*/
protected void setDepth( int depth )
{
this.depth = depth;
}
/**
* Get the current depth in the xml indentation
*
* @return the current depth
*/
protected int getDepth()
{
return depth;
}
/**
* Set the encoding in the xml
*
* @param encoding new encoding
*/
protected void setEncoding( String encoding )
{
this.encoding = encoding;
}
/**
* Get the current encoding in the xml
*
* @return the current encoding
*/
protected String getEncoding()
{
return encoding;
}
/**
* Set the docType in the xml
*
* @param docType new docType
*/
protected void setDocType( String docType )
{
this.docType = docType;
}
/**
* Get the docType in the xml
*
* @return the current docType
*/
protected String getDocType()
{
return docType;
}
/**
* @return the current elementStack;
*/
protected LinkedList getElementStack()
{
return elementStack;
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/SerializerXMLWriter.java 0000664 0000000 0000000 00000005604 11660305702 0031130 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import org.codehaus.plexus.util.xml.pull.XmlSerializer;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
/**
* Write to an MXSerializer.
*
* @author Brett Porter
* @version $Id: SerializerXMLWriter.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class SerializerXMLWriter
implements XMLWriter
{
private final XmlSerializer serializer;
private final String namespace;
private final Stack elements = new Stack();
private List exceptions;
public SerializerXMLWriter( String namespace, XmlSerializer serializer )
{
this.serializer = serializer;
this.namespace = namespace;
}
public void startElement( String name )
{
try
{
serializer.startTag( namespace, name );
elements.push( name );
}
catch ( IOException e )
{
storeException( e );
}
}
public void addAttribute( String key, String value )
{
try
{
serializer.attribute( namespace, key, value );
}
catch ( IOException e )
{
storeException( e );
}
}
public void writeText( String text )
{
try
{
serializer.text( text );
}
catch ( IOException e )
{
storeException( e );
}
}
public void writeMarkup( String text )
{
try
{
serializer.cdsect( text );
}
catch ( IOException e )
{
storeException( e );
}
}
public void endElement()
{
try
{
serializer.endTag( namespace, (String) elements.pop() );
}
catch ( IOException e )
{
storeException( e );
}
}
/**
* @todo Maybe the interface should allow IOExceptions on each?
*/
private void storeException( IOException e )
{
if ( exceptions == null )
{
exceptions = new ArrayList();
}
exceptions.add( e );
}
public List getExceptions()
{
return exceptions == null ? Collections.EMPTY_LIST : exceptions;
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/XMLWriter.java 0000664 0000000 0000000 00000001654 11660305702 0027077 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
/**
* @version $Id: XMLWriter.java 8660 2010-03-05 21:50:36Z hboutemy $
*/
public interface XMLWriter
{
void startElement( String name );
void addAttribute( String key, String value );
void writeText( String text );
void writeMarkup( String text );
void endElement();
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/XmlReader.java 0000664 0000000 0000000 00000070621 11660305702 0027125 0 ustar 00root root 0000000 0000000 /*
* Copyright 2004 Sun Microsystems, Inc.
*
* Licensed 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
*
* 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
* limitations under the License.
*
*/
package org.codehaus.plexus.util.xml;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringReader;
import java.net.URL;
import java.net.URLConnection;
import java.net.HttpURLConnection;
import java.util.Locale;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
import java.text.MessageFormat;
/**
* Character stream that handles (or at least attemtps to) all the necessary Voodo to figure out the charset encoding of
* the XML document within the stream.
*
* IMPORTANT: This class is not related in any way to the org.xml.sax.XMLReader. This one IS a character stream.
*
* All this has to be done without consuming characters from the stream, if not the XML parser will not recognized the
* document as a valid XML. This is not 100% true, but it's close enough (UTF-8 BOM is not handled by all parsers right
* now, XmlReader handles it and things work in all parsers).
*
* The XmlReader class handles the charset encoding of XML documents in Files, raw streams and HTTP streams by offering
* a wide set of constructors.
*
* By default the charset encoding detection is lenient, the constructor with the lenient flag can be used for an script
* (following HTTP MIME and XML specifications). All this is nicely explained by Mark Pilgrim in his blog, Determining the character encoding of a feed.
*
*
* @author Alejandro Abdelnur
* @version revision 1.17 taken on 26/06/2007 from Rome (see https://rome.dev.java.net/source/browse/rome/src/java/com/sun/syndication/io/XmlReader.java)
* @deprecated use XmlStreamReader
* @since 1.4.3
*/
public class XmlReader extends Reader
{
private static final int BUFFER_SIZE = 4096;
private static final String UTF_8 = "UTF-8";
private static final String US_ASCII = "US-ASCII";
private static final String UTF_16BE = "UTF-16BE";
private static final String UTF_16LE = "UTF-16LE";
private static final String UTF_16 = "UTF-16";
private static final String EBCDIC = "CP1047";
private static String _staticDefaultEncoding = null;
private Reader _reader;
private String _encoding;
private String _defaultEncoding;
/**
* Sets the default encoding to use if none is set in HTTP content-type, XML prolog and the rules based on
* content-type are not adequate.
If it is set to NULL the content-type based rules are used. By default
* it is NULL.
*
* @param encoding
* charset encoding to default to.
*/
public static void setDefaultEncoding( String encoding )
{
_staticDefaultEncoding = encoding;
}
/**
* Returns the default encoding to use if none is set in HTTP content-type, XML prolog and the rules based on
* content-type are not adequate. If it is NULL the content-type based rules are used.
*
* @return the default encoding to use.
*/
public static String getDefaultEncoding()
{
return _staticDefaultEncoding;
}
/**
* Creates a Reader for a File.
*
* It looks for the UTF-8 BOM first, if none sniffs the XML prolog charset, if this is also missing defaults to
* UTF-8.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param file
* File to create a Reader from.
* @throws IOException
* thrown if there is a problem reading the file.
*
*/
public XmlReader( File file ) throws IOException
{
this( new FileInputStream( file ) );
}
/**
* Creates a Reader for a raw InputStream.
*
* It follows the same logic used for files.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param is
* InputStream to create a Reader from.
* @throws IOException
* thrown if there is a problem reading the stream.
*
*/
public XmlReader( InputStream is ) throws IOException
{
this( is, true );
}
/**
* Creates a Reader for a raw InputStream.
*
* It follows the same logic used for files.
*
* If lenient detection is indicated and the detection above fails as per specifications it then attempts the
* following:
*
* If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
*
* Else if the XML prolog had a charset encoding that encoding is used.
*
* Else if the content type had a charset encoding that encoding is used.
*
* Else 'UTF-8' is used.
*
* If lenient detection is indicated an XmlStreamReaderException is never thrown.
*
*
* @param is
* InputStream to create a Reader from.
* @param lenient
* indicates if the charset encoding detection should be relaxed.
* @throws IOException
* thrown if there is a problem reading the stream.
* @throws XmlStreamReaderException
* thrown if the charset encoding could not be determined according to the specs.
*
*/
public XmlReader( InputStream is, boolean lenient ) throws IOException, XmlStreamReaderException
{
_defaultEncoding = _staticDefaultEncoding;
try
{
doRawStream( is, lenient );
}
catch ( XmlStreamReaderException ex )
{
if ( !lenient )
{
throw ex;
}
else
{
doLenientDetection( null, ex );
}
}
}
/**
* Creates a Reader using the InputStream of a URL.
*
* If the URL is not of type HTTP and there is not 'content-type' header in the fetched data it uses the same logic
* used for Files.
*
* If the URL is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic used for
* an InputStream with content-type.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param url
* URL to create a Reader from.
* @throws IOException
* thrown if there is a problem reading the stream of the URL.
*
*/
public XmlReader( URL url ) throws IOException
{
this( url.openConnection() );
}
/**
* Creates a Reader using the InputStream of a URLConnection.
*
* If the URLConnection is not of type HttpURLConnection and there is not 'content-type' header in the fetched data
* it uses the same logic used for files.
*
* If the URLConnection is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic
* used for an InputStream with content-type.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param conn
* URLConnection to create a Reader from.
* @throws IOException
* thrown if there is a problem reading the stream of the URLConnection.
*
*/
public XmlReader( URLConnection conn ) throws IOException
{
_defaultEncoding = _staticDefaultEncoding;
boolean lenient = true;
if ( conn instanceof HttpURLConnection )
{
try
{
doHttpStream( conn.getInputStream(), conn.getContentType(), lenient );
}
catch ( XmlStreamReaderException ex )
{
doLenientDetection( conn.getContentType(), ex );
}
}
else if ( conn.getContentType() != null )
{
try
{
doHttpStream( conn.getInputStream(), conn.getContentType(), lenient );
}
catch ( XmlStreamReaderException ex )
{
doLenientDetection( conn.getContentType(), ex );
}
}
else
{
try
{
doRawStream( conn.getInputStream(), lenient );
}
catch ( XmlStreamReaderException ex )
{
doLenientDetection( null, ex );
}
}
}
/**
* Creates a Reader using an InputStream an the associated content-type header.
*
* First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not
* content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default
* encoding mandated by the content-type MIME type.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param is
* InputStream to create the reader from.
* @param httpContentType
* content-type header to use for the resolution of the charset encoding.
* @throws IOException
* thrown if there is a problem reading the file.
*
*/
public XmlReader( InputStream is, String httpContentType ) throws IOException
{
this( is, httpContentType, true );
}
/**
* Creates a Reader using an InputStream an the associated content-type header. This constructor is lenient
* regarding the encoding detection.
*
* First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not
* content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default
* encoding mandated by the content-type MIME type.
*
* If lenient detection is indicated and the detection above fails as per specifications it then attempts the
* following:
*
* If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
*
* Else if the XML prolog had a charset encoding that encoding is used.
*
* Else if the content type had a charset encoding that encoding is used.
*
* Else 'UTF-8' is used.
*
* If lenient detection is indicated an XmlStreamReaderException is never thrown.
*
*
* @param is
* InputStream to create the reader from.
* @param httpContentType
* content-type header to use for the resolution of the charset encoding.
* @param lenient
* indicates if the charset encoding detection should be relaxed.
* @throws IOException
* thrown if there is a problem reading the file.
* @throws XmlStreamReaderException
* thrown if the charset encoding could not be determined according to the specs.
*
*/
public XmlReader( InputStream is, String httpContentType, boolean lenient, String defaultEncoding )
throws IOException, XmlStreamReaderException
{
_defaultEncoding = ( defaultEncoding == null ) ? _staticDefaultEncoding : defaultEncoding;
try
{
doHttpStream( is, httpContentType, lenient );
}
catch ( XmlStreamReaderException ex )
{
if ( !lenient )
{
throw ex;
}
else
{
doLenientDetection( httpContentType, ex );
}
}
}
/**
* Creates a Reader using an InputStream an the associated content-type header. This constructor is lenient
* regarding the encoding detection.
*
* First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not
* content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default
* encoding mandated by the content-type MIME type.
*
* If lenient detection is indicated and the detection above fails as per specifications it then attempts the
* following:
*
* If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
*
* Else if the XML prolog had a charset encoding that encoding is used.
*
* Else if the content type had a charset encoding that encoding is used.
*
* Else 'UTF-8' is used.
*
* If lenient detection is indicated an XmlStreamReaderException is never thrown.
*
*
* @param is
* InputStream to create the reader from.
* @param httpContentType
* content-type header to use for the resolution of the charset encoding.
* @param lenient
* indicates if the charset encoding detection should be relaxed.
* @throws IOException
* thrown if there is a problem reading the file.
* @throws XmlStreamReaderException
* thrown if the charset encoding could not be determined according to the specs.
*
*/
public XmlReader( InputStream is, String httpContentType, boolean lenient ) throws IOException, XmlStreamReaderException
{
this( is, httpContentType, lenient, null );
}
private void doLenientDetection( String httpContentType, XmlStreamReaderException ex ) throws IOException
{
if ( httpContentType != null )
{
if ( httpContentType.startsWith( "text/html" ) )
{
httpContentType = httpContentType.substring( "text/html".length() );
httpContentType = "text/xml" + httpContentType;
try
{
doHttpStream( ex.getInputStream(), httpContentType, true );
ex = null;
}
catch ( XmlStreamReaderException ex2 )
{
ex = ex2;
}
}
}
if ( ex != null )
{
String encoding = ex.getXmlEncoding();
if ( encoding == null )
{
encoding = ex.getContentTypeEncoding();
}
if ( encoding == null )
{
encoding = ( _defaultEncoding == null ) ? UTF_8 : _defaultEncoding;
}
prepareReader( ex.getInputStream(), encoding );
}
}
/**
* Returns the charset encoding of the XmlReader.
*
*
* @return charset encoding.
*
*/
public String getEncoding()
{
return _encoding;
}
public int read( char[] buf, int offset, int len ) throws IOException
{
return _reader.read( buf, offset, len );
}
/**
* Closes the XmlReader stream.
*
*
* @throws IOException
* thrown if there was a problem closing the stream.
*
*/
public void close() throws IOException
{
_reader.close();
}
private void doRawStream( InputStream is, boolean lenient ) throws IOException
{
BufferedInputStream pis = new BufferedInputStream( is, BUFFER_SIZE );
String bomEnc = getBOMEncoding( pis );
String xmlGuessEnc = getXMLGuessEncoding( pis );
String xmlEnc = getXmlProlog( pis, xmlGuessEnc );
String encoding = calculateRawEncoding( bomEnc, xmlGuessEnc, xmlEnc, pis );
prepareReader( pis, encoding );
}
private void doHttpStream( InputStream is, String httpContentType, boolean lenient ) throws IOException
{
BufferedInputStream pis = new BufferedInputStream( is, BUFFER_SIZE );
String cTMime = getContentTypeMime( httpContentType );
String cTEnc = getContentTypeEncoding( httpContentType );
String bomEnc = getBOMEncoding( pis );
String xmlGuessEnc = getXMLGuessEncoding( pis );
String xmlEnc = getXmlProlog( pis, xmlGuessEnc );
String encoding = calculateHttpEncoding( cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc, pis, lenient );
prepareReader( pis, encoding );
}
private void prepareReader( InputStream is, String encoding ) throws IOException
{
_reader = new InputStreamReader( is, encoding );
_encoding = encoding;
}
// InputStream is passed for XmlStreamReaderException creation only
private String calculateRawEncoding( String bomEnc, String xmlGuessEnc, String xmlEnc, InputStream is )
throws IOException
{
String encoding;
if ( bomEnc == null )
{
if ( xmlGuessEnc == null || xmlEnc == null )
{
encoding = ( _defaultEncoding == null ) ? UTF_8 : _defaultEncoding;
}
else if ( xmlEnc.equals( UTF_16 ) && ( xmlGuessEnc.equals( UTF_16BE ) || xmlGuessEnc.equals( UTF_16LE ) ) )
{
encoding = xmlGuessEnc;
}
else
{
encoding = xmlEnc;
}
}
else if ( bomEnc.equals( UTF_8 ) )
{
if ( xmlGuessEnc != null && !xmlGuessEnc.equals( UTF_8 ) )
{
throw new XmlStreamReaderException( RAW_EX_1.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ), bomEnc,
xmlGuessEnc, xmlEnc, is );
}
if ( xmlEnc != null && !xmlEnc.equals( UTF_8 ) )
{
throw new XmlStreamReaderException( RAW_EX_1.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ), bomEnc,
xmlGuessEnc, xmlEnc, is );
}
encoding = UTF_8;
}
else if ( bomEnc.equals( UTF_16BE ) || bomEnc.equals( UTF_16LE ) )
{
if ( xmlGuessEnc != null && !xmlGuessEnc.equals( bomEnc ) )
{
throw new IOException( RAW_EX_1.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ) );
}
if ( xmlEnc != null && !xmlEnc.equals( UTF_16 ) && !xmlEnc.equals( bomEnc ) )
{
throw new XmlStreamReaderException( RAW_EX_1.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ), bomEnc,
xmlGuessEnc, xmlEnc, is );
}
encoding = bomEnc;
}
else
{
throw new XmlStreamReaderException( RAW_EX_2.format( new Object[] { bomEnc, xmlGuessEnc, xmlEnc } ), bomEnc,
xmlGuessEnc, xmlEnc, is );
}
return encoding;
}
// InputStream is passed for XmlStreamReaderException creation only
private String calculateHttpEncoding( String cTMime, String cTEnc, String bomEnc, String xmlGuessEnc,
String xmlEnc, InputStream is, boolean lenient ) throws IOException
{
String encoding;
if ( lenient & xmlEnc != null )
{
encoding = xmlEnc;
}
else
{
boolean appXml = isAppXml( cTMime );
boolean textXml = isTextXml( cTMime );
if ( appXml || textXml )
{
if ( cTEnc == null )
{
if ( appXml )
{
encoding = calculateRawEncoding( bomEnc, xmlGuessEnc, xmlEnc, is );
}
else
{
encoding = ( _defaultEncoding == null ) ? US_ASCII : _defaultEncoding;
}
}
else if ( bomEnc != null && ( cTEnc.equals( UTF_16BE ) || cTEnc.equals( UTF_16LE ) ) )
{
throw new XmlStreamReaderException( HTTP_EX_1.format( new Object[] { cTMime, cTEnc, bomEnc, xmlGuessEnc,
xmlEnc } ), cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc, is );
}
else if ( cTEnc.equals( UTF_16 ) )
{
if ( bomEnc != null && bomEnc.startsWith( UTF_16 ) )
{
encoding = bomEnc;
}
else
{
throw new XmlStreamReaderException( HTTP_EX_2.format( new Object[] { cTMime, cTEnc, bomEnc,
xmlGuessEnc, xmlEnc } ), cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc, is );
}
}
else
{
encoding = cTEnc;
}
}
else
{
throw new XmlStreamReaderException( HTTP_EX_3.format( new Object[] { cTMime, cTEnc, bomEnc, xmlGuessEnc,
xmlEnc } ), cTMime, cTEnc, bomEnc, xmlGuessEnc, xmlEnc, is );
}
}
return encoding;
}
// returns MIME type or NULL if httpContentType is NULL
private static String getContentTypeMime( String httpContentType )
{
String mime = null;
if ( httpContentType != null )
{
int i = httpContentType.indexOf( ";" );
mime = ( ( i == -1 ) ? httpContentType : httpContentType.substring( 0, i ) ).trim();
}
return mime;
}
private static final Pattern CHARSET_PATTERN = Pattern.compile( "charset=([.[^; ]]*)" );
// returns charset parameter value, NULL if not present, NULL if httpContentType is NULL
private static String getContentTypeEncoding( String httpContentType )
{
String encoding = null;
if ( httpContentType != null )
{
int i = httpContentType.indexOf( ";" );
if ( i > -1 )
{
String postMime = httpContentType.substring( i + 1 );
Matcher m = CHARSET_PATTERN.matcher( postMime );
encoding = ( m.find() ) ? m.group( 1 ) : null;
encoding = ( encoding != null ) ? encoding.toUpperCase( Locale.ENGLISH ) : null;
}
}
return encoding;
}
// returns the BOM in the stream, NULL if not present,
// if there was BOM the in the stream it is consumed
private static String getBOMEncoding( BufferedInputStream is ) throws IOException
{
String encoding = null;
int[] bytes = new int[3];
is.mark( 3 );
bytes[0] = is.read();
bytes[1] = is.read();
bytes[2] = is.read();
if ( bytes[0] == 0xFE && bytes[1] == 0xFF )
{
encoding = UTF_16BE;
is.reset();
is.read();
is.read();
}
else if ( bytes[0] == 0xFF && bytes[1] == 0xFE )
{
encoding = UTF_16LE;
is.reset();
is.read();
is.read();
}
else if ( bytes[0] == 0xEF && bytes[1] == 0xBB && bytes[2] == 0xBF )
{
encoding = UTF_8;
}
else
{
is.reset();
}
return encoding;
}
// returns the best guess for the encoding by looking the first bytes of the stream, ', NULL if none
private static String getXmlProlog( BufferedInputStream is, String guessedEnc ) throws IOException
{
String encoding = null;
if ( guessedEnc != null )
{
byte[] bytes = new byte[BUFFER_SIZE];
is.mark( BUFFER_SIZE );
int offset = 0;
int max = BUFFER_SIZE;
int c = is.read( bytes, offset, max );
int firstGT = -1;
String xmlProlog = null;
while ( c != -1 && firstGT == -1 && offset < BUFFER_SIZE )
{
offset += c;
max -= c;
c = is.read( bytes, offset, max );
xmlProlog = new String( bytes, 0, offset, guessedEnc );
firstGT = xmlProlog.indexOf( '>' );
}
if ( firstGT == -1 )
{
if ( c == -1 )
{
throw new IOException( "Unexpected end of XML stream" );
}
else
{
throw new IOException( "XML prolog or ROOT element not found on first " + offset + " bytes" );
}
}
int bytesRead = offset;
if ( bytesRead > 0 )
{
is.reset();
BufferedReader bReader = new BufferedReader( new StringReader( xmlProlog.substring( 0, firstGT + 1 ) ) );
StringBuffer prolog = new StringBuffer();
String line = bReader.readLine();
while ( line != null )
{
prolog.append( line );
line = bReader.readLine();
}
Matcher m = ENCODING_PATTERN.matcher( prolog );
if ( m.find() )
{
encoding = m.group( 1 ).toUpperCase( Locale.ENGLISH );
encoding = encoding.substring( 1, encoding.length() - 1 );
}
}
}
return encoding;
}
// indicates if the MIME type belongs to the APPLICATION XML family
private static boolean isAppXml( String mime )
{
return mime != null
&& ( mime.equals( "application/xml" ) || mime.equals( "application/xml-dtd" )
|| mime.equals( "application/xml-external-parsed-entity" ) || ( mime.startsWith( "application/" ) && mime.endsWith( "+xml" ) ) );
}
// indicates if the MIME type belongs to the TEXT XML family
private static boolean isTextXml( String mime )
{
return mime != null
&& ( mime.equals( "text/xml" ) || mime.equals( "text/xml-external-parsed-entity" ) || ( mime.startsWith( "text/" ) && mime.endsWith( "+xml" ) ) );
}
private static final MessageFormat RAW_EX_1 =
new MessageFormat( "Invalid encoding, BOM [{0}] XML guess [{1}] XML prolog [{2}] encoding mismatch" );
private static final MessageFormat RAW_EX_2 =
new MessageFormat( "Invalid encoding, BOM [{0}] XML guess [{1}] XML prolog [{2}] unknown BOM" );
private static final MessageFormat HTTP_EX_1 =
new MessageFormat(
"Invalid encoding, CT-MIME [{0}] CT-Enc [{1}] BOM [{2}] XML guess [{3}] XML prolog [{4}], BOM must be NULL" );
private static final MessageFormat HTTP_EX_2 =
new MessageFormat(
"Invalid encoding, CT-MIME [{0}] CT-Enc [{1}] BOM [{2}] XML guess [{3}] XML prolog [{4}], encoding mismatch" );
private static final MessageFormat HTTP_EX_3 =
new MessageFormat(
"Invalid encoding, CT-MIME [{0}] CT-Enc [{1}] BOM [{2}] XML guess [{3}] XML prolog [{4}], Invalid MIME" );
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/XmlReaderException.java 0000664 0000000 0000000 00000012061 11660305702 0030776 0 ustar 00root root 0000000 0000000 /*
* Copyright 2004 Sun Microsystems, Inc.
*
* Licensed 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
*
* 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
* limitations under the License.
*
*/
package org.codehaus.plexus.util.xml;
import java.io.InputStream;
import java.io.IOException;
/**
* The XmlReaderException is thrown by the XmlReader constructors if the charset encoding can not be determined
* according to the XML 1.0 specification and RFC 3023.
*
* The exception returns the unconsumed InputStream to allow the application to do an alternate processing with the
* stream. Note that the original InputStream given to the XmlReader cannot be used as that one has been already read.
*
*
* @author Alejandro Abdelnur
* @version revision 1.1 taken on 26/06/2007 from Rome (see https://rome.dev.java.net/source/browse/rome/src/java/com/sun/syndication/io/XmlReaderException.java)
*/
public class XmlReaderException extends IOException
{
private String _bomEncoding;
private String _xmlGuessEncoding;
private String _xmlEncoding;
private String _contentTypeMime;
private String _contentTypeEncoding;
private InputStream _is;
/**
* Creates an exception instance if the charset encoding could not be determined.
*
* Instances of this exception are thrown by the XmlReader.
*
*
* @param msg
* message describing the reason for the exception.
* @param bomEnc
* BOM encoding.
* @param xmlGuessEnc
* XML guess encoding.
* @param xmlEnc
* XML prolog encoding.
* @param is
* the unconsumed InputStream.
*
*/
public XmlReaderException( String msg, String bomEnc, String xmlGuessEnc, String xmlEnc, InputStream is )
{
this( msg, null, null, bomEnc, xmlGuessEnc, xmlEnc, is );
}
/**
* Creates an exception instance if the charset encoding could not be determined.
*
* Instances of this exception are thrown by the XmlReader.
*
*
* @param msg
* message describing the reason for the exception.
* @param ctMime
* MIME type in the content-type.
* @param ctEnc
* encoding in the content-type.
* @param bomEnc
* BOM encoding.
* @param xmlGuessEnc
* XML guess encoding.
* @param xmlEnc
* XML prolog encoding.
* @param is
* the unconsumed InputStream.
*
*/
public XmlReaderException( String msg, String ctMime, String ctEnc, String bomEnc, String xmlGuessEnc,
String xmlEnc, InputStream is )
{
super( msg );
_contentTypeMime = ctMime;
_contentTypeEncoding = ctEnc;
_bomEncoding = bomEnc;
_xmlGuessEncoding = xmlGuessEnc;
_xmlEncoding = xmlEnc;
_is = is;
}
/**
* Returns the BOM encoding found in the InputStream.
*
*
* @return the BOM encoding, null if none.
*
*/
public String getBomEncoding()
{
return _bomEncoding;
}
/**
* Returns the encoding guess based on the first bytes of the InputStream.
*
*
* @return the encoding guess, null if it couldn't be guessed.
*
*/
public String getXmlGuessEncoding()
{
return _xmlGuessEncoding;
}
/**
* Returns the encoding found in the XML prolog of the InputStream.
*
*
* @return the encoding of the XML prolog, null if none.
*
*/
public String getXmlEncoding()
{
return _xmlEncoding;
}
/**
* Returns the MIME type in the content-type used to attempt determining the encoding.
*
*
* @return the MIME type in the content-type, null if there was not content-type or the encoding detection did not
* involve HTTP.
*
*/
public String getContentTypeMime()
{
return _contentTypeMime;
}
/**
* Returns the encoding in the content-type used to attempt determining the encoding.
*
*
* @return the encoding in the content-type, null if there was not content-type, no encoding in it or the encoding
* detection did not involve HTTP.
*
*/
public String getContentTypeEncoding()
{
return _contentTypeEncoding;
}
/**
* Returns the unconsumed InputStream to allow the application to do an alternate encoding detection on the
* InputStream.
*
*
* @return the unconsumed InputStream.
*
*/
public InputStream getInputStream()
{
return _is;
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReader.java 0000664 0000000 0000000 00000025164 11660305702 0030303 0 ustar 00root root 0000000 0000000 /*
* Copyright 2004 Sun Microsystems, Inc.
*
* Licensed 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
*
* 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
* limitations under the License.
*
*/
package org.codehaus.plexus.util.xml;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
/**
* Character stream that handles (or at least attemtps to) all the necessary Voodo to figure out the charset encoding of
* the XML document within the stream.
*
* IMPORTANT: This class is not related in any way to the org.xml.sax.XMLReader. This one IS a character stream.
*
* All this has to be done without consuming characters from the stream, if not the XML parser will not recognized the
* document as a valid XML. This is not 100% true, but it's close enough (UTF-8 BOM is not handled by all parsers right
* now, XmlReader handles it and things work in all parsers).
*
* The XmlReader class handles the charset encoding of XML documents in Files, raw streams and HTTP streams by offering
* a wide set of constructors.
*
* By default the charset encoding detection is lenient, the constructor with the lenient flag can be used for an script
* (following HTTP MIME and XML specifications). All this is nicely explained by Mark Pilgrim in his blog, Determining the character encoding of a feed.
*
*
* @author Alejandro Abdelnur
* @version revision 1.17 taken on 26/06/2007 from Rome (see https://rome.dev.java.net/source/browse/rome/src/java/com/sun/syndication/io/XmlReader.java)
* @since 1.4.4
*/
public class XmlStreamReader
extends XmlReader
{
/**
* Creates a Reader for a File.
*
* It looks for the UTF-8 BOM first, if none sniffs the XML prolog charset, if this is also missing defaults to
* UTF-8.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param file
* File to create a Reader from.
* @throws IOException
* thrown if there is a problem reading the file.
*
*/
public XmlStreamReader( File file ) throws IOException
{
super( file );
}
/**
* Creates a Reader for a raw InputStream.
*
* It follows the same logic used for files.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param is
* InputStream to create a Reader from.
* @throws IOException
* thrown if there is a problem reading the stream.
*
*/
public XmlStreamReader( InputStream is ) throws IOException
{
super( is );
}
/**
* Creates a Reader for a raw InputStream.
*
* It follows the same logic used for files.
*
* If lenient detection is indicated and the detection above fails as per specifications it then attempts the
* following:
*
* If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
*
* Else if the XML prolog had a charset encoding that encoding is used.
*
* Else if the content type had a charset encoding that encoding is used.
*
* Else 'UTF-8' is used.
*
* If lenient detection is indicated an XmlStreamReaderException is never thrown.
*
*
* @param is
* InputStream to create a Reader from.
* @param lenient
* indicates if the charset encoding detection should be relaxed.
* @throws IOException
* thrown if there is a problem reading the stream.
* @throws XmlStreamReaderException
* thrown if the charset encoding could not be determined according to the specs.
*
*/
public XmlStreamReader( InputStream is, boolean lenient ) throws IOException, XmlStreamReaderException
{
super( is, lenient );
}
/**
* Creates a Reader using the InputStream of a URL.
*
* If the URL is not of type HTTP and there is not 'content-type' header in the fetched data it uses the same logic
* used for Files.
*
* If the URL is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic used for
* an InputStream with content-type.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param url
* URL to create a Reader from.
* @throws IOException
* thrown if there is a problem reading the stream of the URL.
*
*/
public XmlStreamReader( URL url ) throws IOException
{
super( url );
}
/**
* Creates a Reader using the InputStream of a URLConnection.
*
* If the URLConnection is not of type HttpURLConnection and there is not 'content-type' header in the fetched data
* it uses the same logic used for files.
*
* If the URLConnection is a HTTP Url or there is a 'content-type' header in the fetched data it uses the same logic
* used for an InputStream with content-type.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param conn
* URLConnection to create a Reader from.
* @throws IOException
* thrown if there is a problem reading the stream of the URLConnection.
*
*/
public XmlStreamReader( URLConnection conn ) throws IOException
{
super( conn );
}
/**
* Creates a Reader using an InputStream an the associated content-type header.
*
* First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not
* content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default
* encoding mandated by the content-type MIME type.
*
* It does a lenient charset encoding detection, check the constructor with the lenient parameter for details.
*
*
* @param is
* InputStream to create the reader from.
* @param httpContentType
* content-type header to use for the resolution of the charset encoding.
* @throws IOException
* thrown if there is a problem reading the file.
*
*/
public XmlStreamReader( InputStream is, String httpContentType ) throws IOException
{
super( is, httpContentType );
}
/**
* Creates a Reader using an InputStream an the associated content-type header. This constructor is lenient
* regarding the encoding detection.
*
* First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not
* content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default
* encoding mandated by the content-type MIME type.
*
* If lenient detection is indicated and the detection above fails as per specifications it then attempts the
* following:
*
* If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
*
* Else if the XML prolog had a charset encoding that encoding is used.
*
* Else if the content type had a charset encoding that encoding is used.
*
* Else 'UTF-8' is used.
*
* If lenient detection is indicated an XmlStreamReaderException is never thrown.
*
*
* @param is
* InputStream to create the reader from.
* @param httpContentType
* content-type header to use for the resolution of the charset encoding.
* @param lenient
* indicates if the charset encoding detection should be relaxed.
* @throws IOException
* thrown if there is a problem reading the file.
* @throws XmlStreamReaderException
* thrown if the charset encoding could not be determined according to the specs.
*
*/
public XmlStreamReader( InputStream is, String httpContentType, boolean lenient, String defaultEncoding )
throws IOException, XmlStreamReaderException
{
super( is, httpContentType, lenient, defaultEncoding );
}
/**
* Creates a Reader using an InputStream an the associated content-type header. This constructor is lenient
* regarding the encoding detection.
*
* First it checks if the stream has BOM. If there is not BOM checks the content-type encoding. If there is not
* content-type encoding checks the XML prolog encoding. If there is not XML prolog encoding uses the default
* encoding mandated by the content-type MIME type.
*
* If lenient detection is indicated and the detection above fails as per specifications it then attempts the
* following:
*
* If the content type was 'text/html' it replaces it with 'text/xml' and tries the detection again.
*
* Else if the XML prolog had a charset encoding that encoding is used.
*
* Else if the content type had a charset encoding that encoding is used.
*
* Else 'UTF-8' is used.
*
* If lenient detection is indicated an XmlStreamReaderException is never thrown.
*
*
* @param is
* InputStream to create the reader from.
* @param httpContentType
* content-type header to use for the resolution of the charset encoding.
* @param lenient
* indicates if the charset encoding detection should be relaxed.
* @throws IOException
* thrown if there is a problem reading the file.
* @throws XmlStreamReaderException
* thrown if the charset encoding could not be determined according to the specs.
*
*/
public XmlStreamReader( InputStream is, String httpContentType, boolean lenient ) throws IOException, XmlStreamReaderException
{
super( is, httpContentType, lenient );
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/XmlStreamReaderException.java 0000664 0000000 0000000 00000005712 11660305702 0032157 0 ustar 00root root 0000000 0000000 /*
* Copyright 2004 Sun Microsystems, Inc.
*
* Licensed 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
*
* 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
* limitations under the License.
*
*/
package org.codehaus.plexus.util.xml;
import java.io.InputStream;
/**
* The XmlStreamReaderException is thrown by the XmlStreamReader constructors if the charset encoding can not be determined
* according to the XML 1.0 specification and RFC 3023.
*
* The exception returns the unconsumed InputStream to allow the application to do an alternate processing with the
* stream. Note that the original InputStream given to the XmlStreamReader cannot be used as that one has been already read.
*
*
* @author Alejandro Abdelnur
* @version revision 1.1 taken on 26/06/2007 from Rome (see https://rome.dev.java.net/source/browse/rome/src/java/com/sun/syndication/io/XmlReaderException.java)
*/
public class XmlStreamReaderException extends XmlReaderException
{
/**
* Creates an exception instance if the charset encoding could not be determined.
*
* Instances of this exception are thrown by the XmlReader.
*
*
* @param msg
* message describing the reason for the exception.
* @param bomEnc
* BOM encoding.
* @param xmlGuessEnc
* XML guess encoding.
* @param xmlEnc
* XML prolog encoding.
* @param is
* the unconsumed InputStream.
*
*/
public XmlStreamReaderException( String msg, String bomEnc, String xmlGuessEnc, String xmlEnc, InputStream is )
{
super( msg, bomEnc, xmlGuessEnc, xmlEnc, is );
}
/**
* Creates an exception instance if the charset encoding could not be determined.
*
* Instances of this exception are thrown by the XmlReader.
*
*
* @param msg
* message describing the reason for the exception.
* @param ctMime
* MIME type in the content-type.
* @param ctEnc
* encoding in the content-type.
* @param bomEnc
* BOM encoding.
* @param xmlGuessEnc
* XML guess encoding.
* @param xmlEnc
* XML prolog encoding.
* @param is
* the unconsumed InputStream.
*
*/
public XmlStreamReaderException( String msg, String ctMime, String ctEnc, String bomEnc, String xmlGuessEnc,
String xmlEnc, InputStream is )
{
super( msg, ctMime, ctEnc, bomEnc, xmlGuessEnc, xmlEnc, is );
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/XmlStreamWriter.java 0000664 0000000 0000000 00000011337 11660305702 0030352 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Character stream that handles (or at least attemtps to) all the necessary Voodo to figure out the charset encoding of
* the XML document written to the stream.
* @author Herve Boutemy
* @version $Id: XmlStreamWriter.java 8010 2009-01-07 12:59:50Z vsiveton $
* @since 1.4.4
*/
public class XmlStreamWriter
extends Writer
{
private static final int BUFFER_SIZE = 4096;
private StringWriter xmlPrologWriter = new StringWriter( BUFFER_SIZE );
private OutputStream out;
private Writer writer;
private String encoding;
public XmlStreamWriter( OutputStream out )
{
this.out = out;
}
public XmlStreamWriter( File file )
throws FileNotFoundException
{
this( new FileOutputStream( file ) );
}
public String getEncoding()
{
return encoding;
}
public void close()
throws IOException
{
if ( writer == null )
{
encoding = "UTF-8";
writer = new OutputStreamWriter( out, encoding );
writer.write( xmlPrologWriter.toString() );
}
writer.close();
}
public void flush()
throws IOException
{
if ( writer != null )
{
writer.flush();
}
}
private void detectEncoding( char[] cbuf, int off, int len )
throws IOException
{
int size = len;
StringBuffer xmlProlog = xmlPrologWriter.getBuffer();
if ( xmlProlog.length() + len > BUFFER_SIZE )
{
size = BUFFER_SIZE - xmlProlog.length();
}
xmlPrologWriter.write( cbuf, off, size );
// try to determine encoding
if ( xmlProlog.length() >= 5 )
{
if ( xmlProlog.substring( 0, 5 ).equals( "" );
if ( xmlPrologEnd > 0 )
{
// ok, full XML prolog written: let's extract encoding
Matcher m = ENCODING_PATTERN.matcher( xmlProlog.substring( 0, xmlPrologEnd ) );
if ( m.find() )
{
encoding = m.group( 1 ).toUpperCase( Locale.ENGLISH );
encoding = encoding.substring( 1, encoding.length() - 1 );
}
else
{
// no encoding found in XML prolog: using default encoding
encoding = "UTF-8";
}
}
else
{
if ( xmlProlog.length() >= BUFFER_SIZE )
{
// no encoding found in first characters: using default encoding
encoding = "UTF-8";
}
}
}
else
{
// no XML prolog: using default encoding
encoding = "UTF-8";
}
if ( encoding != null )
{
// encoding has been chosen: let's do it
xmlPrologWriter = null;
writer = new OutputStreamWriter( out, encoding );
writer.write( xmlProlog.toString() );
if ( len > size )
{
writer.write( cbuf, off + size, len - size );
}
}
}
}
public void write( char[] cbuf, int off, int len )
throws IOException
{
if ( xmlPrologWriter != null )
{
detectEncoding( cbuf, off, len );
}
else
{
writer.write( cbuf, off, len );
}
}
static final Pattern ENCODING_PATTERN = XmlReader.ENCODING_PATTERN;
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/XmlUtil.java 0000664 0000000 0000000 00000024671 11660305702 0026644 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.WriterFactory;
import org.codehaus.plexus.util.xml.pull.MXParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
/**
* Common XML utilities methods.
*
* @author Vincent Siveton
* @version $Id: XmlUtil.java 8010 2009-01-07 12:59:50Z vsiveton $
* @since 1.5.7
*/
public class XmlUtil
{
/** The default line indenter size i.e. 2. */
public static final int DEFAULT_INDENTATION_SIZE = 2;
/** The default line separator ("\n" on UNIX) */
public static final String DEFAULT_LINE_SEPARATOR = System.getProperty( "line.separator" );
/**
* Determines if a given File shall be handled as XML.
*
* @param f not null file
* @return true if the given file has XML content, false otherwise.
*/
public static boolean isXml( File f )
{
if ( f == null )
{
throw new IllegalArgumentException( "f could not be null." );
}
if ( !f.isFile() )
{
throw new IllegalArgumentException( "The file '" + f.getAbsolutePath() + "' is not a file." );
}
Reader reader = null;
try
{
reader = ReaderFactory.newXmlReader( f );
XmlPullParser parser = new MXParser();
parser.setInput( reader );
parser.nextToken();
return true;
}
catch ( Exception e )
{
return false;
}
finally
{
IOUtil.close( reader );
}
}
/**
* Pretty format the input reader. For instance, the following input:
*
* <div><b>content</b></div>
*
* becomes
*
* <div>
* <b>content</b>
* </div>
*
*
* @param reader not null
* @param writer not null
* @throws IOException if any or invalid xml content
* @see #prettyFormat(Reader, Writer, int, String)
* @see ReaderFactory to read an xml content
* @see WriterFactory to write an xml content
*/
public static void prettyFormat( Reader reader, Writer writer )
throws IOException
{
prettyFormat( reader, writer, DEFAULT_INDENTATION_SIZE, DEFAULT_LINE_SEPARATOR );
}
/**
* Pretty format the input reader. For instance, the following input:
*
* <div><b>content</b></div>
*
* becomes
*
* <div>
* <b>content</b>
* </div>
*
*
* @param reader not null
* @param writer not null
* @param indentSize positive number for the indentation
* @param lineSeparator the wanted line separator
* @throws IOException if any or invalid xml content
* @see ReaderFactory to read an xml content
* @see WriterFactory to write an xml content
*/
public static void prettyFormat( Reader reader, Writer writer, int indentSize, String lineSeparator )
throws IOException
{
if ( reader == null )
{
throw new IllegalArgumentException( "The reader is null" );
}
if ( writer == null )
{
throw new IllegalArgumentException( "The writer is null" );
}
if ( indentSize < 0 )
{
indentSize = 0;
}
PrettyPrintXMLWriter xmlWriter = new PrettyPrintXMLWriter( writer );
xmlWriter.setLineIndenter( StringUtils.repeat( " ", indentSize ) );
xmlWriter.setLineSeparator( lineSeparator );
XmlPullParser parser = new MXParser();
try
{
parser.setInput( reader );
prettyFormatInternal( parser, xmlWriter );
}
catch ( XmlPullParserException e )
{
throw new IOException( "Unable to parse the XML: " + e.getMessage() );
}
}
/**
* Pretty format the input stream. For instance, the following input:
*
* <div><b>content</b></div>
*
* becomes
*
* <div>
* <b>content</b>
* </div>
*
*
* @param is not null
* @param os not null
* @throws IOException if any or invalid xml content
* @see #prettyFormat(InputStream, OutputStream, int, String)
*/
public static void prettyFormat( InputStream is, OutputStream os )
throws IOException
{
prettyFormat( is, os, DEFAULT_INDENTATION_SIZE, DEFAULT_LINE_SEPARATOR );
}
/**
* Pretty format the input stream. For instance, the following input:
*
* <div><b>content</b></div>
*
* becomes
*
* <div>
* <b>content</b>
* </div>
*
*
* @param is not null
* @param os not null
* @param indentSize positive number for the indentation
* @param lineSeparator the wanted line separator
* @throws IOException if any or invalid xml content
*/
public static void prettyFormat( InputStream is, OutputStream os, int indentSize, String lineSeparator )
throws IOException
{
if ( is == null )
{
throw new IllegalArgumentException( "The is is null" );
}
if ( os == null )
{
throw new IllegalArgumentException( "The os is null" );
}
if ( indentSize < 0 )
{
indentSize = 0;
}
Reader reader = null;
Writer out = new OutputStreamWriter( os );
PrettyPrintXMLWriter xmlWriter = new PrettyPrintXMLWriter( out );
xmlWriter.setLineIndenter( StringUtils.repeat( " ", indentSize ) );
xmlWriter.setLineSeparator( lineSeparator );
XmlPullParser parser = new MXParser();
try
{
reader = ReaderFactory.newXmlReader( is );
parser.setInput( reader );
prettyFormatInternal( parser, xmlWriter );
}
catch ( XmlPullParserException e )
{
throw new IOException( "Unable to parse the XML: " + e.getMessage() );
}
finally
{
IOUtil.close( reader );
IOUtil.close( out );
}
}
/**
* @param parser not null
* @param writer not null
* @throws XmlPullParserException if any
* @throws IOException if any
*/
private static void prettyFormatInternal( XmlPullParser parser, PrettyPrintXMLWriter writer )
throws XmlPullParserException, IOException
{
boolean hasTag = false;
boolean hasComment = false;
int eventType = parser.getEventType();
while ( eventType != XmlPullParser.END_DOCUMENT )
{
if ( eventType == XmlPullParser.START_TAG )
{
hasTag = true;
if ( hasComment )
{
writer.writeText( writer.getLineIndenter() );
hasComment = false;
}
writer.startElement( parser.getName() );
for ( int i = 0; i < parser.getAttributeCount(); i++ )
{
String key = parser.getAttributeName( i );
String value = parser.getAttributeValue( i );
writer.addAttribute( key, value );
}
}
else if ( eventType == XmlPullParser.TEXT )
{
String text = parser.getText();
if ( !text.trim().equals( "" ) )
{
text = StringUtils.removeDuplicateWhitespace( text );
writer.writeText( text );
}
}
else if ( eventType == XmlPullParser.END_TAG )
{
hasTag = false;
writer.endElement();
}
else if ( eventType == XmlPullParser.COMMENT )
{
hasComment = true;
if ( !hasTag )
{
writer.writeMarkup( writer.getLineSeparator() );
for ( int i = 0; i < writer.getDepth(); i++ )
{
writer.writeMarkup( writer.getLineIndenter() );
}
}
writer.writeMarkup( "" );
if ( !hasTag )
{
writer.writeMarkup( writer.getLineSeparator() );
for ( int i = 0; i < writer.getDepth() - 1; i++ )
{
writer.writeMarkup( writer.getLineIndenter() );
}
}
}
else if ( eventType == XmlPullParser.DOCDECL )
{
writer.writeMarkup( "" );
writer.endOfLine();
}
else if ( eventType == XmlPullParser.PROCESSING_INSTRUCTION )
{
writer.writeMarkup( "" );
writer.endOfLine();
}
else if ( eventType == XmlPullParser.CDSECT )
{
writer.writeMarkup( "" );
}
else if ( eventType == XmlPullParser.ENTITY_REF )
{
writer.writeMarkup( "&" + parser.getName() + ";" );
}
eventType = parser.nextToken();
}
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/XmlWriterUtil.java 0000664 0000000 0000000 00000025615 11660305702 0030040 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import org.codehaus.plexus.util.StringUtils;
/**
* Utility class for the XmlWriter class.
*
* @author Vincent Siveton
* @version $Id: XmlWriterUtil.java 8660 2010-03-05 21:50:36Z hboutemy $
*/
public class XmlWriterUtil
{
/** The vm line separator */
public static final String LS = System.getProperty( "line.separator" );
/** The default line indenter size i.e. 2. */
public static final int DEFAULT_INDENTATION_SIZE = 2;
/** The default column before line wrapping i.e. 80. */
public static final int DEFAULT_COLUMN_LINE = 80;
/**
* Convenience method to write one CRLF.
*
* @param writer not null writer
*/
public static void writeLineBreak( XMLWriter writer )
{
writeLineBreak( writer, 1 );
}
/**
* Convenience method to repeat CRLF.
*
* @param writer not null
* @param repeat positive number
*/
public static void writeLineBreak( XMLWriter writer, int repeat )
{
for ( int i = 0; i < repeat; i++ )
{
writer.writeMarkup( LS );
}
}
/**
* Convenience method to repeat CRLF and to indent the writer by 2.
*
* @param writer not null
* @param repeat
* @param indent positive number
* @see #DEFAULT_INDENTATION_SIZE
* @see #writeLineBreak(XMLWriter, int, int, int)
*/
public static void writeLineBreak( XMLWriter writer, int repeat, int indent )
{
writeLineBreak( writer, repeat, indent, DEFAULT_INDENTATION_SIZE );
}
/**
* Convenience method to repeat CRLF and to indent the writer by indentSize.
*
* @param writer not null
* @param repeat
* @param indent positive number
* @param indentSize positive number
*/
public static void writeLineBreak( XMLWriter writer, int repeat, int indent, int indentSize )
{
writeLineBreak( writer, repeat );
if ( indent < 0 )
{
indent = 0;
}
if ( indentSize < 0 )
{
indentSize = 0;
}
writer.writeText( StringUtils.repeat( " ", indent * indentSize ) );
}
/**
* Convenience method to write XML comment line break. Its size is 80.
*
* @param writer not null
* @see #DEFAULT_COLUMN_LINE
* @see #writeCommentLineBreak(XMLWriter, int)
*/
public static void writeCommentLineBreak( XMLWriter writer )
{
writeCommentLineBreak( writer, DEFAULT_COLUMN_LINE );
}
/**
* Convenience method to write XML comment line break with columnSize as length.
*
* @param writer not null
* @param columnSize positive number
*/
public static void writeCommentLineBreak( XMLWriter writer, int columnSize )
{
if ( columnSize < 10 )
{
columnSize = DEFAULT_COLUMN_LINE;
}
writer.writeMarkup( "" + LS );
}
/**
* Convenience method to write XML comment line. The comment is splitted to have a size of 80.
*
* @param writer not null
* @param comment
* @see #DEFAULT_INDENTATION_SIZE
* @see #writeComment(XMLWriter, String, int, int)
*/
public static void writeComment( XMLWriter writer, String comment )
{
writeComment( writer, comment, 0, DEFAULT_INDENTATION_SIZE );
}
/**
* Convenience method to write XML comment line. The comment is splitted to have a size of 80
* and is indented by indent using 2 as indentation size.
*
* @param writer not null
* @param comment
* @param indent positive number
* @see #DEFAULT_INDENTATION_SIZE
* @see #writeComment(XMLWriter, String, int, int)
*/
public static void writeComment( XMLWriter writer, String comment, int indent )
{
writeComment( writer, comment, indent, DEFAULT_INDENTATION_SIZE );
}
/**
* Convenience method to write XML comment line. The comment is splitted to have a size of 80
* and is indented by indent using indentSize.
*
* @param writer not null
* @param comment
* @param indent positive number
* @param indentSize positive number
* @see #DEFAULT_COLUMN_LINE
* @see #writeComment(XMLWriter, String, int, int, int)
*/
public static void writeComment( XMLWriter writer, String comment, int indent, int indentSize )
{
writeComment( writer, comment, indent, indentSize, DEFAULT_COLUMN_LINE );
}
/**
* Convenience method to write XML comment line. The comment is splitted to have a size of columnSize
* and is indented by indent using indentSize.
*
* @param writer not null
* @param comment
* @param indent positive number
* @param indentSize positive number
* @param columnSize positive number
*/
public static void writeComment( XMLWriter writer, String comment, int indent, int indentSize, int columnSize )
{
if ( comment == null )
{
comment = "null";
}
if ( indent < 0 )
{
indent = 0;
}
if ( indentSize < 0 )
{
indentSize = 0;
}
if ( columnSize < 0 )
{
columnSize = DEFAULT_COLUMN_LINE;
}
String indentation = StringUtils.repeat( " ", indent * indentSize );
int magicNumber = indentation.length() + columnSize - "-->".length() - 1;
String[] sentences = StringUtils.split( comment, LS );
StringBuffer line = new StringBuffer( indentation + "" ).append( LS );
writer.writeMarkup( line.toString() );
}
line = new StringBuffer( indentation + "" ).append( LS );
writer.writeMarkup( line.toString() );
}
/**
* Convenience method to write XML comments between two comments line break.
* The XML comment block is not indented.
*
* @param writer not null
* @param comment
* @see #DEFAULT_INDENTATION_SIZE
* @see #writeCommentText(XMLWriter, String, int, int)
*/
public static void writeCommentText( XMLWriter writer, String comment )
{
writeCommentText( writer, comment, 0, DEFAULT_INDENTATION_SIZE );
}
/**
* Convenience method to write XML comments between two comments line break.
* The XML comment block is also indented by indent using
* 2 as indentation size.
*
* @param writer not null
* @param comment
* @param indent positive number
* @see #DEFAULT_INDENTATION_SIZE
* @see #writeCommentText(XMLWriter, String, int, int)
*/
public static void writeCommentText( XMLWriter writer, String comment, int indent )
{
writeCommentText( writer, comment, indent, DEFAULT_INDENTATION_SIZE );
}
/**
* Convenience method to write XML comment between two comment line break.
* The XML comment block is also indented by indent using indentSize.
*
* @param writer not null
* @param comment
* @param indent positive number
* @param indentSize positive number
* @see #DEFAULT_COLUMN_LINE
* @see #writeCommentText(XMLWriter, String, int, int, int)
*/
public static void writeCommentText( XMLWriter writer, String comment, int indent, int indentSize )
{
writeCommentText( writer, comment, indent, indentSize, DEFAULT_COLUMN_LINE );
}
/**
* Convenience method to write XML comments between two comments line break.
* The XML comment block is also indented by indent using indentSize.
* The column size could be also be specified.
*
* @param writer not null
* @param comment
* @param indent positive number
* @param indentSize positive number
* @param columnSize positive number
*/
public static void writeCommentText( XMLWriter writer, String comment, int indent, int indentSize, int columnSize )
{
if ( indent < 0 )
{
indent = 0;
}
if ( indentSize < 0 )
{
indentSize = 0;
}
if ( columnSize < 0 )
{
columnSize = DEFAULT_COLUMN_LINE;
}
writeLineBreak( writer, 1 );
writer.writeMarkup( StringUtils.repeat( " ", indent * indentSize ) );
writeCommentLineBreak( writer, columnSize );
writeComment( writer, comment, indent, indentSize, columnSize );
writer.writeMarkup( StringUtils.repeat( " ", indent * indentSize ) );
writeCommentLineBreak( writer, columnSize );
writeLineBreak( writer, 1, indent, indentSize );
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/Xpp3Dom.java 0000664 0000000 0000000 00000044567 11660305702 0026546 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import org.codehaus.plexus.util.xml.pull.XmlSerializer;
import java.io.IOException;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
/**
* @version $Id: Xpp3Dom.java 8680 2010-04-06 20:05:21Z bentmann $
* NOTE: remove all the util code in here when separated, this class should be pure data.
*/
public class Xpp3Dom
{
protected String name;
protected String value;
protected Map attributes;
protected final List childList;
protected final Map childMap;
protected Xpp3Dom parent;
private static final String[] EMPTY_STRING_ARRAY = new String[0];
private static final Xpp3Dom[] EMPTY_DOM_ARRAY = new Xpp3Dom[0];
public static final String CHILDREN_COMBINATION_MODE_ATTRIBUTE = "combine.children";
public static final String CHILDREN_COMBINATION_MERGE = "merge";
public static final String CHILDREN_COMBINATION_APPEND = "append";
/**
* This default mode for combining children DOMs during merge means that where element names
* match, the process will try to merge the element data, rather than putting the dominant
* and recessive elements (which share the same element name) as siblings in the resulting
* DOM.
*/
public static final String DEFAULT_CHILDREN_COMBINATION_MODE = CHILDREN_COMBINATION_MERGE;
public static final String SELF_COMBINATION_MODE_ATTRIBUTE = "combine.self";
public static final String SELF_COMBINATION_OVERRIDE = "override";
public static final String SELF_COMBINATION_MERGE = "merge";
/**
* This default mode for combining a DOM node during merge means that where element names
* match, the process will try to merge the element attributes and values, rather than
* overriding the recessive element completely with the dominant one. This means that
* wherever the dominant element doesn't provide the value or a particular attribute, that
* value or attribute will be set from the recessive DOM node.
*/
public static final String DEFAULT_SELF_COMBINATION_MODE = SELF_COMBINATION_MERGE;
public Xpp3Dom( String name )
{
this.name = name;
childList = new ArrayList();
childMap = new HashMap();
}
/**
* Copy constructor.
*/
public Xpp3Dom( Xpp3Dom src )
{
this( src, src.getName() );
}
/**
* Copy constructor with alternative name.
*/
public Xpp3Dom( Xpp3Dom src, String name )
{
this.name = name;
int childCount = src.getChildCount();
childList = new ArrayList( childCount );
childMap = new HashMap( childCount << 1 );
setValue( src.getValue() );
String[] attributeNames = src.getAttributeNames();
for ( int i = 0; i < attributeNames.length; i++ )
{
String attributeName = attributeNames[i];
setAttribute( attributeName, src.getAttribute( attributeName ) );
}
for ( int i = 0; i < childCount; i++ )
{
addChild( new Xpp3Dom( src.getChild( i ) ) );
}
}
// ----------------------------------------------------------------------
// Name handling
// ----------------------------------------------------------------------
public String getName()
{
return name;
}
// ----------------------------------------------------------------------
// Value handling
// ----------------------------------------------------------------------
public String getValue()
{
return value;
}
public void setValue( String value )
{
this.value = value;
}
// ----------------------------------------------------------------------
// Attribute handling
// ----------------------------------------------------------------------
public String[] getAttributeNames()
{
if ( null == attributes || attributes.isEmpty() )
{
return EMPTY_STRING_ARRAY;
}
else
{
return (String[]) attributes.keySet().toArray( new String[attributes.size()] );
}
}
public String getAttribute( String name )
{
return ( null != attributes ) ? (String) attributes.get( name ) : null;
}
/**
* Set the attribute value
* @param name String not null
* @param value String not null
*/
public void setAttribute( String name, String value )
{
if ( null == value ) {
throw new NullPointerException( "Attribute value can not be null" );
}
if ( null == name ) {
throw new NullPointerException( "Attribute name can not be null" );
}
if ( null == attributes )
{
attributes = new HashMap();
}
attributes.put( name, value );
}
// ----------------------------------------------------------------------
// Child handling
// ----------------------------------------------------------------------
public Xpp3Dom getChild( int i )
{
return (Xpp3Dom) childList.get( i );
}
public Xpp3Dom getChild( String name )
{
return (Xpp3Dom) childMap.get( name );
}
public void addChild( Xpp3Dom xpp3Dom )
{
xpp3Dom.setParent( this );
childList.add( xpp3Dom );
childMap.put( xpp3Dom.getName(), xpp3Dom );
}
public Xpp3Dom[] getChildren()
{
if ( null == childList || childList.isEmpty() )
{
return EMPTY_DOM_ARRAY;
}
else
{
return (Xpp3Dom[]) childList.toArray( new Xpp3Dom[childList.size()] );
}
}
public Xpp3Dom[] getChildren( String name )
{
if ( null == childList )
{
return EMPTY_DOM_ARRAY;
}
else
{
ArrayList children = new ArrayList();
int size = childList.size();
for ( int i = 0; i < size; i++ )
{
Xpp3Dom configuration = (Xpp3Dom) childList.get( i );
if ( name.equals( configuration.getName() ) )
{
children.add( configuration );
}
}
return (Xpp3Dom[]) children.toArray( new Xpp3Dom[children.size()] );
}
}
public int getChildCount()
{
if ( null == childList )
{
return 0;
}
return childList.size();
}
public void removeChild( int i )
{
Xpp3Dom child = getChild( i );
childMap.values().remove( child );
childList.remove( i );
// In case of any dangling references
child.setParent( null );
}
// ----------------------------------------------------------------------
// Parent handling
// ----------------------------------------------------------------------
public Xpp3Dom getParent()
{
return parent;
}
public void setParent( Xpp3Dom parent )
{
this.parent = parent;
}
// ----------------------------------------------------------------------
// Helpers
// ----------------------------------------------------------------------
public void writeToSerializer( String namespace, XmlSerializer serializer )
throws IOException
{
// TODO: WARNING! Later versions of plexus-utils psit out an header due to thinking this is a new document - not the desired behaviour!
SerializerXMLWriter xmlWriter = new SerializerXMLWriter( namespace, serializer );
Xpp3DomWriter.write( xmlWriter, this );
if ( xmlWriter.getExceptions().size() > 0 )
{
throw (IOException) xmlWriter.getExceptions().get( 0 );
}
}
/**
* Merges one DOM into another, given a specific algorithm and possible override points for that algorithm.
* The algorithm is as follows:
*
* 1. if the recessive DOM is null, there is nothing to do...return.
*
* 2. Determine whether the dominant node will suppress the recessive one (flag=mergeSelf).
*
* A. retrieve the 'combine.self' attribute on the dominant node, and try to match against 'override'...
* if it matches 'override', then set mergeSelf == false...the dominant node suppresses the recessive
* one completely.
*
* B. otherwise, use the default value for mergeSelf, which is true...this is the same as specifying
* 'combine.self' == 'merge' as an attribute of the dominant root node.
*
* 3. If mergeSelf == true
*
* A. if the dominant root node's value is empty, set it to the recessive root node's value
*
* B. For each attribute in the recessive root node which is not set in the dominant root node, set it.
*
* C. Determine whether children from the recessive DOM will be merged or appended to the dominant
* DOM as siblings (flag=mergeChildren).
*
* i. if childMergeOverride is set (non-null), use that value (true/false)
*
* ii. retrieve the 'combine.children' attribute on the dominant node, and try to match against
* 'append'...if it matches 'append', then set mergeChildren == false...the recessive children
* will be appended as siblings of the dominant children.
*
* iii. otherwise, use the default value for mergeChildren, which is true...this is the same as
* specifying 'combine.children' == 'merge' as an attribute on the dominant root node.
*
* D. Iterate through the recessive children, and:
*
* i. if mergeChildren == true and there is a corresponding dominant child (matched by element name),
* merge the two.
*
* ii. otherwise, add the recessive child as a new child on the dominant root node.
*/
private static void mergeIntoXpp3Dom( Xpp3Dom dominant, Xpp3Dom recessive, Boolean childMergeOverride )
{
// TODO: share this as some sort of assembler, implement a walk interface?
if ( recessive == null )
{
return;
}
boolean mergeSelf = true;
String selfMergeMode = dominant.getAttribute( SELF_COMBINATION_MODE_ATTRIBUTE );
if ( SELF_COMBINATION_OVERRIDE.equals( selfMergeMode ) )
{
mergeSelf = false;
}
if ( mergeSelf )
{
if ( isEmpty( dominant.getValue() ) )
{
dominant.setValue( recessive.getValue() );
}
String[] recessiveAttrs = recessive.getAttributeNames();
for ( int i = 0; i < recessiveAttrs.length; i++ )
{
String attr = recessiveAttrs[i];
if ( isEmpty( dominant.getAttribute( attr ) ) )
{
dominant.setAttribute( attr, recessive.getAttribute( attr ) );
}
}
if ( recessive.getChildCount() > 0 )
{
boolean mergeChildren = true;
if ( childMergeOverride != null )
{
mergeChildren = childMergeOverride.booleanValue();
}
else
{
String childMergeMode = dominant.getAttribute( CHILDREN_COMBINATION_MODE_ATTRIBUTE );
if ( CHILDREN_COMBINATION_APPEND.equals( childMergeMode ) )
{
mergeChildren = false;
}
}
if ( !mergeChildren )
{
Xpp3Dom[] dominantChildren = dominant.getChildren();
// remove these now, so we can append them to the recessive list later.
dominant.childList.clear();
for ( int i = 0, recessiveChildCount = recessive.getChildCount(); i < recessiveChildCount; i++ )
{
Xpp3Dom recessiveChild = recessive.getChild( i );
dominant.addChild( new Xpp3Dom( recessiveChild ) );
}
// now, re-add these children so they'll be appended to the recessive list.
for ( int i = 0; i < dominantChildren.length; i++ )
{
dominant.addChild( dominantChildren[i] );
}
}
else
{
Map commonChildren = new HashMap();
for ( Iterator it = recessive.childMap.keySet().iterator(); it.hasNext(); )
{
String childName = (String) it.next();
Xpp3Dom[] dominantChildren = dominant.getChildren( childName );
if ( dominantChildren.length > 0 )
{
commonChildren.put( childName, Arrays.asList( dominantChildren ).iterator() );
}
}
for ( int i = 0, recessiveChildCount = recessive.getChildCount(); i < recessiveChildCount; i++ )
{
Xpp3Dom recessiveChild = recessive.getChild( i );
Iterator it = (Iterator) commonChildren.get( recessiveChild.getName() );
if ( it == null )
{
dominant.addChild( new Xpp3Dom( recessiveChild ) );
}
else if ( it.hasNext() )
{
Xpp3Dom dominantChild = (Xpp3Dom) it.next();
mergeIntoXpp3Dom( dominantChild, recessiveChild, childMergeOverride );
}
}
}
}
}
}
/**
* Merge two DOMs, with one having dominance in the case of collision.
*
* @see #CHILDREN_COMBINATION_MODE_ATTRIBUTE
* @see #SELF_COMBINATION_MODE_ATTRIBUTE
*
* @param dominant The dominant DOM into which the recessive value/attributes/children will be merged
* @param recessive The recessive DOM, which will be merged into the dominant DOM
* @param childMergeOverride Overrides attribute flags to force merging or appending of child elements
* into the dominant DOM
*/
public static Xpp3Dom mergeXpp3Dom( Xpp3Dom dominant, Xpp3Dom recessive, Boolean childMergeOverride )
{
if ( dominant != null )
{
mergeIntoXpp3Dom( dominant, recessive, childMergeOverride );
return dominant;
}
return recessive;
}
/**
* Merge two DOMs, with one having dominance in the case of collision.
* Merge mechanisms (vs. override for nodes, or vs. append for children) is determined by
* attributes of the dominant root node.
*
* @see #CHILDREN_COMBINATION_MODE_ATTRIBUTE
* @see #SELF_COMBINATION_MODE_ATTRIBUTE
*
* @param dominant The dominant DOM into which the recessive value/attributes/children will be merged
* @param recessive The recessive DOM, which will be merged into the dominant DOM
*/
public static Xpp3Dom mergeXpp3Dom( Xpp3Dom dominant, Xpp3Dom recessive )
{
if ( dominant != null )
{
mergeIntoXpp3Dom( dominant, recessive, null );
return dominant;
}
return recessive;
}
// ----------------------------------------------------------------------
// Standard object handling
// ----------------------------------------------------------------------
public boolean equals( Object obj )
{
if ( obj == this )
{
return true;
}
if ( !( obj instanceof Xpp3Dom ) )
{
return false;
}
Xpp3Dom dom = (Xpp3Dom) obj;
if ( name == null ? dom.name != null : !name.equals( dom.name ) )
{
return false;
}
else if ( value == null ? dom.value != null : !value.equals( dom.value ) )
{
return false;
}
else if ( attributes == null ? dom.attributes != null : !attributes.equals( dom.attributes ) )
{
return false;
}
else if ( childList == null ? dom.childList != null : !childList.equals( dom.childList ) )
{
return false;
}
else
{
return true;
}
}
public int hashCode()
{
int result = 17;
result = 37 * result + ( name != null ? name.hashCode() : 0 );
result = 37 * result + ( value != null ? value.hashCode() : 0 );
result = 37 * result + ( attributes != null ? attributes.hashCode() : 0 );
result = 37 * result + ( childList != null ? childList.hashCode() : 0 );
return result;
}
public String toString()
{
// TODO: WARNING! Later versions of plexus-utils psit out an header due to thinking this is a new document - not the desired behaviour!
StringWriter writer = new StringWriter();
XMLWriter xmlWriter = new PrettyPrintXMLWriter( writer, "UTF-8", null );
Xpp3DomWriter.write( xmlWriter, this );
return writer.toString();
}
public String toUnescapedString()
{
// TODO: WARNING! Later versions of plexus-utils psit out an header due to thinking this is a new document - not the desired behaviour!
StringWriter writer = new StringWriter();
XMLWriter xmlWriter = new PrettyPrintXMLWriter( writer, "UTF-8", null );
Xpp3DomWriter.write( xmlWriter, this, false );
return writer.toString();
}
public static boolean isNotEmpty( String str )
{
return ( ( str != null ) && ( str.length() > 0 ) );
}
public static boolean isEmpty( String str )
{
return ( ( str == null ) || ( str.trim().length() == 0 ) );
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/Xpp3DomBuilder.java 0000664 0000000 0000000 00000012257 11660305702 0030044 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.xml.pull.MXParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;
/**
* @version $Id: Xpp3DomBuilder.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class Xpp3DomBuilder
{
private static final boolean DEFAULT_TRIM = true;
public static Xpp3Dom build( Reader reader )
throws XmlPullParserException, IOException
{
return build( reader, DEFAULT_TRIM );
}
public static Xpp3Dom build( InputStream is, String encoding )
throws XmlPullParserException, IOException
{
return build( is, encoding, DEFAULT_TRIM );
}
public static Xpp3Dom build( InputStream is, String encoding, boolean trim )
throws XmlPullParserException, IOException
{
XmlPullParser parser = new MXParser();
parser.setInput( is, encoding );
try
{
return build( parser, trim );
}
finally
{
IOUtil.close( is );
}
}
public static Xpp3Dom build( Reader reader, boolean trim )
throws XmlPullParserException, IOException
{
XmlPullParser parser = new MXParser();
parser.setInput( reader );
try
{
return build( parser, trim );
}
finally
{
IOUtil.close( reader );
}
}
public static Xpp3Dom build( XmlPullParser parser )
throws XmlPullParserException, IOException
{
return build( parser, DEFAULT_TRIM );
}
public static Xpp3Dom build( XmlPullParser parser, boolean trim )
throws XmlPullParserException, IOException
{
List elements = new ArrayList();
List values = new ArrayList();
int eventType = parser.getEventType();
while ( eventType != XmlPullParser.END_DOCUMENT )
{
if ( eventType == XmlPullParser.START_TAG )
{
String rawName = parser.getName();
Xpp3Dom childConfiguration = new Xpp3Dom( rawName );
int depth = elements.size();
if ( depth > 0 )
{
Xpp3Dom parent = (Xpp3Dom) elements.get( depth - 1 );
parent.addChild( childConfiguration );
}
elements.add( childConfiguration );
if ( parser.isEmptyElementTag() )
{
values.add( null );
}
else
{
values.add( new StringBuffer() );
}
int attributesSize = parser.getAttributeCount();
for ( int i = 0; i < attributesSize; i++ )
{
String name = parser.getAttributeName( i );
String value = parser.getAttributeValue( i );
childConfiguration.setAttribute( name, value );
}
}
else if ( eventType == XmlPullParser.TEXT )
{
int depth = values.size() - 1;
StringBuffer valueBuffer = (StringBuffer) values.get( depth );
String text = parser.getText();
if ( trim )
{
text = text.trim();
}
valueBuffer.append( text );
}
else if ( eventType == XmlPullParser.END_TAG )
{
int depth = elements.size() - 1;
Xpp3Dom finishedConfiguration = (Xpp3Dom) elements.remove( depth );
/* this Object could be null if it is a singleton tag */
Object accumulatedValue = values.remove( depth );
if ( finishedConfiguration.getChildCount() == 0 )
{
if ( accumulatedValue == null )
{
finishedConfiguration.setValue( null );
}
else
{
finishedConfiguration.setValue( accumulatedValue.toString() );
}
}
if ( depth == 0 )
{
return finishedConfiguration;
}
}
eventType = parser.next();
}
throw new IllegalStateException( "End of document found before returning to 0 depth" );
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/Xpp3DomUtils.java 0000664 0000000 0000000 00000021405 11660305702 0027551 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import org.codehaus.plexus.util.xml.pull.XmlSerializer;
import java.io.IOException;
/** @author Jason van Zyl */
public class Xpp3DomUtils
{
public static final String CHILDREN_COMBINATION_MODE_ATTRIBUTE = "combine.children";
public static final String CHILDREN_COMBINATION_MERGE = "merge";
public static final String CHILDREN_COMBINATION_APPEND = "append";
/**
* This default mode for combining children DOMs during merge means that where element names
* match, the process will try to merge the element data, rather than putting the dominant
* and recessive elements (which share the same element name) as siblings in the resulting
* DOM.
*/
public static final String DEFAULT_CHILDREN_COMBINATION_MODE = CHILDREN_COMBINATION_MERGE;
public static final String SELF_COMBINATION_MODE_ATTRIBUTE = "combine.self";
public static final String SELF_COMBINATION_OVERRIDE = "override";
public static final String SELF_COMBINATION_MERGE = "merge";
/**
* This default mode for combining a DOM node during merge means that where element names
* match, the process will try to merge the element attributes and values, rather than
* overriding the recessive element completely with the dominant one. This means that
* wherever the dominant element doesn't provide the value or a particular attribute, that
* value or attribute will be set from the recessive DOM node.
*/
public static final String DEFAULT_SELF_COMBINATION_MODE = SELF_COMBINATION_MERGE;
public void writeToSerializer( String namespace, XmlSerializer serializer, Xpp3Dom dom )
throws IOException
{
// TODO: WARNING! Later versions of plexus-utils psit out an header due to thinking this is a new document - not the desired behaviour!
SerializerXMLWriter xmlWriter = new SerializerXMLWriter( namespace, serializer );
Xpp3DomWriter.write( xmlWriter, dom );
if ( xmlWriter.getExceptions().size() > 0 )
{
throw (IOException) xmlWriter.getExceptions().get( 0 );
}
}
/**
* Merges one DOM into another, given a specific algorithm and possible override points for that algorithm.
* The algorithm is as follows:
*
* 1. if the recessive DOM is null, there is nothing to do...return.
*
* 2. Determine whether the dominant node will suppress the recessive one (flag=mergeSelf).
*
* A. retrieve the 'combine.self' attribute on the dominant node, and try to match against 'override'...
* if it matches 'override', then set mergeSelf == false...the dominant node suppresses the recessive
* one completely.
*
* B. otherwise, use the default value for mergeSelf, which is true...this is the same as specifying
* 'combine.self' == 'merge' as an attribute of the dominant root node.
*
* 3. If mergeSelf == true
*
* A. if the dominant root node's value is empty, set it to the recessive root node's value
*
* B. For each attribute in the recessive root node which is not set in the dominant root node, set it.
*
* C. Determine whether children from the recessive DOM will be merged or appended to the dominant
* DOM as siblings (flag=mergeChildren).
*
* i. if childMergeOverride is set (non-null), use that value (true/false)
*
* ii. retrieve the 'combine.children' attribute on the dominant node, and try to match against
* 'append'...if it matches 'append', then set mergeChildren == false...the recessive children
* will be appended as siblings of the dominant children.
*
* iii. otherwise, use the default value for mergeChildren, which is true...this is the same as
* specifying 'combine.children' == 'merge' as an attribute on the dominant root node.
*
* D. Iterate through the recessive children, and:
*
* i. if mergeChildren == true and there is a corresponding dominant child (matched by element name),
* merge the two.
*
* ii. otherwise, add the recessive child as a new child on the dominant root node.
*/
private static void mergeIntoXpp3Dom( Xpp3Dom dominant, Xpp3Dom recessive, Boolean childMergeOverride )
{
// TODO: share this as some sort of assembler, implement a walk interface?
if ( recessive == null )
{
return;
}
boolean mergeSelf = true;
String selfMergeMode = dominant.getAttribute( SELF_COMBINATION_MODE_ATTRIBUTE );
if ( isNotEmpty( selfMergeMode ) && SELF_COMBINATION_OVERRIDE.equals( selfMergeMode ) )
{
mergeSelf = false;
}
if ( mergeSelf )
{
if ( isEmpty( dominant.getValue() ) )
{
dominant.setValue( recessive.getValue() );
}
String[] recessiveAttrs = recessive.getAttributeNames();
for ( int i = 0; i < recessiveAttrs.length; i++ )
{
String attr = recessiveAttrs[i];
if ( isEmpty( dominant.getAttribute( attr ) ) )
{
dominant.setAttribute( attr, recessive.getAttribute( attr ) );
}
}
boolean mergeChildren = true;
if ( childMergeOverride != null )
{
mergeChildren = childMergeOverride.booleanValue();
}
else
{
String childMergeMode = dominant.getAttribute( CHILDREN_COMBINATION_MODE_ATTRIBUTE );
if ( isNotEmpty( childMergeMode ) && CHILDREN_COMBINATION_APPEND.equals( childMergeMode ) )
{
mergeChildren = false;
}
}
Xpp3Dom[] children = recessive.getChildren();
for ( int i = 0; i < children.length; i++ )
{
Xpp3Dom child = children[i];
Xpp3Dom childDom = dominant.getChild( child.getName() );
if ( mergeChildren && childDom != null )
{
mergeIntoXpp3Dom( childDom, child, childMergeOverride );
}
else
{
dominant.addChild( new Xpp3Dom( child ) );
}
}
}
}
/**
* Merge two DOMs, with one having dominance in the case of collision.
*
* @see #CHILDREN_COMBINATION_MODE_ATTRIBUTE
* @see #SELF_COMBINATION_MODE_ATTRIBUTE
*
* @param dominant The dominant DOM into which the recessive value/attributes/children will be merged
* @param recessive The recessive DOM, which will be merged into the dominant DOM
* @param childMergeOverride Overrides attribute flags to force merging or appending of child elements
* into the dominant DOM
*/
public static Xpp3Dom mergeXpp3Dom( Xpp3Dom dominant, Xpp3Dom recessive, Boolean childMergeOverride )
{
if ( dominant != null )
{
mergeIntoXpp3Dom( dominant, recessive, childMergeOverride );
return dominant;
}
return recessive;
}
/**
* Merge two DOMs, with one having dominance in the case of collision.
* Merge mechanisms (vs. override for nodes, or vs. append for children) is determined by
* attributes of the dominant root node.
*
* @see #CHILDREN_COMBINATION_MODE_ATTRIBUTE
* @see #SELF_COMBINATION_MODE_ATTRIBUTE
*
* @param dominant The dominant DOM into which the recessive value/attributes/children will be merged
* @param recessive The recessive DOM, which will be merged into the dominant DOM
*/
public static Xpp3Dom mergeXpp3Dom( Xpp3Dom dominant, Xpp3Dom recessive )
{
if ( dominant != null )
{
mergeIntoXpp3Dom( dominant, recessive, null );
return dominant;
}
return recessive;
}
public static boolean isNotEmpty( String str )
{
return ( str != null && str.length() > 0 );
}
public static boolean isEmpty( String str )
{
return ( str == null || str.trim().length() == 0 );
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/Xpp3DomWriter.java 0000664 0000000 0000000 00000004130 11660305702 0027721 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.PrintWriter;
import java.io.Writer;
/**
* @version $Id: Xpp3DomWriter.java 8660 2010-03-05 21:50:36Z hboutemy $
*/
public class Xpp3DomWriter
{
public static void write( Writer writer, Xpp3Dom dom )
{
write( new PrettyPrintXMLWriter( writer ), dom );
}
public static void write( PrintWriter writer, Xpp3Dom dom )
{
write( new PrettyPrintXMLWriter( writer ), dom );
}
public static void write( XMLWriter xmlWriter, Xpp3Dom dom )
{
write( xmlWriter, dom, true );
}
public static void write( XMLWriter xmlWriter, Xpp3Dom dom, boolean escape )
{
// TODO: move to XMLWriter?
xmlWriter.startElement( dom.getName() );
String[] attributeNames = dom.getAttributeNames();
for ( int i = 0; i < attributeNames.length; i++ )
{
String attributeName = attributeNames[i];
xmlWriter.addAttribute( attributeName, dom.getAttribute( attributeName ) );
}
Xpp3Dom[] children = dom.getChildren();
for ( int i = 0; i < children.length; i++ )
{
write( xmlWriter, children[i], escape );
}
String value = dom.getValue();
if ( value != null )
{
if ( escape )
{
xmlWriter.writeText( value );
}
else
{
xmlWriter.writeMarkup( value );
}
}
xmlWriter.endElement();
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/pull/ 0000775 0000000 0000000 00000000000 11660305702 0025345 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/pull/MXParser.java 0000664 0000000 0000000 00000410731 11660305702 0027717 0 ustar 00root root 0000000 0000000 /* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/
/*
* Copyright (c) 2003 Extreme! Lab, Indiana University. All rights reserved.
*
* This software is open source. See the bottom of this file for the licence.
*
* $Id: MXParser.java 8238 2009-05-28 23:51:31Z vsiveton $
*/
package org.codehaus.plexus.util.xml.pull;
import java.io.EOFException;
import java.io.IOException;
import java.io.Reader;
import java.io.UnsupportedEncodingException;
import org.codehaus.plexus.util.ReaderFactory;
//import java.util.Hashtable;
//TODO best handling of interning issues
// have isAllNewStringInterned ???
//TODO handling surrogate pairs: http://www.unicode.org/unicode/faq/utf_bom.html#6
//TODO review code for use of bufAbsoluteStart when keeping pos between next()/fillBuf()
/**
* Absolutely minimal implementation of XMLPULL V1 API. Encoding handling done with XmlReader
*
* @see org.codehaus.plexus.util.xml.XmlReader
* @author Aleksander Slominski
*/
public class MXParser
implements XmlPullParser
{
//NOTE: no interning of those strings --> by Java leng spec they MUST be already interned
protected final static String XML_URI = "http://www.w3.org/XML/1998/namespace";
protected final static String XMLNS_URI = "http://www.w3.org/2000/xmlns/";
protected final static String FEATURE_XML_ROUNDTRIP=
//"http://xmlpull.org/v1/doc/features.html#xml-roundtrip";
"http://xmlpull.org/v1/doc/features.html#xml-roundtrip";
protected final static String FEATURE_NAMES_INTERNED =
"http://xmlpull.org/v1/doc/features.html#names-interned";
protected final static String PROPERTY_XMLDECL_VERSION =
"http://xmlpull.org/v1/doc/properties.html#xmldecl-version";
protected final static String PROPERTY_XMLDECL_STANDALONE =
"http://xmlpull.org/v1/doc/properties.html#xmldecl-standalone";
protected final static String PROPERTY_XMLDECL_CONTENT =
"http://xmlpull.org/v1/doc/properties.html#xmldecl-content";
protected final static String PROPERTY_LOCATION =
"http://xmlpull.org/v1/doc/properties.html#location";
/**
* Implementation notice:
* the is instance variable that controls if newString() is interning.
* NOTE: newStringIntern always returns interned strings
* and newString MAY return interned String depending on this variable.
*
NOTE: by default in this minimal implementation it is false!
*/
protected boolean allStringsInterned;
protected void resetStringCache() {
//System.out.println("resetStringCache() minimum called");
}
protected String newString(char[] cbuf, int off, int len) {
return new String(cbuf, off, len);
}
protected String newStringIntern(char[] cbuf, int off, int len) {
return (new String(cbuf, off, len)).intern();
}
private static final boolean TRACE_SIZING = false;
// NOTE: features are not resetable and typically defaults to false ...
protected boolean processNamespaces;
protected boolean roundtripSupported;
// global parser state
protected String location;
protected int lineNumber;
protected int columnNumber;
protected boolean seenRoot;
protected boolean reachedEnd;
protected int eventType;
protected boolean emptyElementTag;
// element stack
protected int depth;
protected char[] elRawName[];
protected int elRawNameEnd[];
protected int elRawNameLine[];
protected String elName[];
protected String elPrefix[];
protected String elUri[];
//protected String elValue[];
protected int elNamespaceCount[];
/**
* Make sure that we have enough space to keep element stack if passed size.
* It will always create one additional slot then current depth
*/
protected void ensureElementsCapacity() {
final int elStackSize = elName != null ? elName.length : 0;
if( (depth + 1) >= elStackSize) {
// we add at least one extra slot ...
final int newSize = (depth >= 7 ? 2 * depth : 8) + 2; // = lucky 7 + 1 //25
if(TRACE_SIZING) {
System.err.println("TRACE_SIZING elStackSize "+elStackSize+" ==> "+newSize);
}
final boolean needsCopying = elStackSize > 0;
String[] arr = null;
// resue arr local variable slot
arr = new String[newSize];
if(needsCopying) System.arraycopy(elName, 0, arr, 0, elStackSize);
elName = arr;
arr = new String[newSize];
if(needsCopying) System.arraycopy(elPrefix, 0, arr, 0, elStackSize);
elPrefix = arr;
arr = new String[newSize];
if(needsCopying) System.arraycopy(elUri, 0, arr, 0, elStackSize);
elUri = arr;
int[] iarr = new int[newSize];
if(needsCopying) {
System.arraycopy(elNamespaceCount, 0, iarr, 0, elStackSize);
} else {
// special initialization
iarr[0] = 0;
}
elNamespaceCount = iarr;
//TODO: avoid using element raw name ...
iarr = new int[newSize];
if(needsCopying) {
System.arraycopy(elRawNameEnd, 0, iarr, 0, elStackSize);
}
elRawNameEnd = iarr;
iarr = new int[newSize];
if(needsCopying) {
System.arraycopy(elRawNameLine, 0, iarr, 0, elStackSize);
}
elRawNameLine = iarr;
final char[][] carr = new char[newSize][];
if(needsCopying) {
System.arraycopy(elRawName, 0, carr, 0, elStackSize);
}
elRawName = carr;
// arr = new String[newSize];
// if(needsCopying) System.arraycopy(elLocalName, 0, arr, 0, elStackSize);
// elLocalName = arr;
// arr = new String[newSize];
// if(needsCopying) System.arraycopy(elDefaultNs, 0, arr, 0, elStackSize);
// elDefaultNs = arr;
// int[] iarr = new int[newSize];
// if(needsCopying) System.arraycopy(elNsStackPos, 0, iarr, 0, elStackSize);
// for (int i = elStackSize; i < iarr.length; i++)
// {
// iarr[i] = (i > 0) ? -1 : 0;
// }
// elNsStackPos = iarr;
//assert depth < elName.length;
}
}
// attribute stack
protected int attributeCount;
protected String attributeName[];
protected int attributeNameHash[];
//protected int attributeNameStart[];
//protected int attributeNameEnd[];
protected String attributePrefix[];
protected String attributeUri[];
protected String attributeValue[];
//protected int attributeValueStart[];
//protected int attributeValueEnd[];
/**
* Make sure that in attributes temporary array is enough space.
*/
protected void ensureAttributesCapacity(int size) {
final int attrPosSize = attributeName != null ? attributeName.length : 0;
if(size >= attrPosSize) {
final int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25
if(TRACE_SIZING) {
System.err.println("TRACE_SIZING attrPosSize "+attrPosSize+" ==> "+newSize);
}
final boolean needsCopying = attrPosSize > 0;
String[] arr = null;
arr = new String[newSize];
if(needsCopying) System.arraycopy(attributeName, 0, arr, 0, attrPosSize);
attributeName = arr;
arr = new String[newSize];
if(needsCopying) System.arraycopy(attributePrefix, 0, arr, 0, attrPosSize);
attributePrefix = arr;
arr = new String[newSize];
if(needsCopying) System.arraycopy(attributeUri, 0, arr, 0, attrPosSize);
attributeUri = arr;
arr = new String[newSize];
if(needsCopying) System.arraycopy(attributeValue, 0, arr, 0, attrPosSize);
attributeValue = arr;
if( ! allStringsInterned ) {
final int[] iarr = new int[newSize];
if(needsCopying) System.arraycopy(attributeNameHash, 0, iarr, 0, attrPosSize);
attributeNameHash = iarr;
}
arr = null;
// //assert attrUri.length > size
}
}
// namespace stack
protected int namespaceEnd;
protected String namespacePrefix[];
protected int namespacePrefixHash[];
protected String namespaceUri[];
protected void ensureNamespacesCapacity(int size) {
final int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0;
if(size >= namespaceSize) {
final int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25
if(TRACE_SIZING) {
System.err.println("TRACE_SIZING namespaceSize "+namespaceSize+" ==> "+newSize);
}
final String[] newNamespacePrefix = new String[newSize];
final String[] newNamespaceUri = new String[newSize];
if(namespacePrefix != null) {
System.arraycopy(
namespacePrefix, 0, newNamespacePrefix, 0, namespaceEnd);
System.arraycopy(
namespaceUri, 0, newNamespaceUri, 0, namespaceEnd);
}
namespacePrefix = newNamespacePrefix;
namespaceUri = newNamespaceUri;
if( ! allStringsInterned ) {
final int[] newNamespacePrefixHash = new int[newSize];
if(namespacePrefixHash != null) {
System.arraycopy(
namespacePrefixHash, 0, newNamespacePrefixHash, 0, namespaceEnd);
}
namespacePrefixHash = newNamespacePrefixHash;
}
//prefixesSize = newSize;
// //assert nsPrefixes.length > size && nsPrefixes.length == newSize
}
}
/**
* simplistic implementation of hash function that has constant
* time to compute - so it also means diminishing hash quality for long strings
* but for XML parsing it should be good enough ...
*/
protected static final int fastHash( char ch[], int off, int len ) {
if(len == 0) return 0;
//assert len >0
int hash = ch[off]; // hash at beginning
//try {
hash = (hash << 7) + ch[ off + len - 1 ]; // hash at the end
//} catch(ArrayIndexOutOfBoundsException aie) {
// aie.printStackTrace(); //should never happen ...
// throw new RuntimeException("this is violation of pre-condition");
//}
if(len > 16) hash = (hash << 7) + ch[ off + (len / 4)]; // 1/4 from beginning
if(len > 8) hash = (hash << 7) + ch[ off + (len / 2)]; // 1/2 of string size ...
// notice that hash is at most done 3 times <<7 so shifted by 21 bits 8 bit value
// so max result == 29 bits so it is quite just below 31 bits for long (2^32) ...
//assert hash >= 0;
return hash;
}
// entity replacement stack
protected int entityEnd;
protected String entityName[];
protected char[] entityNameBuf[];
protected String entityReplacement[];
protected char[] entityReplacementBuf[];
protected int entityNameHash[];
protected void ensureEntityCapacity() {
final int entitySize = entityReplacementBuf != null ? entityReplacementBuf.length : 0;
if(entityEnd >= entitySize) {
final int newSize = entityEnd > 7 ? 2 * entityEnd : 8; // = lucky 7 + 1 //25
if(TRACE_SIZING) {
System.err.println("TRACE_SIZING entitySize "+entitySize+" ==> "+newSize);
}
final String[] newEntityName = new String[newSize];
final char[] newEntityNameBuf[] = new char[newSize][];
final String[] newEntityReplacement = new String[newSize];
final char[] newEntityReplacementBuf[] = new char[newSize][];
if(entityName != null) {
System.arraycopy(entityName, 0, newEntityName, 0, entityEnd);
System.arraycopy(entityNameBuf, 0, newEntityNameBuf, 0, entityEnd);
System.arraycopy(entityReplacement, 0, newEntityReplacement, 0, entityEnd);
System.arraycopy(entityReplacementBuf, 0, newEntityReplacementBuf, 0, entityEnd);
}
entityName = newEntityName;
entityNameBuf = newEntityNameBuf;
entityReplacement = newEntityReplacement;
entityReplacementBuf = newEntityReplacementBuf;
if( ! allStringsInterned ) {
final int[] newEntityNameHash = new int[newSize];
if(entityNameHash != null) {
System.arraycopy(entityNameHash, 0, newEntityNameHash, 0, entityEnd);
}
entityNameHash = newEntityNameHash;
}
}
}
// input buffer management
protected static final int READ_CHUNK_SIZE = 8*1024; //max data chars in one read() call
protected Reader reader;
protected String inputEncoding;
protected int bufLoadFactor = 95; // 99%
//protected int bufHardLimit; // only matters when expanding
protected char buf[] = new char[
Runtime.getRuntime().freeMemory() > 1000000L ? READ_CHUNK_SIZE : 256 ];
protected int bufSoftLimit = ( bufLoadFactor * buf.length ) /100; // desirable size of buffer
protected boolean preventBufferCompaction;
protected int bufAbsoluteStart; // this is buf
protected int bufStart;
protected int bufEnd;
protected int pos;
protected int posStart;
protected int posEnd;
protected char pc[] = new char[
Runtime.getRuntime().freeMemory() > 1000000L ? READ_CHUNK_SIZE : 64 ];
protected int pcStart;
protected int pcEnd;
// parsing state
//protected boolean needsMore;
//protected boolean seenMarkup;
protected boolean usePC;
protected boolean seenStartTag;
protected boolean seenEndTag;
protected boolean pastEndTag;
protected boolean seenAmpersand;
protected boolean seenMarkup;
protected boolean seenDocdecl;
// transient variable set during each call to next/Token()
protected boolean tokenize;
protected String text;
protected String entityRefName;
protected String xmlDeclVersion;
protected Boolean xmlDeclStandalone;
protected String xmlDeclContent;
protected void reset() {
//System.out.println("reset() called");
location = null;
lineNumber = 1;
columnNumber = 0;
seenRoot = false;
reachedEnd = false;
eventType = START_DOCUMENT;
emptyElementTag = false;
depth = 0;
attributeCount = 0;
namespaceEnd = 0;
entityEnd = 0;
reader = null;
inputEncoding = null;
preventBufferCompaction = false;
bufAbsoluteStart = 0;
bufEnd = bufStart = 0;
pos = posStart = posEnd = 0;
pcEnd = pcStart = 0;
usePC = false;
seenStartTag = false;
seenEndTag = false;
pastEndTag = false;
seenAmpersand = false;
seenMarkup = false;
seenDocdecl = false;
xmlDeclVersion = null;
xmlDeclStandalone = null;
xmlDeclContent = null;
resetStringCache();
}
public MXParser() {
}
/**
* Method setFeature
*
* @param name a String
* @param state a boolean
*
* @throws XmlPullParserException
*
*/
public void setFeature(String name,
boolean state) throws XmlPullParserException
{
if(name == null) throw new IllegalArgumentException("feature name should not be null");
if(FEATURE_PROCESS_NAMESPACES.equals(name)) {
if(eventType != START_DOCUMENT) throw new XmlPullParserException(
"namespace processing feature can only be changed before parsing", this, null);
processNamespaces = state;
// } else if(FEATURE_REPORT_NAMESPACE_ATTRIBUTES.equals(name)) {
// if(type != START_DOCUMENT) throw new XmlPullParserException(
// "namespace reporting feature can only be changed before parsing", this, null);
// reportNsAttribs = state;
} else if(FEATURE_NAMES_INTERNED.equals(name)) {
if(state != false) {
throw new XmlPullParserException(
"interning names in this implementation is not supported");
}
} else if(FEATURE_PROCESS_DOCDECL.equals(name)) {
if(state != false) {
throw new XmlPullParserException(
"processing DOCDECL is not supported");
}
//} else if(REPORT_DOCDECL.equals(name)) {
// paramNotifyDoctype = state;
} else if(FEATURE_XML_ROUNDTRIP.equals(name)) {
//if(state == false) {
// throw new XmlPullParserException(
// "roundtrip feature can not be switched off");
//}
roundtripSupported = state;
} else {
throw new XmlPullParserException("unsupporte feature "+name);
}
}
/** Unknown properties are always returned as false */
public boolean getFeature(String name)
{
if(name == null) throw new IllegalArgumentException("feature name should not be nulll");
if(FEATURE_PROCESS_NAMESPACES.equals(name)) {
return processNamespaces;
// } else if(FEATURE_REPORT_NAMESPACE_ATTRIBUTES.equals(name)) {
// return reportNsAttribs;
} else if(FEATURE_NAMES_INTERNED.equals(name)) {
return false;
} else if(FEATURE_PROCESS_DOCDECL.equals(name)) {
return false;
//} else if(REPORT_DOCDECL.equals(name)) {
// return paramNotifyDoctype;
} else if(FEATURE_XML_ROUNDTRIP.equals(name)) {
//return true;
return roundtripSupported;
}
return false;
}
public void setProperty(String name,
Object value)
throws XmlPullParserException
{
if(PROPERTY_LOCATION.equals(name)) {
location = (String) value;
} else {
throw new XmlPullParserException("unsupported property: '"+name+"'");
}
}
public Object getProperty(String name)
{
if(name == null) throw new IllegalArgumentException("property name should not be nulll");
if(PROPERTY_XMLDECL_VERSION.equals(name)) {
return xmlDeclVersion;
} else if(PROPERTY_XMLDECL_STANDALONE.equals(name)) {
return xmlDeclStandalone;
} else if(PROPERTY_XMLDECL_CONTENT.equals(name)) {
return xmlDeclContent;
} else if(PROPERTY_LOCATION.equals(name)) {
return location;
}
return null;
}
public void setInput(Reader in) throws XmlPullParserException
{
reset();
reader = in;
}
public void setInput(java.io.InputStream inputStream, String inputEncoding)
throws XmlPullParserException
{
if(inputStream == null) {
throw new IllegalArgumentException("input stream can not be null");
}
Reader reader;
try {
if(inputEncoding != null) {
reader = ReaderFactory.newReader(inputStream, inputEncoding);
} else {
reader = ReaderFactory.newXmlReader(inputStream);
}
} catch (UnsupportedEncodingException une) {
throw new XmlPullParserException(
"could not create reader for encoding "+inputEncoding+" : "+une, this, une);
}
catch ( IOException e )
{
throw new XmlPullParserException(
"could not create reader : "+e, this, e);
}
setInput(reader);
//must be here as reset() was called in setInput() and has set this.inputEncoding to null ...
this.inputEncoding = inputEncoding;
}
public String getInputEncoding() {
return inputEncoding;
}
public void defineEntityReplacementText(String entityName,
String replacementText)
throws XmlPullParserException
{
// throw new XmlPullParserException("not allowed");
if ( !replacementText.startsWith( "&#" ) && this.entityName != null && replacementText.length() > 1 )
{
String tmp = replacementText.substring( 1, replacementText.length() - 1 );
for ( int i = 0; i < this.entityName.length; i++ )
{
if ( this.entityName[i] != null && this.entityName[i].equals( tmp ) )
{
replacementText = this.entityReplacement[i];
}
}
}
//protected char[] entityReplacement[];
ensureEntityCapacity();
// this is to make sure that if interning works we will take advantage of it ...
this.entityName[entityEnd] = newString(entityName.toCharArray(), 0, entityName.length());
entityNameBuf[entityEnd] = entityName.toCharArray();
entityReplacement[entityEnd] = replacementText;
entityReplacementBuf[entityEnd] = replacementText.toCharArray();
if(!allStringsInterned) {
entityNameHash[ entityEnd ] =
fastHash(entityNameBuf[entityEnd], 0, entityNameBuf[entityEnd].length);
}
++entityEnd;
//TODO disallow < or & in entity replacement text (or ]]>???)
// TOOD keepEntityNormalizedForAttributeValue cached as well ...
}
public int getNamespaceCount(int depth)
throws XmlPullParserException
{
if(processNamespaces == false || depth == 0) {
return 0;
}
//int maxDepth = eventType == END_TAG ? this.depth + 1 : this.depth;
//if(depth < 0 || depth > maxDepth) throw new IllegalArgumentException(
if(depth < 0 || depth > this.depth) throw new IllegalArgumentException(
"napespace count mayt be for depth 0.."+this.depth+" not "+depth);
return elNamespaceCount[ depth ];
}
public String getNamespacePrefix(int pos)
throws XmlPullParserException
{
//int end = eventType == END_TAG ? elNamespaceCount[ depth + 1 ] : namespaceEnd;
//if(pos < end) {
if(pos < namespaceEnd) {
return namespacePrefix[ pos ];
} else {
throw new XmlPullParserException(
"position "+pos+" exceeded number of available namespaces "+namespaceEnd);
}
}
public String getNamespaceUri(int pos) throws XmlPullParserException
{
//int end = eventType == END_TAG ? elNamespaceCount[ depth + 1 ] : namespaceEnd;
//if(pos < end) {
if(pos < namespaceEnd) {
return namespaceUri[ pos ];
} else {
throw new XmlPullParserException(
"position "+pos+" exceedded number of available namespaces "+namespaceEnd);
}
}
public String getNamespace( String prefix )
//throws XmlPullParserException
{
//int count = namespaceCount[ depth ];
if(prefix != null) {
for( int i = namespaceEnd -1; i >= 0; i--) {
if( prefix.equals( namespacePrefix[ i ] ) ) {
return namespaceUri[ i ];
}
}
if("xml".equals( prefix )) {
return XML_URI;
} else if("xmlns".equals( prefix )) {
return XMLNS_URI;
}
} else {
for( int i = namespaceEnd -1; i >= 0; i--) {
if( namespacePrefix[ i ] == null) { //"") { //null ) { //TODO check FIXME Alek
return namespaceUri[ i ];
}
}
}
return null;
}
public int getDepth()
{
return depth;
}
private static int findFragment(int bufMinPos, char[] b, int start, int end) {
//System.err.println("bufStart="+bufStart+" b="+printable(new String(b, start, end - start))+" start="+start+" end="+end);
if(start < bufMinPos) {
start = bufMinPos;
if(start > end) start = end;
return start;
}
if(end - start > 65) {
start = end - 10; // try to find good location
}
int i = start + 1;
while(--i > bufMinPos) {
if((end - i) > 65) break;
final char c = b[i];
if(c == '<' && (start - i) > 10) break;
}
return i;
}
/**
* Return string describing current position of parsers as
* text 'STATE [seen %s...] @line:column'.
*/
public String getPositionDescription ()
{
String fragment = null;
if(posStart <= pos) {
final int start = findFragment(0, buf, posStart, pos);
//System.err.println("start="+start);
if(start < pos) {
fragment = new String(buf, start, pos - start);
}
if(bufAbsoluteStart > 0 || start > 0) fragment = "..." + fragment;
}
// return " at line "+tokenizerPosRow
// +" and column "+(tokenizerPosCol-1)
// +(fragment != null ? " seen "+printable(fragment)+"..." : "");
return " "+TYPES[ eventType ] +
(fragment != null ? " seen "+printable(fragment)+"..." : "")
+" "+(location != null ? location : "")
+"@"+getLineNumber()+":"+getColumnNumber();
}
public int getLineNumber()
{
return lineNumber;
}
public int getColumnNumber()
{
return columnNumber;
}
public boolean isWhitespace() throws XmlPullParserException
{
if(eventType == TEXT || eventType == CDSECT) {
if(usePC) {
for (int i = pcStart; i = 0; i--) {
// if( prefix.equals( namespacePrefix[ i ] ) ) {
// return namespaceUri[ i ];
// }
// }
// } else {
// for( int i = namespaceEnd -1; i >= 0; i--) {
// if( namespacePrefix[ i ] == null ) {
// return namespaceUri[ i ];
// }
// }
//
// }
// return "";
}
public String getName()
{
if(eventType == START_TAG) {
//return elName[ depth - 1 ] ;
return elName[ depth ] ;
} else if(eventType == END_TAG) {
return elName[ depth ] ;
} else if(eventType == ENTITY_REF) {
if(entityRefName == null) {
entityRefName = newString(buf, posStart, posEnd - posStart);
}
return entityRefName;
} else {
return null;
}
}
public String getPrefix()
{
if(eventType == START_TAG) {
//return elPrefix[ depth - 1 ] ;
return elPrefix[ depth ] ;
} else if(eventType == END_TAG) {
return elPrefix[ depth ] ;
}
return null;
// if(eventType != START_TAG && eventType != END_TAG) return null;
// int maxDepth = eventType == END_TAG ? depth : depth - 1;
// return elPrefix[ maxDepth ];
}
public boolean isEmptyElementTag() throws XmlPullParserException
{
if(eventType != START_TAG) throw new XmlPullParserException(
"parser must be on START_TAG to check for empty element", this, null);
return emptyElementTag;
}
public int getAttributeCount()
{
if(eventType != START_TAG) return -1;
return attributeCount;
}
public String getAttributeNamespace(int index)
{
if(eventType != START_TAG) throw new IndexOutOfBoundsException(
"only START_TAG can have attributes");
if(processNamespaces == false) return NO_NAMESPACE;
if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
"attribute position must be 0.."+(attributeCount-1)+" and not "+index);
return attributeUri[ index ];
}
public String getAttributeName(int index)
{
if(eventType != START_TAG) throw new IndexOutOfBoundsException(
"only START_TAG can have attributes");
if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
"attribute position must be 0.."+(attributeCount-1)+" and not "+index);
return attributeName[ index ];
}
public String getAttributePrefix(int index)
{
if(eventType != START_TAG) throw new IndexOutOfBoundsException(
"only START_TAG can have attributes");
if(processNamespaces == false) return null;
if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
"attribute position must be 0.."+(attributeCount-1)+" and not "+index);
return attributePrefix[ index ];
}
public String getAttributeType(int index) {
if(eventType != START_TAG) throw new IndexOutOfBoundsException(
"only START_TAG can have attributes");
if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
"attribute position must be 0.."+(attributeCount-1)+" and not "+index);
return "CDATA";
}
public boolean isAttributeDefault(int index) {
if(eventType != START_TAG) throw new IndexOutOfBoundsException(
"only START_TAG can have attributes");
if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
"attribute position must be 0.."+(attributeCount-1)+" and not "+index);
return false;
}
public String getAttributeValue(int index)
{
if(eventType != START_TAG) throw new IndexOutOfBoundsException(
"only START_TAG can have attributes");
if(index < 0 || index >= attributeCount) throw new IndexOutOfBoundsException(
"attribute position must be 0.."+(attributeCount-1)+" and not "+index);
return attributeValue[ index ];
}
public String getAttributeValue(String namespace,
String name)
{
if(eventType != START_TAG) throw new IndexOutOfBoundsException(
"only START_TAG can have attributes"+getPositionDescription());
if(name == null) {
throw new IllegalArgumentException("attribute name can not be null");
}
// TODO make check if namespace is interned!!! etc. for names!!!
if(processNamespaces) {
if(namespace == null) {
namespace = "";
}
for(int i = 0; i < attributeCount; ++i) {
if((namespace == attributeUri[ i ] ||
namespace.equals(attributeUri[ i ]) )
//(namespace != null && namespace.equals(attributeUri[ i ]))
// taking advantage of String.intern()
&& name.equals(attributeName[ i ]) )
{
return attributeValue[i];
}
}
} else {
if(namespace != null && namespace.length() == 0) {
namespace = null;
}
if(namespace != null) throw new IllegalArgumentException(
"when namespaces processing is disabled attribute namespace must be null");
for(int i = 0; i < attributeCount; ++i) {
if(name.equals(attributeName[i]))
{
return attributeValue[i];
}
}
}
return null;
}
public int getEventType()
throws XmlPullParserException
{
return eventType;
}
public void require(int type, String namespace, String name)
throws XmlPullParserException, IOException
{
if(processNamespaces == false && namespace != null) {
throw new XmlPullParserException(
"processing namespaces must be enabled on parser (or factory)"+
" to have possible namespaces delcared on elements"
+(" (postion:"+ getPositionDescription())+")");
}
if (type != getEventType()
|| (namespace != null && !namespace.equals (getNamespace()))
|| (name != null && !name.equals (getName ())) )
{
throw new XmlPullParserException (
"expected event "+TYPES[ type ]
+(name != null ? " with name '"+name+"'" : "")
+(namespace != null && name != null ? " and" : "")
+(namespace != null ? " with namespace '"+namespace+"'" : "")
+" but got"
+(type != getEventType() ? " "+TYPES[ getEventType() ] : "")
+(name != null && getName() != null && !name.equals (getName ())
? " name '"+getName()+"'" : "")
+(namespace != null && name != null
&& getName() != null && !name.equals (getName ())
&& getNamespace() != null && !namespace.equals (getNamespace())
? " and" : "")
+(namespace != null && getNamespace() != null && !namespace.equals (getNamespace())
? " namespace '"+getNamespace()+"'" : "")
+(" (postion:"+ getPositionDescription())+")");
}
}
/**
* Skip sub tree that is currently porser positioned on.
*
NOTE: parser must be on START_TAG and when funtion returns
* parser will be positioned on corresponding END_TAG
*/
public void skipSubTree()
throws XmlPullParserException, IOException
{
require(START_TAG, null, null);
int level = 1;
while(level > 0) {
int eventType = next();
if(eventType == END_TAG) {
--level;
} else if(eventType == START_TAG) {
++level;
}
}
}
// public String readText() throws XmlPullParserException, IOException
// {
// if (getEventType() != TEXT) return "";
// String result = getText();
// next();
// return result;
// }
public String nextText() throws XmlPullParserException, IOException
{
// String result = null;
// boolean onStartTag = false;
// if(eventType == START_TAG) {
// onStartTag = true;
// next();
// }
// if(eventType == TEXT) {
// result = getText();
// next();
// } else if(onStartTag && eventType == END_TAG) {
// result = "";
// } else {
// throw new XmlPullParserException(
// "parser must be on START_TAG or TEXT to read text", this, null);
// }
// if(eventType != END_TAG) {
// throw new XmlPullParserException(
// "event TEXT it must be immediately followed by END_TAG", this, null);
// }
// return result;
if(getEventType() != START_TAG) {
throw new XmlPullParserException(
"parser must be on START_TAG to read next text", this, null);
}
int eventType = next();
if(eventType == TEXT) {
final String result = getText();
eventType = next();
if(eventType != END_TAG) {
throw new XmlPullParserException(
"TEXT must be immediately followed by END_TAG and not "
+TYPES[ getEventType() ], this, null);
}
return result;
} else if(eventType == END_TAG) {
return "";
} else {
throw new XmlPullParserException(
"parser must be on START_TAG or TEXT to read text", this, null);
}
}
public int nextTag() throws XmlPullParserException, IOException
{
next();
if(eventType == TEXT && isWhitespace()) { // skip whitespace
next();
}
if (eventType != START_TAG && eventType != END_TAG) {
throw new XmlPullParserException("expected START_TAG or END_TAG not "
+TYPES[ getEventType() ], this, null);
}
return eventType;
}
public int next()
throws XmlPullParserException, IOException
{
tokenize = false;
return nextImpl();
}
public int nextToken()
throws XmlPullParserException, IOException
{
tokenize = true;
return nextImpl();
}
protected int nextImpl()
throws XmlPullParserException, IOException
{
text = null;
pcEnd = pcStart = 0;
usePC = false;
bufStart = posEnd;
if(pastEndTag) {
pastEndTag = false;
--depth;
namespaceEnd = elNamespaceCount[ depth ]; // less namespaces available
}
if(emptyElementTag) {
emptyElementTag = false;
pastEndTag = true;
return eventType = END_TAG;
}
// [1] document ::= prolog element Misc*
if(depth > 0) {
if(seenStartTag) {
seenStartTag = false;
return eventType = parseStartTag();
}
if(seenEndTag) {
seenEndTag = false;
return eventType = parseEndTag();
}
// ASSUMPTION: we are _on_ first character of content or markup!!!!
// [43] content ::= CharData? ((element | Reference | CDSect | PI | Comment) CharData?)*
char ch;
if(seenMarkup) { // we have read ahead ...
seenMarkup = false;
ch = '<';
} else if(seenAmpersand) {
seenAmpersand = false;
ch = '&';
} else {
ch = more();
}
posStart = pos - 1; // VERY IMPORTANT: this is correct start of event!!!
// when true there is some potential event TEXT to return - keep gathering
boolean hadCharData = false;
// when true TEXT data is not continuous (like ) and requires PC merging
boolean needsMerging = false;
MAIN_LOOP:
while(true) {
// work on MARKUP
if(ch == '<') {
if(hadCharData) {
//posEnd = pos - 1;
if(tokenize) {
seenMarkup = true;
return eventType = TEXT;
}
}
ch = more();
if(ch == '/') {
if(!tokenize && hadCharData) {
seenEndTag = true;
//posEnd = pos - 2;
return eventType = TEXT;
}
return eventType = parseEndTag();
} else if(ch == '!') {
ch = more();
if(ch == '-') {
// note: if(tokenize == false) posStart/End is NOT changed!!!!
parseComment();
if(tokenize) return eventType = COMMENT;
if( !usePC && hadCharData ) {
needsMerging = true;
} else {
posStart = pos; //completely ignore comment
}
} else if(ch == '[') {
//posEnd = pos - 3;
// must remember previous posStart/End as it merges with content of CDATA
//int oldStart = posStart + bufAbsoluteStart;
//int oldEnd = posEnd + bufAbsoluteStart;
parseCDSect(hadCharData);
if(tokenize) return eventType = CDSECT;
final int cdStart = posStart;
final int cdEnd = posEnd;
final int cdLen = cdEnd - cdStart;
if(cdLen > 0) { // was there anything inside CDATA section?
hadCharData = true;
if(!usePC) {
needsMerging = true;
}
}
// posStart = oldStart;
// posEnd = oldEnd;
// if(cdLen > 0) { // was there anything inside CDATA section?
// if(hadCharData) {
// // do merging if there was anything in CDSect!!!!
// // if(!usePC) {
// // // posEnd is correct already!!!
// // if(posEnd > posStart) {
// // joinPC();
// // } else {
// // usePC = true;
// // pcStart = pcEnd = 0;
// // }
// // }
// // if(pcEnd + cdLen >= pc.length) ensurePC(pcEnd + cdLen);
// // // copy [cdStart..cdEnd) into PC
// // System.arraycopy(buf, cdStart, pc, pcEnd, cdLen);
// // pcEnd += cdLen;
// if(!usePC) {
// needsMerging = true;
// posStart = cdStart;
// posEnd = cdEnd;
// }
// } else {
// if(!usePC) {
// needsMerging = true;
// posStart = cdStart;
// posEnd = cdEnd;
// hadCharData = true;
// }
// }
// //hadCharData = true;
// } else {
// if( !usePC && hadCharData ) {
// needsMerging = true;
// }
// }
} else {
throw new XmlPullParserException(
"unexpected character in markup "+printable(ch), this, null);
}
} else if(ch == '?') {
parsePI();
if(tokenize) return eventType = PROCESSING_INSTRUCTION;
if( !usePC && hadCharData ) {
needsMerging = true;
} else {
posStart = pos; //completely ignore PI
}
} else if( isNameStartChar(ch) ) {
if(!tokenize && hadCharData) {
seenStartTag = true;
//posEnd = pos - 2;
return eventType = TEXT;
}
return eventType = parseStartTag();
} else {
throw new XmlPullParserException(
"unexpected character in markup "+printable(ch), this, null);
}
// do content comapctation if it makes sense!!!!
} else if(ch == '&') {
// work on ENTITTY
//posEnd = pos - 1;
if(tokenize && hadCharData) {
seenAmpersand = true;
return eventType = TEXT;
}
final int oldStart = posStart + bufAbsoluteStart;
final int oldEnd = posEnd + bufAbsoluteStart;
final char[] resolvedEntity = parseEntityRef();
if(tokenize) return eventType = ENTITY_REF;
// check if replacement text can be resolved !!!
if(resolvedEntity == null) {
if(entityRefName == null) {
entityRefName = newString(buf, posStart, posEnd - posStart);
}
throw new XmlPullParserException(
"could not resolve entity named '"+printable(entityRefName)+"'",
this, null);
}
//int entStart = posStart;
//int entEnd = posEnd;
posStart = oldStart - bufAbsoluteStart;
posEnd = oldEnd - bufAbsoluteStart;
if(!usePC) {
if(hadCharData) {
joinPC(); // posEnd is already set correctly!!!
needsMerging = false;
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
//assert usePC == true;
// write into PC replacement text - do merge for replacement text!!!!
for (int i = 0; i < resolvedEntity.length; i++)
{
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = resolvedEntity[ i ];
}
hadCharData = true;
//assert needsMerging == false;
} else {
if(needsMerging) {
//assert usePC == false;
joinPC(); // posEnd is already set correctly!!!
//posStart = pos - 1;
needsMerging = false;
}
//no MARKUP not ENTITIES so work on character data ...
// [14] CharData ::= [^<&]* - ([^<&]* ']]>' [^<&]*)
hadCharData = true;
boolean normalizedCR = false;
final boolean normalizeInput = tokenize == false || roundtripSupported == false;
// use loop locality here!!!!
boolean seenBracket = false;
boolean seenBracketBracket = false;
do {
// check that ]]> does not show in
if(ch == ']') {
if(seenBracket) {
seenBracketBracket = true;
} else {
seenBracket = true;
}
} else if(seenBracketBracket && ch == '>') {
throw new XmlPullParserException(
"characters ]]> are not allowed in content", this, null);
} else {
if(seenBracket) {
seenBracketBracket = seenBracket = false;
}
// assert seenTwoBrackets == seenBracket == false;
}
if(normalizeInput) {
// deal with normalization issues ...
if(ch == '\r') {
normalizedCR = true;
posEnd = pos -1;
// posEnd is already set
if(!usePC) {
if(posEnd > posStart) {
joinPC();
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
//assert usePC == true;
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
} else if(ch == '\n') {
// if(!usePC) { joinPC(); } else { if(pcEnd >= pc.length) ensurePC(); }
if(!normalizedCR && usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
}
normalizedCR = false;
} else {
if(usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = ch;
}
normalizedCR = false;
}
}
ch = more();
} while(ch != '<' && ch != '&');
posEnd = pos - 1;
continue MAIN_LOOP; // skip ch = more() from below - we are already ahead ...
}
ch = more();
} // endless while(true)
} else {
if(seenRoot) {
return parseEpilog();
} else {
return parseProlog();
}
}
}
protected int parseProlog()
throws XmlPullParserException, IOException
{
// [2] prolog: ::= XMLDecl? Misc* (doctypedecl Misc*)? and look for [39] element
char ch;
if(seenMarkup) {
ch = buf[ pos - 1 ];
} else {
ch = more();
}
if(eventType == START_DOCUMENT) {
// bootstrap parsing with getting first character input!
// deal with BOM
// detect BOM and crop it (Unicode int Order Mark)
if(ch == '\uFFFE') {
throw new XmlPullParserException(
"first character in input was UNICODE noncharacter (0xFFFE)"+
"- input requires int swapping", this, null);
}
if(ch == '\uFEFF') {
// skipping UNICODE int Order Mark (so called BOM)
ch = more();
}
}
seenMarkup = false;
boolean gotS = false;
posStart = pos - 1;
final boolean normalizeIgnorableWS = tokenize == true && roundtripSupported == false;
boolean normalizedCR = false;
while(true) {
// deal with Misc
// [27] Misc ::= Comment | PI | S
// deal with docdecl --> mark it!
// else parseStartTag seen <[^/]
if(ch == '<') {
if(gotS && tokenize) {
posEnd = pos - 1;
seenMarkup = true;
return eventType = IGNORABLE_WHITESPACE;
}
ch = more();
if(ch == '?') {
// check if it is 'xml'
// deal with XMLDecl
boolean isXMLDecl = parsePI();
if(tokenize) {
if (isXMLDecl) {
return eventType = START_DOCUMENT;
}
return eventType = PROCESSING_INSTRUCTION;
}
} else if(ch == '!') {
ch = more();
if(ch == 'D') {
if(seenDocdecl) {
throw new XmlPullParserException(
"only one docdecl allowed in XML document", this, null);
}
seenDocdecl = true;
parseDocdecl();
if(tokenize) return eventType = DOCDECL;
} else if(ch == '-') {
parseComment();
if(tokenize) return eventType = COMMENT;
} else {
throw new XmlPullParserException(
"unexpected markup posStart) {
joinPC();
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
//assert usePC == true;
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
} else if(ch == '\n') {
if(!normalizedCR && usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
}
normalizedCR = false;
} else {
if(usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = ch;
}
normalizedCR = false;
}
}
} else {
throw new XmlPullParserException(
"only whitespace content allowed before start tag and not "+printable(ch),
this, null);
}
ch = more();
}
}
protected int parseEpilog()
throws XmlPullParserException, IOException
{
if(eventType == END_DOCUMENT) {
throw new XmlPullParserException("already reached end of XML input", this, null);
}
if(reachedEnd) {
return eventType = END_DOCUMENT;
}
boolean gotS = false;
final boolean normalizeIgnorableWS = tokenize == true && roundtripSupported == false;
boolean normalizedCR = false;
try {
// epilog: Misc*
char ch;
if(seenMarkup) {
ch = buf[ pos - 1 ];
} else {
ch = more();
}
seenMarkup = false;
posStart = pos - 1;
if(!reachedEnd) {
while(true) {
// deal with Misc
// [27] Misc ::= Comment | PI | S
if(ch == '<') {
if(gotS && tokenize) {
posEnd = pos - 1;
seenMarkup = true;
return eventType = IGNORABLE_WHITESPACE;
}
ch = more();
if(reachedEnd) {
break;
}
if(ch == '?') {
// check if it is 'xml'
// deal with XMLDecl
parsePI();
if(tokenize) return eventType = PROCESSING_INSTRUCTION;
} else if(ch == '!') {
ch = more();
if(reachedEnd) {
break;
}
if(ch == 'D') {
parseDocdecl(); //FIXME
if(tokenize) return eventType = DOCDECL;
} else if(ch == '-') {
parseComment();
if(tokenize) return eventType = COMMENT;
} else {
throw new XmlPullParserException(
"unexpected markup posStart) {
joinPC();
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
//assert usePC == true;
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
} else if(ch == '\n') {
if(!normalizedCR && usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
}
normalizedCR = false;
} else {
if(usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = ch;
}
normalizedCR = false;
}
}
} else {
throw new XmlPullParserException(
"in epilog non whitespace content is not allowed but got "+printable(ch),
this, null);
}
ch = more();
if(reachedEnd) {
break;
}
}
}
// throw Exception("unexpected content in epilog
// catch EOFException return END_DOCUMENT
//try {
} catch(EOFException ex) {
reachedEnd = true;
}
if(reachedEnd) {
if(tokenize && gotS) {
posEnd = pos; // well - this is LAST available character pos
return eventType = IGNORABLE_WHITESPACE;
}
return eventType = END_DOCUMENT;
} else {
throw new XmlPullParserException("internal error in parseEpilog");
}
}
public int parseEndTag() throws XmlPullParserException, IOException {
//ASSUMPTION ch is past "'
char ch = more();
if(!isNameStartChar(ch)) {
throw new XmlPullParserException(
"expected name start and not "+printable(ch), this, null);
}
posStart = pos - 3;
final int nameStart = pos - 1 + bufAbsoluteStart;
do {
ch = more();
} while(isNameChar(ch));
// now we go one level down -- do checks
//--depth; //FIXME
// check that end tag name is the same as start tag
//String name = new String(buf, nameStart - bufAbsoluteStart,
// (pos - 1) - (nameStart - bufAbsoluteStart));
//int last = pos - 1;
int off = nameStart - bufAbsoluteStart;
//final int len = last - off;
final int len = (pos - 1) - off;
final char[] cbuf = elRawName[depth];
if(elRawNameEnd[depth] != len) {
// construct strings for exception
final String startname = new String(cbuf, 0, elRawNameEnd[depth]);
final String endname = new String(buf, off, len);
throw new XmlPullParserException(
"end tag name must match start tag name <"+startname+">"
+" from line "+elRawNameLine[depth], this, null);
}
for (int i = 0; i < len; i++)
{
if(buf[off++] != cbuf[i]) {
// construct strings for exception
final String startname = new String(cbuf, 0, len);
final String endname = new String(buf, off - i - 1, len);
throw new XmlPullParserException(
"end tag name must be the same as start tag <"+startname+">"
+" from line "+elRawNameLine[depth], this, null);
}
}
while(isS(ch)) { ch = more(); } // skip additional white spaces
if(ch != '>') {
throw new XmlPullParserException(
"expected > to finsh end tag not "+printable(ch)
+" from line "+elRawNameLine[depth], this, null);
}
//namespaceEnd = elNamespaceCount[ depth ]; //FIXME
posEnd = pos;
pastEndTag = true;
return eventType = END_TAG;
}
public int parseStartTag() throws XmlPullParserException, IOException {
//ASSUMPTION ch is past '
// [44] EmptyElemTag ::= '<' Name (S Attribute)* S? '/>'
++depth; //FIXME
posStart = pos - 2;
emptyElementTag = false;
attributeCount = 0;
// retrieve name
final int nameStart = pos - 1 + bufAbsoluteStart;
int colonPos = -1;
char ch = buf[ pos - 1];
if(ch == ':' && processNamespaces) throw new XmlPullParserException(
"when namespaces processing enabled colon can not be at element name start",
this, null);
while(true) {
ch = more();
if(!isNameChar(ch)) break;
if(ch == ':' && processNamespaces) {
if(colonPos != -1) throw new XmlPullParserException(
"only one colon is allowed in name of element when namespaces are enabled",
this, null);
colonPos = pos - 1 + bufAbsoluteStart;
}
}
// retrieve name
ensureElementsCapacity();
//TODO check for efficient interning and then use elRawNameInterned!!!!
int elLen = (pos - 1) - (nameStart - bufAbsoluteStart);
if(elRawName[ depth ] == null || elRawName[ depth ].length < elLen) {
elRawName[ depth ] = new char[ 2 * elLen ];
}
System.arraycopy(buf, nameStart - bufAbsoluteStart, elRawName[ depth ], 0, elLen);
elRawNameEnd[ depth ] = elLen;
elRawNameLine[ depth ] = lineNumber;
String name = null;
// work on prefixes and namespace URI
String prefix = null;
if(processNamespaces) {
if(colonPos != -1) {
prefix = elPrefix[ depth ] = newString(buf, nameStart - bufAbsoluteStart,
colonPos - nameStart);
name = elName[ depth ] = newString(buf, colonPos + 1 - bufAbsoluteStart,
//(pos -1) - (colonPos + 1));
pos - 2 - (colonPos - bufAbsoluteStart));
} else {
prefix = elPrefix[ depth ] = null;
name = elName[ depth ] = newString(buf, nameStart - bufAbsoluteStart, elLen);
}
} else {
name = elName[ depth ] = newString(buf, nameStart - bufAbsoluteStart, elLen);
}
while(true) {
while(isS(ch)) { ch = more(); } // skip additional white spaces
if(ch == '>') {
break;
} else if(ch == '/') {
if(emptyElementTag) throw new XmlPullParserException(
"repeated / in tag declaration", this, null);
emptyElementTag = true;
ch = more();
if(ch != '>') throw new XmlPullParserException(
"expected > to end empty tag not "+printable(ch), this, null);
break;
} else if(isNameStartChar(ch)) {
ch = parseAttribute();
ch = more();
continue;
} else {
throw new XmlPullParserException(
"start tag unexpected character "+printable(ch), this, null);
}
//ch = more(); // skip space
}
// now when namespaces were declared we can resolve them
if(processNamespaces) {
String uri = getNamespace(prefix);
if(uri == null) {
if(prefix == null) { // no prefix and no uri => use default namespace
uri = NO_NAMESPACE;
} else {
throw new XmlPullParserException(
"could not determine namespace bound to element prefix "+prefix,
this, null);
}
}
elUri[ depth ] = uri;
//String uri = getNamespace(prefix);
//if(uri == null && prefix == null) { // no prefix and no uri => use default namespace
// uri = "";
//}
// resolve attribute namespaces
for (int i = 0; i < attributeCount; i++)
{
final String attrPrefix = attributePrefix[ i ];
if(attrPrefix != null) {
final String attrUri = getNamespace(attrPrefix);
if(attrUri == null) {
throw new XmlPullParserException(
"could not determine namespace bound to attribute prefix "+attrPrefix,
this, null);
}
attributeUri[ i ] = attrUri;
} else {
attributeUri[ i ] = NO_NAMESPACE;
}
}
//TODO
//[ WFC: Unique Att Spec ]
// check namespaced attribute uniqueness contraint!!!
for (int i = 1; i < attributeCount; i++)
{
for (int j = 0; j < i; j++)
{
if( attributeUri[j] == attributeUri[i]
&& (allStringsInterned && attributeName[j].equals(attributeName[i])
|| (!allStringsInterned
&& attributeNameHash[ j ] == attributeNameHash[ i ]
&& attributeName[j].equals(attributeName[i])) )
) {
// prepare data for nice error messgae?
String attr1 = attributeName[j];
if(attributeUri[j] != null) attr1 = attributeUri[j]+":"+attr1;
String attr2 = attributeName[i];
if(attributeUri[i] != null) attr2 = attributeUri[i]+":"+attr2;
throw new XmlPullParserException(
"duplicated attributes "+attr1+" and "+attr2, this, null);
}
}
}
} else { // ! processNamespaces
//[ WFC: Unique Att Spec ]
// check raw attribute uniqueness contraint!!!
for (int i = 1; i < attributeCount; i++)
{
for (int j = 0; j < i; j++)
{
if((allStringsInterned && attributeName[j].equals(attributeName[i])
|| (!allStringsInterned
&& attributeNameHash[ j ] == attributeNameHash[ i ]
&& attributeName[j].equals(attributeName[i])) )
) {
// prepare data for nice error messgae?
final String attr1 = attributeName[j];
final String attr2 = attributeName[i];
throw new XmlPullParserException(
"duplicated attributes "+attr1+" and "+attr2, this, null);
}
}
}
}
elNamespaceCount[ depth ] = namespaceEnd;
posEnd = pos;
return eventType = START_TAG;
}
protected char parseAttribute() throws XmlPullParserException, IOException
{
// parse attribute
// [41] Attribute ::= Name Eq AttValue
// [WFC: No External Entity References]
// [WFC: No < in Attribute Values]
final int prevPosStart = posStart + bufAbsoluteStart;
final int nameStart = pos - 1 + bufAbsoluteStart;
int colonPos = -1;
char ch = buf[ pos - 1 ];
if(ch == ':' && processNamespaces) throw new XmlPullParserException(
"when namespaces processing enabled colon can not be at attribute name start",
this, null);
boolean startsWithXmlns = processNamespaces && ch == 'x';
int xmlnsPos = 0;
ch = more();
while(isNameChar(ch)) {
if(processNamespaces) {
if(startsWithXmlns && xmlnsPos < 5) {
++xmlnsPos;
if(xmlnsPos == 1) { if(ch != 'm') startsWithXmlns = false; }
else if(xmlnsPos == 2) { if(ch != 'l') startsWithXmlns = false; }
else if(xmlnsPos == 3) { if(ch != 'n') startsWithXmlns = false; }
else if(xmlnsPos == 4) { if(ch != 's') startsWithXmlns = false; }
else if(xmlnsPos == 5) {
if(ch != ':') throw new XmlPullParserException(
"after xmlns in attribute name must be colon"
+"when namespaces are enabled", this, null);
//colonPos = pos - 1 + bufAbsoluteStart;
}
}
if(ch == ':') {
if(colonPos != -1) throw new XmlPullParserException(
"only one colon is allowed in attribute name"
+" when namespaces are enabled", this, null);
colonPos = pos - 1 + bufAbsoluteStart;
}
}
ch = more();
}
ensureAttributesCapacity(attributeCount);
// --- start processing attributes
String name = null;
String prefix = null;
// work on prefixes and namespace URI
if(processNamespaces) {
if(xmlnsPos < 4) startsWithXmlns = false;
if(startsWithXmlns) {
if(colonPos != -1) {
//prefix = attributePrefix[ attributeCount ] = null;
final int nameLen = pos - 2 - (colonPos - bufAbsoluteStart);
if(nameLen == 0) {
throw new XmlPullParserException(
"namespace prefix is required after xmlns: "
+" when namespaces are enabled", this, null);
}
name = //attributeName[ attributeCount ] =
newString(buf, colonPos - bufAbsoluteStart + 1, nameLen);
//pos - 1 - (colonPos + 1 - bufAbsoluteStart)
}
} else {
if(colonPos != -1) {
int prefixLen = colonPos - nameStart;
prefix = attributePrefix[ attributeCount ] =
newString(buf, nameStart - bufAbsoluteStart,prefixLen);
//colonPos - (nameStart - bufAbsoluteStart));
int nameLen = pos - 2 - (colonPos - bufAbsoluteStart);
name = attributeName[ attributeCount ] =
newString(buf, colonPos - bufAbsoluteStart + 1, nameLen);
//pos - 1 - (colonPos + 1 - bufAbsoluteStart));
//name.substring(0, colonPos-nameStart);
} else {
prefix = attributePrefix[ attributeCount ] = null;
name = attributeName[ attributeCount ] =
newString(buf, nameStart - bufAbsoluteStart,
pos - 1 - (nameStart - bufAbsoluteStart));
}
if(!allStringsInterned) {
attributeNameHash[ attributeCount ] = name.hashCode();
}
}
} else {
// retrieve name
name = attributeName[ attributeCount ] =
newString(buf, nameStart - bufAbsoluteStart,
pos - 1 - (nameStart - bufAbsoluteStart));
////assert name != null;
if(!allStringsInterned) {
attributeNameHash[ attributeCount ] = name.hashCode();
}
}
// [25] Eq ::= S? '=' S?
while(isS(ch)) { ch = more(); } // skip additional spaces
if(ch != '=') throw new XmlPullParserException(
"expected = after attribute name", this, null);
ch = more();
while(isS(ch)) { ch = more(); } // skip additional spaces
// [10] AttValue ::= '"' ([^<&"] | Reference)* '"'
// | "'" ([^<&'] | Reference)* "'"
final char delimit = ch;
if(delimit != '"' && delimit != '\'') throw new XmlPullParserException(
"attribute value must start with quotation or apostrophe not "
+printable(delimit), this, null);
// parse until delimit or < and resolve Reference
//[67] Reference ::= EntityRef | CharRef
//int valueStart = pos + bufAbsoluteStart;
boolean normalizedCR = false;
usePC = false;
pcStart = pcEnd;
posStart = pos;
while(true) {
ch = more();
if(ch == delimit) {
break;
} if(ch == '<') {
throw new XmlPullParserException(
"markup not allowed inside attribute value - illegal < ", this, null);
} if(ch == '&') {
// extractEntityRef
posEnd = pos - 1;
if(!usePC) {
final boolean hadCharData = posEnd > posStart;
if(hadCharData) {
// posEnd is already set correctly!!!
joinPC();
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
//assert usePC == true;
final char[] resolvedEntity = parseEntityRef();
// check if replacement text can be resolved !!!
if(resolvedEntity == null) {
if(entityRefName == null) {
entityRefName = newString(buf, posStart, posEnd - posStart);
}
throw new XmlPullParserException(
"could not resolve entity named '"+printable(entityRefName)+"'",
this, null);
}
// write into PC replacement text - do merge for replacement text!!!!
for (int i = 0; i < resolvedEntity.length; i++)
{
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = resolvedEntity[ i ];
}
} else if(ch == '\t' || ch == '\n' || ch == '\r') {
// do attribute value normalization
// as described in http://www.w3.org/TR/REC-xml#AVNormalize
// TODO add test for it form spec ...
// handle EOL normalization ...
if(!usePC) {
posEnd = pos - 1;
if(posEnd > posStart) {
joinPC();
} else {
usePC = true;
pcEnd = pcStart = 0;
}
}
//assert usePC == true;
if(pcEnd >= pc.length) ensurePC(pcEnd);
if(ch != '\n' || !normalizedCR) {
pc[pcEnd++] = ' '; //'\n';
}
} else {
if(usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = ch;
}
}
normalizedCR = ch == '\r';
}
if(processNamespaces && startsWithXmlns) {
String ns = null;
if(!usePC) {
ns = newStringIntern(buf, posStart, pos - 1 - posStart);
} else {
ns = newStringIntern(pc, pcStart, pcEnd - pcStart);
}
ensureNamespacesCapacity(namespaceEnd);
int prefixHash = -1;
if(colonPos != -1) {
if(ns.length() == 0) {
throw new XmlPullParserException(
"non-default namespace can not be declared to be empty string", this, null);
}
// declare new namespace
namespacePrefix[ namespaceEnd ] = name;
if(!allStringsInterned) {
prefixHash = namespacePrefixHash[ namespaceEnd ] = name.hashCode();
}
} else {
// declare new default namespace...
namespacePrefix[ namespaceEnd ] = null; //""; //null; //TODO check FIXME Alek
if(!allStringsInterned) {
prefixHash = namespacePrefixHash[ namespaceEnd ] = -1;
}
}
namespaceUri[ namespaceEnd ] = ns;
// detect duplicate namespace declarations!!!
final int startNs = elNamespaceCount[ depth - 1 ];
for (int i = namespaceEnd - 1; i >= startNs; --i)
{
if(((allStringsInterned || name == null) && namespacePrefix[ i ] == name)
|| (!allStringsInterned && name != null &&
namespacePrefixHash[ i ] == prefixHash
&& name.equals(namespacePrefix[ i ])
))
{
final String s = name == null ? "default" : "'"+name+"'";
throw new XmlPullParserException(
"duplicated namespace declaration for "+s+" prefix", this, null);
}
}
++namespaceEnd;
} else {
if(!usePC) {
attributeValue[ attributeCount ] =
new String(buf, posStart, pos - 1 - posStart);
} else {
attributeValue[ attributeCount ] =
new String(pc, pcStart, pcEnd - pcStart);
}
++attributeCount;
}
posStart = prevPosStart - bufAbsoluteStart;
return ch;
}
protected char[] charRefOneCharBuf = new char[1];
protected char[] parseEntityRef()
throws XmlPullParserException, IOException
{
// entity reference http://www.w3.org/TR/2000/REC-xml-20001006#NT-Reference
// [67] Reference ::= EntityRef | CharRef
// ASSUMPTION just after &
entityRefName = null;
posStart = pos;
char ch = more();
StringBuffer sb = new StringBuffer();
if(ch == '#') {
// parse character reference
char charRef = 0;
ch = more();
if(ch == 'x') {
//encoded in hex
while(true) {
ch = more();
if(ch >= '0' && ch <= '9') {
charRef = (char)(charRef * 16 + (ch - '0'));
sb.append( ch );
} else if(ch >= 'a' && ch <= 'f') {
charRef = (char)(charRef * 16 + (ch - ('a' - 10)));
sb.append( ch );
} else if(ch >= 'A' && ch <= 'F') {
charRef = (char)(charRef * 16 + (ch - ('A' - 10)));
sb.append( ch );
} else if(ch == ';') {
break;
} else {
throw new XmlPullParserException(
"character reference (with hex value) may not contain "
+printable(ch), this, null);
}
}
} else {
// encoded in decimal
while(true) {
if(ch >= '0' && ch <= '9') {
charRef = (char)(charRef * 10 + (ch - '0'));
} else if(ch == ';') {
break;
} else {
throw new XmlPullParserException(
"character reference (with decimal value) may not contain "
+printable(ch), this, null);
}
ch = more();
}
}
posEnd = pos - 1;
if ( sb.length() > 0 )
{
char[] tmp = toChars( Integer.parseInt( sb.toString(), 16 ) );
charRefOneCharBuf = tmp;
if ( tokenize )
{
text = newString( charRefOneCharBuf, 0, charRefOneCharBuf.length );
}
return charRefOneCharBuf;
}
charRefOneCharBuf[0] = charRef;
if(tokenize) {
text = newString(charRefOneCharBuf, 0, 1);
}
return charRefOneCharBuf;
} else {
// [68] EntityRef ::= '&' Name ';'
// scan anem until ;
if(!isNameStartChar(ch)) {
throw new XmlPullParserException(
"entity reference names can not start with character '"
+printable(ch)+"'", this, null);
}
while(true) {
ch = more();
if(ch == ';') {
break;
}
if(!isNameChar(ch)) {
throw new XmlPullParserException(
"entity reference name can not contain character "
+printable(ch)+"'", this, null);
}
}
posEnd = pos - 1;
// determine what name maps to
final int len = posEnd - posStart;
if(len == 2 && buf[posStart] == 'l' && buf[posStart+1] == 't') {
if(tokenize) {
text = "<";
}
charRefOneCharBuf[0] = '<';
return charRefOneCharBuf;
//if(paramPC || isParserTokenizing) {
// if(pcEnd >= pc.length) ensurePC();
// pc[pcEnd++] = '<';
//}
} else if(len == 3 && buf[posStart] == 'a'
&& buf[posStart+1] == 'm' && buf[posStart+2] == 'p') {
if(tokenize) {
text = "&";
}
charRefOneCharBuf[0] = '&';
return charRefOneCharBuf;
} else if(len == 2 && buf[posStart] == 'g' && buf[posStart+1] == 't') {
if(tokenize) {
text = ">";
}
charRefOneCharBuf[0] = '>';
return charRefOneCharBuf;
} else if(len == 4 && buf[posStart] == 'a' && buf[posStart+1] == 'p'
&& buf[posStart+2] == 'o' && buf[posStart+3] == 's')
{
if(tokenize) {
text = "'";
}
charRefOneCharBuf[0] = '\'';
return charRefOneCharBuf;
} else if(len == 4 && buf[posStart] == 'q' && buf[posStart+1] == 'u'
&& buf[posStart+2] == 'o' && buf[posStart+3] == 't')
{
if(tokenize) {
text = "\"";
}
charRefOneCharBuf[0] = '"';
return charRefOneCharBuf;
} else {
final char[] result = lookuEntityReplacement(len);
if(result != null) {
return result;
}
}
if(tokenize) text = null;
return null;
}
}
protected char[] lookuEntityReplacement(int entitNameLen)
throws XmlPullParserException, IOException
{
if(!allStringsInterned) {
final int hash = fastHash(buf, posStart, posEnd - posStart);
LOOP:
for (int i = entityEnd - 1; i >= 0; --i)
{
if(hash == entityNameHash[ i ] && entitNameLen == entityNameBuf[ i ].length) {
final char[] entityBuf = entityNameBuf[ i ];
for (int j = 0; j < entitNameLen; j++)
{
if(buf[posStart + j] != entityBuf[j]) continue LOOP;
}
if(tokenize) text = entityReplacement[ i ];
return entityReplacementBuf[ i ];
}
}
} else {
entityRefName = newString(buf, posStart, posEnd - posStart);
for (int i = entityEnd - 1; i >= 0; --i)
{
// take advantage that interning for newStirng is enforced
if(entityRefName == entityName[ i ]) {
if(tokenize) text = entityReplacement[ i ];
return entityReplacementBuf[ i ];
}
}
}
return null;
}
protected void parseComment()
throws XmlPullParserException, IOException
{
// implements XML 1.0 Section 2.5 Comments
//ASSUMPTION: seen
ch = more();
if(seenDashDash && ch != '>') {
throw new XmlPullParserException(
"in comment after two dashes (--) next character must be >"
+" not "+printable(ch), this, null);
}
if(ch == '-') {
if(!seenDash) {
seenDash = true;
} else {
seenDashDash = true;
seenDash = false;
}
} else if(ch == '>') {
if(seenDashDash) {
break; // found end sequence!!!!
} else {
seenDashDash = false;
}
seenDash = false;
} else {
seenDash = false;
}
if(normalizeIgnorableWS) {
if(ch == '\r') {
normalizedCR = true;
//posEnd = pos -1;
//joinPC();
// posEnd is alreadys set
if(!usePC) {
posEnd = pos -1;
if(posEnd > posStart) {
joinPC();
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
//assert usePC == true;
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
} else if(ch == '\n') {
if(!normalizedCR && usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
}
normalizedCR = false;
} else {
if(usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = ch;
}
normalizedCR = false;
}
}
}
} catch(EOFException ex) {
// detect EOF and create meaningful error ...
throw new XmlPullParserException(
"comment started on line "+curLine+" and column "+curColumn+" was not closed",
this, ex);
}
if(tokenize) {
posEnd = pos - 3;
if(usePC) {
pcEnd -= 2;
}
}
}
protected boolean parsePI()
throws XmlPullParserException, IOException
{
// implements XML 1.0 Section 2.6 Processing Instructions
// [16] PI ::= '' Char*)))? '?>'
// [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
//ASSUMPTION: seen
//ch = more();
if(ch == '?') {
seenQ = true;
} else if(ch == '>') {
if(seenQ) {
break; // found end sequence!!!!
}
seenQ = false;
} else {
if(piTargetEnd == -1 && isS(ch)) {
piTargetEnd = pos - 1 + bufAbsoluteStart;
// [17] PITarget ::= Name - (('X' | 'x') ('M' | 'm') ('L' | 'l'))
if((piTargetEnd - piTargetStart) == 3) {
if((buf[piTargetStart] == 'x' || buf[piTargetStart] == 'X')
&& (buf[piTargetStart+1] == 'm' || buf[piTargetStart+1] == 'M')
&& (buf[piTargetStart+2] == 'l' || buf[piTargetStart+2] == 'L')
)
{
if(piTargetStart > 3) { // posStart) {
joinPC();
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
//assert usePC == true;
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
} else if(ch == '\n') {
if(!normalizedCR && usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
}
normalizedCR = false;
} else {
if(usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = ch;
}
normalizedCR = false;
}
}
ch = more();
}
} catch(EOFException ex) {
// detect EOF and create meaningful error ...
throw new XmlPullParserException(
"processing instruction started on line "+curLine+" and column "+curColumn
+" was not closed",
this, ex);
}
if(piTargetEnd == -1) {
piTargetEnd = pos - 2 + bufAbsoluteStart;
//throw new XmlPullParserException(
// "processing instruction must have PITarget name", this, null);
}
piTargetStart -= bufAbsoluteStart;
piTargetEnd -= bufAbsoluteStart;
if(tokenize) {
posEnd = pos - 2;
if(normalizeIgnorableWS) {
--pcEnd;
}
}
return true;
}
// protected final static char[] VERSION = {'v','e','r','s','i','o','n'};
// protected final static char[] NCODING = {'n','c','o','d','i','n','g'};
// protected final static char[] TANDALONE = {'t','a','n','d','a','l','o','n','e'};
// protected final static char[] YES = {'y','e','s'};
// protected final static char[] NO = {'n','o'};
protected final static char[] VERSION = "version".toCharArray();
protected final static char[] NCODING = "ncoding".toCharArray();
protected final static char[] TANDALONE = "tandalone".toCharArray();
protected final static char[] YES = "yes".toCharArray();
protected final static char[] NO = "no".toCharArray();
protected void parseXmlDecl(char ch)
throws XmlPullParserException, IOException
{
// [23] XMLDecl ::= ''
// first make sure that relative positions will stay OK
preventBufferCompaction = true;
bufStart = 0; // necessary to keep pos unchanged during expansion!
// --- parse VersionInfo
// [24] VersionInfo ::= S 'version' Eq ("'" VersionNum "'" | '"' VersionNum '"')
// parse is positioned just on first S past 'z') && (ch < 'A' || ch > 'Z') && (ch < '0' || ch > '9')
&& ch != '_' && ch != '.' && ch != ':' && ch != '-')
{
throw new XmlPullParserException(
" 'z') && (ch < 'A' || ch > 'Z'))
{
throw new XmlPullParserException(
" 'z') && (ch < 'A' || ch > 'Z') && (ch < '0' || ch > '9')
&& ch != '.' && ch != '_' && ch != '-')
{
throw new XmlPullParserException(
" as last part of ') {
throw new XmlPullParserException(
"expected ?> as last part of '
int bracketLevel = 0;
final boolean normalizeIgnorableWS = tokenize == true && roundtripSupported == false;
boolean normalizedCR = false;
while(true) {
ch = more();
if(ch == '[') ++bracketLevel;
if(ch == ']') --bracketLevel;
if(ch == '>' && bracketLevel == 0) break;
if(normalizeIgnorableWS) {
if(ch == '\r') {
normalizedCR = true;
//posEnd = pos -1;
//joinPC();
// posEnd is alreadys set
if(!usePC) {
posEnd = pos -1;
if(posEnd > posStart) {
joinPC();
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
//assert usePC == true;
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
} else if(ch == '\n') {
if(!normalizedCR && usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
}
normalizedCR = false;
} else {
if(usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = ch;
}
normalizedCR = false;
}
}
}
posEnd = pos - 1;
}
protected void parseCDSect(boolean hadCharData)
throws XmlPullParserException, IOException
{
// implements XML 1.0 Section 2.7 CDATA Sections
// [18] CDSect ::= CDStart CData CDEnd
// [19] CDStart ::= '' Char*))
// [21] CDEnd ::= ']]>'
//ASSUMPTION: seen posStart) {
joinPC();
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
}
}
boolean seenBracket = false;
boolean seenBracketBracket = false;
boolean normalizedCR = false;
while(true) {
// scan until it hits "]]>"
ch = more();
if(ch == ']') {
if(!seenBracket) {
seenBracket = true;
} else {
seenBracketBracket = true;
//seenBracket = false;
}
} else if(ch == '>') {
if(seenBracket && seenBracketBracket) {
break; // found end sequence!!!!
} else {
seenBracketBracket = false;
}
seenBracket = false;
} else {
if(seenBracket) {
seenBracket = false;
}
}
if(normalizeInput) {
// deal with normalization issues ...
if(ch == '\r') {
normalizedCR = true;
posStart = cdStart - bufAbsoluteStart;
posEnd = pos - 1; // posEnd is alreadys set
if(!usePC) {
if(posEnd > posStart) {
joinPC();
} else {
usePC = true;
pcStart = pcEnd = 0;
}
}
//assert usePC == true;
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
} else if(ch == '\n') {
if(!normalizedCR && usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = '\n';
}
normalizedCR = false;
} else {
if(usePC) {
if(pcEnd >= pc.length) ensurePC(pcEnd);
pc[pcEnd++] = ch;
}
normalizedCR = false;
}
}
}
} catch(EOFException ex) {
// detect EOF and create meaningful error ...
throw new XmlPullParserException(
"CDATA section started on line "+curLine+" and column "+curColumn+" was not closed",
this, ex);
}
if(normalizeInput) {
if(usePC) {
pcEnd = pcEnd - 2;
}
}
posStart = cdStart - bufAbsoluteStart;
posEnd = pos - 3;
}
protected void fillBuf() throws IOException, XmlPullParserException {
if(reader == null) throw new XmlPullParserException(
"reader must be set before parsing is started");
// see if we are in compaction area
if(bufEnd > bufSoftLimit) {
// expand buffer it makes sense!!!!
boolean compact = bufStart > bufSoftLimit;
boolean expand = false;
if(preventBufferCompaction) {
compact = false;
expand = true;
} else if(!compact) {
//freeSpace
if(bufStart < buf.length / 2) {
// less then half buffer available forcompactin --> expand instead!!!
expand = true;
} else {
// at least half of buffer can be reclaimed --> worthwhile effort!!!
compact = true;
}
}
// if buffer almost full then compact it
if(compact) {
//TODO: look on trashing
// //assert bufStart > 0
System.arraycopy(buf, bufStart, buf, 0, bufEnd - bufStart);
if(TRACE_SIZING) System.out.println(
"TRACE_SIZING fillBuf() compacting "+bufStart
+" bufEnd="+bufEnd
+" pos="+pos+" posStart="+posStart+" posEnd="+posEnd
+" buf first 100 chars:"+new String(buf, bufStart,
bufEnd - bufStart < 100 ? bufEnd - bufStart : 100 ));
} else if(expand) {
final int newSize = 2 * buf.length;
final char newBuf[] = new char[ newSize ];
if(TRACE_SIZING) System.out.println("TRACE_SIZING fillBuf() "+buf.length+" => "+newSize);
System.arraycopy(buf, bufStart, newBuf, 0, bufEnd - bufStart);
buf = newBuf;
if(bufLoadFactor > 0) {
bufSoftLimit = ( bufLoadFactor * buf.length ) /100;
}
} else {
throw new XmlPullParserException("internal error in fillBuffer()");
}
bufEnd -= bufStart;
pos -= bufStart;
posStart -= bufStart;
posEnd -= bufStart;
bufAbsoluteStart += bufStart;
bufStart = 0;
if(TRACE_SIZING) System.out.println(
"TRACE_SIZING fillBuf() after bufEnd="+bufEnd
+" pos="+pos+" posStart="+posStart+" posEnd="+posEnd
+" buf first 100 chars:"+new String(buf, 0, bufEnd < 100 ? bufEnd : 100));
}
// at least one charcter must be read or error
final int len = buf.length - bufEnd > READ_CHUNK_SIZE ? READ_CHUNK_SIZE : buf.length - bufEnd;
final int ret = reader.read(buf, bufEnd, len);
if(ret > 0) {
bufEnd += ret;
if(TRACE_SIZING) System.out.println(
"TRACE_SIZING fillBuf() after filling in buffer"
+" buf first 100 chars:"+new String(buf, 0, bufEnd < 100 ? bufEnd : 100));
return;
}
if(ret == -1) {
if(bufAbsoluteStart == 0 && pos == 0) {
throw new EOFException("input contained no data");
} else {
if(seenRoot && depth == 0) { // inside parsing epilog!!!
reachedEnd = true;
return;
} else {
StringBuffer expectedTagStack = new StringBuffer();
if(depth > 0) {
//final char[] cbuf = elRawName[depth];
//final String startname = new String(cbuf, 0, elRawNameEnd[depth]);
expectedTagStack.append(" - expected end tag");
if(depth > 1) {
expectedTagStack.append("s"); //more than one end tag
}
expectedTagStack.append(" ");
for (int i = depth; i > 0; i--)
{
String tagName = new String(elRawName[i], 0, elRawNameEnd[i]);
expectedTagStack.append("');
}
expectedTagStack.append(" to close");
for (int i = depth; i > 0; i--)
{
if(i != depth) {
expectedTagStack.append(" and"); //more than one end tag
}
String tagName = new String(elRawName[i], 0, elRawNameEnd[i]);
expectedTagStack.append(" start tag <"+tagName+">");
expectedTagStack.append(" from line "+elRawNameLine[i]);
}
expectedTagStack.append(", parser stopped on");
}
throw new EOFException("no more data available"
+expectedTagStack.toString()+getPositionDescription());
}
}
} else {
throw new IOException("error reading input, returned "+ret);
}
}
protected char more() throws IOException, XmlPullParserException {
if(pos >= bufEnd) {
fillBuf();
// this return value should be ignonored as it is used in epilog parsing ...
if(reachedEnd) return (char)-1;
}
final char ch = buf[pos++];
//line/columnNumber
if(ch == '\n') { ++lineNumber; columnNumber = 1; }
else { ++columnNumber; }
//System.out.print(ch);
return ch;
}
// /**
// * This function returns position of parser in XML input stream
// * (how many characters were processed.
// * NOTE: this logical position and not byte offset as encodings
// * such as UTF8 may use more than one byte to encode one character.
// */
// public int getCurrentInputPosition() {
// return pos + bufAbsoluteStart;
// }
protected void ensurePC(int end) {
//assert end >= pc.length;
final int newSize = end > READ_CHUNK_SIZE ? 2 * end : 2 * READ_CHUNK_SIZE;
final char[] newPC = new char[ newSize ];
if(TRACE_SIZING) System.out.println("TRACE_SIZING ensurePC() "+pc.length+" ==> "+newSize+" end="+end);
System.arraycopy(pc, 0, newPC, 0, pcEnd);
pc = newPC;
//assert end < pc.length;
}
protected void joinPC() {
//assert usePC == false;
//assert posEnd > posStart;
final int len = posEnd - posStart;
final int newEnd = pcEnd + len + 1;
if(newEnd >= pc.length) ensurePC(newEnd); // add 1 for extra space for one char
//assert newEnd < pc.length;
System.arraycopy(buf, posStart, pc, pcEnd, len);
pcEnd += len;
usePC = true;
}
protected char requireInput(char ch, char[] input)
throws XmlPullParserException, IOException
{
for (int i = 0; i < input.length; i++)
{
if(ch != input[i]) {
throw new XmlPullParserException(
"expected "+printable(input[i])+" in "+new String(input)
+" and not "+printable(ch), this, null);
}
ch = more();
}
return ch;
}
protected char requireNextS()
throws XmlPullParserException, IOException
{
final char ch = more();
if(!isS(ch)) {
throw new XmlPullParserException(
"white space is required and not "+printable(ch), this, null);
}
return skipS(ch);
}
protected char skipS(char ch)
throws XmlPullParserException, IOException
{
while(isS(ch)) { ch = more(); } // skip additional spaces
return ch;
}
// nameStart / name lookup tables based on XML 1.1 http://www.w3.org/TR/2001/WD-xml11-20011213/
protected static final int LOOKUP_MAX = 0x400;
protected static final char LOOKUP_MAX_CHAR = (char)LOOKUP_MAX;
// protected static int lookupNameStartChar[] = new int[ LOOKUP_MAX_CHAR / 32 ];
// protected static int lookupNameChar[] = new int[ LOOKUP_MAX_CHAR / 32 ];
protected static boolean lookupNameStartChar[] = new boolean[ LOOKUP_MAX ];
protected static boolean lookupNameChar[] = new boolean[ LOOKUP_MAX ];
private static final void setName(char ch)
//{ lookupNameChar[ (int)ch / 32 ] |= (1 << (ch % 32)); }
{ lookupNameChar[ ch ] = true; }
private static final void setNameStart(char ch)
//{ lookupNameStartChar[ (int)ch / 32 ] |= (1 << (ch % 32)); setName(ch); }
{ lookupNameStartChar[ ch ] = true; setName(ch); }
static {
setNameStart(':');
for (char ch = 'A'; ch <= 'Z'; ++ch) setNameStart(ch);
setNameStart('_');
for (char ch = 'a'; ch <= 'z'; ++ch) setNameStart(ch);
for (char ch = '\u00c0'; ch <= '\u02FF'; ++ch) setNameStart(ch);
for (char ch = '\u0370'; ch <= '\u037d'; ++ch) setNameStart(ch);
for (char ch = '\u037f'; ch < '\u0400'; ++ch) setNameStart(ch);
setName('-');
setName('.');
for (char ch = '0'; ch <= '9'; ++ch) setName(ch);
setName('\u00b7');
for (char ch = '\u0300'; ch <= '\u036f'; ++ch) setName(ch);
}
//private final static boolean isNameStartChar(char ch) {
protected boolean isNameStartChar(char ch) {
return (ch < LOOKUP_MAX_CHAR && lookupNameStartChar[ ch ])
|| (ch >= LOOKUP_MAX_CHAR && ch <= '\u2027')
|| (ch >= '\u202A' && ch <= '\u218F')
|| (ch >= '\u2800' && ch <= '\uFFEF')
;
// if(ch < LOOKUP_MAX_CHAR) return lookupNameStartChar[ ch ];
// else return ch <= '\u2027'
// || (ch >= '\u202A' && ch <= '\u218F')
// || (ch >= '\u2800' && ch <= '\uFFEF')
// ;
//return false;
// return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == ':'
// || (ch >= '0' && ch <= '9');
// if(ch < LOOKUP_MAX_CHAR) return (lookupNameStartChar[ (int)ch / 32 ] & (1 << (ch % 32))) != 0;
// if(ch <= '\u2027') return true;
// //[#x202A-#x218F]
// if(ch < '\u202A') return false;
// if(ch <= '\u218F') return true;
// // added pairts [#x2800-#xD7FF] | [#xE000-#xFDCF] | [#xFDE0-#xFFEF] | [#x10000-#x10FFFF]
// if(ch < '\u2800') return false;
// if(ch <= '\uFFEF') return true;
// return false;
// else return (supportXml11 && ( (ch < '\u2027') || (ch > '\u2029' && ch < '\u2200') ...
}
//private final static boolean isNameChar(char ch) {
protected boolean isNameChar(char ch) {
//return isNameStartChar(ch);
// if(ch < LOOKUP_MAX_CHAR) return (lookupNameChar[ (int)ch / 32 ] & (1 << (ch % 32))) != 0;
return (ch < LOOKUP_MAX_CHAR && lookupNameChar[ ch ])
|| (ch >= LOOKUP_MAX_CHAR && ch <= '\u2027')
|| (ch >= '\u202A' && ch <= '\u218F')
|| (ch >= '\u2800' && ch <= '\uFFEF')
;
//return false;
// return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == ':'
// || (ch >= '0' && ch <= '9');
// if(ch < LOOKUP_MAX_CHAR) return (lookupNameStartChar[ (int)ch / 32 ] & (1 << (ch % 32))) != 0;
//else return
// else if(ch <= '\u2027') return true;
// //[#x202A-#x218F]
// else if(ch < '\u202A') return false;
// else if(ch <= '\u218F') return true;
// // added pairts [#x2800-#xD7FF] | [#xE000-#xFDCF] | [#xFDE0-#xFFEF] | [#x10000-#x10FFFF]
// else if(ch < '\u2800') return false;
// else if(ch <= '\uFFEF') return true;
//else return false;
}
protected boolean isS(char ch) {
return (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t');
// || (supportXml11 && (ch == '\u0085' || ch == '\u2028');
}
//protected boolean isChar(char ch) { return (ch < '\uD800' || ch > '\uDFFF')
// ch != '\u0000' ch < '\uFFFE'
//protected char printable(char ch) { return ch; }
protected String printable(char ch) {
if(ch == '\n') {
return "\\n";
} else if(ch == '\r') {
return "\\r";
} else if(ch == '\t') {
return "\\t";
} else if(ch == '\'') {
return "\\'";
} if(ch > 127 || ch < 32) {
return "\\u"+Integer.toHexString((int)ch);
}
return ""+ch;
}
protected String printable(String s) {
if(s == null) return null;
final int sLen = s.length();
StringBuffer buf = new StringBuffer(sLen + 10);
for(int i = 0; i < sLen; ++i) {
buf.append(printable(s.charAt(i)));
}
s = buf.toString();
return s;
}
//
// Imported code from ASF Harmony project rev 770909
// http://svn.apache.org/repos/asf/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/java/lang/Character.java
//
private static int toCodePoint( char high, char low )
{
// See RFC 2781, Section 2.2
// http://www.faqs.org/rfcs/rfc2781.html
int h = ( high & 0x3FF ) << 10;
int l = low & 0x3FF;
return ( h | l ) + 0x10000;
}
private static final char MIN_HIGH_SURROGATE = '\uD800';
private static final char MAX_HIGH_SURROGATE = '\uDBFF';
private static boolean isHighSurrogate( char ch )
{
return ( MIN_HIGH_SURROGATE <= ch && MAX_HIGH_SURROGATE >= ch );
}
private static final int MIN_CODE_POINT = 0x000000;
private static final int MAX_CODE_POINT = 0x10FFFF;
private static final int MIN_SUPPLEMENTARY_CODE_POINT = 0x10000;
private static boolean isValidCodePoint( int codePoint )
{
return ( MIN_CODE_POINT <= codePoint && MAX_CODE_POINT >= codePoint );
}
private static boolean isSupplementaryCodePoint( int codePoint )
{
return ( MIN_SUPPLEMENTARY_CODE_POINT <= codePoint && MAX_CODE_POINT >= codePoint );
}
/**
* TODO add javadoc
*
* @param codePoint
* @return
*/
public static char[] toChars( int codePoint )
{
if ( !isValidCodePoint( codePoint ) )
{
throw new IllegalArgumentException();
}
if ( isSupplementaryCodePoint( codePoint ) )
{
int cpPrime = codePoint - 0x10000;
int high = 0xD800 | ( ( cpPrime >> 10 ) & 0x3FF );
int low = 0xDC00 | ( cpPrime & 0x3FF );
return new char[] { (char) high, (char) low };
}
return new char[] { (char) codePoint };
}
}
/*
* Indiana University Extreme! Lab Software License, Version 1.2
*
* Copyright (C) 2003 The Trustees of Indiana University.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1) All redistributions of source code must retain the above
* copyright notice, the list of authors in the original source
* code, this list of conditions and the disclaimer listed in this
* license;
*
* 2) All redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the disclaimer
* listed in this license in the documentation and/or other
* materials provided with the distribution;
*
* 3) Any documentation included with all redistributions must include
* the following acknowledgement:
*
* "This product includes software developed by the Indiana
* University Extreme! Lab. For further information please visit
* http://www.extreme.indiana.edu/"
*
* Alternatively, this acknowledgment may appear in the software
* itself, and wherever such third-party acknowledgments normally
* appear.
*
* 4) The name "Indiana University" or "Indiana University
* Extreme! Lab" shall not be used to endorse or promote
* products derived from this software without prior written
* permission from Indiana University. For written permission,
* please contact http://www.extreme.indiana.edu/.
*
* 5) Products derived from this software may not use "Indiana
* University" name nor may "Indiana University" appear in their name,
* without prior written permission of the Indiana University.
*
* Indiana University provides no reassurances that the source code
* provided does not infringe the patent or any other intellectual
* property rights of any other entity. Indiana University disclaims any
* liability to any recipient for claims brought by any other entity
* based on infringement of intellectual property rights or otherwise.
*
* LICENSEE UNDERSTANDS THAT SOFTWARE IS PROVIDED "AS IS" FOR WHICH
* NO WARRANTIES AS TO CAPABILITIES OR ACCURACY ARE MADE. INDIANA
* UNIVERSITY GIVES NO WARRANTIES AND MAKES NO REPRESENTATION THAT
* SOFTWARE IS FREE OF INFRINGEMENT OF THIRD PARTY PATENT, COPYRIGHT, OR
* OTHER PROPRIETARY RIGHTS. INDIANA UNIVERSITY MAKES NO WARRANTIES THAT
* SOFTWARE IS FREE FROM "BUGS", "VIRUSES", "TROJAN HORSES", "TRAP
* DOORS", "WORMS", OR OTHER HARMFUL CODE. LICENSEE ASSUMES THE ENTIRE
* RISK AS TO THE PERFORMANCE OF SOFTWARE AND/OR ASSOCIATED MATERIALS,
* AND TO THE PERFORMANCE AND VALIDITY OF INFORMATION GENERATED USING
* SOFTWARE.
*/
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/pull/MXSerializer.java 0000664 0000000 0000000 00000121717 11660305702 0030577 0 ustar 00root root 0000000 0000000 /* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/
// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/)
package org.codehaus.plexus.util.xml.pull;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
/**
* Implementation of XmlSerializer interface from XmlPull V1 API.
* This implementation is optimized for performance and low memory footprint.
*
*
Implemented features:
* - FEATURE_NAMES_INTERNED - when enabled all returned names
* (namespaces, prefixes) will be interned and it is required that
* all names passed as arguments MUST be interned
*
- FEATURE_SERIALIZER_ATTVALUE_USE_APOSTROPHE
*
* Implemented properties:
* - PROPERTY_SERIALIZER_INDENTATION
*
- PROPERTY_SERIALIZER_LINE_SEPARATOR
*
*
*/
public class MXSerializer implements XmlSerializer {
protected final static String XML_URI = "http://www.w3.org/XML/1998/namespace";
protected final static String XMLNS_URI = "http://www.w3.org/2000/xmlns/";
private static final boolean TRACE_SIZING = false;
protected final String FEATURE_SERIALIZER_ATTVALUE_USE_APOSTROPHE =
"http://xmlpull.org/v1/doc/features.html#serializer-attvalue-use-apostrophe";
protected final String FEATURE_NAMES_INTERNED =
"http://xmlpull.org/v1/doc/features.html#names-interned";
protected final String PROPERTY_SERIALIZER_INDENTATION =
"http://xmlpull.org/v1/doc/properties.html#serializer-indentation";
protected final String PROPERTY_SERIALIZER_LINE_SEPARATOR =
"http://xmlpull.org/v1/doc/properties.html#serializer-line-separator";
protected final static String PROPERTY_LOCATION =
"http://xmlpull.org/v1/doc/properties.html#location";
// properties/features
protected boolean namesInterned;
protected boolean attributeUseApostrophe;
protected String indentationString = null; //" ";
protected String lineSeparator = "\n";
protected String location;
protected Writer out;
protected int autoDeclaredPrefixes;
protected int depth = 0;
// element stack
protected String elNamespace[] = new String[ 2 ];
protected String elName[] = new String[ elNamespace.length ];
protected int elNamespaceCount[] = new int[ elNamespace.length ];
//namespace stack
protected int namespaceEnd = 0;
protected String namespacePrefix[] = new String[ 8 ];
protected String namespaceUri[] = new String[ namespacePrefix.length ];
protected boolean finished;
protected boolean pastRoot;
protected boolean setPrefixCalled;
protected boolean startTagIncomplete;
protected boolean doIndent;
protected boolean seenTag;
protected boolean seenBracket;
protected boolean seenBracketBracket;
// buffer output if needed to write escaped String see text(String)
private static final int BUF_LEN = Runtime.getRuntime().freeMemory() > 1000000L ? 8*1024 : 256;
protected char buf[] = new char[ BUF_LEN ];
protected static final String precomputedPrefixes[];
static {
precomputedPrefixes = new String[32]; //arbitrary number ...
for (int i = 0; i < precomputedPrefixes.length; i++)
{
precomputedPrefixes[i] = ("n"+i).intern();
}
}
private boolean checkNamesInterned = false;
private void checkInterning(String name) {
if(namesInterned && name != name.intern()) {
throw new IllegalArgumentException(
"all names passed as arguments must be interned"
+"when NAMES INTERNED feature is enabled");
}
}
protected void reset() {
location = null;
out = null;
autoDeclaredPrefixes = 0;
depth = 0;
// nullify references on all levels to allow it to be GCed
for (int i = 0; i < elNamespaceCount.length; i++)
{
elName[ i ] = null;
elNamespace[ i ] = null;
elNamespaceCount[ i ] = 2;
}
namespaceEnd = 0;
//NOTE: no need to intern() as all literal strings and string-valued constant expressions
//are interned. String literals are defined in 3.10.5 of the Java Language Specification
// just checking ...
//assert "xmlns" == "xmlns".intern();
//assert XMLNS_URI == XMLNS_URI.intern();
//TODO: how to prevent from reporting this namespace?
// this is special namespace declared for consistency with XML infoset
namespacePrefix[ namespaceEnd ] = "xmlns";
namespaceUri[ namespaceEnd ] = XMLNS_URI;
++namespaceEnd;
namespacePrefix[ namespaceEnd ] = "xml";
namespaceUri[ namespaceEnd ] = XML_URI;
++namespaceEnd;
finished = false;
pastRoot = false;
setPrefixCalled = false;
startTagIncomplete = false;
//doIntent is not changed
seenTag = false;
seenBracket = false;
seenBracketBracket = false;
}
protected void ensureElementsCapacity() {
final int elStackSize = elName.length;
//assert (depth + 1) >= elName.length;
// we add at least one extra slot ...
final int newSize = (depth >= 7 ? 2 * depth : 8) + 2; // = lucky 7 + 1 //25
if(TRACE_SIZING) {
System.err.println(
getClass().getName()+" elStackSize "+elStackSize+" ==> "+newSize);
}
final boolean needsCopying = elStackSize > 0;
String[] arr = null;
// reuse arr local variable slot
arr = new String[newSize];
if(needsCopying) System.arraycopy(elName, 0, arr, 0, elStackSize);
elName = arr;
arr = new String[newSize];
if(needsCopying) System.arraycopy(elNamespace, 0, arr, 0, elStackSize);
elNamespace = arr;
final int[] iarr = new int[newSize];
if(needsCopying) {
System.arraycopy(elNamespaceCount, 0, iarr, 0, elStackSize);
} else {
// special initialization
iarr[0] = 0;
}
elNamespaceCount = iarr;
}
protected void ensureNamespacesCapacity() { //int size) {
//int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0;
//assert (namespaceEnd >= namespacePrefix.length);
//if(size >= namespaceSize) {
//int newSize = size > 7 ? 2 * size : 8; // = lucky 7 + 1 //25
final int newSize = namespaceEnd > 7 ? 2 * namespaceEnd : 8;
if(TRACE_SIZING) {
System.err.println(
getClass().getName()+" namespaceSize "+namespacePrefix.length+" ==> "+newSize);
}
final String[] newNamespacePrefix = new String[newSize];
final String[] newNamespaceUri = new String[newSize];
if(namespacePrefix != null) {
System.arraycopy(
namespacePrefix, 0, newNamespacePrefix, 0, namespaceEnd);
System.arraycopy(
namespaceUri, 0, newNamespaceUri, 0, namespaceEnd);
}
namespacePrefix = newNamespacePrefix;
namespaceUri = newNamespaceUri;
// TODO use hashes for quick namespace->prefix lookups
// if( ! allStringsInterned ) {
// int[] newNamespacePrefixHash = new int[newSize];
// if(namespacePrefixHash != null) {
// System.arraycopy(
// namespacePrefixHash, 0, newNamespacePrefixHash, 0, namespaceEnd);
// }
// namespacePrefixHash = newNamespacePrefixHash;
// }
//prefixesSize = newSize;
// ////assert nsPrefixes.length > size && nsPrefixes.length == newSize
//}
}
public void setFeature(String name,
boolean state) throws IllegalArgumentException, IllegalStateException
{
if(name == null) {
throw new IllegalArgumentException("feature name can not be null");
}
if(FEATURE_NAMES_INTERNED.equals(name)) {
namesInterned = state;
} else if(FEATURE_SERIALIZER_ATTVALUE_USE_APOSTROPHE.equals(name)) {
attributeUseApostrophe = state;
} else {
throw new IllegalStateException("unsupported feature "+name);
}
}
public boolean getFeature(String name) throws IllegalArgumentException
{
if(name == null) {
throw new IllegalArgumentException("feature name can not be null");
}
if(FEATURE_NAMES_INTERNED.equals(name)) {
return namesInterned;
} else if(FEATURE_SERIALIZER_ATTVALUE_USE_APOSTROPHE.equals(name)) {
return attributeUseApostrophe;
} else {
return false;
}
}
// precomputed variables to simplify writing indentation
protected int offsetNewLine;
protected int indentationJump;
protected char[] indentationBuf;
protected int maxIndentLevel;
protected boolean writeLineSepartor; //should end-of-line be written
protected boolean writeIndentation; // is indentation used?
/**
* For maximum efficiency when writing indents the required output is pre-computed
* This is internal function that recomputes buffer after user requested chnages.
*/
protected void rebuildIndentationBuf() {
if(doIndent == false) return;
final int maxIndent = 65; //hardcoded maximum indentation size in characters
int bufSize = 0;
offsetNewLine = 0;
if(writeLineSepartor) {
offsetNewLine = lineSeparator.length();
bufSize += offsetNewLine;
}
maxIndentLevel = 0;
if(writeIndentation) {
indentationJump = indentationString.length();
maxIndentLevel = maxIndent / indentationJump;
bufSize += maxIndentLevel * indentationJump;
}
if(indentationBuf == null || indentationBuf.length < bufSize) {
indentationBuf = new char[bufSize + 8];
}
int bufPos = 0;
if(writeLineSepartor) {
for (int i = 0; i < lineSeparator.length(); i++)
{
indentationBuf[ bufPos++ ] = lineSeparator.charAt(i);
}
}
if(writeIndentation) {
for (int i = 0; i < maxIndentLevel; i++)
{
for (int j = 0; j < indentationString.length(); j++)
{
indentationBuf[ bufPos++ ] = indentationString.charAt(j);
}
}
}
}
// if(doIndent) writeIndent();
protected void writeIndent() throws IOException {
final int start = writeLineSepartor ? 0 : offsetNewLine;
final int level = (depth > maxIndentLevel) ? maxIndentLevel : depth;
out.write( indentationBuf, start, (level * indentationJump) + offsetNewLine);
}
public void setProperty(String name,
Object value) throws IllegalArgumentException, IllegalStateException
{
if(name == null) {
throw new IllegalArgumentException("property name can not be null");
}
if(PROPERTY_SERIALIZER_INDENTATION.equals(name)) {
indentationString = (String)value;
} else if(PROPERTY_SERIALIZER_LINE_SEPARATOR.equals(name)) {
lineSeparator = (String)value;
} else if(PROPERTY_LOCATION.equals(name)) {
location = (String) value;
} else {
throw new IllegalStateException("unsupported property "+name);
}
writeLineSepartor = lineSeparator != null && lineSeparator.length() > 0;
writeIndentation = indentationString != null && indentationString.length() > 0;
// optimize - do not write when nothing to write ...
doIndent = indentationString != null && (writeLineSepartor || writeIndentation);
//NOTE: when indentationString == null there is no indentation
// (even though writeLineSeparator may be true ...)
rebuildIndentationBuf();
seenTag = false; // for consistency
}
public Object getProperty(String name) throws IllegalArgumentException
{
if(name == null) {
throw new IllegalArgumentException("property name can not be null");
}
if(PROPERTY_SERIALIZER_INDENTATION.equals(name)) {
return indentationString;
} else if(PROPERTY_SERIALIZER_LINE_SEPARATOR.equals(name)) {
return lineSeparator;
} else if(PROPERTY_LOCATION.equals(name)) {
return location;
} else {
return null;
}
}
private String getLocation() {
return location != null ? " @"+location : "";
}
// this is special method that can be accessed directly to retrieve Writer serializer is using
public Writer getWriter()
{
return out;
}
public void setOutput(Writer writer)
{
reset();
out = writer;
}
public void setOutput(OutputStream os, String encoding) throws IOException
{
if(os == null) throw new IllegalArgumentException("output stream can not be null");
reset();
if(encoding != null) {
out = new OutputStreamWriter(os, encoding);
} else {
out = new OutputStreamWriter(os);
}
}
public void startDocument (String encoding, Boolean standalone) throws IOException
{
char apos = attributeUseApostrophe ? '\'' : '"';
if(attributeUseApostrophe) {
out.write("");
if(writeLineSepartor) {
out.write(lineSeparator);
}
}
public void endDocument() throws IOException
{
// close all unclosed tag;
while(depth > 0) {
endTag(elNamespace[ depth ], elName[ depth ]);
}
if(writeLineSepartor) {
out.write(lineSeparator);
}
//assert depth == 0;
//assert startTagIncomplete == false;
finished = pastRoot = startTagIncomplete = true;
out.flush();
}
public void setPrefix(String prefix, String namespace) throws IOException
{
if(startTagIncomplete) closeStartTag();
//assert prefix != null;
//assert namespace != null;
if (prefix == null) {
prefix = "";
}
if(!namesInterned) {
prefix = prefix.intern(); //will throw NPE if prefix==null
} else if(checkNamesInterned) {
checkInterning(prefix);
} else if(prefix == null) {
throw new IllegalArgumentException("prefix must be not null"+getLocation());
}
//check that prefix is not duplicated ...
for (int i = elNamespaceCount[ depth ]; i < namespaceEnd; i++)
{
if(prefix == namespacePrefix[ i ]) {
throw new IllegalStateException("duplicated prefix "+printable(prefix)+getLocation());
}
}
if(!namesInterned) {
namespace = namespace.intern();
} else if(checkNamesInterned) {
checkInterning(namespace);
} else if(namespace == null) {
throw new IllegalArgumentException("namespace must be not null"+getLocation());
}
if(namespaceEnd >= namespacePrefix.length) {
ensureNamespacesCapacity();
}
namespacePrefix[ namespaceEnd ] = prefix;
namespaceUri[ namespaceEnd ] = namespace;
++namespaceEnd;
setPrefixCalled = true;
}
protected String lookupOrDeclarePrefix( String namespace ) {
return getPrefix(namespace, true);
}
public String getPrefix(String namespace, boolean generatePrefix)
{
//assert namespace != null;
if(!namesInterned) {
// when String is interned we can do much faster namespace stack lookups ...
namespace = namespace.intern();
} else if(checkNamesInterned) {
checkInterning(namespace);
//assert namespace != namespace.intern();
}
if(namespace == null) {
throw new IllegalArgumentException("namespace must be not null"+getLocation());
} else if(namespace.length() == 0) {
throw new IllegalArgumentException("default namespace cannot have prefix"+getLocation());
}
// first check if namespace is already in scope
for (int i = namespaceEnd - 1; i >= 0 ; --i)
{
if(namespace == namespaceUri[ i ]) {
final String prefix = namespacePrefix[ i ];
// now check that prefix is still in scope
for (int p = namespaceEnd - 1; p > i ; --p)
{
if(prefix == namespacePrefix[ p ])
continue; // too bad - prefix is redeclared with different namespace
}
return prefix;
}
}
// so not found it ...
if(!generatePrefix) {
return null;
}
return generatePrefix(namespace);
}
private String generatePrefix(String namespace) {
//assert namespace == namespace.intern();
while(true) {
++autoDeclaredPrefixes;
//fast lookup uses table that was pre-initialized in static{} ....
final String prefix = autoDeclaredPrefixes < precomputedPrefixes.length
? precomputedPrefixes[autoDeclaredPrefixes] : ("n"+autoDeclaredPrefixes).intern();
// make sure this prefix is not declared in any scope (avoid hiding in-scope prefixes)!
for (int i = namespaceEnd - 1; i >= 0 ; --i)
{
if(prefix == namespacePrefix[ i ]) {
continue; // prefix is already declared - generate new and try again
}
}
// declare prefix
if(namespaceEnd >= namespacePrefix.length) {
ensureNamespacesCapacity();
}
namespacePrefix[ namespaceEnd ] = prefix;
namespaceUri[ namespaceEnd ] = namespace;
++namespaceEnd;
return prefix;
}
}
public int getDepth()
{
return depth;
}
public String getNamespace ()
{
return elNamespace[depth];
}
public String getName()
{
return elName[depth];
}
public XmlSerializer startTag (String namespace, String name) throws IOException
{
if(startTagIncomplete) {
closeStartTag();
}
seenBracket = seenBracketBracket = false;
if(doIndent && depth > 0 && seenTag) {
writeIndent();
}
seenTag = true;
setPrefixCalled = false;
startTagIncomplete = true;
++depth;
if( (depth + 1) >= elName.length) {
ensureElementsCapacity();
}
////assert namespace != null;
if(checkNamesInterned && namesInterned) checkInterning(namespace);
elNamespace[ depth ] = (namesInterned || namespace == null) ? namespace : namespace.intern();
//assert name != null;
//elName[ depth ] = name;
if(checkNamesInterned && namesInterned) checkInterning(name);
elName[ depth ] = (namesInterned || name == null) ? name : name.intern();
if(out == null) {
throw new IllegalStateException("setOutput() must called set before serialization can start");
}
out.write('<');
if(namespace != null) {
if(namespace.length() > 0) {
//ALEK: in future make it as feature on serializer
String prefix = null;
if(depth > 0 && (namespaceEnd - elNamespaceCount[depth-1]) == 1) {
// if only one prefix was declared un-declare it if prefix is already declared on parent el with the same URI
String uri = namespaceUri[namespaceEnd-1];
if(uri == namespace || uri.equals(namespace)) {
String elPfx = namespacePrefix[namespaceEnd-1];
// 2 == to skip predefined namespaces (xml and xmlns ...)
for(int pos = elNamespaceCount[depth-1] - 1; pos >= 2; --pos ) {
String pf = namespacePrefix[pos];
if(pf == elPfx || pf.equals(elPfx)) {
String n = namespaceUri[pos];
if(n == uri || n.equals(uri)) {
--namespaceEnd; //un-declare namespace
prefix = elPfx;
}
break;
}
}
}
}
if(prefix == null) {
prefix = lookupOrDeclarePrefix( namespace );
}
//assert prefix != null;
// make sure that default ("") namespace to not print ":"
if(prefix.length() > 0) {
out.write(prefix);
out.write(':');
}
} else {
// make sure that default namespace can be declared
for (int i = namespaceEnd - 1; i >= 0 ; --i)
{
if(namespacePrefix[ i ] == "") {
final String uri = namespaceUri[ i ];
if(uri == null) {
// declare default namespace
setPrefix("", "");
} else if(uri.length() > 0) {
throw new IllegalStateException(
"start tag can not be written in empty default namespace "+
"as default namespace is currently bound to '"+uri+"'"+getLocation());
}
break;
}
}
}
}
out.write(name);
return this;
}
public XmlSerializer attribute (String namespace, String name,
String value) throws IOException
{
if(!startTagIncomplete) {
throw new IllegalArgumentException("startTag() must be called before attribute()"+getLocation());
}
//assert setPrefixCalled == false;
out.write(' ');
////assert namespace != null;
if(namespace != null && namespace.length() > 0) {
//namespace = namespace.intern();
if(!namesInterned) {
namespace = namespace.intern();
} else if(checkNamesInterned) {
checkInterning(namespace);
}
String prefix = lookupOrDeclarePrefix( namespace );
//assert( prefix != null);
if(prefix.length() == 0) {
// needs to declare prefix to hold default namespace
//NOTE: attributes such as a='b' are in NO namespace
prefix = generatePrefix(namespace);
}
out.write(prefix);
out.write(':');
// if(prefix.length() > 0) {
// out.write(prefix);
// out.write(':');
// }
}
//assert name != null;
out.write(name);
out.write('=');
//assert value != null;
out.write( attributeUseApostrophe ? '\'' : '"');
writeAttributeValue(value, out);
out.write( attributeUseApostrophe ? '\'' : '"');
return this;
}
protected void closeStartTag() throws IOException {
if(finished) {
throw new IllegalArgumentException("trying to write past already finished output"+getLocation());
}
if(seenBracket) {
seenBracket = seenBracketBracket = false;
}
if( startTagIncomplete || setPrefixCalled ) {
if(setPrefixCalled) {
throw new IllegalArgumentException(
"startTag() must be called immediately after setPrefix()"+getLocation());
}
if(!startTagIncomplete) {
throw new IllegalArgumentException("trying to close start tag that is not opened"+getLocation());
}
// write all namespace declarations!
writeNamespaceDeclarations();
out.write('>');
elNamespaceCount[ depth ] = namespaceEnd;
startTagIncomplete = false;
}
}
private void writeNamespaceDeclarations() throws IOException
{
//int start = elNamespaceCount[ depth - 1 ];
for (int i = elNamespaceCount[ depth - 1 ]; i < namespaceEnd; i++)
{
if(doIndent && namespaceUri[ i ].length() > 40) {
writeIndent();
out.write(" ");
}
if(namespacePrefix[ i ] != "") {
out.write(" xmlns:");
out.write(namespacePrefix[ i ]);
out.write('=');
} else {
out.write(" xmlns=");
}
out.write( attributeUseApostrophe ? '\'' : '"');
//NOTE: escaping of namespace value the same way as attributes!!!!
writeAttributeValue(namespaceUri[ i ], out);
out.write( attributeUseApostrophe ? '\'' : '"');
}
}
public XmlSerializer endTag(String namespace, String name) throws IOException
{
// check that level is valid
////assert namespace != null;
//if(namespace != null) {
// namespace = namespace.intern();
//}
seenBracket = seenBracketBracket = false;
if(namespace != null) {
if(!namesInterned) {
namespace = namespace.intern();
} else if(checkNamesInterned) {
checkInterning(namespace);
}
}
if(namespace != elNamespace[ depth ])
{
throw new IllegalArgumentException(
"expected namespace "+printable(elNamespace[ depth ])
+" and not "+printable(namespace)+getLocation());
}
if(name == null) {
throw new IllegalArgumentException("end tag name can not be null"+getLocation());
}
if(checkNamesInterned && namesInterned) {
checkInterning(name);
}
if((!namesInterned && !name.equals(elName[ depth ]))
|| (namesInterned && name != elName[ depth ]))
{
throw new IllegalArgumentException(
"expected element name "+printable(elName[ depth ])+" and not "+printable(name)+getLocation());
}
if(startTagIncomplete) {
writeNamespaceDeclarations();
out.write(" />"); //space is added to make it easier to work in XHTML!!!
--depth;
} else {
--depth;
//assert startTagIncomplete == false;
if(doIndent && seenTag) { writeIndent(); }
out.write(" 0) {
//TODO prefix should be alredy known from matching start tag ...
final String prefix = lookupOrDeclarePrefix( namespace );
//assert( prefix != null);
if(prefix.length() > 0) {
out.write(prefix);
out.write(':');
}
}
out.write(name);
out.write('>');
}
namespaceEnd = elNamespaceCount[ depth ];
startTagIncomplete = false;
seenTag = true;
return this;
}
public XmlSerializer text (String text) throws IOException
{
//assert text != null;
if(startTagIncomplete || setPrefixCalled) closeStartTag();
if(doIndent && seenTag) seenTag = false;
writeElementContent(text, out);
return this;
}
public XmlSerializer text (char [] buf, int start, int len) throws IOException
{
if(startTagIncomplete || setPrefixCalled) closeStartTag();
if(doIndent && seenTag) seenTag = false;
writeElementContent(buf, start, len, out);
return this;
}
public void cdsect (String text) throws IOException
{
if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag();
if(doIndent && seenTag) seenTag = false;
out.write("");
}
public void entityRef (String text) throws IOException
{
if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag();
if(doIndent && seenTag) seenTag = false;
out.write('&');
out.write(text); //escape?
out.write(';');
}
public void processingInstruction (String text) throws IOException
{
if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag();
if(doIndent && seenTag) seenTag = false;
out.write("");
}
public void comment (String text) throws IOException
{
if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag();
if(doIndent && seenTag) seenTag = false;
out.write("");
}
public void docdecl (String text) throws IOException
{
if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag();
if(doIndent && seenTag) seenTag = false;
out.write("");
}
public void ignorableWhitespace (String text) throws IOException
{
if(startTagIncomplete || setPrefixCalled || seenBracket) closeStartTag();
if(doIndent && seenTag) seenTag = false;
if(text.length() == 0) {
throw new IllegalArgumentException(
"empty string is not allowed for ignorable whitespace"+getLocation());
}
out.write(text); //no escape?
}
public void flush () throws IOException
{
if(!finished && startTagIncomplete) closeStartTag();
out.flush();
}
// --- utility methods
protected void writeAttributeValue(String value, Writer out) throws IOException
{
//.[apostrophe and <, & escaped],
final char quot = attributeUseApostrophe ? '\'' : '"';
final String quotEntity = attributeUseApostrophe ? "'" : """;
int pos = 0;
for (int i = 0; i < value.length(); i++)
{
char ch = value.charAt(i);
if(ch == '&') {
if(i > pos) out.write(value.substring(pos, i));
out.write("&");
pos = i + 1;
} if(ch == '<') {
if(i > pos) out.write(value.substring(pos, i));
out.write("<");
pos = i + 1;
}else if(ch == quot) {
if(i > pos) out.write(value.substring(pos, i));
out.write(quotEntity);
pos = i + 1;
} else if(ch < 32) {
//in XML 1.0 only legal character are #x9 | #xA | #xD
// and they must be escaped otherwise in attribute value they are normalized to spaces
if(ch == 13 || ch == 10 || ch == 9) {
if(i > pos) out.write(value.substring(pos, i));
out.write("&#");
out.write(Integer.toString(ch));
out.write(';');
pos = i + 1;
} else {
throw new IllegalStateException(
"character "+Integer.toString(ch)+" is not allowed in output"+getLocation());
// in XML 1.1 legal are [#x1-#xD7FF]
// if(ch > 0) {
// if(i > pos) out.write(text.substring(pos, i));
// out.write("&#");
// out.write(Integer.toString(ch));
// out.write(';');
// pos = i + 1;
// } else {
// throw new IllegalStateException(
// "character zero is not allowed in XML 1.1 output"+getLocation());
// }
}
}
}
if(pos > 0) {
out.write(value.substring(pos));
} else {
out.write(value); // this is shortcut to the most common case
}
}
protected void writeElementContent(String text, Writer out) throws IOException
{
// escape '<', '&', ']]>', <32 if necessary
int pos = 0;
for (int i = 0; i < text.length(); i++)
{
//TODO: check if doing char[] text.getChars() would be faster than getCharAt(i) ...
char ch = text.charAt(i);
if(ch == ']') {
if(seenBracket) {
seenBracketBracket = true;
} else {
seenBracket = true;
}
} else {
if(ch == '&') {
if(i > pos) out.write(text.substring(pos, i));
out.write("&");
pos = i + 1;
} else if(ch == '<') {
if(i > pos) out.write(text.substring(pos, i));
out.write("<");
pos = i + 1;
} else if(seenBracketBracket && ch == '>') {
if(i > pos) out.write(text.substring(pos, i));
out.write(">");
pos = i + 1;
} else if(ch < 32) {
//in XML 1.0 only legal character are #x9 | #xA | #xD
if( ch == 9 || ch == 10 || ch == 13) {
// pass through
// } else if(ch == 13) { //escape
// if(i > pos) out.write(text.substring(pos, i));
// out.write("&#");
// out.write(Integer.toString(ch));
// out.write(';');
// pos = i + 1;
} else {
throw new IllegalStateException(
"character "+Integer.toString(ch)+" is not allowed in output"+getLocation());
// in XML 1.1 legal are [#x1-#xD7FF]
// if(ch > 0) {
// if(i > pos) out.write(text.substring(pos, i));
// out.write("&#");
// out.write(Integer.toString(ch));
// out.write(';');
// pos = i + 1;
// } else {
// throw new IllegalStateException(
// "character zero is not allowed in XML 1.1 output"+getLocation());
// }
}
}
if(seenBracket) {
seenBracketBracket = seenBracket = false;
}
}
}
if(pos > 0) {
out.write(text.substring(pos));
} else {
out.write(text); // this is shortcut to the most common case
}
}
protected void writeElementContent(char[] buf, int off, int len, Writer out) throws IOException
{
// escape '<', '&', ']]>'
final int end = off + len;
int pos = off;
for (int i = off; i < end; i++)
{
final char ch = buf[i];
if(ch == ']') {
if(seenBracket) {
seenBracketBracket = true;
} else {
seenBracket = true;
}
} else {
if(ch == '&') {
if(i > pos) {
out.write(buf, pos, i - pos);
}
out.write("&");
pos = i + 1;
} else if(ch == '<') {
if(i > pos) {
out.write(buf, pos, i - pos);
}
out.write("<");
pos = i + 1;
} else if(seenBracketBracket && ch == '>') {
if(i > pos) {
out.write(buf, pos, i - pos);
}
out.write(">");
pos = i + 1;
} else if(ch < 32) {
//in XML 1.0 only legal character are #x9 | #xA | #xD
if( ch == 9 || ch == 10 || ch == 13) {
// pass through
// } else if(ch == 13 ) { //if(ch == '\r') {
// if(i > pos) {
// out.write(buf, pos, i - pos);
// }
// out.write("&#");
// out.write(Integer.toString(ch));
// out.write(';');
// pos = i + 1;
} else {
throw new IllegalStateException(
"character "+Integer.toString(ch)+" is not allowed in output"+getLocation());
// in XML 1.1 legal are [#x1-#xD7FF]
// if(ch > 0) {
// if(i > pos) out.write(text.substring(pos, i));
// out.write("&#");
// out.write(Integer.toString(ch));
// out.write(';');
// pos = i + 1;
// } else {
// throw new IllegalStateException(
// "character zero is not allowed in XML 1.1 output"+getLocation());
// }
}
}
if(seenBracket) {
seenBracketBracket = seenBracket = false;
}
// assert seenBracketBracket == seenBracket == false;
}
}
if(end > pos) {
out.write(buf, pos, end - pos);
}
}
/** simple utility method -- good for debugging */
protected static final String printable(String s) {
if(s == null) return "null";
StringBuffer retval = new StringBuffer(s.length() + 16);
retval.append("'");
char ch;
for (int i = 0; i < s.length(); i++) {
addPrintable(retval, s.charAt(i));
}
retval.append("'");
return retval.toString();
}
protected static final String printable(char ch) {
StringBuffer retval = new StringBuffer();
addPrintable(retval, ch);
return retval.toString();
}
private static void addPrintable(StringBuffer retval, char ch)
{
switch (ch)
{
case '\b':
retval.append("\\b");
break;
case '\t':
retval.append("\\t");
break;
case '\n':
retval.append("\\n");
break;
case '\f':
retval.append("\\f");
break;
case '\r':
retval.append("\\r");
break;
case '\"':
retval.append("\\\"");
break;
case '\'':
retval.append("\\\'");
break;
case '\\':
retval.append("\\\\");
break;
default:
if (ch < 0x20 || ch > 0x7e) {
final String ss = "0000" + Integer.toString(ch, 16);
retval.append("\\u" + ss.substring(ss.length() - 4, ss.length()));
} else {
retval.append(ch);
}
}
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParser.java 0000664 0000000 0000000 00000127730 11660305702 0030774 0 ustar 00root root 0000000 0000000 /* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/
// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/)
package org.codehaus.plexus.util.xml.pull;
import java.io.InputStream;
import java.io.IOException;
import java.io.Reader;
/**
* XML Pull Parser is an interface that defines parsing functionality provided
* in XMLPULL V1 API (visit this website to
* learn more about API and its implementations).
*
* There are following different
* kinds of parser depending on which features are set:
* - non-validating parser as defined in XML 1.0 spec when
* FEATURE_PROCESS_DOCDECL is set to true
*
- validating parser as defined in XML 1.0 spec when
* FEATURE_VALIDATION is true (and that implies that FEATURE_PROCESS_DOCDECL is true)
*
- when FEATURE_PROCESS_DOCDECL is false (this is default and
* if different value is required necessary must be changed before parsing is started)
* then parser behaves like XML 1.0 compliant non-validating parser under condition that
* no DOCDECL is present in XML documents
* (internal entities can still be defined with defineEntityReplacementText()).
* This mode of operation is intended for operation in constrained environments such as J2ME.
*
*
*
* There are two key methods: next() and nextToken(). While next() provides
* access to high level parsing events, nextToken() allows access to lower
* level tokens.
*
*
The current event state of the parser
* can be determined by calling the
* getEventType() method.
* Initially, the parser is in the START_DOCUMENT
* state.
*
*
The method next() advances the parser to the
* next event. The int value returned from next determines the current parser
* state and is identical to the value returned from following calls to
* getEventType ().
*
*
The following event types are seen by next()
* - START_TAG
- An XML start tag was read.
*
- TEXT
- Text content was read;
* the text content can be retrieved using the getText() method.
* (when in validating mode next() will not report ignorable whitespaces, use nextToken() instead)
*
- END_TAG
- An end tag was read
*
- END_DOCUMENT
- No more events are available
*
*
* after first next() or nextToken() (or any other next*() method)
* is called user application can obtain
* XML version, standalone and encoding from XML declaration
* in following ways:
* - version:
* getProperty("http://xmlpull.org/v1/doc/properties.html#xmldecl-version")
* returns String ("1.0") or null if XMLDecl was not read or if property is not supported
*
- standalone:
* getProperty("http://xmlpull.org/v1/doc/features.html#xmldecl-standalone")
* returns Boolean: null if there was no standalone declaration
* or if property is not supported
* otherwise returns Boolean(true) if standalone="yes" and Boolean(false) when standalone="no"
*
- encoding: obtained from getInputEncoding()
* null if stream had unknown encoding (not set in setInputStream)
* and it was not declared in XMLDecl
*
*
* A minimal example for using this API may look as follows:
*
* import java.io.IOException;
* import java.io.StringReader;
*
* import org.xmlpull.v1.XmlPullParser;
* import org.xmlpull.v1.XmlPullParserException.html;
* import org.xmlpull.v1.XmlPullParserFactory;
*
* public class SimpleXmlPullApp
* {
*
* public static void main (String args[])
* throws XmlPullParserException, IOException
* {
* XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
* factory.setNamespaceAware(true);
* XmlPullParser xpp = factory.newPullParser();
*
* xpp.setInput( new StringReader ( "<foo>Hello World!</foo>" ) );
* int eventType = xpp.getEventType();
* while (eventType != xpp.END_DOCUMENT) {
* if(eventType == xpp.START_DOCUMENT) {
* System.out.println("Start document");
* } else if(eventType == xpp.END_DOCUMENT) {
* System.out.println("End document");
* } else if(eventType == xpp.START_TAG) {
* System.out.println("Start tag "+xpp.getName());
* } else if(eventType == xpp.END_TAG) {
* System.out.println("End tag "+xpp.getName());
* } else if(eventType == xpp.TEXT) {
* System.out.println("Text "+xpp.getText());
* }
* eventType = xpp.next();
* }
* }
* }
*
*
* The above example will generate the following output:
*
* Start document
* Start tag foo
* Text Hello World!
* End tag foo
*
*
* For more details on API usage, please refer to the
* quick Introduction available at http://www.xmlpull.org
*
* @see #defineEntityReplacementText
* @see #getName
* @see #getNamespace
* @see #getText
* @see #next
* @see #nextToken
* @see #setInput
* @see #FEATURE_PROCESS_DOCDECL
* @see #FEATURE_VALIDATION
* @see #START_DOCUMENT
* @see #START_TAG
* @see #TEXT
* @see #END_TAG
* @see #END_DOCUMENT
*
* @author Stefan Haustein
* @author Aleksander Slominski
*/
public interface XmlPullParser {
/** This constant represents the default namespace (empty string "") */
String NO_NAMESPACE = "";
// ----------------------------------------------------------------------------
// EVENT TYPES as reported by next()
/**
* Signalize that parser is at the very beginning of the document
* and nothing was read yet.
* This event type can only be observed by calling getEvent()
* before the first call to next(), nextToken, or nextTag()).
*
* @see #next
* @see #nextToken
*/
int START_DOCUMENT = 0;
/**
* Logical end of the xml document. Returned from getEventType, next()
* and nextToken()
* when the end of the input document has been reached.
*
NOTE: calling again
* next() or nextToken()
* will result in exception being thrown.
*
* @see #next
* @see #nextToken
*/
int END_DOCUMENT = 1;
/**
* Returned from getEventType(),
* next(), nextToken() when
* a start tag was read.
* The name of start tag is available from getName(), its namespace and prefix are
* available from getNamespace() and getPrefix()
* if namespaces are enabled.
* See getAttribute* methods to retrieve element attributes.
* See getNamespace* methods to retrieve newly declared namespaces.
*
* @see #next
* @see #nextToken
* @see #getName
* @see #getPrefix
* @see #getNamespace
* @see #getAttributeCount
* @see #getDepth
* @see #getNamespaceCount
* @see #getNamespace
* @see #FEATURE_PROCESS_NAMESPACES
*/
int START_TAG = 2;
/**
* Returned from getEventType(), next(), or
* nextToken() when an end tag was read.
* The name of start tag is available from getName(), its
* namespace and prefix are
* available from getNamespace() and getPrefix().
*
* @see #next
* @see #nextToken
* @see #getName
* @see #getPrefix
* @see #getNamespace
* @see #FEATURE_PROCESS_NAMESPACES
*/
int END_TAG = 3;
/**
* Character data was read and will is available by calling getText().
*
Please note: next() will
* accumulate multiple
* events into one TEXT event, skipping IGNORABLE_WHITESPACE,
* PROCESSING_INSTRUCTION and COMMENT events,
* In contrast, nextToken() will stop reading
* text when any other event is observed.
* Also, when the state was reached by calling next(), the text value will
* be normalized, whereas getText() will
* return unnormalized content in the case of nextToken(). This allows
* an exact roundtrip without changing line ends when examining low
* level events, whereas for high level applications the text is
* normalized appropriately.
*
* @see #next
* @see #nextToken
* @see #getText
*/
int TEXT = 4;
// ----------------------------------------------------------------------------
// additional events exposed by lower level nextToken()
/**
* A CDATA sections was just read;
* this token is available only from calls to nextToken().
* A call to next() will accumulate various text events into a single event
* of type TEXT. The text contained in the CDATA section is available
* by calling getText().
*
* @see #nextToken
* @see #getText
*/
int CDSECT = 5;
/**
* An entity reference was just read;
* this token is available from nextToken()
* only. The entity name is available by calling getName(). If available,
* the replacement text can be obtained by calling getTextt(); otherwise,
* the user is responsible for resolving the entity reference.
* This event type is never returned from next(); next() will
* accumulate the replacement text and other text
* events to a single TEXT event.
*
* @see #nextToken
* @see #getText
*/
int ENTITY_REF = 6;
/**
* Ignorable whitespace was just read.
* This token is available only from nextToken()).
* For non-validating
* parsers, this event is only reported by nextToken() when outside
* the root element.
* Validating parsers may be able to detect ignorable whitespace at
* other locations.
* The ignorable whitespace string is available by calling getText()
*
*
NOTE: this is different from calling the
* isWhitespace() method, since text content
* may be whitespace but not ignorable.
*
* Ignorable whitespace is skipped by next() automatically; this event
* type is never returned from next().
*
* @see #nextToken
* @see #getText
*/
int IGNORABLE_WHITESPACE = 7;
/**
* An XML processing instruction declaration was just read. This
* event type is available only via nextToken().
* getText() will return text that is inside the processing instruction.
* Calls to next() will skip processing instructions automatically.
* @see #nextToken
* @see #getText
*/
int PROCESSING_INSTRUCTION = 8;
/**
* An XML comment was just read. This event type is this token is
* available via nextToken() only;
* calls to next() will skip comments automatically.
* The content of the comment can be accessed using the getText()
* method.
*
* @see #nextToken
* @see #getText
*/
int COMMENT = 9;
/**
* An XML document type declaration was just read. This token is
* available from nextToken() only.
* The unparsed text inside the doctype is available via
* the getText() method.
*
* @see #nextToken
* @see #getText
*/
int DOCDECL = 10;
/**
* This array can be used to convert the event type integer constants
* such as START_TAG or TEXT to
* to a string. For example, the value of TYPES[START_TAG] is
* the string "START_TAG".
*
* This array is intended for diagnostic output only. Relying
* on the contents of the array may be dangerous since malicious
* applications may alter the array, although it is final, due
* to limitations of the Java language.
*/
String [] TYPES = {
"START_DOCUMENT",
"END_DOCUMENT",
"START_TAG",
"END_TAG",
"TEXT",
"CDSECT",
"ENTITY_REF",
"IGNORABLE_WHITESPACE",
"PROCESSING_INSTRUCTION",
"COMMENT",
"DOCDECL"
};
// ----------------------------------------------------------------------------
// namespace related features
/**
* This feature determines whether the parser processes
* namespaces. As for all features, the default value is false.
*
NOTE: The value can not be changed during
* parsing an must be set before parsing.
*
* @see #getFeature
* @see #setFeature
*/
String FEATURE_PROCESS_NAMESPACES =
"http://xmlpull.org/v1/doc/features.html#process-namespaces";
/**
* This feature determines whether namespace attributes are
* exposed via the attribute access methods. Like all features,
* the default value is false. This feature cannot be changed
* during parsing.
*
* @see #getFeature
* @see #setFeature
*/
String FEATURE_REPORT_NAMESPACE_ATTRIBUTES =
"http://xmlpull.org/v1/doc/features.html#report-namespace-prefixes";
/**
* This feature determines whether the document declaration
* is processed. If set to false,
* the DOCDECL event type is reported by nextToken()
* and ignored by next().
*
* If this featue is activated, then the document declaration
* must be processed by the parser.
*
*
Please note: If the document type declaration
* was ignored, entity references may cause exceptions
* later in the parsing process.
* The default value of this feature is false. It cannot be changed
* during parsing.
*
* @see #getFeature
* @see #setFeature
*/
String FEATURE_PROCESS_DOCDECL =
"http://xmlpull.org/v1/doc/features.html#process-docdecl";
/**
* If this feature is activated, all validation errors as
* defined in the XML 1.0 sepcification are reported.
* This implies that FEATURE_PROCESS_DOCDECL is true and both, the
* internal and external document type declaration will be processed.
*
Please Note: This feature can not be changed
* during parsing. The default value is false.
*
* @see #getFeature
* @see #setFeature
*/
String FEATURE_VALIDATION =
"http://xmlpull.org/v1/doc/features.html#validation";
/**
* Use this call to change the general behaviour of the parser,
* such as namespace processing or doctype declaration handling.
* This method must be called before the first call to next or
* nextToken. Otherwise, an exception is thrown.
*
Example: call setFeature(FEATURE_PROCESS_NAMESPACES, true) in order
* to switch on namespace processing. The initial settings correspond
* to the properties requested from the XML Pull Parser factory.
* If none were requested, all feautures are deactivated by default.
*
* @exception XmlPullParserException If the feature is not supported or can not be set
* @exception IllegalArgumentException If string with the feature name is null
*/
void setFeature(String name,
boolean state) throws XmlPullParserException;
/**
* Returns the current value of the given feature.
*
Please note: unknown features are
* always returned as false.
*
* @param name The name of feature to be retrieved.
* @return The value of the feature.
* @exception IllegalArgumentException if string the feature name is null
*/
boolean getFeature(String name);
/**
* Set the value of a property.
*
* The property name is any fully-qualified URI.
*
* @exception XmlPullParserException If the property is not supported or can not be set
* @exception IllegalArgumentException If string with the property name is null
*/
void setProperty(String name,
Object value) throws XmlPullParserException;
/**
* Look up the value of a property.
*
* The property name is any fully-qualified URI.
*
NOTE: unknown properties are always
* returned as null.
*
* @param name The name of property to be retrieved.
* @return The value of named property.
*/
Object getProperty(String name);
/**
* Set the input source for parser to the given reader and
* resets the parser. The event type is set to the initial value
* START_DOCUMENT.
* Setting the reader to null will just stop parsing and
* reset parser state,
* allowing the parser to free internal resources
* such as parsing buffers.
*/
void setInput(Reader in) throws XmlPullParserException;
/**
* Sets the input stream the parser is going to process.
* This call resets the parser state and sets the event type
* to the initial value START_DOCUMENT.
*
*
NOTE: If an input encoding string is passed,
* it MUST be used. Otherwise,
* if inputEncoding is null, the parser SHOULD try to determine
* input encoding following XML 1.0 specification (see below).
* If encoding detection is supported then following feature
* http://xmlpull.org/v1/doc/features.html#detect-encoding
* MUST be true amd otherwise it must be false
*
* @param inputStream contains a raw byte input stream of possibly
* unknown encoding (when inputEncoding is null).
*
* @param inputEncoding if not null it MUST be used as encoding for inputStream
*/
void setInput(InputStream inputStream, String inputEncoding)
throws XmlPullParserException;
/**
* Returns the input encoding if known, null otherwise.
* If setInput(InputStream, inputEncoding) was called with an inputEncoding
* value other than null, this value must be returned
* from this method. Otherwise, if inputEncoding is null and
* the parser suppports the encoding detection feature
* (http://xmlpull.org/v1/doc/features.html#detect-encoding),
* it must return the detected encoding.
* If setInput(Reader) was called, null is returned.
* After first call to next if XML declaration was present this method
* will return encoding declared.
*/
String getInputEncoding();
/**
* Set new value for entity replacement text as defined in
* XML 1.0 Section 4.5
* Construction of Internal Entity Replacement Text.
* If FEATURE_PROCESS_DOCDECL or FEATURE_VALIDATION are set, calling this
* function will result in an exception -- when processing of DOCDECL is
* enabled, there is no need to the entity replacement text manually.
*
*
The motivation for this function is to allow very small
* implementations of XMLPULL that will work in J2ME environments.
* Though these implementations may not be able to process the document type
* declaration, they still can work with known DTDs by using this function.
*
*
Please notes: The given value is used literally as replacement text
* and it corresponds to declaring entity in DTD that has all special characters
* escaped: left angle bracket is replaced with <, ampersnad with &
* and so on.
*
*
Note: The given value is the literal replacement text and must not
* contain any other entity reference (if it contains any entity reference
* there will be no further replacement).
*
*
Note: The list of pre-defined entity names will
* always contain standard XML entities such as
* amp (&), lt (<), gt (>), quot ("), and apos (').
* Those cannot be redefined by this method!
*
* @see #setInput
* @see #FEATURE_PROCESS_DOCDECL
* @see #FEATURE_VALIDATION
*/
void defineEntityReplacementText( String entityName,
String replacementText ) throws XmlPullParserException;
/**
* Returns the numbers of elements in the namespace stack for the given
* depth.
* If namespaces are not enabled, 0 is returned.
*
*
NOTE: when parser is on END_TAG then it is allowed to call
* this function with getDepth()+1 argument to retrieve position of namespace
* prefixes and URIs that were declared on corresponding START_TAG.
*
NOTE: to retrieve lsit of namespaces declared in current element:
* XmlPullParser pp = ...
* int nsStart = pp.getNamespaceCount(pp.getDepth()-1);
* int nsEnd = pp.getNamespaceCount(pp.getDepth());
* for (int i = nsStart; i < nsEnd; i++) {
* String prefix = pp.getNamespacePrefix(i);
* String ns = pp.getNamespaceUri(i);
* // ...
* }
*
*
* @see #getNamespacePrefix
* @see #getNamespaceUri
* @see #getNamespace()
* @see #getNamespace(String)
*/
int getNamespaceCount(int depth) throws XmlPullParserException;
/**
* Returns the namespace prefixe for the given position
* in the namespace stack.
* Default namespace declaration (xmlns='...') will have null as prefix.
* If the given index is out of range, an exception is thrown.
* Please note: when the parser is on an END_TAG,
* namespace prefixes that were declared
* in the corresponding START_TAG are still accessible
* although they are no longer in scope.
*/
String getNamespacePrefix(int pos) throws XmlPullParserException;
/**
* Returns the namespace URI for the given position in the
* namespace stack
* If the position is out of range, an exception is thrown.
*
NOTE: when parser is on END_TAG then namespace prefixes that were declared
* in corresponding START_TAG are still accessible even though they are not in scope
*/
String getNamespaceUri(int pos) throws XmlPullParserException;
/**
* Returns the URI corresponding to the given prefix,
* depending on current state of the parser.
*
*
If the prefix was not declared in the current scope,
* null is returned. The default namespace is included
* in the namespace table and is available via
* getNamespace (null).
*
*
This method is a convenience method for
*
*
* for (int i = getNamespaceCount(getDepth ())-1; i >= 0; i--) {
* if (getNamespacePrefix(i).equals( prefix )) {
* return getNamespaceUri(i);
* }
* }
* return null;
*
*
* Please note: parser implementations
* may provide more efifcient lookup, e.g. using a Hashtable.
* The 'xml' prefix is bound to "http://www.w3.org/XML/1998/namespace", as
* defined in the
* Namespaces in XML
* specification. Analogous, the 'xmlns' prefix is resolved to
* http://www.w3.org/2000/xmlns/
*
* @see #getNamespaceCount
* @see #getNamespacePrefix
* @see #getNamespaceUri
*/
String getNamespace (String prefix);
// --------------------------------------------------------------------------
// miscellaneous reporting methods
/**
* Returns the current depth of the element.
* Outside the root element, the depth is 0. The
* depth is incremented by 1 when a start tag is reached.
* The depth is decremented AFTER the end tag
* event was observed.
*
*
* <!-- outside --> 0
* <root> 1
* sometext 1
* <foobar> 2
* </foobar> 2
* </root> 1
* <!-- outside --> 0
*
*/
int getDepth();
/**
* Returns a short text describing the current parser state, including
* the position, a
* description of the current event and the data source if known.
* This method is especially useful to provide meaningful
* error messages and for debugging purposes.
*/
String getPositionDescription ();
/**
* Returns the current line number, starting from 1.
* When the parser does not know the current line number
* or can not determine it, -1 is returned (e.g. for WBXML).
*
* @return current line number or -1 if unknown.
*/
int getLineNumber();
/**
* Returns the current column number, starting from 0.
* When the parser does not know the current column number
* or can not determine it, -1 is returned (e.g. for WBXML).
*
* @return current column number or -1 if unknown.
*/
int getColumnNumber();
// --------------------------------------------------------------------------
// TEXT related methods
/**
* Checks whether the current TEXT event contains only whitespace
* characters.
* For IGNORABLE_WHITESPACE, this is always true.
* For TEXT and CDSECT, false is returned when the current event text
* contains at least one non-white space character. For any other
* event type an exception is thrown.
*
* Please note: non-validating parsers are not
* able to distinguish whitespace and ignorable whitespace,
* except from whitespace outside the root element. Ignorable
* whitespace is reported as separate event, which is exposed
* via nextToken only.
*
*/
boolean isWhitespace() throws XmlPullParserException;
/**
* Returns the text content of the current event as String.
* The value returned depends on current event type,
* for example for TEXT event it is element content
* (this is typical case when next() is used).
*
* See description of nextToken() for detailed description of
* possible returned values for different types of events.
*
*
NOTE: in case of ENTITY_REF, this method returns
* the entity replacement text (or null if not available). This is
* the only case where
* getText() and getTextCharacters() return different values.
*
* @see #getEventType
* @see #next
* @see #nextToken
*/
String getText ();
/**
* Returns the buffer that contains the text of the current event,
* as well as the start offset and length relevant for the current
* event. See getText(), next() and nextToken() for description of possible returned values.
*
*
Please note: this buffer must not
* be modified and its content MAY change after a call to
* next() or nextToken(). This method will always return the
* same value as getText(), except for ENTITY_REF. In the case
* of ENTITY ref, getText() returns the replacement text and
* this method returns the actual input buffer containing the
* entity name.
* If getText() returns null, this method returns null as well and
* the values returned in the holder array MUST be -1 (both start
* and length).
*
* @see #getText
* @see #next
* @see #nextToken
*
* @param holderForStartAndLength Must hold an 2-element int array
* into which the start offset and length values will be written.
* @return char buffer that contains the text of the current event
* (null if the current event has no text associated).
*/
char[] getTextCharacters(int [] holderForStartAndLength);
// --------------------------------------------------------------------------
// START_TAG / END_TAG shared methods
/**
* Returns the namespace URI of the current element.
* The default namespace is represented
* as empty string.
* If namespaces are not enabled, an empty String ("") is always returned.
* The current event must be START_TAG or END_TAG; otherwise,
* null is returned.
*/
String getNamespace ();
/**
* For START_TAG or END_TAG events, the (local) name of the current
* element is returned when namespaces are enabled. When namespace
* processing is disabled, the raw name is returned.
* For ENTITY_REF events, the entity name is returned.
* If the current event is not START_TAG, END_TAG, or ENTITY_REF,
* null is returned.
*
Please note: To reconstruct the raw element name
* when namespaces are enabled and the prefix is not null,
* you will need to add the prefix and a colon to localName..
*
*/
String getName();
/**
* Returns the prefix of the current element.
* If the element is in the default namespace (has no prefix),
* null is returned.
* If namespaces are not enabled, or the current event
* is not START_TAG or END_TAG, null is returned.
*/
String getPrefix();
/**
* Returns true if the current event is START_TAG and the tag
* is degenerated
* (e.g. <foobar/>).
*
NOTE: if the parser is not on START_TAG, an exception
* will be thrown.
*/
boolean isEmptyElementTag() throws XmlPullParserException;
// --------------------------------------------------------------------------
// START_TAG Attributes retrieval methods
/**
* Returns the number of attributes of the current start tag, or
* -1 if the current event type is not START_TAG
*
* @see #getAttributeNamespace
* @see #getAttributeName
* @see #getAttributePrefix
* @see #getAttributeValue
*/
int getAttributeCount();
/**
* Returns the namespace URI of the attribute
* with the given index (starts from 0).
* Returns an empty string ("") if namespaces are not enabled
* or the attribute has no namespace.
* Throws an IndexOutOfBoundsException if the index is out of range
* or the current event type is not START_TAG.
*
*
NOTE: if FEATURE_REPORT_NAMESPACE_ATTRIBUTES is set
* then namespace attributes (xmlns:ns='...') must be reported
* with namespace
* http://www.w3.org/2000/xmlns/
* (visit this URL for description!).
* The default namespace attribute (xmlns="...") will be reported with empty namespace.
*
NOTE:The xml prefix is bound as defined in
* Namespaces in XML
* specification to "http://www.w3.org/XML/1998/namespace".
*
* @param index zero based index of attribute
* @return attribute namespace,
* empty string ("") is returned if namesapces processing is not enabled or
* namespaces processing is enabled but attribute has no namespace (it has no prefix).
*/
String getAttributeNamespace (int index);
/**
* Returns the local name of the specified attribute
* if namespaces are enabled or just attribute name if namespaces are disabled.
* Throws an IndexOutOfBoundsException if the index is out of range
* or current event type is not START_TAG.
*
* @param index zero based index of attribute
* @return attribute name (null is never returned)
*/
String getAttributeName (int index);
/**
* Returns the prefix of the specified attribute
* Returns null if the element has no prefix.
* If namespaces are disabled it will always return null.
* Throws an IndexOutOfBoundsException if the index is out of range
* or current event type is not START_TAG.
*
* @param index zero based index of attribute
* @return attribute prefix or null if namespaces processing is not enabled.
*/
String getAttributePrefix(int index);
/**
* Returns the type of the specified attribute
* If parser is non-validating it MUST return CDATA.
*
* @param index zero based index of attribute
* @return attribute type (null is never returned)
*/
String getAttributeType(int index);
/**
* Returns if the specified attribute was not in input was declared in XML.
* If parser is non-validating it MUST always return false.
* This information is part of XML infoset:
*
* @param index zero based index of attribute
* @return false if attribute was in input
*/
boolean isAttributeDefault(int index);
/**
* Returns the given attributes value.
* Throws an IndexOutOfBoundsException if the index is out of range
* or current event type is not START_TAG.
*
*
NOTE: attribute value must be normalized
* (including entity replacement text if PROCESS_DOCDECL is false) as described in
* XML 1.0 section
* 3.3.3 Attribute-Value Normalization
*
* @see #defineEntityReplacementText
*
* @param index zero based index of attribute
* @return value of attribute (null is never returned)
*/
String getAttributeValue(int index);
/**
* Returns the attributes value identified by namespace URI and namespace localName.
* If namespaces are disabled namespace must be null.
* If current event type is not START_TAG then IndexOutOfBoundsException will be thrown.
*
*
NOTE: attribute value must be normalized
* (including entity replacement text if PROCESS_DOCDECL is false) as described in
* XML 1.0 section
* 3.3.3 Attribute-Value Normalization
*
* @see #defineEntityReplacementText
*
* @param namespace Namespace of the attribute if namespaces are enabled otherwise must be null
* @param name If namespaces enabled local name of attribute otherwise just attribute name
* @return value of attribute or null if attribute with given name does not exist
*/
String getAttributeValue(String namespace,
String name);
// --------------------------------------------------------------------------
// actual parsing methods
/**
* Returns the type of the current event (START_TAG, END_TAG, TEXT, etc.)
*
* @see #next()
* @see #nextToken()
*/
int getEventType()
throws XmlPullParserException;
/**
* Get next parsing event - element content wil be coalesced and only one
* TEXT event must be returned for whole element content
* (comments and processing instructions will be ignored and emtity references
* must be expanded or exception mus be thrown if entity reerence can not be exapnded).
* If element content is empty (content is "") then no TEXT event will be reported.
*
*
NOTE: empty element (such as <tag/>) will be reported
* with two separate events: START_TAG, END_TAG - it must be so to preserve
* parsing equivalency of empty element to <tag></tag>.
* (see isEmptyElementTag ())
*
* @see #isEmptyElementTag
* @see #START_TAG
* @see #TEXT
* @see #END_TAG
* @see #END_DOCUMENT
*/
int next()
throws XmlPullParserException, IOException;
/**
* This method works similarly to next() but will expose
* additional event types (COMMENT, CDSECT, DOCDECL, ENTITY_REF, PROCESSING_INSTRUCTION, or
* IGNORABLE_WHITESPACE) if they are available in input.
*
*
If special feature
* FEATURE_XML_ROUNDTRIP
* (identified by URI: http://xmlpull.org/v1/doc/features.html#xml-roundtrip)
* is enabled it is possible to do XML document round trip ie. reproduce
* exectly on output the XML input using getText():
* returned content is always unnormalized (exactly as in input).
* Otherwise returned content is end-of-line normalized as described
* XML 1.0 End-of-Line Handling
* and. Also when this feature is enabled exact content of START_TAG, END_TAG,
* DOCDECL and PROCESSING_INSTRUCTION is available.
*
*
Here is the list of tokens that can be returned from nextToken()
* and what getText() and getTextCharacters() returns:
* - START_DOCUMENT
- null
*
- END_DOCUMENT
- null
*
- START_TAG
- null unless FEATURE_XML_ROUNDTRIP
* enabled and then returns XML tag, ex: <tag attr='val'>
*
- END_TAG
- null unless FEATURE_XML_ROUNDTRIP
* id enabled and then returns XML tag, ex: </tag>
*
- TEXT
- return element content.
*
Note: that element content may be delivered in multiple consecutive TEXT events.
* - IGNORABLE_WHITESPACE
- return characters that are determined to be ignorable white
* space. If the FEATURE_XML_ROUNDTRIP is enabled all whitespace content outside root
* element will always reported as IGNORABLE_WHITESPACE otherise rteporting is optional.
*
Note: that element content may be delevered in multiple consecutive IGNORABLE_WHITESPACE events.
* - CDSECT
-
* return text inside CDATA
* (ex. 'fo<o' from <!CDATA[fo<o]]>)
*
- PROCESSING_INSTRUCTION
-
* if FEATURE_XML_ROUNDTRIP is true
* return exact PI content ex: 'pi foo' from <?pi foo?>
* otherwise it may be exact PI content or concatenation of PI target,
* space and data so for example for
* <?target data?> string "target data" may
* be returned if FEATURE_XML_ROUNDTRIP is false.
*
- COMMENT
- return comment content ex. 'foo bar' from <!--foo bar-->
*
- ENTITY_REF
- getText() MUST return entity replacement text if PROCESS_DOCDECL is false
* otherwise getText() MAY return null,
* additionally getTextCharacters() MUST return entity name
* (for example 'entity_name' for &entity_name;).
*
NOTE: this is the only place where value returned from getText() and
* getTextCharacters() are different
*
NOTE: it is user responsibility to resolve entity reference
* if PROCESS_DOCDECL is false and there is no entity replacement text set in
* defineEntityReplacementText() method (getText() will be null)
*
NOTE: character entities (ex.  ) and standard entities such as
* & < > " ' are reported as well
* and are not reported as TEXT tokens but as ENTITY_REF tokens!
* This requirement is added to allow to do roundtrip of XML documents!
* - DOCDECL
-
* if FEATURE_XML_ROUNDTRIP is true or PROCESS_DOCDECL is false
* then return what is inside of DOCDECL for example it returns:
* " titlepage SYSTEM "http://www.foo.bar/dtds/typo.dtd"
* [<!ENTITY % active.links "INCLUDE">]"
* for input document that contained:
* <!DOCTYPE titlepage SYSTEM "http://www.foo.bar/dtds/typo.dtd"
* [<!ENTITY % active.links "INCLUDE">]>
* otherwise if FEATURE_XML_ROUNDTRIP is false and PROCESS_DOCDECL is true
* then what is returned is undefined (it may be even null)
*
*
*
* NOTE: there is no gurantee that there will only one TEXT or
* IGNORABLE_WHITESPACE event from nextToken() as parser may chose to deliver element content in
* multiple tokens (dividing element content into chunks)
*
*
NOTE: whether returned text of token is end-of-line normalized
* is depending on FEATURE_XML_ROUNDTRIP.
*
*
NOTE: XMLDecl (<?xml ...?>) is not reported but its content
* is available through optional properties (see class description above).
*
* @see #next
* @see #START_TAG
* @see #TEXT
* @see #END_TAG
* @see #END_DOCUMENT
* @see #COMMENT
* @see #DOCDECL
* @see #PROCESSING_INSTRUCTION
* @see #ENTITY_REF
* @see #IGNORABLE_WHITESPACE
*/
int nextToken()
throws XmlPullParserException, IOException;
//-----------------------------------------------------------------------------
// utility methods to mak XML parsing easier ...
/**
* Test if the current event is of the given type and if the
* namespace and name do match. null will match any namespace
* and any name. If the test is not passed, an exception is
* thrown. The exception text indicates the parser position,
* the expected event and the current event that is not meeting the
* requirement.
*
*
Essentially it does this
*
* if (type != getEventType()
* || (namespace != null && !namespace.equals( getNamespace () ) )
* || (name != null && !name.equals( getName() ) ) )
* throw new XmlPullParserException( "expected "+ TYPES[ type ]+getPositionDescription());
*
*/
void require(int type, String namespace, String name)
throws XmlPullParserException, IOException;
/**
* If current event is START_TAG then if next element is TEXT then element content is returned
* or if next event is END_TAG then empty string is returned, otherwise exception is thrown.
* After calling this function successfully parser will be positioned on END_TAG.
*
* The motivation for this function is to allow to parse consistently both
* empty elements and elements that has non empty content, for example for input:
* - <tag>foo</tag>
*
- <tag></tag> (which is equivalent to <tag/>
* both input can be parsed with the same code:
*
* p.nextTag()
* p.requireEvent(p.START_TAG, "", "tag");
* String content = p.nextText();
* p.requireEvent(p.END_TAG, "", "tag");
*
* This function together with nextTag make it very easy to parse XML that has
* no mixed content.
*
*
* Essentially it does this
*
* if(getEventType() != START_TAG) {
* throw new XmlPullParserException(
* "parser must be on START_TAG to read next text", this, null);
* }
* int eventType = next();
* if(eventType == TEXT) {
* String result = getText();
* eventType = next();
* if(eventType != END_TAG) {
* throw new XmlPullParserException(
* "event TEXT it must be immediately followed by END_TAG", this, null);
* }
* return result;
* } else if(eventType == END_TAG) {
* return "";
* } else {
* throw new XmlPullParserException(
* "parser must be on START_TAG or TEXT to read text", this, null);
* }
*
*/
String nextText() throws XmlPullParserException, IOException;
/**
* Call next() and return event if it is START_TAG or END_TAG
* otherwise throw an exception.
* It will skip whitespace TEXT before actual tag if any.
*
* essentially it does this
*
* int eventType = next();
* if(eventType == TEXT && isWhitespace()) { // skip whitespace
* eventType = next();
* }
* if (eventType != START_TAG && eventType != END_TAG) {
* throw new XmlPullParserException("expected start or end tag", this, null);
* }
* return eventType;
*
*/
int nextTag() throws XmlPullParserException, IOException;
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/pull/XmlPullParserException.java 0000664 0000000 0000000 00000004357 11660305702 0032652 0 ustar 00root root 0000000 0000000 /* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/
// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/)
package org.codehaus.plexus.util.xml.pull;
/**
* This exception is thrown to signal XML Pull Parser related faults.
*
* @author Aleksander Slominski
*/
public class XmlPullParserException extends Exception {
protected Throwable detail;
protected int row = -1;
protected int column = -1;
/* public XmlPullParserException() {
}*/
public XmlPullParserException(String s) {
super(s);
}
/*
public XmlPullParserException(String s, Throwable thrwble) {
super(s);
this.detail = thrwble;
}
public XmlPullParserException(String s, int row, int column) {
super(s);
this.row = row;
this.column = column;
}
*/
public XmlPullParserException(String msg, XmlPullParser parser, Throwable chain) {
super ((msg == null ? "" : msg+" ")
+ (parser == null ? "" : "(position:"+parser.getPositionDescription()+") ")
+ (chain == null ? "" : "caused by: "+chain));
if (parser != null) {
this.row = parser.getLineNumber();
this.column = parser.getColumnNumber();
}
this.detail = chain;
}
public Throwable getDetail() { return detail; }
// public void setDetail(Throwable cause) { this.detail = cause; }
public int getLineNumber() { return row; }
public int getColumnNumber() { return column; }
/*
public String getMessage() {
if(detail == null)
return super.getMessage();
else
return super.getMessage() + "; nested exception is: \n\t"
+ detail.getMessage();
}
*/
//NOTE: code that prints this and detail is difficult in J2ME
public void printStackTrace() {
if (detail == null) {
super.printStackTrace();
} else {
synchronized(System.err) {
System.err.println(super.getMessage() + "; nested exception is:");
detail.printStackTrace();
}
}
}
}
plexus-utils2-2.0.5/src/main/java/org/codehaus/plexus/util/xml/pull/XmlSerializer.java 0000664 0000000 0000000 00000035255 11660305702 0031014 0 ustar 00root root 0000000 0000000 /* -*- c-basic-offset: 4; indent-tabs-mode: nil; -*- //------100-columns-wide------>|*/
// for license please see accompanying LICENSE.txt file (available also at http://www.xmlpull.org/)
package org.codehaus.plexus.util.xml.pull;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;
/**
* Define an interface to serialization of XML Infoset.
* This interface abstracts away if serialized XML is XML 1.0 compatible text or
* other formats of XML 1.0 serializations (such as binary XML for example with WBXML).
*
* PLEASE NOTE: This interface will be part of XmlPull 1.2 API.
* It is included as basis for discussion. It may change in any way.
*
*
Exceptions that may be thrown are: IOException or runtime exception
* (more runtime exceptions can be thrown but are not declared and as such
* have no semantics defined for this interface):
*
* - IllegalArgumentException - for almost all methods to signal that
* argument is illegal
*
- IllegalStateException - to signal that call has good arguments but
* is not expected here (violation of contract) and for features/properties
* when requesting setting unimplemented feature/property
* (UnsupportedOperationException would be better but it is not in MIDP)
*
*
* NOTE: writing CDSECT, ENTITY_REF, IGNORABLE_WHITESPACE,
* PROCESSING_INSTRUCTION, COMMENT, and DOCDECL in some implementations
* may not be supported (for example when serializing to WBXML).
* In such case IllegalStateException will be thrown and it is recommended
* to use an optional feature to signal that implementation is not
* supporting this kind of output.
*/
public interface XmlSerializer {
/**
* Set feature identified by name (recommended to be URI for uniqueness).
* Some well known optional features are defined in
*
* http://www.xmlpull.org/v1/doc/features.html.
*
* If feature is not recognized or can not be set
* then IllegalStateException MUST be thrown.
*
* @exception IllegalStateException If the feature is not supported or can not be set
*/
void setFeature(String name,
boolean state)
throws IllegalArgumentException, IllegalStateException;
/**
* Return the current value of the feature with given name.
*
NOTE: unknown properties are always returned as null
*
* @param name The name of feature to be retrieved.
* @return The value of named feature.
* @exception IllegalArgumentException if feature string is null
*/
boolean getFeature(String name);
/**
* Set the value of a property.
* (the property name is recommended to be URI for uniqueness).
* Some well known optional properties are defined in
*
* http://www.xmlpull.org/v1/doc/properties.html.
*
* If property is not recognized or can not be set
* then IllegalStateException MUST be thrown.
*
* @exception IllegalStateException if the property is not supported or can not be set
*/
void setProperty(String name,
Object value)
throws IllegalArgumentException, IllegalStateException;
/**
* Look up the value of a property.
*
* The property name is any fully-qualified URI. I
*
NOTE: unknown properties are always returned as null
*
* @param name The name of property to be retrieved.
* @return The value of named property.
*/
Object getProperty(String name);
/**
* Set to use binary output stream with given encoding.
*/
void setOutput (OutputStream os, String encoding)
throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Set the output to the given writer.
* WARNING no information about encoding is available!
*/
void setOutput (Writer writer)
throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Write <?xml declaration with encoding (if encoding not null)
* and standalone flag (if standalone not null)
* This method can only be called just after setOutput.
*/
void startDocument (String encoding, Boolean standalone)
throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Finish writing. All unclosed start tags will be closed and output
* will be flushed. After calling this method no more output can be
* serialized until next call to setOutput()
*/
void endDocument ()
throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Binds the given prefix to the given namespace.
* This call is valid for the next element including child elements.
* The prefix and namespace MUST be always declared even if prefix
* is not used in element (startTag() or attribute()) - for XML 1.0
* it must result in declaring xmlns:prefix='namespace'
* (or xmlns:prefix="namespace" depending what character is used
* to quote attribute value).
*
*
NOTE: this method MUST be called directly before startTag()
* and if anything but startTag() or setPrefix() is called next there will be exception.
*
NOTE: prefixes "xml" and "xmlns" are already bound
* and can not be redefined see:
* Namespaces in XML Errata.
*
NOTE: to set default namespace use as prefix empty string.
*
* @param prefix must be not null (or IllegalArgumentException is thrown)
* @param namespace must be not null
*/
void setPrefix (String prefix, String namespace)
throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Return namespace that corresponds to given prefix
* If there is no prefix bound to this namespace return null
* but if generatePrefix is false then return generated prefix.
*
*
NOTE: if the prefix is empty string "" and default namespace is bound
* to this prefix then empty string ("") is returned.
*
*
NOTE: prefixes "xml" and "xmlns" are already bound
* will have values as defined
* Namespaces in XML specification
*/
String getPrefix (String namespace, boolean generatePrefix)
throws IllegalArgumentException;
/**
* Returns the current depth of the element.
* Outside the root element, the depth is 0. The
* depth is incremented by 1 when startTag() is called.
* The depth is decremented after the call to endTag()
* event was observed.
*
*
* <!-- outside --> 0
* <root> 1
* sometext 1
* <foobar> 2
* </foobar> 2
* </root> 1
* <!-- outside --> 0
*
*/
int getDepth();
/**
* Returns the namespace URI of the current element as set by startTag().
*
* NOTE: that means in particular that:
* - if there was startTag("", ...) then getNamespace() returns ""
*
- if there was startTag(null, ...) then getNamespace() returns null
*
*
* @return namespace set by startTag() that is currently in scope
*/
String getNamespace ();
/**
* Returns the name of the current element as set by startTag().
* It can only be null before first call to startTag()
* or when last endTag() is called to close first startTag().
*
* @return namespace set by startTag() that is currently in scope
*/
String getName();
/**
* Writes a start tag with the given namespace and name.
* If there is no prefix defined for the given namespace,
* a prefix will be defined automatically.
* The explicit prefixes for namespaces can be established by calling setPrefix()
* immediately before this method.
* If namespace is null no namespace prefix is printed but just name.
* If namespace is empty string then serializer will make sure that
* default empty namespace is declared (in XML 1.0 xmlns='')
* or throw IllegalStateException if default namespace is already bound
* to non-empty string.
*/
XmlSerializer startTag (String namespace, String name)
throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Write an attribute. Calls to attribute() MUST follow a call to
* startTag() immediately. If there is no prefix defined for the
* given namespace, a prefix will be defined automatically.
* If namespace is null or empty string
* no namespace prefix is printed but just name.
*/
XmlSerializer attribute (String namespace, String name, String value)
throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Write end tag. Repetition of namespace and name is just for avoiding errors.
* Background: in kXML endTag had no arguments, and non matching tags were
* very difficult to find...
* If namespace is null no namespace prefix is printed but just name.
* If namespace is empty string then serializer will make sure that
* default empty namespace is declared (in XML 1.0 xmlns='').
*/
XmlSerializer endTag (String namespace, String name)
throws IOException, IllegalArgumentException, IllegalStateException;
// /**
// * Writes a start tag with the given namespace and name.
// *
If there is no prefix defined (prefix == null) for the given namespace,
// * a prefix will be defined automatically.
// *
If explicit prefixes is passed (prefix != null) then it will be used
// *and namespace declared if not already declared or
// * throw IllegalStateException the same prefix was already set on this
// * element (setPrefix()) and was bound to different namespace.
// *
If namespace is null then prefix must be null too or IllegalStateException is thrown.
// *
If namespace is null then no namespace prefix is printed but just name.
// *
If namespace is empty string then serializer will make sure that
// * default empty namespace is declared (in XML 1.0 xmlns='')
// * or throw IllegalStateException if default namespace is already bound
// * to non-empty string.
// */
// XmlSerializer startTag (String prefix, String namespace, String name)
// throws IOException, IllegalArgumentException, IllegalStateException;
//
// /**
// * Write an attribute. Calls to attribute() MUST follow a call to
// * startTag() immediately.
// *
If there is no prefix defined (prefix == null) for the given namespace,
// * a prefix will be defined automatically.
// *
If explicit prefixes is passed (prefix != null) then it will be used
// * and namespace declared if not already declared or
// * throw IllegalStateException the same prefix was already set on this
// * element (setPrefix()) and was bound to different namespace.
// *
If namespace is null then prefix must be null too or IllegalStateException is thrown.
// *
If namespace is null then no namespace prefix is printed but just name.
// *
If namespace is empty string then serializer will make sure that
// * default empty namespace is declared (in XML 1.0 xmlns='')
// * or throw IllegalStateException if default namespace is already bound
// * to non-empty string.
// */
// XmlSerializer attribute (String prefix, String namespace, String name, String value)
// throws IOException, IllegalArgumentException, IllegalStateException;
//
// /**
// * Write end tag. Repetition of namespace, prefix, and name is just for avoiding errors.
// *
If namespace or name arguments are different from corresponding startTag call
// * then IllegalArgumentException is thrown, if prefix argument is not null and is different
// * from corresponding starTag then IllegalArgumentException is thrown.
// *
If namespace is null then prefix must be null too or IllegalStateException is thrown.
// *
If namespace is null then no namespace prefix is printed but just name.
// *
If namespace is empty string then serializer will make sure that
// * default empty namespace is declared (in XML 1.0 xmlns='').
// *
Background: in kXML endTag had no arguments, and non matching tags were
// * very difficult to find...
// */
// ALEK: This is really optional as prefix in end tag MUST correspond to start tag but good for error checking
// XmlSerializer endTag (String prefix, String namespace, String name)
// throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Writes text, where special XML chars are escaped automatically
*/
XmlSerializer text (String text)
throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Writes text, where special XML chars are escaped automatically
*/
XmlSerializer text (char [] buf, int start, int len)
throws IOException, IllegalArgumentException, IllegalStateException;
void cdsect (String text)
throws IOException, IllegalArgumentException, IllegalStateException;
void entityRef (String text) throws IOException,
IllegalArgumentException, IllegalStateException;
void processingInstruction (String text)
throws IOException, IllegalArgumentException, IllegalStateException;
void comment (String text)
throws IOException, IllegalArgumentException, IllegalStateException;
void docdecl (String text)
throws IOException, IllegalArgumentException, IllegalStateException;
void ignorableWhitespace (String text)
throws IOException, IllegalArgumentException, IllegalStateException;
/**
* Write all pending output to the stream.
* If method startTag() or attribute() was called then start tag is closed (final >)
* before flush() is called on underlying output stream.
*
* NOTE: if there is need to close start tag
* (so no more attribute() calls are allowed) but without flushing output
* call method text() with empty string (text("")).
*
*/
void flush ()
throws IOException;
}
plexus-utils2-2.0.5/src/main/javadoc/ 0000775 0000000 0000000 00000000000 11660305702 0017400 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/ 0000775 0000000 0000000 00000000000 11660305702 0020167 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/ 0000775 0000000 0000000 00000000000 11660305702 0021762 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 11660305702 0023302 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/ 0000775 0000000 0000000 00000000000 11660305702 0024257 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/cli/ 0000775 0000000 0000000 00000000000 11660305702 0025026 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/cli/package.html 0000664 0000000 0000000 00000000046 11660305702 0027307 0 ustar 00root root 0000000 0000000
Command-line utilities.
plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/cli/shell/ 0000775 0000000 0000000 00000000000 11660305702 0026135 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/cli/shell/package.html 0000664 0000000 0000000 00000000037 11660305702 0030416 0 ustar 00root root 0000000 0000000
Shell utilities.
plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/dag/ 0000775 0000000 0000000 00000000000 11660305702 0025012 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/dag/package.html 0000664 0000000 0000000 00000000060 11660305702 0027267 0 ustar 00root root 0000000 0000000
Directed Acyclic Graph utilities.
plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/interpolation/ 0000775 0000000 0000000 00000000000 11660305702 0027146 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/interpolation/package.html 0000664 0000000 0000000 00000000047 11660305702 0031430 0 ustar 00root root 0000000 0000000
Interpolation utilities.
plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/introspection/ 0000775 0000000 0000000 00000000000 11660305702 0027157 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/introspection/package.html 0000664 0000000 0000000 00000000047 11660305702 0031441 0 ustar 00root root 0000000 0000000
Introspection utilities.
plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/package.html 0000664 0000000 0000000 00000000037 11660305702 0026540 0 ustar 00root root 0000000 0000000
Misc. utilities.
plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/reflection/ 0000775 0000000 0000000 00000000000 11660305702 0026411 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/reflection/package.html 0000664 0000000 0000000 00000000044 11660305702 0030670 0 ustar 00root root 0000000 0000000
Reflection utilities.
plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/xml/ 0000775 0000000 0000000 00000000000 11660305702 0025057 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/xml/package.html 0000664 0000000 0000000 00000000035 11660305702 0027336 0 ustar 00root root 0000000 0000000
XML utilities.
plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/xml/pull/ 0000775 0000000 0000000 00000000000 11660305702 0026033 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/javadoc/org/codehaus/plexus/util/xml/pull/package.html 0000664 0000000 0000000 00000000454 11660305702 0030317 0 ustar 00root root 0000000 0000000
XML Pull Parser interface and implementation.
XML Pull Parser is an interface that defines parsing functionlity provided
in XMLPULL V1 API (visit this website to
learn more about API and its implementations).
plexus-utils2-2.0.5/src/main/resources/ 0000775 0000000 0000000 00000000000 11660305702 0020003 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/resources/META-INF/ 0000775 0000000 0000000 00000000000 11660305702 0021143 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/resources/META-INF/LICENSE 0000664 0000000 0000000 00000026136 11660305702 0022160 0 ustar 00root root 0000000 0000000
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed 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
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
limitations under the License.
plexus-utils2-2.0.5/src/main/resources/META-INF/NOTICE 0000664 0000000 0000000 00000000732 11660305702 0022051 0 ustar 00root root 0000000 0000000 This product includes software developed by the Indiana University
Extreme! Lab (http://www.extreme.indiana.edu/).
This product includes software developed by
The Apache Software Foundation (http://www.apache.org/).
This product includes software developed by
ThoughtWorks (http://www.thoughtworks.com).
This product includes software developed by
javolution (http://javolution.org/).
This product includes software developed by
Rome (https://rome.dev.java.net/). plexus-utils2-2.0.5/src/main/resources/licenses/ 0000775 0000000 0000000 00000000000 11660305702 0021610 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/main/resources/licenses/extreme.indiana.edu.license.TXT 0000664 0000000 0000000 00000004220 11660305702 0027457 0 ustar 00root root 0000000 0000000 Indiana University Extreme! Lab Software License
Version 1.1.1
Copyright (c) 2002 Extreme! Lab, Indiana University. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the distribution.
3. The end-user documentation included with the redistribution, if any,
must include the following acknowledgment:
"This product includes software developed by the Indiana University
Extreme! Lab (http://www.extreme.indiana.edu/)."
Alternately, this acknowledgment may appear in the software itself,
if and wherever such third-party acknowledgments normally appear.
4. The names "Indiana Univeristy" and "Indiana Univeristy Extreme! Lab"
must not be used to endorse or promote products derived from this
software without prior written permission. For written permission,
please contact http://www.extreme.indiana.edu/.
5. Products derived from this software may not use "Indiana Univeristy"
name nor may "Indiana Univeristy" appear in their name, without prior
written permission of the Indiana University.
THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHORS, COPYRIGHT HOLDERS OR ITS CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
plexus-utils2-2.0.5/src/main/resources/licenses/javolution.license.TXT 0000664 0000000 0000000 00000002600 11660305702 0026022 0 ustar 00root root 0000000 0000000 Javolution - Java(TM) Solution for Real-Time and Embedded Systems
Copyright (c) 2006, Javolution (http://javolution.org)
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
plexus-utils2-2.0.5/src/main/resources/licenses/thoughtworks.TXT 0000664 0000000 0000000 00000003572 11660305702 0024770 0 ustar 00root root 0000000 0000000
/********************************************************************************
* CruiseControl, a Continuous Integration Toolkit
* Copyright (c) 2001-2003, ThoughtWorks, Inc.
* 651 W Washington Ave. Suite 500
* Chicago, IL 60661 USA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* + Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* + Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* + Neither the name of ThoughtWorks, Inc., CruiseControl, nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************/ plexus-utils2-2.0.5/src/site/ 0000775 0000000 0000000 00000000000 11660305702 0016011 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/site/site.xml 0000664 0000000 0000000 00000000403 11660305702 0017474 0 ustar 00root root 0000000 0000000
plexus-utils2-2.0.5/src/test/ 0000775 0000000 0000000 00000000000 11660305702 0016024 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/ 0000775 0000000 0000000 00000000000 11660305702 0016745 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/ 0000775 0000000 0000000 00000000000 11660305702 0017534 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/ 0000775 0000000 0000000 00000000000 11660305702 0021327 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/ 0000775 0000000 0000000 00000000000 11660305702 0022647 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/ 0000775 0000000 0000000 00000000000 11660305702 0023624 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/AbstractTestThread.java 0000664 0000000 0000000 00000013605 11660305702 0030227 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
/**
* A thread which is registered with a ThreadRegistry and notifies it when it has completed
* running. Collects any errors and makes it available for analysis.
*
* Created on 1/07/2003
*
* @author Bert van Brakel
* @version $Revision: 8010 $
*/
public abstract class AbstractTestThread implements Runnable
{
//~ Instance fields ----------------------------------------------------------------------------
private String name;
public static final boolean DEBUG = true;
private boolean isRunning = false;
/** Error msg provided by implementing class (of why the test failed) */
private String errorMsg = null;
/** The registry to notify on completion */
private TestThreadManager registry;
/** The error thrown when running the test. Not neccesarily a test failuer as some tests
* may test for an exception */
private Throwable error;
/** If the thread has been run */
private boolean hasRun = false;
/** Flag indicating if the test has passed. Some test might require an
* exception so using the error to determine if the test has passed is
* not sufficient.
*/
private boolean passed = false;
//~ Constructors -------------------------------------------------------------------------------
/**
* Constructor
*
* Remember to call setThreadRegistry(ThreadRegistry)
*/
public AbstractTestThread()
{
super();
}
public AbstractTestThread( TestThreadManager registry )
{
super();
setThreadRegistry( registry );
}
//~ Methods ------------------------------------------------------------------------------------
/**
* @return
*/
public Throwable getError()
{
return error;
}
/**
* Resets the test back to it's state before starting. If the test
* is currently running this method will block until the test has
* finished running. Subclasses should call this method if
* overriding it.
*
* */
public void reset()
{
//shouldn't reset until the test has finished running
synchronized ( this )
{
while ( isRunning )
{
try
{
wait();
}
catch ( InterruptedException e )
{
}
}
errorMsg = null;
error = null;
hasRun = false;
passed = false;
}
}
/**
* Start this TestThread running. If the test is currently running then
* this method does nothing.
*
*/
public final void start()
{
//shouldn't have multiple threads running this test at the same time
synchronized ( this )
{
if ( isRunning == false )
{
isRunning = true;
Thread t = new Thread( this );
t.start();
}
}
}
/**
* @return
*/
public String getErrorMsg()
{
return errorMsg;
}
/**
* @return
*/
public boolean hasFailed()
{
return !passed;
}
/**
* DOCUMENT ME!
*
* @return DOCUMENT ME!
*/
public boolean hasPassed()
{
return passed;
}
/**
* Don't override this. Calls doRun()
*
* @see java.lang.Runnable#run()
*/
public final void run()
{
if ( registry == null )
{
throw new IllegalArgumentException( "The ThreadRegistry is null. Ensure this is set before running this thread" );
}
passed = false;
try
{
doRun();
}
catch ( Throwable t )
{
error = t;
}
registry.completed( this );
hasRun = true;
isRunning = false;
//notify objects with blocked methods which are waiting
//on this test to complete running
synchronized ( this )
{
notifyAll();
}
}
/**
* Override this to run your custom test
*
* @throws Throwable
*/
public abstract void doRun() throws Throwable;
/**
* Set the registry this thread should notify when it has completed running
*
* @param registry
*/
public void setThreadRegistry( TestThreadManager registry )
{
this.registry = registry;
}
/**
* Test if the test has run
*
* @return
*/
public boolean hasRun()
{
return hasRun;
}
/**
* @param throwable
*/
public void setError( Throwable throwable )
{
error = throwable;
}
/**
* @param string
*/
public void setErrorMsg( String string )
{
errorMsg = string;
}
/**
* @param b
*/
public void setPassed( boolean b )
{
passed = b;
}
/**
* @return
*/
public String getName()
{
return name;
}
/**
* @param string
*/
public void setName( String string )
{
name = string;
}
private final void debug( String msg )
{
if ( DEBUG )
{
System.out.println( this + ":" + msg );
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/CollectionUtilsTest.java 0000664 0000000 0000000 00000016551 11660305702 0030453 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import junit.framework.TestCase;
public class CollectionUtilsTest
extends TestCase
{
public void testMergeMaps()
{
Map dominantMap = new HashMap();
dominantMap.put( "a", "a" );
dominantMap.put( "b", "b" );
dominantMap.put( "c", "c" );
dominantMap.put( "d", "d" );
dominantMap.put( "e", "e" );
dominantMap.put( "f", "f" );
Map recessiveMap = new HashMap();
recessiveMap.put( "a", "invalid" );
recessiveMap.put( "b", "invalid" );
recessiveMap.put( "c", "invalid" );
recessiveMap.put( "x", "x" );
recessiveMap.put( "y", "y" );
recessiveMap.put( "z", "z" );
Map result = CollectionUtils.mergeMaps( dominantMap, recessiveMap );
// We should have 9 elements
assertEquals( 9, result.keySet().size() );
// Check the elements.
assertEquals( "a", result.get( "a" ) );
assertEquals( "b", result.get( "b" ) );
assertEquals( "c", result.get( "c" ) );
assertEquals( "d", result.get( "d" ) );
assertEquals( "e", result.get( "e" ) );
assertEquals( "f", result.get( "f" ) );
assertEquals( "x", result.get( "x" ) );
assertEquals( "y", result.get( "y" ) );
assertEquals( "z", result.get( "z" ) );
}
public void testMergeMapArray()
{
// Test empty array of Maps
Map result0 = CollectionUtils.mergeMaps( new Map[]
{
} );
assertNull( result0 );
// Test with an array with a single element.
Map map1 = new HashMap();
map1.put( "a", "a" );
Map result1 = CollectionUtils.mergeMaps( new Map[]
{
map1
} );
assertEquals( "a", result1.get( "a" ) );
// Test with an array with two elements.
Map map2 = new HashMap();
map2.put( "a", "aa" );
map2.put( "b", "bb" );
Map result2 = CollectionUtils.mergeMaps( new Map[]
{
map1,
map2
} );
assertEquals( "a", result2.get( "a" ) );
assertEquals( "bb", result2.get( "b" ) );
// Now swap the dominant order.
Map result3 = CollectionUtils.mergeMaps( new Map[]
{
map2,
map1
} );
assertEquals( "aa", result3.get( "a" ) );
assertEquals( "bb", result3.get( "b" ) );
// Test with an array with three elements.
Map map3 = new HashMap();
map3.put( "a", "aaa" );
map3.put( "b", "bbb" );
map3.put( "c", "ccc" );
Map result4 = CollectionUtils.mergeMaps( new Map[]
{
map1,
map2,
map3
} );
assertEquals( "a", result4.get( "a" ) );
assertEquals( "bb", result4.get( "b" ) );
assertEquals( "ccc", result4.get( "c" ) );
// Now swap the dominant order.
Map result5 = CollectionUtils.mergeMaps( new Map[]
{
map3,
map2,
map1
} );
assertEquals( "aaa", result5.get( "a" ) );
assertEquals( "bbb", result5.get( "b" ) );
assertEquals( "ccc", result5.get( "c" ) );
}
public void testMavenPropertiesLoading()
{
// Mimic MavenSession properties loading. Properties listed
// in dominant order.
Properties systemProperties = new Properties();
Properties userBuildProperties = new Properties();
Properties projectBuildProperties = new Properties();
Properties projectProperties = new Properties();
Properties driverProperties = new Properties();
// System properties
systemProperties.setProperty( "maven.home", "/projects/maven" );
// User build properties
userBuildProperties.setProperty( "maven.username", "jvanzyl" );
userBuildProperties.setProperty( "maven.repo.remote.enabled", "false" );
userBuildProperties.setProperty( "maven.repo.local", "/opt/maven/artifact" );
// Project build properties
projectBuildProperties.setProperty( "maven.final.name", "maven" );
String mavenRepoRemote = "http://www.ibiblio.org/maven,http://foo/bar";
// Project properties
projectProperties.setProperty( "maven.repo.remote", mavenRepoRemote );
String basedir = "/home/jvanzyl/projects/maven";
// Driver properties
driverProperties.setProperty( "basedir", basedir );
driverProperties.setProperty( "maven.build.src", "${basedir}/src" );
driverProperties.setProperty( "maven.build.dir", "${basedir}/target" );
driverProperties.setProperty( "maven.build.dest", "${maven.build.dir}/classes" );
driverProperties.setProperty( "maven.repo.remote", "http://www.ibiblio.org/maven" );
driverProperties.setProperty( "maven.final.name", "maven-1.0" );
driverProperties.setProperty( "maven.repo.remote.enabled", "true" );
driverProperties.setProperty( "maven.repo.local", "${maven.home}/artifact" );
Map result = CollectionUtils.mergeMaps( new Map[]
{
systemProperties,
userBuildProperties,
projectBuildProperties,
projectProperties,
driverProperties
} );
// Values that should be taken from systemProperties.
assertEquals( "/projects/maven", (String) result.get( "maven.home" ) );
// Values that should be taken from userBuildProperties.
assertEquals( "/opt/maven/artifact", (String) result.get( "maven.repo.local" ) );
assertEquals( "false", (String) result.get( "maven.repo.remote.enabled" ) );
assertEquals( "jvanzyl", (String) result.get( "maven.username" ) );
// Values take from projectBuildProperties.
assertEquals( "maven", (String) result.get( "maven.final.name" ) );
// Values take from projectProperties.
assertEquals( mavenRepoRemote, (String) result.get( "maven.repo.remote" ) );
}
public void testIteratorToListWithAPopulatedList()
{
List original = new ArrayList();
original.add( "en" );
original.add( "to" );
original.add( "tre" );
List copy = CollectionUtils.iteratorToList( original.iterator() );
assertNotNull( copy );
assertEquals( 3, copy.size() );
assertEquals( "en", copy.get( 0 ) );
assertEquals( "to", copy.get( 1 ) );
assertEquals( "tre", copy.get( 2 ) );
}
public void testIteratorToListWithAEmptyList()
{
List original = new ArrayList();
List copy = CollectionUtils.iteratorToList( original.iterator() );
assertNotNull( copy );
assertEquals( 0, copy.size() );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/DirectoryScannerTest.java 0000664 0000000 0000000 00000034376 11660305702 0030622 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* Base class for testcases doing tests with files.
*
* @author Dan T. Tran
*/
public class DirectoryScannerTest
extends FileBasedTestCase
{
private static String testDir = getTestDirectory().getPath();
public void testCrossPlatformIncludesString()
throws IOException, URISyntaxException
{
DirectoryScanner ds = new DirectoryScanner();
ds.setBasedir( new File( getTestResourcesDir() + File.separator + "directory-scanner" ).getCanonicalFile() );
String fs;
if ( File.separatorChar == '/' )
{
fs = "\\";
}
else
{
fs = "/";
}
ds.setIncludes( new String[] { "foo" + fs } );
ds.addDefaultExcludes();
ds.scan();
String[] files = ds.getIncludedFiles();
assertEquals( 1, files.length );
}
public void testCrossPlatformExcludesString()
throws IOException, URISyntaxException
{
DirectoryScanner ds = new DirectoryScanner();
ds.setBasedir( new File( getTestResourcesDir() + File.separator + "directory-scanner" ).getCanonicalFile() );
ds.setIncludes( new String[] { "**" } );
String fs;
if ( File.separatorChar == '/' )
{
fs = "\\";
}
else
{
fs = "/";
}
ds.setExcludes( new String[] { "foo" + fs } );
ds.addDefaultExcludes();
ds.scan();
String[] files = ds.getIncludedFiles();
assertEquals( 0, files.length );
}
private String getTestResourcesDir()
throws URISyntaxException
{
ClassLoader cloader = Thread.currentThread().getContextClassLoader();
URL resource = cloader.getResource( "test.txt" );
if ( resource == null )
{
fail( "Cannot locate test-resources directory containing 'test.txt' in the classloader." );
}
File file = new File( new URI( resource.toExternalForm() ).normalize().getPath() );
return file.getParent();
}
private void createTestFiles()
throws IOException
{
FileUtils.mkdir( testDir );
this.createFile( new File( testDir + "/scanner1.dat" ), 0 );
this.createFile( new File( testDir + "/scanner2.dat" ), 0 );
this.createFile( new File( testDir + "/scanner3.dat" ), 0 );
this.createFile( new File( testDir + "/scanner4.dat" ), 0 );
this.createFile( new File( testDir + "/scanner5.dat" ), 0 );
}
public void testGeneral()
throws IOException
{
this.createTestFiles();
String includes = "scanner1.dat,scanner2.dat,scanner3.dat,scanner4.dat,scanner5.dat";
String excludes = "scanner1.dat,scanner2.dat";
List fileNames = FileUtils.getFiles( new File( testDir ), includes, excludes, false );
assertEquals( "Wrong number of results.", 3, fileNames.size() );
assertTrue( "3 not found.", fileNames.contains( new File( "scanner3.dat" ) ) );
assertTrue( "4 not found.", fileNames.contains( new File( "scanner4.dat" ) ) );
assertTrue( "5 not found.", fileNames.contains( new File( "scanner5.dat" ) ) );
}
public void testIncludesExcludesWithWhiteSpaces()
throws IOException
{
this.createTestFiles();
String includes = "scanner1.dat,\n \n,scanner2.dat \n\r, scanner3.dat\n, \tscanner4.dat,scanner5.dat\n,";
String excludes = "scanner1.dat,\n \n,scanner2.dat \n\r,,";
List fileNames = FileUtils.getFiles( new File( testDir ), includes, excludes, false );
assertEquals( "Wrong number of results.", 3, fileNames.size() );
assertTrue( "3 not found.", fileNames.contains( new File( "scanner3.dat" ) ) );
assertTrue( "4 not found.", fileNames.contains( new File( "scanner4.dat" ) ) );
assertTrue( "5 not found.", fileNames.contains( new File( "scanner5.dat" ) ) );
}
private void createTestDirectories()
throws IOException
{
FileUtils.mkdir( testDir + File.separator + "directoryTest" );
FileUtils.mkdir( testDir + File.separator + "directoryTest" + File.separator + "testDir123" );
FileUtils.mkdir( testDir + File.separator + "directoryTest" + File.separator + "test_dir_123" );
FileUtils.mkdir( testDir + File.separator + "directoryTest" + File.separator + "test-dir-123" );
this.createFile( new File( testDir + File.separator + "directoryTest" + File.separator + "testDir123"
+ File.separator + "file1.dat" ), 0 );
this.createFile( new File( testDir + File.separator + "directoryTest" + File.separator + "test_dir_123"
+ File.separator + "file1.dat" ), 0 );
this.createFile( new File( testDir + File.separator + "directoryTest" + File.separator + "test-dir-123"
+ File.separator + "file1.dat" ), 0 );
}
public void testDirectoriesWithHyphens()
throws IOException
{
this.createTestDirectories();
DirectoryScanner ds = new DirectoryScanner();
String[] includes = { "**/*.dat" };
String[] excludes = { "" };
ds.setIncludes( includes );
ds.setExcludes( excludes );
ds.setBasedir( new File( testDir + File.separator + "directoryTest" ) );
ds.setCaseSensitive( true );
ds.scan();
String[] files = ds.getIncludedFiles();
assertEquals( "Wrong number of results.", 3, files.length );
}
public void testAntExcludesOverrideIncludes()
throws IOException
{
printTestHeader();
File dir = new File( testDir, "regex-dir" );
dir.mkdirs();
String[] excludedPaths = { "target/foo.txt" };
createFiles( dir, excludedPaths );
String[] includedPaths = { "src/main/resources/project/target/foo.txt" };
createFiles( dir, includedPaths );
DirectoryScanner ds = new DirectoryScanner();
String[] includes = { "**/target/*" };
String[] excludes = { "target/*" };
// This doesn't work, since excluded patterns refine included ones, meaning they operate on
// the list of paths that passed the included patterns, and can override them.
// String[] includes = {"**src/**/target/**/*" };
// String[] excludes = { "**/target/**/*" };
ds.setIncludes( includes );
ds.setExcludes( excludes );
ds.setBasedir( dir );
ds.scan();
assertInclusionsAndExclusions( ds.getIncludedFiles(), excludedPaths, includedPaths );
}
public void testAntExcludesOverrideIncludesWithExplicitAntPrefix()
throws IOException
{
printTestHeader();
File dir = new File( testDir, "regex-dir" );
dir.mkdirs();
String[] excludedPaths = { "target/foo.txt" };
createFiles( dir, excludedPaths );
String[] includedPaths = { "src/main/resources/project/target/foo.txt" };
createFiles( dir, includedPaths );
DirectoryScanner ds = new DirectoryScanner();
String[] includes =
{ SelectorUtils.ANT_HANDLER_PREFIX + "**/target/**/*" + SelectorUtils.PATTERN_HANDLER_SUFFIX };
String[] excludes = { SelectorUtils.ANT_HANDLER_PREFIX + "target/**/*" + SelectorUtils.PATTERN_HANDLER_SUFFIX };
// This doesn't work, since excluded patterns refine included ones, meaning they operate on
// the list of paths that passed the included patterns, and can override them.
// String[] includes = {"**src/**/target/**/*" };
// String[] excludes = { "**/target/**/*" };
ds.setIncludes( includes );
ds.setExcludes( excludes );
ds.setBasedir( dir );
ds.scan();
assertInclusionsAndExclusions( ds.getIncludedFiles(), excludedPaths, includedPaths );
}
public void testRegexIncludeWithExcludedPrefixDirs()
throws IOException
{
printTestHeader();
File dir = new File( testDir, "regex-dir" );
dir.mkdirs();
String[] excludedPaths = { "src/main/foo.txt" };
createFiles( dir, excludedPaths );
String[] includedPaths = { "src/main/resources/project/target/foo.txt" };
createFiles( dir, includedPaths );
String regex = ".+/target.*";
DirectoryScanner ds = new DirectoryScanner();
String includeExpr = SelectorUtils.REGEX_HANDLER_PREFIX + regex + SelectorUtils.PATTERN_HANDLER_SUFFIX;
String[] includes = { includeExpr };
ds.setIncludes( includes );
ds.setBasedir( dir );
ds.scan();
assertInclusionsAndExclusions( ds.getIncludedFiles(), excludedPaths, includedPaths );
}
public void testRegexExcludeWithNegativeLookahead()
throws IOException
{
printTestHeader();
File dir = new File( testDir, "regex-dir" );
try
{
FileUtils.deleteDirectory( dir );
}
catch ( IOException e )
{
}
dir.mkdirs();
String[] excludedPaths = { "target/foo.txt" };
createFiles( dir, excludedPaths );
String[] includedPaths = { "src/main/resources/project/target/foo.txt" };
createFiles( dir, includedPaths );
String regex = "(?!.*src/).*target.*";
DirectoryScanner ds = new DirectoryScanner();
String excludeExpr = SelectorUtils.REGEX_HANDLER_PREFIX + regex + SelectorUtils.PATTERN_HANDLER_SUFFIX;
String[] excludes = { excludeExpr };
ds.setExcludes( excludes );
ds.setBasedir( dir );
ds.scan();
assertInclusionsAndExclusions( ds.getIncludedFiles(), excludedPaths, includedPaths );
}
public void testRegexWithSlashInsideCharacterClass()
throws IOException
{
printTestHeader();
File dir = new File( testDir, "regex-dir" );
try
{
FileUtils.deleteDirectory( dir );
}
catch ( IOException e )
{
}
dir.mkdirs();
String[] excludedPaths = { "target/foo.txt", "target/src/main/target/foo.txt" };
createFiles( dir, excludedPaths );
String[] includedPaths = { "module/src/main/target/foo.txt" };
createFiles( dir, includedPaths );
// NOTE: The portion "[^/]" is the interesting part of this pattern.
String regex = "(?!((?!target/)[^/]+/)*src/).*target.*";
DirectoryScanner ds = new DirectoryScanner();
String excludeExpr = SelectorUtils.REGEX_HANDLER_PREFIX + regex + SelectorUtils.PATTERN_HANDLER_SUFFIX;
String[] excludes = { excludeExpr };
ds.setExcludes( excludes );
ds.setBasedir( dir );
ds.scan();
assertInclusionsAndExclusions( ds.getIncludedFiles(), excludedPaths, includedPaths );
}
private void printTestHeader()
{
StackTraceElement ste = new Throwable().getStackTrace()[1];
System.out.println( "Test: " + ste.getMethodName() );
}
private void assertInclusionsAndExclusions( String[] files, String[] excludedPaths, String[] includedPaths )
{
Arrays.sort( files );
System.out.println( "Included files: " );
for ( int i = 0; i < files.length; i++ )
{
System.out.println( files[i] );
}
List failedToExclude = new ArrayList();
for ( int i = 0; i < excludedPaths.length; i++ )
{
String alt = excludedPaths[i].replace( '/', '\\' );
System.out.println( "Searching for exclusion as: " + excludedPaths[i] + "\nor: " + alt );
if ( Arrays.binarySearch( files, excludedPaths[i] ) > -1 || Arrays.binarySearch( files, alt ) > -1 )
{
failedToExclude.add( excludedPaths[i] );
}
}
List failedToInclude = new ArrayList();
for ( int i = 0; i < includedPaths.length; i++ )
{
String alt = includedPaths[i].replace( '/', '\\' );
System.out.println( "Searching for inclusion as: " + includedPaths[i] + "\nor: " + alt );
if ( Arrays.binarySearch( files, includedPaths[i] ) < 0 && Arrays.binarySearch( files, alt ) < 0 )
{
failedToInclude.add( includedPaths[i] );
}
}
StringBuffer buffer = new StringBuffer();
if ( !failedToExclude.isEmpty() )
{
buffer.append( "Should NOT have included:\n" ).append(
StringUtils.join( failedToExclude.iterator(),
"\n\t- " ) );
}
if ( !failedToInclude.isEmpty() )
{
if ( buffer.length() > 0 )
{
buffer.append( "\n\n" );
}
buffer.append( "Should have included:\n" )
.append( StringUtils.join( failedToInclude.iterator(), "\n\t- " ) );
}
if ( buffer.length() > 0 )
{
fail( buffer.toString() );
}
}
private void createFiles( File dir, String[] paths )
throws IOException
{
for ( int i = 0; i < paths.length; i++ )
{
String path = paths[i].replace( '/', File.separatorChar ).replace( '\\', File.separatorChar );
File file = new File( dir, path );
if ( path.endsWith( File.separator ) )
{
file.mkdirs();
}
else
{
if ( file.getParentFile() != null )
{
file.getParentFile().mkdirs();
}
createFile( file, 0 );
}
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/DirectoryWalkerTest.java 0000664 0000000 0000000 00000003125 11660305702 0030442 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.File;
import junit.framework.TestCase;
public class DirectoryWalkerTest extends TestCase {
public void testDirectoryWalk()
{
DirectoryWalker walker = new DirectoryWalker();
walker.addSCMExcludes();
walker.setBaseDir( new File("src/test/resources/directorywalker") );
WalkCollector collector = new WalkCollector();
walker.addDirectoryWalkListener( collector );
walker.scan();
assertEquals( "Walk Collector / Starting Count", 1, collector.startCount );
assertNotNull( "Walk Collector / Starting Dir", collector.startingDir );
assertEquals( "Walk Collector / Finish Count", 1, collector.finishCount );
assertEquals( "Walk Collector / Steps Count", 4, collector.steps.size() );
assertTrue( "Walk Collector / percentage low >= 0", collector.percentageLow >= 0 );
assertTrue( "Walk Collector / percentage high <= 100", collector.percentageHigh <= 100 );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/FileBasedTestCase.java 0000664 0000000 0000000 00000017525 11660305702 0027753 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.Arrays;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.codehaus.plexus.util.FileUtils;
/**
* Base class for testcases doing tests with files.
*
* @author Jeremias Maerki
*/
public abstract class FileBasedTestCase
extends TestCase
{
private static File testDir;
public static File getTestDirectory()
{
if ( testDir == null )
{
testDir = ( new File( "target/test/io/" ) ).getAbsoluteFile();
}
return testDir;
}
protected byte[] createFile( final File file, final long size )
throws IOException
{
if ( !file.getParentFile().exists() )
{
throw new IOException( "Cannot create file " + file + " as the parent directory does not exist" );
}
byte[] data = generateTestData( size );
final BufferedOutputStream output = new BufferedOutputStream( new FileOutputStream( file ) );
try
{
output.write( data );
return data;
}
finally
{
output.close();
}
}
protected boolean createSymlink( final File link, final File target )
{
try
{
String[] args = { "ln", "-s", target.getAbsolutePath(), link.getAbsolutePath() };
Process process = Runtime.getRuntime().exec( args );
process.waitFor();
if ( 0 != process.exitValue() )
{
return false;
}
}
catch ( Exception e )
{
// assume platform does not support "ln" command, tests should be skipped
return false;
}
return true;
}
protected byte[] generateTestData( final long size )
{
try
{
ByteArrayOutputStream baout = new ByteArrayOutputStream();
generateTestData( baout, size );
return baout.toByteArray();
}
catch ( IOException ioe )
{
throw new RuntimeException( "This should never happen: " + ioe.getMessage() );
}
}
protected void generateTestData( final OutputStream out, final long size )
throws IOException
{
for ( int i = 0; i < size; i++ )
{
//output.write((byte)'X');
// nice varied byte pattern compatible with Readers and Writers
out.write( (byte) ( ( i % 127 ) + 1 ) );
}
}
protected File newFile( String filename ) throws IOException
{
final File destination = new File( getTestDirectory(), filename );
/*
assertTrue( filename + "Test output data file shouldn't previously exist",
!destination.exists() );
*/
if ( destination.exists() )
{
FileUtils.forceDelete( destination );
}
return destination;
}
protected void checkFile( final File file, final File referenceFile )
throws Exception
{
assertTrue( "Check existence of output file", file.exists() );
assertEqualContent( referenceFile, file );
}
protected void checkWrite( final OutputStream output ) throws Exception
{
try
{
new PrintStream( output ).write( 0 );
}
catch ( final Throwable t )
{
throw new AssertionFailedError( "The copy() method closed the stream " + "when it shouldn't have. "
+ t.getMessage() );
}
}
protected void checkWrite( final Writer output ) throws Exception
{
try
{
new PrintWriter( output ).write( 'a' );
}
catch ( final Throwable t )
{
throw new AssertionFailedError( "The copy() method closed the stream " + "when it shouldn't have. "
+ t.getMessage() );
}
}
protected void deleteFile( final File file )
throws Exception
{
if ( file.exists() )
{
assertTrue( "Couldn't delete file: " + file, file.delete() );
}
}
// ----------------------------------------------------------------------
// Assertions
// ----------------------------------------------------------------------
/** Assert that the content of two files is the same. */
private void assertEqualContent( final File f0, final File f1 )
throws IOException
{
/* This doesn't work because the filesize isn't updated until the file
* is closed.
assertTrue( "The files " + f0 + " and " + f1 +
" have differing file sizes (" + f0.length() +
" vs " + f1.length() + ")", ( f0.length() == f1.length() ) );
*/
final InputStream is0 = new FileInputStream( f0 );
try
{
final InputStream is1 = new FileInputStream( f1 );
try
{
final byte[] buf0 = new byte[1024];
final byte[] buf1 = new byte[1024];
int n0 = 0;
int n1 = 0;
while ( -1 != n0 )
{
n0 = is0.read( buf0 );
n1 = is1.read( buf1 );
assertTrue( "The files " + f0 + " and " + f1 +
" have differing number of bytes available (" + n0 +
" vs " + n1 + ")", ( n0 == n1 ) );
assertTrue( "The files " + f0 + " and " + f1 +
" have different content", Arrays.equals( buf0, buf1 ) );
}
}
finally
{
is1.close();
}
}
finally
{
is0.close();
}
}
/** Assert that the content of a file is equal to that in a byte[]. */
protected void assertEqualContent( final byte[] b0, final File file )
throws IOException
{
final InputStream is = new FileInputStream( file );
try
{
byte[] b1 = new byte[b0.length];
int numRead = is.read( b1 );
assertTrue( "Different number of bytes", numRead == b0.length && is.available() == 0 );
for ( int i = 0;
i < numRead;
assertTrue( "Byte " + i + " differs (" + b0[i] + " != " + b1[i] + ")",
b0[i] == b1[i] ), i++
)
;
}
finally
{
is.close();
}
}
protected void assertIsDirectory( File file )
{
assertTrue( "The File doesn't exists: " + file.getAbsolutePath(), file.exists() );
assertTrue( "The File isn't a directory: " + file.getAbsolutePath(), file.isDirectory() );
}
protected void assertIsFile( File file )
{
assertTrue( "The File doesn't exists: " + file.getAbsolutePath(), file.exists() );
assertTrue( "The File isn't a file: " + file.getAbsolutePath(), file.isFile() );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/FileUtilsTest.java 0000664 0000000 0000000 00000127263 11660305702 0027242 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.net.URL;
import java.util.Properties;
/**
* This is used to test FileUtils for correctness.
*
* @author Peter Donald
* @author Matthew Hawthorne
* @version $Id: FileUtilsTest.java 8145 2009-03-25 19:54:54Z bentmann $
* @see FileUtils
*/
public final class FileUtilsTest
extends FileBasedTestCase
{
// Test data
/**
* Size of test directory.
*/
private static final int TEST_DIRECTORY_SIZE = 0;
private final File testFile1;
private final File testFile2;
private static int testFile1Size;
private static int testFile2Size;
public FileUtilsTest()
throws Exception
{
testFile1 = new File( getTestDirectory(), "file1-test.txt" );
testFile2 = new File( getTestDirectory(), "file1a-test.txt" );
testFile1Size = (int) testFile1.length();
testFile2Size = (int) testFile2.length();
}
/**
* @see junit.framework.TestCase#setUp()
*/
protected void setUp()
throws Exception
{
getTestDirectory().mkdirs();
createFile( testFile1, testFile1Size );
createFile( testFile2, testFile2Size );
FileUtils.deleteDirectory( getTestDirectory() );
getTestDirectory().mkdirs();
createFile( testFile1, testFile1Size );
createFile( testFile2, testFile2Size );
}
// byteCountToDisplaySize
public void testByteCountToDisplaySize()
{
assertEquals( FileUtils.byteCountToDisplaySize( 0 ), "0 bytes" );
assertEquals( FileUtils.byteCountToDisplaySize( 1024 ), "1 KB" );
assertEquals( FileUtils.byteCountToDisplaySize( 1024 * 1024 ), "1 MB" );
assertEquals( FileUtils.byteCountToDisplaySize( 1024 * 1024 * 1024 ), "1 GB" );
}
// waitFor
public void testWaitFor()
{
FileUtils.waitFor( "", -1 );
FileUtils.waitFor( "", 2 );
}
public void testToFile()
throws Exception
{
URL url = getClass().getResource( "/test.txt" );
url = new URL( url.toString() + "/name%20%23%2520%3F%7B%7D%5B%5D%3C%3E.txt" );
File file = FileUtils.toFile( url );
assertEquals( "name #%20?{}[]<>.txt", file.getName() );
}
public void testToFileBadProtocol()
throws Exception
{
URL url = new URL( "http://maven.apache.org/" );
File file = FileUtils.toFile( url );
assertNull( file );
}
public void testToFileNull()
throws Exception
{
File file = FileUtils.toFile( null );
assertNull( file );
}
// Hacked to sanity by Trygve
public void testToURLs()
throws Exception
{
File[] files = new File[]{new File( "file1" ), new File( "file2" ),};
URL[] urls = FileUtils.toURLs( files );
assertEquals( "The length of the generated URL's is not equals to the length of files. " + "Was " + files
.length + ", expected " + urls.length, files.length, urls.length );
for ( int i = 0; i < urls.length; i++ )
{
assertEquals( files[i].toURL(), urls[i] );
}
}
public void testGetFilesFromExtension()
{
// TODO I'm not sure what is supposed to happen here
FileUtils.getFilesFromExtension( "dir", null );
// Non-existent files
final String[] emptyFileNames =
FileUtils.getFilesFromExtension( getTestDirectory().getAbsolutePath(), new String[]{"java"} );
assertTrue( emptyFileNames.length == 0 );
// Existing files
// TODO Figure out how to test this
/*
final String[] fileNames =
FileUtils.getFilesFromExtension(
getClass().getResource("/java/util/").getFile(),
new String[] { "class" });
assertTrue(fileNames.length > 0);
*/
}
// mkdir
public void testMkdir()
{
final File dir = new File( getTestDirectory(), "testdir" );
FileUtils.mkdir( dir.getAbsolutePath() );
dir.deleteOnExit();
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
try
{
File winFile = new File( getTestDirectory(), "bla*bla" );
winFile.deleteOnExit();
FileUtils.mkdir( winFile.getAbsolutePath() );
assertTrue( false );
}
catch ( IllegalArgumentException e)
{
assertTrue( true );
}
}
}
// contentEquals
public void testContentEquals()
throws Exception
{
// Non-existent files
final File file = new File( getTestDirectory(), getName() );
assertTrue( FileUtils.contentEquals( file, file ) );
// TODO Should comparing 2 directories throw an Exception instead of returning false?
// Directories
assertTrue( !FileUtils.contentEquals( getTestDirectory(), getTestDirectory() ) );
// Different files
final File objFile1 = new File( getTestDirectory(), getName() + ".object" );
objFile1.deleteOnExit();
FileUtils.copyURLToFile( getClass().getResource( "/java/lang/Object.class" ), objFile1 );
final File objFile2 = new File( getTestDirectory(), getName() + ".collection" );
objFile2.deleteOnExit();
FileUtils.copyURLToFile( getClass().getResource( "/java/util/Collection.class" ), objFile2 );
assertTrue( "Files should not be equal.", !FileUtils.contentEquals( objFile1, objFile2 ) );
// Equal files
file.createNewFile();
assertTrue( FileUtils.contentEquals( file, file ) );
}
// removePath
public void testRemovePath()
{
final String fileName = FileUtils.removePath( new File( getTestDirectory(), getName() ).getAbsolutePath() );
assertEquals( getName(), fileName );
}
// getPath
public void testGetPath()
{
final String fileName = FileUtils.getPath( new File( getTestDirectory(), getName() ).getAbsolutePath() );
assertEquals( getTestDirectory().getAbsolutePath(), fileName );
}
// copyURLToFile
public void testCopyURLToFile()
throws Exception
{
// Creates file
final File file = new File( getTestDirectory(), getName() );
file.deleteOnExit();
// Loads resource
final String resourceName = "/java/lang/Object.class";
FileUtils.copyURLToFile( getClass().getResource( resourceName ), file );
// Tests that resource was copied correctly
final FileInputStream fis = new FileInputStream( file );
try
{
assertTrue( "Content is not equal.",
IOUtil.contentEquals( getClass().getResourceAsStream( resourceName ), fis ) );
}
finally
{
fis.close();
}
}
// catPath
public void testCatPath()
{
// TODO StringIndexOutOfBoundsException thrown if file doesn't contain slash.
// Is this acceptable?
//assertEquals("", FileUtils.catPath("a", "b"));
assertEquals( "/a/c", FileUtils.catPath( "/a/b", "c" ) );
assertEquals( "/a/d", FileUtils.catPath( "/a/b/c", "../d" ) );
}
// forceMkdir
public void testForceMkdir()
throws Exception
{
// Tests with existing directory
FileUtils.forceMkdir( getTestDirectory() );
// Creates test file
final File testFile = new File( getTestDirectory(), getName() );
testFile.deleteOnExit();
testFile.createNewFile();
assertTrue( "Test file does not exist.", testFile.exists() );
// Tests with existing file
try
{
FileUtils.forceMkdir( testFile );
fail( "Exception expected." );
}
catch ( IOException ex )
{
}
testFile.delete();
// Tests with non-existent directory
FileUtils.forceMkdir( testFile );
assertTrue( "Directory was not created.", testFile.exists() );
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
try
{
File winFile = new File( getTestDirectory(), "bla*bla" );
winFile.deleteOnExit();
FileUtils.forceMkdir( winFile );
assertTrue( false );
}
catch ( IllegalArgumentException e)
{
assertTrue( true );
}
}
}
// sizeOfDirectory
public void testSizeOfDirectory()
throws Exception
{
final File file = new File( getTestDirectory(), getName() );
// Non-existent file
try
{
FileUtils.sizeOfDirectory( file );
fail( "Exception expected." );
}
catch ( IllegalArgumentException ex )
{
}
// Creates file
file.createNewFile();
file.deleteOnExit();
// Existing file
try
{
FileUtils.sizeOfDirectory( file );
fail( "Exception expected." );
}
catch ( IllegalArgumentException ex )
{
}
// Existing directory
file.delete();
file.mkdir();
assertEquals( "Unexpected directory size", TEST_DIRECTORY_SIZE, FileUtils.sizeOfDirectory( file ) );
}
// isFileNewer
// TODO Finish test
public void XtestIsFileNewer()
{
}
// copyFile
public void testCopyFile1()
throws Exception
{
final File destination = new File( getTestDirectory(), "copy1.txt" );
FileUtils.copyFile( testFile1, destination );
assertTrue( "Check Exist", destination.exists() );
assertTrue( "Check Full copy", destination.length() == testFile1Size );
}
public void testCopyFile2()
throws Exception
{
final File destination = new File( getTestDirectory(), "copy2.txt" );
FileUtils.copyFile( testFile1, destination );
assertTrue( "Check Exist", destination.exists() );
assertTrue( "Check Full copy", destination.length() == testFile2Size );
}
// copyFileIfModified
public void testCopyIfModifiedWhenSourceIsNewer()
throws Exception
{
FileUtils.forceMkdir( new File( getTestDirectory() + "/temp" ) );
// Place destination
File destination = new File( getTestDirectory() + "/temp/copy1.txt" );
FileUtils.copyFile( testFile1, destination );
// Make sure source is newer
Thread.sleep( 1000 );
// Place source
File source = new File( getTestDirectory(), "copy1.txt" );
FileUtils.copyFile( testFile1, source );
// Copy will occur when source is newer
assertTrue( "Failed copy. Target file should have been updated.",
FileUtils.copyFileIfModified( source, destination ) );
}
public void testCopyIfModifiedWhenSourceIsOlder()
throws Exception
{
FileUtils.forceMkdir( new File( getTestDirectory() + "/temp" ) );
// Place source
File source = new File( getTestDirectory() + "copy1.txt" );
FileUtils.copyFile( testFile1, source );
// Make sure desintation is newer
Thread.sleep( 1000 );
// Place destination
File desintation = new File( getTestDirectory(), "/temp/copy1.txt" );
FileUtils.copyFile( testFile1, desintation );
// Copy will occur when desintation is newer
assertFalse( "Source file should not have been copied.", FileUtils.copyFileIfModified( source, desintation ) );
}
// forceDelete
public void testForceDeleteAFile1()
throws Exception
{
final File destination = new File( getTestDirectory(), "copy1.txt" );
destination.createNewFile();
assertTrue( "Copy1.txt doesn't exist to delete", destination.exists() );
FileUtils.forceDelete( destination );
assertTrue( "Check No Exist", !destination.exists() );
}
public void testForceDeleteAFile2()
throws Exception
{
final File destination = new File( getTestDirectory(), "copy2.txt" );
destination.createNewFile();
assertTrue( "Copy2.txt doesn't exist to delete", destination.exists() );
FileUtils.forceDelete( destination );
assertTrue( "Check No Exist", !destination.exists() );
}
// copyFileToDirectory
public void testCopyFile1ToDir()
throws Exception
{
final File directory = new File( getTestDirectory(), "subdir" );
if ( !directory.exists() )
{
directory.mkdirs();
}
final File destination = new File( directory, testFile1.getName() );
FileUtils.copyFileToDirectory( testFile1, directory );
assertTrue( "Check Exist", destination.exists() );
assertTrue( "Check Full copy", destination.length() == testFile1Size );
}
public void testCopyFile2ToDir()
throws Exception
{
final File directory = new File( getTestDirectory(), "subdir" );
if ( !directory.exists() )
{
directory.mkdirs();
}
final File destination = new File( directory, testFile1.getName() );
FileUtils.copyFileToDirectory( testFile1, directory );
assertTrue( "Check Exist", destination.exists() );
assertTrue( "Check Full copy", destination.length() == testFile2Size );
}
// copyFileToDirectoryIfModified
public void testCopyFile1ToDirIfModified()
throws Exception
{
final File directory = new File( getTestDirectory(), "subdir" );
if ( directory.exists() )
{
FileUtils.forceDelete( directory );
}
directory.mkdirs();
final File destination = new File( directory, testFile1.getName() );
FileUtils.copyFileToDirectoryIfModified( testFile1, directory );
final File target = new File( getTestDirectory() + "/subdir", testFile1.getName() );
long timestamp = target.lastModified();
assertTrue( "Check Exist", destination.exists() );
assertTrue( "Check Full copy", destination.length() == testFile1Size );
FileUtils.copyFileToDirectoryIfModified( testFile1, directory );
assertTrue( "Timestamp was changed", timestamp == target.lastModified() );
}
public void testCopyFile2ToDirIfModified()
throws Exception
{
final File directory = new File( getTestDirectory(), "subdir" );
if ( directory.exists() )
{
FileUtils.forceDelete( directory );
}
directory.mkdirs();
final File destination = new File( directory, testFile2.getName() );
FileUtils.copyFileToDirectoryIfModified( testFile2, directory );
final File target = new File( getTestDirectory() + "/subdir", testFile2.getName() );
long timestamp = target.lastModified();
assertTrue( "Check Exist", destination.exists() );
assertTrue( "Check Full copy", destination.length() == testFile2Size );
FileUtils.copyFileToDirectoryIfModified( testFile2, directory );
assertTrue( "Timestamp was changed", timestamp == target.lastModified() );
}
// forceDelete
public void testForceDeleteDir()
throws Exception
{
FileUtils.forceDelete( getTestDirectory().getParentFile() );
assertTrue( "Check No Exist", !getTestDirectory().getParentFile().exists() );
}
// resolveFile
public void testResolveFileDotDot()
throws Exception
{
final File file = FileUtils.resolveFile( getTestDirectory(), ".." );
assertEquals( "Check .. operator", file, getTestDirectory().getParentFile() );
}
public void testResolveFileDot()
throws Exception
{
final File file = FileUtils.resolveFile( getTestDirectory(), "." );
assertEquals( "Check . operator", file, getTestDirectory() );
}
// normalize
public void testNormalize()
throws Exception
{
final String[] src = {"", "/", "///", "/foo", "/foo//", "/./", "/foo/./", "/foo/./bar", "/foo/../bar",
"/foo/../bar/../baz", "/foo/bar/../../baz", "/././", "/foo/./../bar", "/foo/.././bar/", "//foo//./bar",
"/../", "/foo/../../"};
final String[] dest = {"", "/", "/", "/foo", "/foo/", "/", "/foo/", "/foo/bar", "/bar", "/baz", "/baz", "/",
"/bar", "/bar/", "/foo/bar", null, null};
assertEquals( "Oops, test writer goofed", src.length, dest.length );
for ( int i = 0; i < src.length; i++ )
{
assertEquals( "Check if '" + src[i] + "' normalized to '" + dest[i] + "'", dest[i],
FileUtils.normalize( src[i] ) );
}
}
private String replaceAll( String text, String lookFor, String replaceWith )
{
StringBuffer sb = new StringBuffer( text );
while ( true )
{
int idx = sb.indexOf( lookFor );
if ( idx < 0 )
{
break;
}
sb.replace( idx, idx + lookFor.length(), replaceWith );
}
return sb.toString();
}
/**
* Test the FileUtils implementation.
*/
// Used to exist as IOTestCase class
public void testFileUtils()
throws Exception
{
// Loads file from classpath
final String path = "/test.txt";
final URL url = this.getClass().getResource( path );
assertNotNull( path + " was not found.", url );
String filename = url.getFile();
//The following line applies a fix for spaces in a path
filename = replaceAll( filename, "%20", " " );
final String filename2 = "test2.txt";
assertTrue( "test.txt extension == \"txt\"", FileUtils.getExtension( filename ).equals( "txt" ) );
assertTrue( "Test file does not exist: " + filename, FileUtils.fileExists( filename ) );
assertTrue( "Second test file does not exist", !FileUtils.fileExists( filename2 ) );
FileUtils.fileWrite( filename2, filename );
assertTrue( "Second file was written", FileUtils.fileExists( filename2 ) );
final String file2contents = FileUtils.fileRead( filename2 );
assertTrue( "Second file's contents correct", FileUtils.fileRead( filename2 ).equals( file2contents ) );
FileUtils.fileAppend( filename2, filename );
assertTrue( "Second file's contents correct",
FileUtils.fileRead( filename2 ).equals( file2contents + file2contents ) );
FileUtils.fileDelete( filename2 );
assertTrue( "Second test file does not exist", !FileUtils.fileExists( filename2 ) );
final String contents = FileUtils.fileRead( filename );
assertTrue( "FileUtils.fileRead()", contents.equals( "This is a test" ) );
}
public void testGetExtension()
{
final String[][] tests =
{{"filename.ext", "ext"}
, {"README", ""}
, {"domain.dot.com", "com"}
, {"image.jpeg", "jpeg"}
, {"folder" + File.separator + "image.jpeg", "jpeg"}
, {"folder" + File.separator + "README", ""}};
for ( int i = 0; i < tests.length; i++ )
{
assertEquals( tests[i][1], FileUtils.getExtension( tests[i][0] ) );
//assertEquals(tests[i][1], FileUtils.extension(tests[i][0]));
}
}
public void testGetExtensionWithPaths()
{
// Since the utilities are based on the separator for the platform
// running the test, ensure we are using the right separator
final String sep = File.separator;
final String[][] testsWithPaths = {
{ sep + "tmp" + sep + "foo" + sep + "filename.ext", "ext"}
, {"C:" + sep + "temp" + sep + "foo" + sep + "filename.ext", "ext"}
, {"" + sep + "tmp" + sep + "foo.bar" + sep + "filename.ext", "ext"}
, {"C:" + sep + "temp" + sep + "foo.bar" + sep + "filename.ext", "ext"}
, {"" + sep + "tmp" + sep + "foo.bar" + sep + "README", ""}
, {"C:" + sep + "temp" + sep + "foo.bar" + sep + "README", ""}
, {".." + sep + "filename.ext", "ext"}, {"blabla", ""}};
for ( int i = 0; i < testsWithPaths.length; i++ )
{
assertEquals( testsWithPaths[i][1], FileUtils.getExtension( testsWithPaths[i][0] ) );
//assertEquals(testsWithPaths[i][1], FileUtils.extension(testsWithPaths[i][0]));
}
}
public void testRemoveExtension()
{
final String[][] tests = {{"filename.ext", "filename"}, {"first.second.third.ext", "first.second.third"},
{"README", "README"}, {"domain.dot.com", "domain.dot"}, {"image.jpeg", "image"}};
for ( int i = 0; i < tests.length; i++ )
{
assertEquals( tests[i][1], FileUtils.removeExtension( tests[i][0] ) );
//assertEquals(tests[i][1], FileUtils.basename(tests[i][0]));
}
}
/* TODO: Reenable this test */
public void testRemoveExtensionWithPaths()
{
// Since the utilities are based on the separator for the platform
// running the test, ensure we are using the right separator
final String sep = File.separator;
final String[][] testsWithPaths =
{{sep + "tmp" + sep + "foo" + sep + "filename.ext"
, sep + "tmp" + sep + "foo" + sep + "filename"}
, {"C:" + sep + "temp" + sep + "foo" + sep + "filename.ext"
, "C:" + sep + "temp" + sep + "foo" + sep + "filename"}
, {sep + "tmp" + sep + "foo.bar" + sep + "filename.ext"
, sep + "tmp" + sep + "foo.bar" + sep + "filename"}
, {"C:" + sep + "temp" + sep + "foo.bar" + sep + "filename.ext"
, "C:" + sep + "temp" + sep + "foo.bar" + sep + "filename"}
, {sep + "tmp" + sep + "foo.bar" + sep + "README"
, sep + "tmp" + sep + "foo.bar" + sep + "README"}
, {"C:" + sep + "temp" + sep + "foo.bar" + sep + "README"
, "C:" + sep + "temp" + sep + "foo.bar" + sep + "README"}
, {".." + sep + "filename.ext"
, ".." + sep + "filename"}};
for ( int i = 0; i < testsWithPaths.length; i++ )
{
assertEquals( testsWithPaths[i][1], FileUtils.removeExtension( testsWithPaths[i][0] ) );
//assertEquals(testsWithPaths[i][1], FileUtils.basename(testsWithPaths[i][0]));
}
}
public void testCopyDirectoryStructureWithAEmptyDirectoryStruture()
throws Exception
{
File from = new File( getTestDirectory(), "from" );
FileUtils.deleteDirectory( from );
assertTrue( from.mkdirs() );
File to = new File( getTestDirectory(), "to" );
assertTrue( to.mkdirs() );
FileUtils.copyDirectoryStructure( from, to );
}
public void testCopyDirectoryStructureWithAPopulatedStructure()
throws Exception
{
// Make a structure to copy
File from = new File( getTestDirectory(), "from" );
FileUtils.deleteDirectory( from );
File fRoot = new File( from, "root.txt" );
File d1 = new File( from, "1" );
File d1_1 = new File( d1, "1_1" );
File d2 = new File( from, "2" );
File f2 = new File( d2, "2.txt" );
File d2_1 = new File( d2, "2_1" );
File f2_1 = new File( d2_1, "2_1.txt" );
assertTrue( from.mkdir() );
assertTrue( d1.mkdir() );
assertTrue( d1_1.mkdir() );
assertTrue( d2.mkdir() );
assertTrue( d2_1.mkdir() );
createFile( fRoot, 100 );
createFile( f2, 100 );
createFile( f2_1, 100 );
File to = new File( getTestDirectory(), "to" );
assertTrue( to.mkdirs() );
FileUtils.copyDirectoryStructure( from, to );
checkFile( fRoot, new File( to, "root.txt" ) );
assertIsDirectory( new File( to, "1" ) );
assertIsDirectory( new File( to, "1/1_1" ) );
assertIsDirectory( new File( to, "2" ) );
assertIsDirectory( new File( to, "2/2_1" ) );
checkFile( f2, new File( to, "2/2.txt" ) );
checkFile( f2_1, new File( to, "2/2_1/2_1.txt" ) );
}
public void testCopyDirectoryStructureIfModified()
throws Exception
{
// Make a structure to copy
File from = new File( getTestDirectory(), "from" );
FileUtils.deleteDirectory( from );
File fRoot = new File( from, "root.txt" );
File d1 = new File( from, "1" );
File d1_1 = new File( d1, "1_1" );
File d2 = new File( from, "2" );
File f2 = new File( d2, "2.txt" );
File d2_1 = new File( d2, "2_1" );
File f2_1 = new File( d2_1, "2_1.txt" );
assertTrue( from.mkdir() );
assertTrue( d1.mkdir() );
assertTrue( d1_1.mkdir() );
assertTrue( d2.mkdir() );
assertTrue( d2_1.mkdir() );
createFile( fRoot, 100 );
createFile( f2, 100 );
createFile( f2_1, 100 );
File to = new File( getTestDirectory(), "to" );
assertTrue( to.mkdirs() );
FileUtils.copyDirectoryStructureIfModified( from, to );
File files[] = {new File( to, "root.txt" ), new File( to, "2/2.txt" ), new File( to, "2/2_1/2_1.txt" )};
long timestamps[] = {files[0].lastModified(), files[1].lastModified(), files[2].lastModified()};
checkFile( fRoot, files[0] );
assertIsDirectory( new File( to, "1" ) );
assertIsDirectory( new File( to, "1/1_1" ) );
assertIsDirectory( new File( to, "2" ) );
assertIsDirectory( new File( to, "2/2_1" ) );
checkFile( f2, files[1] );
checkFile( f2_1, files[2] );
FileUtils.copyDirectoryStructureIfModified( from, to );
assertTrue( "Unmodified file was overwritten", timestamps[0] == files[0].lastModified() );
assertTrue( "Unmodified file was overwritten", timestamps[1] == files[1].lastModified() );
assertTrue( "Unmodified file was overwritten", timestamps[2] == files[2].lastModified() );
files[1].setLastModified( f2.lastModified() - 5000L );
timestamps[1] = files[1].lastModified();
FileUtils.copyDirectoryStructureIfModified( from, to );
assertTrue( "Unmodified file was overwritten", timestamps[0] == files[0].lastModified() );
assertTrue( "Outdated file was not overwritten", timestamps[1] < files[1].lastModified() );
assertTrue( "Unmodified file was overwritten", timestamps[2] == files[2].lastModified() );
}
public void testCopyDirectoryStructureToSelf()
throws Exception
{
// Make a structure to copy
File toFrom = new File( getTestDirectory(), "tofrom" );
FileUtils.deleteDirectory( toFrom );
File fRoot = new File( toFrom, "root.txt" );
File dSub = new File( toFrom, "subdir" );
File f1 = new File( dSub, "notempty.txt" );
File dSubSub = new File( dSub, "subsubdir" );
File f2 = new File( dSubSub, "notemptytoo.txt" );
assertTrue( toFrom.mkdir() );
assertTrue( dSub.mkdir() );
assertTrue( dSubSub.mkdir() );
createFile( fRoot, 100 );
createFile( f1, 100 );
createFile( f2, 100 );
try
{
FileUtils.copyDirectoryStructure( toFrom, toFrom );
fail( "An exception must be thrown." );
}
catch ( IOException e )
{
// expected
}
}
public void testFilteredFileCopy()
throws Exception
{
File compareFile = new File( getTestDirectory(), "compare.txt" );
FileUtils.fileWrite( compareFile.getAbsolutePath(), "UTF-8", "This is a test. Test sample text\n" );
File destFile = new File( getTestDirectory(), "target.txt" );
final Properties filterProperties = new Properties();
filterProperties.setProperty( "s", "sample text" );
// test ${token}
FileUtils.FilterWrapper[] wrappers1 = new FileUtils.FilterWrapper[]{new FileUtils.FilterWrapper()
{
public Reader getReader( Reader reader )
{
return new InterpolationFilterReader( reader, filterProperties, "${", "}" );
}
}};
File srcFile = new File( getTestDirectory(), "root.txt" );
FileUtils.fileWrite( srcFile.getAbsolutePath(), "UTF-8", "This is a test. Test ${s}\n" );
FileUtils.copyFile( srcFile, destFile, "UTF-8", wrappers1 );
assertTrue( "Files should be equal.", FileUtils.contentEquals( compareFile, destFile ) );
srcFile.delete();
destFile.delete();
compareFile.delete();
}
public void testFilteredWithoutFilterAndOlderFile()
throws Exception
{
String content = "This is a test.";
File sourceFile = new File( getTestDirectory(), "source.txt" );
FileUtils.fileWrite( sourceFile.getAbsolutePath(), "UTF-8", content );
File destFile = new File( getTestDirectory(), "target.txt" );
if ( destFile.exists() )
{
destFile.delete();
}
FileUtils.copyFile( sourceFile, destFile, null, null );
assertEqualContent( content.getBytes( "UTF-8" ), destFile );
String newercontent = "oldercontent";
File olderFile = new File( getTestDirectory(), "oldersource.txt" );
FileUtils.fileWrite( olderFile.getAbsolutePath(), "UTF-8", newercontent );
// very old file ;-)
olderFile.setLastModified( 1 );
destFile = new File( getTestDirectory(), "target.txt" );
FileUtils.copyFile( olderFile, destFile, null, null );
String destFileContent = FileUtils.fileRead( destFile, "UTF-8" );
assertEquals( content, destFileContent );
}
public void testFilteredWithoutFilterAndOlderFileAndOverwrite()
throws Exception
{
String content = "This is a test.";
File sourceFile = new File( getTestDirectory(), "source.txt" );
FileUtils.fileWrite( sourceFile.getAbsolutePath(), "UTF-8", content );
File destFile = new File( getTestDirectory(), "target.txt" );
if ( destFile.exists() )
{
destFile.delete();
}
FileUtils.copyFile( sourceFile, destFile, null, null );
assertEqualContent( content.getBytes( "UTF-8" ), destFile );
String newercontent = "oldercontent";
File olderFile = new File( getTestDirectory(), "oldersource.txt" );
FileUtils.fileWrite( olderFile.getAbsolutePath(), "UTF-8", newercontent );
// very old file ;-)
olderFile.setLastModified( 1 );
destFile = new File( getTestDirectory(), "target.txt" );
FileUtils.copyFile( olderFile, destFile, null, null, true );
String destFileContent = FileUtils.fileRead( destFile, "UTF-8" );
assertEquals( newercontent, destFileContent );
}
public void testFileRead() throws IOException
{
File testFile = new File( getTestDirectory(), "testFileRead.txt" );
String testFileName = testFile.getAbsolutePath();
/*
* NOTE: The method under test uses the JVM's default encoding which by its nature varies from machine to
* machine. As a consequence, we cannot know in advance which characters are supported by the effective encoding
* of the test runner. Therefore this test must be restricted to ASCII characters which are reasonably safe to
* survive the roundtrip test.
*/
String testString = "Only US-ASCII characters here, see comment above!";
Writer writer = null;
try
{
writer = new OutputStreamWriter( new FileOutputStream( testFile ) );
writer.write( testString );
writer.flush();
}
finally
{
IOUtil.close( writer );
}
assertEquals( "testString should be equal", testString, FileUtils.fileRead( testFile ) );
assertEquals( "testString should be equal", testString, FileUtils.fileRead( testFileName ) );
testFile.delete();
}
public void testFileReadWithEncoding() throws IOException
{
String encoding = "UTF-8";
File testFile = new File( getTestDirectory(), "testFileRead.txt" );
String testFileName = testFile.getAbsolutePath();
// unicode escaped Japanese hiragana, "aiueo" + Umlaut a
String testString = "\u3042\u3044\u3046\u3048\u304a\u00e4";
Writer writer = null;
try
{
writer = new OutputStreamWriter( new FileOutputStream( testFile ), encoding );
writer.write( testString );
writer.flush();
}
finally
{
IOUtil.close( writer );
}
assertEquals( "testString should be equal", testString, FileUtils.fileRead( testFile, "UTF-8" ) );
assertEquals( "testString should be equal", testString, FileUtils.fileRead( testFileName, "UTF-8" ) );
testFile.delete();
}
public void testFileAppend() throws IOException
{
String baseString = "abc";
File testFile = new File( getTestDirectory(), "testFileAppend.txt" );
String testFileName = testFile.getAbsolutePath();
Writer writer = null;
try
{
writer = new OutputStreamWriter( new FileOutputStream( testFile ) );
writer.write( baseString );
writer.flush();
}
finally
{
IOUtil.close( writer );
}
// unicode escaped Japanese hiragana, "aiueo" + Umlaut a
String testString = "\u3042\u3044\u3046\u3048\u304a\u00e4";
FileUtils.fileAppend( testFileName, testString );
assertEqualContent( ( baseString + testString ).getBytes(), testFile );
testFile.delete();
}
public void testFileAppendWithEncoding() throws IOException
{
String baseString = "abc";
String encoding = "UTF-8";
File testFile = new File( getTestDirectory(), "testFileAppend.txt" );
String testFileName = testFile.getAbsolutePath();
Writer writer = null;
try
{
writer = new OutputStreamWriter( new FileOutputStream( testFile ), encoding );
writer.write( baseString );
writer.flush();
}
finally
{
IOUtil.close( writer );
}
// unicode escaped Japanese hiragana, "aiueo" + Umlaut a
String testString = "\u3042\u3044\u3046\u3048\u304a\u00e4";
FileUtils.fileAppend( testFileName, encoding, testString );
assertEqualContent( ( baseString + testString ).getBytes( encoding ), testFile );
testFile.delete();
}
public void testFileWrite() throws IOException
{
File testFile = new File( getTestDirectory(), "testFileWrite.txt" );
String testFileName = testFile.getAbsolutePath();
// unicode escaped Japanese hiragana, "aiueo" + Umlaut a
String testString = "\u3042\u3044\u3046\u3048\u304a\u00e4";
FileUtils.fileWrite( testFileName, testString );
assertEqualContent( testString.getBytes(), testFile );
testFile.delete();
}
public void testFileWriteWithEncoding() throws IOException
{
String encoding = "UTF-8";
File testFile = new File( getTestDirectory(), "testFileWrite.txt" );
String testFileName = testFile.getAbsolutePath();
// unicode escaped Japanese hiragana, "aiueo" + Umlaut a
String testString = "\u3042\u3044\u3046\u3048\u304a\u00e4";
FileUtils.fileWrite( testFileName, encoding, testString );
assertEqualContent( testString.getBytes( encoding ), testFile );
testFile.delete();
}
/**
* Workaround for the following Sun bugs. They are fixed in JDK 6u1 and JDK 5u11.
*
* @see Sun bug id=4403166
* @see Sun bug id=6182812
* @see Sun bug id=6481955
*
* @throws Exception
*/
public void testDeleteLongPathOnWindows()
throws Exception
{
if ( !Os.isFamily( Os.FAMILY_WINDOWS ) )
{
return;
}
File a = new File( getTestDirectory(), "longpath" );
a.mkdir();
File a1 = new File( a, "a" );
a1.mkdir();
StringBuffer path = new StringBuffer( "" );
for ( int i = 0; i < 100; i++ )
{
path.append( "../a/" );
}
File f = new File( a1, path.toString() + "test.txt" );
InputStream is = new ByteArrayInputStream( "Blabla".getBytes( "UTF-8" ) );
OutputStream os = new FileOutputStream( f.getCanonicalFile() );
IOUtil.copy( is, os );
IOUtil.close( is );
IOUtil.close( os );
FileUtils.forceDelete( f );
File f1 = new File( a1, "test.txt" );
if ( f1.exists() )
{
throw new Exception( "Unable to delete the file :" + f1.getAbsolutePath() );
}
}
//Test for bug PLXUTILS-10
public void testCopyFileOnSameFile()
throws IOException
{
String content = "ggrgreeeeeeeeeeeeeeeeeeeeeeeoierjgioejrgiojregioejrgufcdxivbsdibgfizgerfyaezgv!zeez";
final File theFile = File.createTempFile( "test", ".txt" );
theFile.deleteOnExit();
FileUtils.fileAppend( theFile.getAbsolutePath(), content );
assertTrue( theFile.length() > 0 );
// Now copy file over itself
FileUtils.copyFile( theFile, theFile );
// This should not fail
assertTrue( theFile.length() > 0 );
}
public void testExtensions()
throws Exception
{
String[][] values = {
{ "fry.frozen", "frozen" },
{ "fry", "" },
{ "fry.", "" },
{ "/turanga/leela/meets.fry", "fry" },
{ "/3000/turanga.leela.fry/zoidberg.helps", "helps" },
{ "/3000/turanga.leela.fry/zoidberg.", "" },
{ "/3000/turanga.leela.fry/zoidberg", "" },
{ "/3000/leela.fry.bender/", "" },
{ "/3000/leela.fry.bdner/.", "" },
{ "/3000/leela.fry.bdner/foo.bar.txt", "txt" } };
for ( int i = 0; i < values.length; i++ )
{
String fileName = values[i][0].replace( '/', File.separatorChar );
String ext = values[i][1];
String computed = FileUtils.extension( fileName );
assertEquals( "case [" + i + "]:" + fileName + " -> " + ext + ", computed : " + computed, ext, computed );
}
}
public void testIsValidWindowsFileName()
throws Exception
{
File f = new File( "c:\test" );
assertTrue( FileUtils.isValidWindowsFileName( f ) );
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
f = new File( "c:\test\bla:bla" );
assertFalse( FileUtils.isValidWindowsFileName( f ) );
f = new File( "c:\test\bla*bla" );
assertFalse( FileUtils.isValidWindowsFileName( f ) );
f = new File( "c:\test\bla\"bla" );
assertFalse( FileUtils.isValidWindowsFileName( f ) );
f = new File( "c:\test\blabla" );
assertFalse( FileUtils.isValidWindowsFileName( f ) );
f = new File( "c:\test\bla|bla" );
assertFalse( FileUtils.isValidWindowsFileName( f ) );
f = new File( "c:\test\bla*bla" );
assertFalse( FileUtils.isValidWindowsFileName( f ) );
}
}
public void testDeleteDirectoryWithValidFileSymlink()
throws Exception
{
File symlinkTarget = new File( getTestDirectory(), "fileSymlinkTarget" );
createFile( symlinkTarget, 1 );
File symlink = new File( getTestDirectory(), "fileSymlink" );
createSymlink( symlink, symlinkTarget );
try
{
FileUtils.deleteDirectory( getTestDirectory() );
}
finally
{
/*
* Ensure to cleanup problematic symlink or "mvn clean" will fail
*/
symlink.delete();
}
assertTrue( "Failed to delete test directory", !getTestDirectory().exists() );
}
public void testDeleteDirectoryWithValidDirSymlink()
throws Exception
{
File symlinkTarget = new File( getTestDirectory(), "dirSymlinkTarget" );
symlinkTarget.mkdir();
File symlink = new File( getTestDirectory(), "dirSymlink" );
createSymlink( symlink, symlinkTarget );
try
{
FileUtils.deleteDirectory( getTestDirectory() );
}
finally
{
/*
* Ensure to cleanup problematic symlink or "mvn clean" will fail
*/
symlink.delete();
}
assertTrue( "Failed to delete test directory", !getTestDirectory().exists() );
}
public void testDeleteDirectoryWithDanglingSymlink()
throws Exception
{
File symlinkTarget = new File( getTestDirectory(), "missingSymlinkTarget" );
File symlink = new File( getTestDirectory(), "danglingSymlink" );
createSymlink( symlink, symlinkTarget );
try
{
FileUtils.deleteDirectory( getTestDirectory() );
}
finally
{
/*
* Ensure to cleanup problematic symlink or "mvn clean" will fail
*/
symlink.delete();
}
assertTrue( "Failed to delete test directory", !getTestDirectory().exists() );
}
public void testcopyDirectoryLayoutWithExcludesIncludes()
throws Exception
{
File destination = new File( "target", "copyDirectoryStructureWithExcludesIncludes" );
if ( !destination.exists() )
{
destination.mkdirs();
}
FileUtils.cleanDirectory( destination );
File source = new File( "src/test/resources/dir-layout-copy" );
FileUtils.copyDirectoryLayout( source, destination, null, null );
assertTrue( destination.exists() );
File[] childs = destination.listFiles();
assertEquals( 2, childs.length );
for ( int i = 0, size = childs.length; i < size; i++ )
{
File current = childs[i];
if ( current.getName().endsWith( "empty-dir" ) || current.getName().endsWith( "dir1" ) )
{
if ( current.getName().endsWith( "dir1" ) )
{
assertEquals( 1, current.listFiles().length );
assertTrue( current.listFiles()[0].getName().endsWith( "dir2" ) );
}
}
else
{
fail( "not empty-dir or dir1" );
}
}
}
/**
* Be sure that {@link FileUtils#createTempFile(String, String, File)} is always unique.
* @throws Exception if any
*/
public void testCreateTempFile()
throws Exception
{
File last = FileUtils.createTempFile( "unique", ".tmp", null );
for (int i = 0; i < 10; i ++ )
{
File current = FileUtils.createTempFile( "unique", ".tmp", null );
assertTrue( "No unique name: " + current.getName(),
!current.getName().equals( last.getName() ) );
last = current;
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/IOUtilTest.java 0000664 0000000 0000000 00000040166 11660305702 0026503 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.Arrays;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
/**
* This is used to test IOUtil for correctness. The following checks are performed:
*
* - The return must not be null, must be the same type and equals() to the method's second arg
* - All bytes must have been read from the source (available() == 0)
* - The source and destination content must be identical (byte-wise comparison check)
* - The output stream must not have been closed (a byte/char is written to test this, and
* subsequent size checked)
*
* Due to interdependencies in IOUtils and IOUtilsTestlet, one bug may cause
* multiple tests to fail.
*
* @author Jeff Turner
*/
public final class IOUtilTest
extends TestCase
{
/*
* Note: this is not particularly beautiful code. A better way to check for
* flush and close status would be to implement "trojan horse" wrapper
* implementations of the various stream classes, which set a flag when
* relevant methods are called. (JT)
*/
private int FILE_SIZE = 1024 * 4 + 1;
private File testDirectory;
private File testFile;
public void setUp()
{
try
{
testDirectory = ( new File( "target/test/io/" ) ).getAbsoluteFile();
if ( !testDirectory.exists() )
{
testDirectory.mkdirs();
}
testFile = new File( testDirectory, "file2-test.txt" );
createFile( testFile, FILE_SIZE );
}
catch ( IOException ioe )
{
throw new RuntimeException( "Can't run this test because environment could not be built" );
}
}
public void tearDown()
{
testFile.delete();
testDirectory.delete();
}
public IOUtilTest( String name )
{
super( name );
}
private void createFile( File file, long size )
throws IOException
{
BufferedOutputStream output =
new BufferedOutputStream( new FileOutputStream( file ) );
for ( int i = 0; i < size; i++ )
{
output.write( (byte) ( i % 128 ) ); // nice varied byte pattern compatible with Readers and Writers
}
output.close();
}
/** Assert that the contents of two byte arrays are the same. */
private void assertEqualContent( byte[] b0, byte[] b1 )
{
assertTrue( "Content not equal according to java.util.Arrays#equals()", Arrays.equals( b0, b1 ) );
}
/** Assert that the content of two files is the same. */
private void assertEqualContent( File f0, File f1 )
throws IOException
{
FileInputStream is0 = new FileInputStream( f0 );
FileInputStream is1 = new FileInputStream( f1 );
byte[] buf0 = new byte[FILE_SIZE];
byte[] buf1 = new byte[FILE_SIZE];
int n0 = 0;
int n1 = 0;
try
{
while ( -1 != n0 )
{
n0 = is0.read( buf0 );
n1 = is1.read( buf1 );
assertTrue( "The files " + f0 + " and " + f1 +
" have differing number of bytes available (" + n0 +
" vs " + n1 + ")", ( n0 == n1 ) );
assertTrue( "The files " + f0 + " and " + f1 +
" have different content", Arrays.equals( buf0, buf1 ) );
}
}
finally
{
is0.close();
is1.close();
}
}
/** Assert that the content of a file is equal to that in a byte[]. */
private void assertEqualContent( byte[] b0, File file )
throws IOException
{
FileInputStream is = new FileInputStream( file );
byte[] b1 = new byte[b0.length];
int numRead = is.read( b1 );
assertTrue( "Different number of bytes", numRead == b0.length && is.available() == 0 );
for ( int i = 0;
i < numRead;
assertTrue( "Byte " + i + " differs (" + b0[i] + " != " + b1[i] + ")", b0[i] == b1[i] ), i++
)
;
is.close();
}
public void testInputStreamToOutputStream()
throws Exception
{
File destination = newFile( "copy1.txt" );
FileInputStream fin = new FileInputStream( testFile );
FileOutputStream fout = new FileOutputStream( destination );
IOUtil.copy( fin, fout );
assertTrue( "Not all bytes were read", fin.available() == 0 );
fout.flush();
checkFile( destination );
checkWrite( fout );
fout.close();
fin.close();
deleteFile( destination );
}
public void testInputStreamToWriter()
throws Exception
{
File destination = newFile( "copy2.txt" );
FileInputStream fin = new FileInputStream( testFile );
FileWriter fout = new FileWriter( destination );
IOUtil.copy( fin, fout );
assertTrue( "Not all bytes were read", fin.available() == 0 );
fout.flush();
checkFile( destination );
checkWrite( fout );
fout.close();
fin.close();
deleteFile( destination );
}
public void testInputStreamToString()
throws Exception
{
FileInputStream fin = new FileInputStream( testFile );
String out = IOUtil.toString( fin );
assertNotNull( out );
assertTrue( "Not all bytes were read", fin.available() == 0 );
assertTrue( "Wrong output size: out.length()=" + out.length() +
"!=" + FILE_SIZE, out.length() == FILE_SIZE );
fin.close();
}
public void testReaderToOutputStream()
throws Exception
{
File destination = newFile( "copy3.txt" );
FileReader fin = new FileReader( testFile );
FileOutputStream fout = new FileOutputStream( destination );
IOUtil.copy( fin, fout );
//Note: this method *does* flush. It is equivalent to:
// OutputStreamWriter _out = new OutputStreamWriter(fout);
// IOUtil.copy( fin, _out, 4096 ); // copy( Reader, Writer, int );
// _out.flush();
// out = fout;
// Note: rely on the method to flush
checkFile( destination );
checkWrite( fout );
fout.close();
fin.close();
deleteFile( destination );
}
public void testReaderToWriter()
throws Exception
{
File destination = newFile( "copy4.txt" );
FileReader fin = new FileReader( testFile );
FileWriter fout = new FileWriter( destination );
IOUtil.copy( fin, fout );
fout.flush();
checkFile( destination );
checkWrite( fout );
fout.close();
fin.close();
deleteFile( destination );
}
public void testReaderToString()
throws Exception
{
FileReader fin = new FileReader( testFile );
String out = IOUtil.toString( fin );
assertNotNull( out );
assertTrue( "Wrong output size: out.length()=" +
out.length() + "!=" + FILE_SIZE,
out.length() == FILE_SIZE );
fin.close();
}
public void testStringToOutputStream()
throws Exception
{
File destination = newFile( "copy5.txt" );
FileReader fin = new FileReader( testFile );
// Create our String. Rely on testReaderToString() to make sure this is valid.
String str = IOUtil.toString( fin );
FileOutputStream fout = new FileOutputStream( destination );
IOUtil.copy( str, fout );
//Note: this method *does* flush. It is equivalent to:
// OutputStreamWriter _out = new OutputStreamWriter(fout);
// IOUtil.copy( str, _out, 4096 ); // copy( Reader, Writer, int );
// _out.flush();
// out = fout;
// note: we don't flush here; this IOUtils method does it for us
checkFile( destination );
checkWrite( fout );
fout.close();
fin.close();
deleteFile( destination );
}
public void testStringToWriter()
throws Exception
{
File destination = newFile( "copy6.txt" );
FileReader fin = new FileReader( testFile );
// Create our String. Rely on testReaderToString() to make sure this is valid.
String str = IOUtil.toString( fin );
FileWriter fout = new FileWriter( destination );
IOUtil.copy( str, fout );
fout.flush();
checkFile( destination );
checkWrite( fout );
fout.close();
fin.close();
deleteFile( destination );
}
public void testInputStreamToByteArray()
throws Exception
{
FileInputStream fin = new FileInputStream( testFile );
byte[] out = IOUtil.toByteArray( fin );
assertNotNull( out );
assertTrue( "Not all bytes were read", fin.available() == 0 );
assertTrue( "Wrong output size: out.length=" + out.length +
"!=" + FILE_SIZE, out.length == FILE_SIZE );
assertEqualContent( out, testFile );
fin.close();
}
public void testStringToByteArray()
throws Exception
{
FileReader fin = new FileReader( testFile );
// Create our String. Rely on testReaderToString() to make sure this is valid.
String str = IOUtil.toString( fin );
byte[] out = IOUtil.toByteArray( str );
assertEqualContent( str.getBytes(), out );
fin.close();
}
public void testByteArrayToWriter()
throws Exception
{
File destination = newFile( "copy7.txt" );
FileWriter fout = new FileWriter( destination );
FileInputStream fin = new FileInputStream( testFile );
// Create our byte[]. Rely on testInputStreamToByteArray() to make sure this is valid.
byte[] in = IOUtil.toByteArray( fin );
IOUtil.copy( in, fout );
fout.flush();
checkFile( destination );
checkWrite( fout );
fout.close();
fin.close();
deleteFile( destination );
}
public void testByteArrayToString()
throws Exception
{
FileInputStream fin = new FileInputStream( testFile );
byte[] in = IOUtil.toByteArray( fin );
// Create our byte[]. Rely on testInputStreamToByteArray() to make sure this is valid.
String str = IOUtil.toString( in );
assertEqualContent( in, str.getBytes() );
fin.close();
}
public void testByteArrayToOutputStream()
throws Exception
{
File destination = newFile( "copy8.txt" );
FileOutputStream fout = new FileOutputStream( destination );
FileInputStream fin = new FileInputStream( testFile );
// Create our byte[]. Rely on testInputStreamToByteArray() to make sure this is valid.
byte[] in = IOUtil.toByteArray( fin );
IOUtil.copy( in, fout );
fout.flush();
checkFile( destination );
checkWrite( fout );
fout.close();
fin.close();
deleteFile( destination );
}
// ----------------------------------------------------------------------
// Test closeXXX()
// ----------------------------------------------------------------------
public void testCloseInputStream()
throws Exception
{
IOUtil.close( (InputStream) null );
TestInputStream inputStream = new TestInputStream();
IOUtil.close( inputStream );
assertTrue( inputStream.closed );
}
public void testCloseOutputStream()
throws Exception
{
IOUtil.close( (OutputStream) null );
TestOutputStream outputStream = new TestOutputStream();
IOUtil.close( outputStream );
assertTrue( outputStream.closed );
}
public void testCloseReader()
throws Exception
{
IOUtil.close( (Reader) null );
TestReader reader = new TestReader();
IOUtil.close( reader );
assertTrue( reader.closed );
}
public void testCloseWriter()
throws Exception
{
IOUtil.close( (Writer) null );
TestWriter writer = new TestWriter();
IOUtil.close( writer );
assertTrue( writer.closed );
}
private class TestInputStream
extends InputStream
{
boolean closed;
public void close()
{
closed = true;
}
public int read()
{
fail( "This method shouldn't be called" );
return 0;
}
}
private class TestOutputStream
extends OutputStream
{
boolean closed;
public void close()
{
closed = true;
}
public void write( int value )
{
fail( "This method shouldn't be called" );
}
}
private class TestReader
extends Reader
{
boolean closed;
public void close()
{
closed = true;
}
public int read( char cbuf[], int off, int len )
{
fail( "This method shouldn't be called" );
return 0;
}
}
private class TestWriter
extends Writer
{
boolean closed;
public void close()
{
closed = true;
}
public void write( char cbuf[], int off, int len )
{
fail( "This method shouldn't be called" );
}
public void flush()
{
fail( "This method shouldn't be called" );
}
}
// ----------------------------------------------------------------------
// Utility methods
// ----------------------------------------------------------------------
private File newFile( String filename )
throws Exception
{
File destination = new File( testDirectory, filename );
assertTrue( filename + "Test output data file shouldn't previously exist",
!destination.exists() );
return destination;
}
private void checkFile( File file )
throws Exception
{
assertTrue( "Check existence of output file", file.exists() );
assertEqualContent( testFile, file );
}
private void checkWrite( OutputStream output )
throws Exception
{
try
{
new PrintStream( output ).write( 0 );
}
catch ( Throwable t )
{
throw new AssertionFailedError( "The copy() method closed the stream " +
"when it shouldn't have. " + t.getMessage() );
}
}
private void checkWrite( Writer output )
throws Exception
{
try
{
new PrintWriter( output ).write( 'a' );
}
catch ( Throwable t )
{
throw new AssertionFailedError( "The copy() method closed the stream " +
"when it shouldn't have. " + t.getMessage() );
}
}
private void deleteFile( File file )
throws Exception
{
assertTrue( "Wrong output size: file.length()=" +
file.length() + "!=" + FILE_SIZE + 1,
file.length() == FILE_SIZE + 1 );
assertTrue( "File would not delete", ( file.delete() || ( !file.exists() ) ) );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/InterpolationFilterReaderTest.java 0000664 0000000 0000000 00000012604 11660305702 0032452 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.StringReader;
import java.util.HashMap;
import java.util.Map;
import junit.framework.TestCase;
public class InterpolationFilterReaderTest
extends TestCase
{
/*
* Added and commented by jdcasey@03-Feb-2005 because it is a bug in the
* InterpolationFilterReader.
* kenneyw@15-04-2005 fixed the bug.
*/
public void testShouldNotInterpolateExpressionAtEndOfDataWithInvalidEndToken()
throws Exception
{
Map m = new HashMap();
m.put( "test", "TestValue" );
String testStr = "This is a ${test";
assertEquals( "This is a ${test", interpolate( testStr, m ) );
}
/*
* kenneyw@14-04-2005 Added test to check above fix.
*/
public void testShouldNotInterpolateExpressionWithMissingEndToken()
throws Exception
{
Map m = new HashMap();
m.put( "test", "TestValue" );
String testStr = "This is a ${test, really";
assertEquals( "This is a ${test, really", interpolate( testStr, m ) );
}
public void testShouldNotInterpolateWithMalformedStartToken()
throws Exception
{
Map m = new HashMap();
m.put( "test", "testValue" );
String foo = "This is a $!test} again";
assertEquals( "This is a $!test} again", interpolate( foo, m ) );
}
public void testShouldNotInterpolateWithMalformedEndToken()
throws Exception
{
Map m = new HashMap();
m.put( "test", "testValue" );
String foo = "This is a ${test!} again";
assertEquals( "This is a ${test!} again", interpolate( foo, m, "${", "$}" ) );
}
public void testInterpolationWithMulticharDelimiters()
throws Exception
{
Map m = new HashMap();
m.put( "test", "testValue" );
String foo = "This is a ${test$} again";
assertEquals( "This is a testValue again", interpolate( foo, m, "${", "$}" ) );
}
public void testDefaultInterpolationWithNonInterpolatedValueAtEnd()
throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "${name} is an ${noun}. ${not.interpolated}";
assertEquals( "jason is an asshole. ${not.interpolated}", interpolate( foo, m ) );
}
public void testDefaultInterpolationWithInterpolatedValueAtEnd()
throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "${name} is an ${noun}";
assertEquals( "jason is an asshole", interpolate( foo, m ) );
}
public void testInterpolationWithSpecifiedBoundaryTokens()
throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "@name@ is an @noun@. @not.interpolated@ baby @foo@. @bar@";
assertEquals( "jason is an asshole. @not.interpolated@ baby @foo@. @bar@", interpolate( foo, m, "@", "@" ) );
}
public void testInterpolationWithSpecifiedBoundaryTokensWithNonInterpolatedValueAtEnd()
throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "@name@ is an @foobarred@";
assertEquals( "jason is an @foobarred@", interpolate( foo, m, "@", "@" ) );
}
public void testInterpolationWithSpecifiedBoundaryTokensWithInterpolatedValueAtEnd()
throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "@name@ is an @noun@";
assertEquals( "jason is an asshole", interpolate( foo, m, "@", "@" ) );
}
public void testInterpolationWithSpecifiedBoundaryTokensAndAdditionalTokenCharacter()
throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "@name@ (known as jason@somewhere) is an @noun@";
assertEquals( "jason (known as jason@somewhere) is an asshole", interpolate( foo, m, "@", "@" ) );
}
// ----------------------------------------------------------------------
//
// ----------------------------------------------------------------------
private String interpolate( String input, Map context )
throws Exception
{
return IOUtil.toString( new InterpolationFilterReader( new StringReader( input ), context ) );
}
private String interpolate( String input, Map context, String startToken, String endToken )
throws Exception
{
return IOUtil.toString( new InterpolationFilterReader( new StringReader( input ),
context, startToken, endToken ) );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/LineOrientedInterpolatingReaderTest.java 0000664 0000000 0000000 00000014302 11660305702 0033573 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import junit.framework.TestCase;
/**
* Generated by JUnitDoclet, a tool provided by ObjectFab GmbH under LGPL.
* Please see www.junitdoclet.org, www.gnu.org and www.objectfab.de for
* informations about the tool, the licence and the authors.
*/
public class LineOrientedInterpolatingReaderTest
extends TestCase
{
public LineOrientedInterpolatingReaderTest( String name )
{
super( name );
}
/**
* The JUnit setup method
*/
protected void setUp() throws Exception
{
}
/**
* The teardown method for JUnit
*/
protected void tearDown() throws Exception
{
}
/*
* Added and commented by jdcasey@03-Feb-2005 because it is a bug in the
* InterpolationFilterReader.
*/
public void testShouldInterpolateExpressionAtEndOfDataWithInvalidEndToken() throws IOException
{
String testStr = "This is a ${test";
LineOrientedInterpolatingReader iReader = new LineOrientedInterpolatingReader(
new StringReader( testStr ),
Collections
.singletonMap(
"test",
"TestValue" ) );
BufferedReader reader = new BufferedReader( iReader );
String result = reader.readLine();
assertEquals( "This is a ${test", result );
}
public void testDefaultInterpolationWithNonInterpolatedValueAtEnd() throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "${name} is an ${noun}. ${not.interpolated}";
LineOrientedInterpolatingReader reader = new LineOrientedInterpolatingReader( new StringReader( foo ), m );
StringWriter writer = new StringWriter();
IOUtil.copy( reader, writer );
String bar = writer.toString();
assertEquals( "jason is an asshole. ${not.interpolated}", bar );
}
public void testDefaultInterpolationWithEscapedExpression() throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "${name} is an ${noun}. \\${noun} value";
LineOrientedInterpolatingReader reader = new LineOrientedInterpolatingReader( new StringReader( foo ), m );
StringWriter writer = new StringWriter();
IOUtil.copy( reader, writer );
String bar = writer.toString();
assertEquals( "jason is an asshole. ${noun} value", bar );
}
public void testDefaultInterpolationWithInterpolatedValueAtEnd() throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "${name} is an ${noun}";
LineOrientedInterpolatingReader reader = new LineOrientedInterpolatingReader( new StringReader( foo ), m );
StringWriter writer = new StringWriter();
IOUtil.copy( reader, writer );
String bar = writer.toString();
assertEquals( "jason is an asshole", bar );
}
public void testInterpolationWithSpecifiedBoundaryTokens() throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "@name@ is an @noun@. @not.interpolated@ baby @foo@. @bar@";
LineOrientedInterpolatingReader reader = new LineOrientedInterpolatingReader( new StringReader( foo ), m, "@",
"@" );
StringWriter writer = new StringWriter();
IOUtil.copy( reader, writer );
String bar = writer.toString();
assertEquals( "jason is an asshole. @not.interpolated@ baby @foo@. @bar@", bar );
}
public void testInterpolationWithSpecifiedBoundaryTokensWithNonInterpolatedValueAtEnd() throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "@name@ is an @foobarred@";
LineOrientedInterpolatingReader reader = new LineOrientedInterpolatingReader( new StringReader( foo ), m, "@",
"@" );
StringWriter writer = new StringWriter();
IOUtil.copy( reader, writer );
String bar = writer.toString();
assertEquals( "jason is an @foobarred@", bar );
}
public void testInterpolationWithSpecifiedBoundaryTokensWithInterpolatedValueAtEnd() throws Exception
{
Map m = new HashMap();
m.put( "name", "jason" );
m.put( "noun", "asshole" );
String foo = "@name@ is an @noun@";
LineOrientedInterpolatingReader reader = new LineOrientedInterpolatingReader( new StringReader( foo ), m, "@",
"@" );
StringWriter writer = new StringWriter();
IOUtil.copy( reader, writer );
String bar = writer.toString();
assertEquals( "jason is an asshole", bar );
}
} plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/OsTest.java 0000664 0000000 0000000 00000005076 11660305702 0025720 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.util.Iterator;
import junit.framework.TestCase;
/**
* Test Case for Os
*/
public class OsTest
extends TestCase
{
public void testUndefinedFamily()
{
assertFalse( Os.isFamily( "bogus family" ) );
}
public void testOs()
{
Iterator iter = Os.getValidFamilies().iterator();
String currentFamily = null;
String notCurrentFamily = null;
while ( iter.hasNext() && ( currentFamily == null || notCurrentFamily == null ) )
{
String fam = (String) iter.next();
if ( Os.isFamily( fam ) )
{
currentFamily = fam;
}
else
{
notCurrentFamily = fam;
}
}
//make sure the OS_FAMILY is set right.
assertEquals( currentFamily, Os.OS_FAMILY );
// check the current family and one of the others
assertTrue( Os.isOs( currentFamily, null, null, null ) );
assertFalse( Os.isOs( notCurrentFamily, null, null, null ) );
// check for junk
assertFalse( Os.isOs( "junk", null, null, null ) );
// check the current name
assertTrue( Os.isOs( currentFamily, Os.OS_NAME, null, null ) );
// check some other name
assertFalse( Os.isOs( currentFamily, "myos", null, null ) );
// check the arch
assertTrue( Os.isOs( currentFamily, Os.OS_NAME, Os.OS_ARCH, null ) );
assertFalse( Os.isOs( currentFamily, Os.OS_NAME, "myarch", null ) );
// check the version
assertTrue( Os.isOs( currentFamily, Os.OS_NAME, Os.OS_ARCH, Os.OS_VERSION ) );
assertFalse( Os.isOs( currentFamily, Os.OS_NAME, Os.OS_ARCH, "myversion" ) );
}
public void testValidList()
{
assertTrue(Os.isValidFamily( "dos" ) );
assertFalse( Os.isValidFamily( "" ) );
assertFalse( Os.isValidFamily( null ) );
assertFalse( Os.isValidFamily( "something" ) );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/PathToolTest.java 0000664 0000000 0000000 00000014137 11660305702 0027067 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
/**
* @author Vincent Siveton
* @version $Id: PathToolTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class PathToolTest
extends TestCase
{
/**
* @throws Exception
*/
public void testGetRelativePath()
throws Exception
{
assertEquals( PathTool.getRelativePath( null, null ), "" );
assertEquals( PathTool.getRelativePath( null, "/usr/local/java/bin" ), "" );
assertEquals( PathTool.getRelativePath( "/usr/local/", null ), "" );
assertEquals( PathTool.getRelativePath( "/usr/local/", "/usr/local/java/bin" ), ".." );
assertEquals( PathTool.getRelativePath( "/usr/local/", "/usr/local/java/bin/java.sh" ), "../.." );
assertEquals( PathTool.getRelativePath( "/usr/local/java/bin/java.sh", "/usr/local/" ), "" );
}
/**
* @throws Exception
*/
public void testGetDirectoryComponent()
throws Exception
{
assertEquals( PathTool.getDirectoryComponent( null ), "" );
assertEquals( PathTool.getDirectoryComponent( "/usr/local/java/bin" ), "/usr/local/java" );
assertEquals( PathTool.getDirectoryComponent( "/usr/local/java/bin/" ), "/usr/local/java/bin" );
assertEquals( PathTool.getDirectoryComponent( "/usr/local/java/bin/java.sh" ), "/usr/local/java/bin" );
}
/**
* @throws Exception
*/
public void testCalculateLink()
throws Exception
{
assertEquals( PathTool.calculateLink( "/index.html", "../.." ), "../../index.html" );
assertEquals( PathTool.calculateLink( "http://plexus.codehaus.org/plexus-utils/index.html", "../.." ),
"http://plexus.codehaus.org/plexus-utils/index.html" );
assertEquals( PathTool.calculateLink( "/usr/local/java/bin/java.sh", "../.." ),
"../../usr/local/java/bin/java.sh" );
assertEquals( PathTool.calculateLink( "../index.html", "/usr/local/java/bin" ),
"/usr/local/java/bin/../index.html" );
assertEquals( PathTool.calculateLink( "../index.html", "http://plexus.codehaus.org/plexus-utils" ),
"http://plexus.codehaus.org/plexus-utils/../index.html" );
}
/**
* @throws Exception
*/
public void testGetRelativeWebPath()
throws Exception
{
assertEquals( PathTool.getRelativeWebPath( null, null ), "" );
assertEquals( PathTool.getRelativeWebPath( null, "http://plexus.codehaus.org/" ), "" );
assertEquals( PathTool.getRelativeWebPath( "http://plexus.codehaus.org/", null ), "" );
assertEquals( PathTool.getRelativeWebPath( "http://plexus.codehaus.org/",
"http://plexus.codehaus.org/plexus-utils/index.html" ),
"plexus-utils/index.html" );
assertEquals( PathTool.getRelativeWebPath( "http://plexus.codehaus.org/plexus-utils/index.html",
"http://plexus.codehaus.org/" ), "../../" );
}
/**
* @throws Exception
*/
public void testGetRelativeFilePath()
throws Exception
{
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
assertEquals( PathTool.getRelativeFilePath( null, null ), "" );
assertEquals( PathTool.getRelativeFilePath( null, "c:\\tools\\java\\bin" ), "" );
assertEquals( PathTool.getRelativeFilePath( "c:\\tools\\java", null ), "" );
assertEquals( PathTool.getRelativeFilePath( "c:\\tools", "c:\\tools\\java\\bin" ), "java\\bin" );
assertEquals( PathTool.getRelativeFilePath( "c:\\tools", "c:\\tools\\java\\bin\\" ), "java\\bin\\" );
assertEquals( PathTool.getRelativeFilePath( "c:\\tools\\java\\bin", "c:\\tools" ), "..\\.." );
assertEquals( PathTool.getRelativeFilePath( "c:\\tools\\", "c:\\tools\\java\\bin\\java.exe" ),
"java\\bin\\java.exe" );
assertEquals( PathTool.getRelativeFilePath( "c:\\tools\\java\\bin\\java.sh", "c:\\tools" ), "..\\..\\.." );
assertEquals( PathTool.getRelativeFilePath( "c:\\tools", "c:\\bin" ), "..\\bin" );
assertEquals( PathTool.getRelativeFilePath( "c:\\bin", "c:\\tools" ), "..\\tools" );
assertEquals( PathTool.getRelativeFilePath( "c:\\bin", "c:\\bin" ), "" );
}
else
{
assertEquals( PathTool.getRelativeFilePath( null, null ), "" );
assertEquals( PathTool.getRelativeFilePath( null, "/usr/local/java/bin" ), "" );
assertEquals( PathTool.getRelativeFilePath( "/usr/local", null ), "" );
assertEquals( PathTool.getRelativeFilePath( "/usr/local", "/usr/local/java/bin" ), "java/bin" );
assertEquals( PathTool.getRelativeFilePath( "/usr/local", "/usr/local/java/bin/" ), "java/bin/" );
assertEquals( PathTool.getRelativeFilePath( "/usr/local/java/bin", "/usr/local/" ), "../../" );
assertEquals( PathTool.getRelativeFilePath( "/usr/local/", "/usr/local/java/bin/java.sh" ),
"java/bin/java.sh" );
assertEquals( PathTool.getRelativeFilePath( "/usr/local/java/bin/java.sh", "/usr/local/" ), "../../../" );
assertEquals( PathTool.getRelativeFilePath( "/usr/local/", "/bin" ), "../../bin" );
assertEquals( PathTool.getRelativeFilePath( "/bin", "/usr/local" ), "../usr/local" );
assertEquals( PathTool.getRelativeFilePath( "/bin", "/bin" ), "" );
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/ReflectionUtilsTest.java 0000664 0000000 0000000 00000005723 11660305702 0030451 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
import java.util.Map;
import java.util.HashMap;
/**
* This is used to test ReflectionUtils for correctness.
*
* @author Jesse McConnell
* @version $Id:$
* @see org.codehaus.plexus.util.ReflectionUtils
*/
public final class ReflectionUtilsTest
extends TestCase
{
public ReflectionUtilsTestClass testClass = new ReflectionUtilsTestClass();
protected void setUp() throws Exception
{
}
public void testSimpleVariableAccess()
throws IllegalAccessException
{
assertEquals("woohoo", (String)ReflectionUtils.getValueIncludingSuperclasses( "myString", testClass ) );
}
public void testComplexVariableAccess()
throws IllegalAccessException
{
Map map = (Map)ReflectionUtils.getVariablesAndValuesIncludingSuperclasses( testClass );
Map myMap = (Map)map.get( "myMap" );
assertEquals( "myValue", (String)myMap.get( "myKey" ) );
assertEquals( "myOtherValue", (String)myMap.get( "myOtherKey") );
}
public void testSuperClassVariableAccess()
throws IllegalAccessException
{
assertEquals("super-duper", (String)ReflectionUtils.getValueIncludingSuperclasses( "mySuperString", testClass ) );
}
public void testSettingVariableValue()
throws IllegalAccessException
{
ReflectionUtils.setVariableValueInObject( testClass, "mySettableString", "mySetString" );
assertEquals("mySetString", (String)ReflectionUtils.getValueIncludingSuperclasses( "mySettableString", testClass ) );
ReflectionUtils.setVariableValueInObject( testClass, "myParentsSettableString", "myParentsSetString" );
assertEquals("myParentsSetString", (String)ReflectionUtils.getValueIncludingSuperclasses( "myParentsSettableString", testClass ) );
}
private class ReflectionUtilsTestClass
extends AbstractReflectionUtilsTestClass
{
private String myString = "woohoo";
private String mySettableString;
private Map myMap = new HashMap();
public ReflectionUtilsTestClass()
{
myMap.put("myKey", "myValue");
myMap.put( "myOtherKey", "myOtherValue" );
}
}
private class AbstractReflectionUtilsTestClass
{
private String mySuperString = "super-duper";
private String myParentsSettableString;
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/StringInputStreamTest.java 0000664 0000000 0000000 00000001560 11660305702 0030773 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
/**
* @author Ben Walding
* @version $Id: StringInputStreamTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class StringInputStreamTest extends TestCase
{
public void testFoo()
{
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/StringUtilsTest.java 0000664 0000000 0000000 00000020016 11660305702 0027615 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.util.Arrays;
import java.util.Locale;
import junit.framework.TestCase;
/**
* Test string utils.
*
* @author Brett Porter
* @version $Id: StringUtilsTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class StringUtilsTest
extends TestCase
{
public void testIsEmpty()
{
assertEquals( true, StringUtils.isEmpty( null ) );
assertEquals( true, StringUtils.isEmpty( "" ) );
assertEquals( true, StringUtils.isEmpty( " " ) );
assertEquals( false, StringUtils.isEmpty( "foo" ) );
assertEquals( false, StringUtils.isEmpty( " foo " ) );
}
public void testIsNotEmpty()
{
assertEquals( false, StringUtils.isNotEmpty( null ) );
assertEquals( false, StringUtils.isNotEmpty( "" ) );
assertEquals( true, StringUtils.isNotEmpty( " " ) );
assertEquals( true, StringUtils.isNotEmpty( "foo" ) );
assertEquals( true, StringUtils.isNotEmpty( " foo " ) );
}
public void testIsBlank()
{
assertEquals( true, StringUtils.isBlank( null ) );
assertEquals( true, StringUtils.isBlank( "" ) );
assertEquals( true, StringUtils.isBlank( " \t\r\n" ) );
assertEquals( false, StringUtils.isBlank( "foo" ) );
assertEquals( false, StringUtils.isBlank( " foo " ) );
}
public void testIsNotBlank()
{
assertEquals( false, StringUtils.isNotBlank( null ) );
assertEquals( false, StringUtils.isNotBlank( "" ) );
assertEquals( false, StringUtils.isNotBlank( " \t\r\n" ) );
assertEquals( true, StringUtils.isNotBlank( "foo" ) );
assertEquals( true, StringUtils.isNotBlank( " foo " ) );
}
public void testCapitalizeFirstLetter()
{
assertEquals( "Id", StringUtils.capitalizeFirstLetter( "id" ) );
assertEquals( "Id", StringUtils.capitalizeFirstLetter( "Id" ) );
}
public void testCapitalizeFirstLetterTurkish()
{
Locale l = Locale.getDefault();
Locale.setDefault( new Locale( "tr" ) );
assertEquals( "Id", StringUtils.capitalizeFirstLetter( "id" ) );
assertEquals( "Id", StringUtils.capitalizeFirstLetter( "Id" ) );
Locale.setDefault( l );
}
public void testLowerCaseFirstLetter()
{
assertEquals( "id", StringUtils.lowercaseFirstLetter( "id" ) );
assertEquals( "id", StringUtils.lowercaseFirstLetter( "Id" ) );
}
public void testLowerCaseFirstLetterTurkish()
{
Locale l = Locale.getDefault();
Locale.setDefault( new Locale( "tr" ) );
assertEquals( "id", StringUtils.lowercaseFirstLetter( "id" ) );
assertEquals( "id", StringUtils.lowercaseFirstLetter( "Id" ) );
Locale.setDefault( l );
}
public void testRemoveAndHump()
{
assertEquals( "Id", StringUtils.removeAndHump( "id", "-" ) );
assertEquals( "SomeId", StringUtils.removeAndHump( "some-id", "-" ) );
}
public void testRemoveAndHumpTurkish()
{
Locale l = Locale.getDefault();
Locale.setDefault( new Locale( "tr" ) );
assertEquals( "Id", StringUtils.removeAndHump( "id", "-" ) );
assertEquals( "SomeId", StringUtils.removeAndHump( "some-id", "-" ) );
Locale.setDefault( l );
}
public void testQuote_EscapeEmbeddedSingleQuotes()
{
String src = "This \'is a\' test";
String check = "\'This \\\'is a\\\' test\'";
char[] escaped = { '\'', '\"' };
String result = StringUtils.quoteAndEscape( src, '\'', escaped, '\\', false );
assertEquals( check, result );
}
public void testQuote_EscapeEmbeddedDoubleQuotesAndSpaces()
{
String src = "This \"is a\" test";
String check = "\'This\\ \\\"is\\ a\\\"\\ test\'";
char[] escaped = { '\'', '\"', ' ' };
String result = StringUtils.quoteAndEscape( src, '\'', escaped, '\\', false );
assertEquals( check, result );
}
public void testQuote_DontQuoteIfUnneeded()
{
String src = "ThisIsATest";
char[] escaped = { '\'', '\"' };
String result = StringUtils.quoteAndEscape( src, '\'', escaped, '\\', false );
assertEquals( src, result );
}
public void testQuote_WrapWithSingleQuotes()
{
String src = "This is a test";
String check = "\'This is a test\'";
char[] escaped = { '\'', '\"' };
String result = StringUtils.quoteAndEscape( src, '\'', escaped, '\\', false );
assertEquals( check, result );
}
public void testQuote_PreserveExistingQuotes()
{
String src = "\'This is a test\'";
char[] escaped = { '\'', '\"' };
String result = StringUtils.quoteAndEscape( src, '\'', escaped, '\\', false );
assertEquals( src, result );
}
public void testQuote_WrapExistingQuotesWhenForceIsTrue()
{
String src = "\'This is a test\'";
String check = "\'\\\'This is a test\\\'\'";
char[] escaped = { '\'', '\"' };
String result = StringUtils.quoteAndEscape( src, '\'', escaped, '\\', true );
assertEquals( check, result );
}
public void testQuote_ShortVersion_SingleQuotesPreserved()
{
String src = "\'This is a test\'";
String result = StringUtils.quoteAndEscape( src, '\'' );
assertEquals( src, result );
}
public void testSplit()
{
String[] tokens;
tokens = StringUtils.split( "", ", " );
assertNotNull( tokens );
assertEquals( Arrays.asList( new String[0] ), Arrays.asList( tokens ) );
tokens = StringUtils.split( ", ,,, ,", ", " );
assertNotNull( tokens );
assertEquals( Arrays.asList( new String[0] ), Arrays.asList( tokens ) );
tokens = StringUtils.split( "this", ", " );
assertNotNull( tokens );
assertEquals( Arrays.asList( new String[] { "this" } ), Arrays.asList( tokens ) );
tokens = StringUtils.split( "this is a test", ", " );
assertNotNull( tokens );
assertEquals( Arrays.asList( new String[] { "this", "is", "a", "test" } ), Arrays.asList( tokens ) );
tokens = StringUtils.split( " this is a test ", ", " );
assertNotNull( tokens );
assertEquals( Arrays.asList( new String[] { "this", "is", "a", "test" } ), Arrays.asList( tokens ) );
tokens = StringUtils.split( "this is a test, really", ", " );
assertNotNull( tokens );
assertEquals( Arrays.asList( new String[] { "this", "is", "a", "test", "really" } ), Arrays.asList( tokens ) );
}
public void testRemoveDuplicateWhitespace()
throws Exception
{
String s = "this is test ";
assertEquals( "this is test ", StringUtils.removeDuplicateWhitespace( s ) );
s = "this \r\n is \n \r test ";
assertEquals( "this is test ", StringUtils.removeDuplicateWhitespace( s ) );
}
public void testUnifyLineSeparators()
throws Exception
{
String s = "this\r\nis\na\r\ntest";
try
{
StringUtils.unifyLineSeparators( s, "abs" );
assertTrue( "Exception NOT catched", false );
}
catch ( IllegalArgumentException e)
{
assertTrue( "Exception catched", true );
}
assertEquals( "this\nis\na\ntest", StringUtils.unifyLineSeparators( s, "\n" ) );
assertEquals( "this\r\nis\r\na\r\ntest", StringUtils.unifyLineSeparators( s, "\r\n" ) );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/SweeperPoolTest.java 0000664 0000000 0000000 00000012637 11660305702 0027604 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
import java.util.Vector;
/**
* Created on 21/06/2003
*
* @author Bert van Brakel
* @version $Revision: 8010 $
*/
public class SweeperPoolTest extends TestCase
{
/** The pool under test */
TestObjectPool pool;
/** A bunch of object to pool */
Object o1;
Object o2;
Object o3;
Object o4;
Object o5;
Object o6;
/**
* Constructor
*
*
*/
public SweeperPoolTest()
{
super();
}
/**
* Constructor
*
* @param arg0
*/
public SweeperPoolTest( String arg0 )
{
super( arg0 );
}
/**
* Test the pool limits it's size, and disposes unneeded objects correctly
*
*/
public void testMaxSize()
{
int sweepInterval = 0;
int initialCapacity = 5;
int maxSize = 2;
int minSize = 1;
int triggerSize = 2;
pool =
new TestObjectPool(
maxSize,
minSize,
initialCapacity,
sweepInterval,
triggerSize );
Object tmp = pool.get();
assertNull( "Expected object from pool to be null", tmp );
pool.put( o1 );
assertEquals( "Expected pool to contain 1 object", 1, pool.getSize() );
tmp = pool.get();
assertSame(
"Expected returned pool object to be the same as the one put in",
tmp,
o1 );
pool.put( o1 );
pool.put( o2 );
assertEquals( "Expected pool to contain 2 objects", 2, pool.getSize() );
pool.put( o3 );
assertEquals(
"Expected pool to contain only a maximuim of 2 objects.",
2,
pool.getSize() );
assertEquals(
"Expected 1 disposed pool object",
1,
pool.testGetDisposedObjects().size() );
tmp = pool.testGetDisposedObjects().iterator().next();
tmp = pool.get();
assertEquals(
"Expected pool size to be 1 after removing one object",
1,
pool.getSize() );
Object tmp2 = pool.get();
assertEquals(
"Expected pool size to be 0 after removing 2 objects",
0,
pool.getSize() );
assertNotSame( "Expected returned objects to be differnet", tmp, tmp2 );
}
public void testSweepAndTrim1()
{
//test trigger
int sweepInterval = 1;
int initialCapacity = 5;
int maxSize = 5;
int minSize = 1;
int triggerSize = 2;
pool =
new TestObjectPool(
maxSize,
minSize,
initialCapacity,
sweepInterval,
triggerSize );
pool.put( o1 );
pool.put( o2 );
pool.put( o3 );
pool.put( o4 );
//give the seeper some time to run
synchronized ( this )
{
try
{
wait( 2 * 1000 );
}
catch ( InterruptedException e )
{
fail(
"Unexpected exception thrown. e="
+ Tracer.traceToString( e ) );
}
}
assertEquals(
"Expected pool to only contain 1 object",
1,
pool.getSize() );
assertEquals(
"Expected 3 diposed objects",
3,
pool.testGetDisposedObjects().size() );
}
/**
* @see junit.framework.TestCase#setUp()
*/
protected void setUp() throws Exception
{
o1 = new Object();
o2 = new Object();
o3 = new Object();
o4 = new Object();
o5 = new Object();
o6 = new Object();
super.setUp();
}
/**
* @see junit.framework.TestCase#tearDown()
*/
protected void tearDown() throws Exception
{
pool.dispose();
assertTrue( pool.isDisposed() );
pool = null;
super.tearDown();
}
class TestObjectPool extends SweeperPool
{
private Vector disposedObjects = new Vector();
public TestObjectPool(
int maxSize,
int minSize,
int intialCapacity,
int sweepInterval,
int triggerSize )
{
super( maxSize, minSize, intialCapacity, sweepInterval, triggerSize );
}
public void reset()
{
disposedObjects.clear();
}
/**
* @see nz.co.bonzo.beans.castor.pool.ObjectPool#objectDisposed(java.lang.Object)
*/
public void objectDisposed( Object obj )
{
disposedObjects.add( obj );
}
public Vector testGetDisposedObjects()
{
return disposedObjects;
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/TestThreadManager.java 0000664 0000000 0000000 00000012122 11660305702 0030027 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.util.Collection;
import java.util.Iterator;
import java.util.Vector;
import java.util.logging.Logger;
/**
* Manages a number of test threads, which notify this manager when they have
* completed. Allows TestCases to easily start and manage multiple test threads.
*
* Created on 9/06/2003
*
* @author Bert van Brakel
* @version $Revision: 8010 $
*
*/
public class TestThreadManager
{
//~ Instance fields ----------------------------------------------------------------------------
/** Test threads which have completed running */
private Collection runThreads = new Vector();
/** Test threads still needing to be run, or are currently running*/
private Collection toRunThreads = new Vector();
private Logger logger = null;
/** Any test threads which failed */
private Vector failedThreads = new Vector();
/**The object to notify when all the test threads have complleted. Clients use this
* to lock on (wait) while waiting for the tests to complete*/
private Object notify = null;
//~ Constructors -------------------------------------------------------------------------------
public TestThreadManager( Object notify )
{
super();
this.notify = notify;
}
//~ Methods ------------------------------------------------------------------------------------
/**
* @return
*/
public Collection getRunThreads()
{
return runThreads;
}
public void runTestThreads()
{
failedThreads.clear();
//use an array as the tests may run very quickly
//and modify the toRunThreads vector and hence
//cause a Concurrent ModificationException on an
//iterator
Object[] threads = toRunThreads.toArray();
for ( int i = 0; i < threads.length; i++ )
{
//System.out.println("Starting thread " + i +" ..." );
( (AbstractTestThread) threads[i] ).start();
}
}
public Collection getFailedTests()
{
return failedThreads;
}
/**
* Return the object which threads can wait on to be notified
* when all the test threads have completed running
*
* @return
*/
public Object getNotifyObject()
{
return notify;
}
public boolean hasFailedThreads()
{
if ( failedThreads.size() == 0 )
{
return false;
}
else
return true;
}
/**
* Determine if any threads are still running!
*
* @return DOCUMENT ME!
*/
public boolean isStillRunningThreads()
{
return !toRunThreads.isEmpty();
}
/**
* @return
*/
public Collection getToRunThreads()
{
return toRunThreads;
}
/**
* DOCUMENT ME!
*/
public void clear()
{
toRunThreads.clear();
runThreads.clear();
failedThreads.clear();
}
/* (non-Javadoc)
* @see java.util.Collection#remove(java.lang.Object)
*/
public synchronized void completed( AbstractTestThread thread )
{
toRunThreads.remove( thread );
runThreads.add( thread );
if ( thread.hasFailed() )
{
failedThreads.add( thread );
}
//wakeup thread which is waiting for the threads to complete
//execution
if ( toRunThreads.isEmpty() )
{
synchronized ( notify )
{
notify.notify();
}
}
}
/**
* Overide this to add your own stuff. Called after
* registerThread(Object)
*
* @param thread DOCUMENT ME!
*/
public void doRegisterThread( AbstractTestThread thread )
{
}
public final void registerThread( AbstractTestThread thread )
{
thread.setThreadRegistry( this );
if ( toRunThreads.contains( thread ) == false )
{
toRunThreads.add( thread );
doRegisterThread( thread );
}
}
/**
* Put all the runThreads back in the que to be run again and
* clear the failedTest collection
*/
public void reset()
{
toRunThreads.clear();
Iterator iter = runThreads.iterator();
while ( iter.hasNext() )
{
AbstractTestThread test = (AbstractTestThread) iter.next();
test.reset();
registerThread( test );
}
runThreads.clear();
failedThreads.clear();
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/Tracer.java 0000664 0000000 0000000 00000002512 11660305702 0025707 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.PrintWriter;
import java.io.StringWriter;
/**
* Convenience class to handle throwable stacktraces
*
* Created on 18/06/2003
*
* @author Bert van Brakel
* @version $Revision: 8010 $
*/
public class Tracer
{
/**
* Constructor
*
*
*/
private Tracer()
{
super();
}
/**
* Return the throwable stack trace as a string
* */
public static String traceToString( Throwable t )
{
if ( t == null )
{
return null;
}
StringWriter sw = new StringWriter();
t.printStackTrace( new PrintWriter( sw ) );
return sw.toString();
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/WalkCollector.java 0000664 0000000 0000000 00000003367 11660305702 0027245 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.File;
import java.util.ArrayList;
import java.util.List;
class WalkCollector
implements DirectoryWalkListener
{
public List steps;
public File startingDir;
public int startCount;
public int finishCount;
public int percentageLow;
public int percentageHigh;
public WalkCollector()
{
steps = new ArrayList();
startCount = 0;
finishCount = 0;
percentageLow = 0;
percentageHigh = 0;
}
public void directoryWalkStarting( File basedir )
{
debug( "Walk Starting: " + basedir );
startCount++;
startingDir = basedir;
}
public void directoryWalkStep( int percentage, File file )
{
percentageLow = Math.min( percentageLow, percentage );
percentageHigh = Math.max( percentageHigh, percentage );
debug( "Walk Step: [" + percentage + "%] " + file );
steps.add( file );
}
public void directoryWalkFinished()
{
debug( "Walk Finished." );
finishCount++;
}
public void debug( String message )
{
System.out.println( message );
}
} plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/cli/ 0000775 0000000 0000000 00000000000 11660305702 0024373 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/cli/CommandLineUtilsTest.java 0000664 0000000 0000000 00000007515 11660305702 0031315 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.cli;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.util.Arrays;
import java.util.Iterator;
import java.util.Locale;
import java.util.Properties;
import org.codehaus.plexus.util.Os;
import junit.framework.TestCase;
public class CommandLineUtilsTest
extends TestCase
{
public void testQuoteArguments()
{
try
{
String result = CommandLineUtils.quote( "Hello" );
System.out.println( result );
assertEquals( "Hello", result );
result = CommandLineUtils.quote( "Hello World" );
System.out.println( result );
assertEquals( "\"Hello World\"", result );
result = CommandLineUtils.quote( "\"Hello World\"" );
System.out.println( result );
assertEquals( "\'\"Hello World\"\'", result );
}
catch ( Exception e )
{
fail( e.getMessage() );
}
try
{
CommandLineUtils.quote( "\"Hello \'World\'\'" );
fail();
}
catch ( Exception e )
{
}
}
/**
* Tests that case-insensitive environment variables are normalized to upper case.
*/
public void testGetSystemEnvVarsCaseInsensitive()
throws Exception
{
Properties vars = CommandLineUtils.getSystemEnvVars( false );
for ( Iterator it = vars.keySet().iterator(); it.hasNext(); )
{
String variable = (String) it.next();
assertEquals( variable.toUpperCase( Locale.ENGLISH ), variable );
}
}
/**
* Tests that environment variables on Windows are normalized to upper case. Does nothing on Unix platforms.
*/
public void testGetSystemEnvVarsWindows()
throws Exception
{
if ( !Os.isFamily( Os.FAMILY_WINDOWS ) )
{
return;
}
Properties vars = CommandLineUtils.getSystemEnvVars();
for ( Iterator it = vars.keySet().iterator(); it.hasNext(); )
{
String variable = (String) it.next();
assertEquals( variable.toUpperCase( Locale.ENGLISH ), variable );
}
}
/**
* Tests the splitting of a command line into distinct arguments.
*/
public void testTranslateCommandline()
throws Exception
{
assertCmdLineArgs( new String[] {}, null );
assertCmdLineArgs( new String[] {}, "" );
assertCmdLineArgs( new String[] { "foo", "bar" }, "foo bar" );
assertCmdLineArgs( new String[] { "foo", "bar" }, " foo bar " );
assertCmdLineArgs( new String[] { "foo", " double quotes ", "bar" }, "foo \" double quotes \" bar" );
assertCmdLineArgs( new String[] { "foo", " single quotes ", "bar" }, "foo ' single quotes ' bar" );
assertCmdLineArgs( new String[] { "foo", " \" ", "bar" }, "foo ' \" ' bar" );
assertCmdLineArgs( new String[] { "foo", " ' ", "bar" }, "foo \" ' \" bar" );
}
private void assertCmdLineArgs( String[] expected, String cmdLine )
throws Exception
{
String[] actual = CommandLineUtils.translateCommandline( cmdLine );
assertNotNull( actual );
assertEquals( expected.length, actual.length );
assertEquals( Arrays.asList( expected ), Arrays.asList( actual ) );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/cli/CommandlineTest.java 0000664 0000000 0000000 00000046775 11660305702 0030347 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.cli;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.Os;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.cli.shell.BourneShell;
import org.codehaus.plexus.util.cli.shell.CmdShell;
import org.codehaus.plexus.util.cli.shell.Shell;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import junit.framework.TestCase;
public class CommandlineTest
extends TestCase
{
private String baseDir;
/**
* @param testName
*/
public CommandlineTest( final String testName )
{
super( testName );
}
/*
* @see TestCase#setUp()
*/
public void setUp()
throws Exception
{
super.setUp();
baseDir = System.getProperty( "basedir" );
if ( baseDir == null )
{
baseDir = new File( "." ).getCanonicalPath();
}
}
public void testCommandlineWithoutCommandInConstructor()
{
try
{
Commandline cmd = new Commandline( new Shell() );
cmd.setWorkingDirectory( baseDir );
cmd.createArgument().setValue( "cd" );
cmd.createArgument().setValue( "." );
// NOTE: cmd.toString() uses CommandLineUtils.toString( String[] ), which *quotes* the result.
assertEquals( "cd .", cmd.toString() );
}
catch ( Exception e )
{
fail( e.getMessage() );
}
}
public void testCommandlineWithCommandInConstructor()
{
try
{
Commandline cmd = new Commandline( "cd .", new Shell() );
cmd.setWorkingDirectory( baseDir );
// NOTE: cmd.toString() uses CommandLineUtils.toString( String[] ), which *quotes* the result.
assertEquals( "cd .", cmd.toString() );
}
catch ( Exception e )
{
fail( e.getMessage() );
}
}
public void testExecute()
{
try
{
// allow it to detect the proper shell here.
Commandline cmd = new Commandline();
cmd.setWorkingDirectory( baseDir );
cmd.setExecutable( "echo" );
assertEquals( "echo", cmd.getShell().getOriginalExecutable() );
cmd.createArgument().setValue( "Hello" );
StringWriter swriter = new StringWriter();
Process process = cmd.execute();
Reader reader = new InputStreamReader( process.getInputStream() );
char[] chars = new char[16];
int read = -1;
while ( ( read = reader.read( chars ) ) > -1 )
{
swriter.write( chars, 0, read );
}
String output = swriter.toString().trim();
assertEquals( "Hello", output );
}
catch ( Exception e )
{
fail( e.getMessage() );
}
}
public void testSetLine()
{
try
{
Commandline cmd = new Commandline( new Shell() );
cmd.setWorkingDirectory( baseDir );
cmd.setExecutable( "echo" );
cmd.createArgument().setLine( null );
cmd.createArgument().setLine( "Hello" );
// NOTE: cmd.toString() uses CommandLineUtils.toString( String[] ), which *quotes* the result.
assertEquals( "echo Hello", cmd.toString() );
}
catch ( Exception e )
{
fail( e.getMessage() );
}
}
public void testCreateCommandInReverseOrder()
{
try
{
Commandline cmd = new Commandline( new Shell() );
cmd.setWorkingDirectory( baseDir );
cmd.createArgument().setValue( "." );
cmd.createArgument( true ).setValue( "cd" );
// NOTE: cmd.toString() uses CommandLineUtils.toString( String[] ), which *quotes* the result.
assertEquals( "cd .", cmd.toString() );
}
catch ( Exception e )
{
fail( e.getMessage() );
}
}
public void testSetFile()
{
try
{
Commandline cmd = new Commandline( new Shell() );
cmd.setWorkingDirectory( baseDir );
cmd.createArgument().setValue( "more" );
File f = new File( "test.txt" );
cmd.createArgument().setFile( f );
String fileName = f.getAbsolutePath();
if ( fileName.indexOf( " " ) >= 0 )
{
fileName = "\"" + fileName + "\"";
}
// NOTE: cmd.toString() uses CommandLineUtils.toString( String[] ), which *quotes* the result.
assertEquals( "more " + fileName, cmd.toString() );
}
catch ( Exception e )
{
fail( e.getMessage() );
}
}
public void testGetShellCommandLineWindows()
throws Exception
{
Commandline cmd = new Commandline( new CmdShell() );
cmd.setExecutable( "c:\\Program Files\\xxx" );
cmd.addArguments( new String[] {
"a",
"b"
} );
String[] shellCommandline = cmd.getShellCommandline();
assertEquals( "Command line size", 4, shellCommandline.length );
assertEquals( "cmd.exe", shellCommandline[0] );
assertEquals( "/X", shellCommandline[1] );
assertEquals( "/C", shellCommandline[2] );
String expectedShellCmd = "\"c:" + File.separator + "Program Files" + File.separator
+ "xxx\" a b";
expectedShellCmd = "\"" + expectedShellCmd + "\"";
assertEquals( expectedShellCmd, shellCommandline[3] );
}
public void testGetShellCommandLineWindowsWithSeveralQuotes()
throws Exception
{
Commandline cmd = new Commandline( new CmdShell() );
cmd.setExecutable( "c:\\Program Files\\xxx" );
cmd.addArguments( new String[] {
"c:\\Documents and Settings\\whatever",
"b"
} );
String[] shellCommandline = cmd.getShellCommandline();
assertEquals( "Command line size", 4, shellCommandline.length );
assertEquals( "cmd.exe", shellCommandline[0] );
assertEquals( "/X", shellCommandline[1] );
assertEquals( "/C", shellCommandline[2] );
String expectedShellCmd = "\"c:" + File.separator + "Program Files" + File.separator
+ "xxx\" \"c:\\Documents and Settings\\whatever\" b";
expectedShellCmd = "\"" + expectedShellCmd + "\"";
assertEquals( expectedShellCmd, shellCommandline[3] );
}
/**
* Test the command line generated for the bash shell
* @throws Exception
*/
public void testGetShellCommandLineBash()
throws Exception
{
Commandline cmd = new Commandline( new BourneShell() );
cmd.setExecutable( "/bin/echo" );
cmd.addArguments( new String[] {
"hello world"
} );
String[] shellCommandline = cmd.getShellCommandline();
assertEquals( "Command line size", 3, shellCommandline.length );
assertEquals( "/bin/sh", shellCommandline[0] );
assertEquals( "-c", shellCommandline[1] );
String expectedShellCmd = "/bin/echo \'hello world\'";
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
expectedShellCmd = "\\bin\\echo \'hello world\'";
}
assertEquals( expectedShellCmd, shellCommandline[2] );
}
/**
* Test the command line generated for the bash shell
* @throws Exception
*/
public void testGetShellCommandLineBash_WithWorkingDirectory()
throws Exception
{
Commandline cmd = new Commandline( new BourneShell() );
cmd.setExecutable( "/bin/echo" );
cmd.addArguments( new String[] {
"hello world"
} );
File root = File.listRoots()[0];
File workingDirectory = new File( root, "path with spaces" );
cmd.setWorkingDirectory( workingDirectory );
String[] shellCommandline = cmd.getShellCommandline();
assertEquals( "Command line size", 3, shellCommandline.length );
assertEquals( "/bin/sh", shellCommandline[0] );
assertEquals( "-c", shellCommandline[1] );
String expectedShellCmd = "cd \"" + root.getAbsolutePath()
+ "path with spaces\" && /bin/echo \'hello world\'";
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
expectedShellCmd = "cd \"" + root.getAbsolutePath()
+ "path with spaces\" && \\bin\\echo \'hello world\'";
}
assertEquals( expectedShellCmd, shellCommandline[2] );
}
/**
* Test the command line generated for the bash shell
* @throws Exception
*/
public void testGetShellCommandLineBash_WithSingleQuotedArg()
throws Exception
{
Commandline cmd = new Commandline( new BourneShell() );
cmd.setExecutable( "/bin/echo" );
cmd.addArguments( new String[] {
"\'hello world\'"
} );
String[] shellCommandline = cmd.getShellCommandline();
assertEquals( "Command line size", 3, shellCommandline.length );
assertEquals( "/bin/sh", shellCommandline[0] );
assertEquals( "-c", shellCommandline[1] );
String expectedShellCmd = "/bin/echo \'hello world\'";
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
expectedShellCmd = "\\bin\\echo \'hello world\'";
}
assertEquals( expectedShellCmd, shellCommandline[2] );
}
public void testGetShellCommandLineNonWindows()
throws Exception
{
Commandline cmd = new Commandline( new BourneShell() );
cmd.setExecutable( "/usr/bin" );
cmd.addArguments( new String[] {
"a",
"b"
} );
String[] shellCommandline = cmd.getShellCommandline();
assertEquals( "Command line size", 3, shellCommandline.length );
assertEquals( "/bin/sh", shellCommandline[0] );
assertEquals( "-c", shellCommandline[1] );
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
assertEquals( "\\usr\\bin a b", shellCommandline[2] );
}
else
{
assertEquals( "/usr/bin a b", shellCommandline[2] );
}
}
public void testEnvironment()
throws Exception
{
Commandline cmd = new Commandline();
cmd.addEnvironment( "name", "value" );
assertEquals( "name=value", cmd.getEnvironmentVariables()[0] );
}
public void testEnvironmentWitOverrideSystemEnvironment()
throws Exception
{
Commandline cmd = new Commandline();
cmd.addSystemEnvironment();
cmd.addEnvironment( "JAVA_HOME", "/usr/jdk1.5" );
String[] environmentVariables = cmd.getEnvironmentVariables();
for ( int i = 0, size = environmentVariables.length; i < size; i++ )
{
if ( "JAVA_HOME=/usr/jdk1.5".equals( environmentVariables[i] ) )
{
return;
}
}
fail( "can't find JAVA_HOME=/usr/jdk1.5" );
}
/**
* Test an executable with a single apostrophe ' in its path
*
* @throws Exception
*/
public void testQuotedPathWithSingleApostrophe()
throws Exception
{
File dir = new File( System.getProperty( "basedir" ), "target/test/quotedpath'test" );
createAndCallScript( dir, "echo Quoted" );
dir = new File( System.getProperty( "basedir" ), "target/test/quoted path'test" );
createAndCallScript( dir, "echo Quoted" );
}
/**
* Test an executable with a single quotation mark \" in its path only for non Windows box.
*
* @throws Exception
*/
public void testQuotedPathWithQuotationMark()
throws Exception
{
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
System.out.println( "testQuotedPathWithQuotationMark() skipped on Windows" );
return;
}
File dir = new File( System.getProperty( "basedir" ), "target/test/quotedpath\"test" );
createAndCallScript( dir, "echo Quoted" );
dir = new File( System.getProperty( "basedir" ), "target/test/quoted path\"test" );
createAndCallScript( dir, "echo Quoted" );
}
/**
* Test an executable with a single quotation mark \" and ' in its path only for non
* Windows box.
*
* @throws Exception
*/
public void testQuotedPathWithQuotationMarkAndApostrophe()
throws Exception
{
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
System.out.println( "testQuotedPathWithQuotationMarkAndApostrophe() skipped on Windows" );
return;
}
File dir = new File( System.getProperty( "basedir" ), "target/test/quotedpath\"'test" );
createAndCallScript( dir, "echo Quoted" );
dir = new File( System.getProperty( "basedir" ), "target/test/quoted path\"'test" );
createAndCallScript( dir, "echo Quoted" );
}
/**
* Test an executable with a quote in its path and no space
*
* @throws Exception
*/
public void testOnlyQuotedPath()
throws Exception
{
File dir = new File( System.getProperty( "basedir" ), "target/test/quotedpath\'test" );
File javaHome = new File( System.getProperty( "java.home" ) );
File java;
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
java = new File( javaHome, "/bin/java.exe" );
}
else
{
java = new File( javaHome, "/bin/java" );
}
if ( !java.exists() )
{
throw new IOException( java.getAbsolutePath() + " doesn't exist" );
}
createAndCallScript( dir, java.getAbsolutePath() + " -version" );
}
public void testDollarSignInArgumentPath()
throws Exception
{
File dir = new File( System.getProperty( "basedir" ), "target/test" );
if ( !dir.exists() )
{
assertTrue( "Can't create dir:" + dir.getAbsolutePath(), dir.mkdirs() );
}
FileWriter writer = null;
try
{
writer = new FileWriter( new File( dir, "test$1.txt" ) );
IOUtil.copy( "Success", writer );
}
finally
{
IOUtil.close( writer );
}
Commandline cmd = new Commandline();
//cmd.getShell().setShellCommand( "/bin/sh" );
cmd.getShell().setQuotedArgumentsEnabled( true );
cmd.setExecutable( "cat" );
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
cmd.setExecutable( "dir" );
}
cmd.setWorkingDirectory( dir );
cmd.createArg().setLine( "test$1.txt" );
executeCommandLine( cmd );
}
public void testTimeOutException() throws Exception
{
File javaHome = new File( System.getProperty( "java.home" ) );
File java;
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
java = new File( javaHome, "/bin/java.exe" );
}
else
{
java = new File( javaHome, "/bin/java" );
}
if ( !java.exists() )
{
throw new IOException( java.getAbsolutePath() + " doesn't exist" );
}
Commandline cli = new Commandline();
cli.setExecutable( java.getAbsolutePath() );
cli.createArg().setLine( "-version" );
CommandLineUtils.StringStreamConsumer err = new CommandLineUtils.StringStreamConsumer();
try
{
// if the os is faster than 1s to execute java -version the unit will fail :-)
CommandLineUtils.executeCommandLine( cli, new DefaultConsumer(), err, 1 );
}
catch ( CommandLineTimeOutException e )
{
// it works
}
}
/**
* Make the file executable for Unix box.
*
* @param path not null
* @throws IOException if any
*/
private static void makeExecutable( File path )
throws IOException
{
if ( path == null )
{
throw new IllegalArgumentException( "The file is null" );
}
if ( !path.isFile() )
{
throw new IllegalArgumentException( "The file '" + path.getAbsolutePath() + "' should be a file" );
}
if ( !Os.isFamily( Os.FAMILY_WINDOWS ) )
{
Process proc = Runtime.getRuntime().exec( new String[] { "chmod", "a+x", path.getAbsolutePath() } );
while ( true )
{
try
{
proc.waitFor();
break;
}
catch ( InterruptedException e )
{
// ignore
}
}
}
}
/**
* Create and execute a script file in the given dir with the given content. The script file will be called
* echo.bat for Windows box, otherwise echo.
*
* @param dir the parent dir where echo.bat or echo will be created
* @param content the content of the script file
* @throws Exception if any
*/
private static void createAndCallScript( File dir, String content )
throws Exception
{
if ( !dir.exists() )
{
assertTrue( "Can't create dir:" + dir.getAbsolutePath(), dir.mkdirs() );
}
// Create a script file
File bat;
if ( Os.isFamily( Os.FAMILY_WINDOWS ) )
{
bat = new File( dir, "echo.bat" );
}
else
{
bat = new File( dir, "echo" );
}
Writer w = new FileWriter( bat );
try
{
IOUtil.copy( content, w );
}
finally
{
IOUtil.close( w );
}
// Change permission
makeExecutable( bat );
Commandline cmd = new Commandline();
cmd.setExecutable( bat.getAbsolutePath() );
cmd.setWorkingDirectory( dir );
// Execute the script file
executeCommandLine( cmd );
}
/**
* Execute the command line
*
* @param cmd not null
* @throws Exception if any
*/
private static void executeCommandLine( Commandline cmd )
throws Exception
{
CommandLineUtils.StringStreamConsumer err = new CommandLineUtils.StringStreamConsumer();
try
{
System.out.println( "Command line is: " + StringUtils.join( cmd.getShellCommandline(), " " ) );
int exitCode = CommandLineUtils.executeCommandLine( cmd, new DefaultConsumer(), err );
if ( exitCode != 0 )
{
StringBuffer msg = new StringBuffer( "Exit code: " + exitCode + " - " + err.getOutput() );
throw new Exception( msg.toString() );
}
}
catch ( CommandLineException e )
{
throw new Exception( "Unable to execute command: " + e.getMessage(), e );
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/cli/DefaultConsumerTest.java 0000664 0000000 0000000 00000002171 11660305702 0031177 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.cli;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
public class DefaultConsumerTest extends TestCase
{
/**
* @param testName
*/
public DefaultConsumerTest( String testName )
{
super( testName );
}
/*
* @see TestCase#setUp()
*/
public void setUp() throws Exception
{
super.setUp();
}
public void testConsumeLine()
{
DefaultConsumer cons = new DefaultConsumer();
cons.consumeLine( "Test DefaultConsumer consumeLine" );
}
} plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/cli/EnhancedStringTokenizerTest.java 0000664 0000000 0000000 00000007403 11660305702 0032671 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.cli;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
public class EnhancedStringTokenizerTest extends TestCase
{
/**
* @param testName
*/
public EnhancedStringTokenizerTest( final String testName )
{
super( testName );
}
/*
* @see TestCase#setUp()
*/
public void setUp() throws Exception
{
super.setUp();
}
public void test1()
{
EnhancedStringTokenizer est = new EnhancedStringTokenizer( "this is a test string" );
StringBuffer sb = new StringBuffer();
while ( est.hasMoreTokens() )
{
sb.append( est.nextToken() );
sb.append( " " );
}
assertEquals( "this is a test string ", sb.toString() );
}
public void test2()
{
EnhancedStringTokenizer est = new EnhancedStringTokenizer( "1,,,3,,4", "," );
assertEquals( "Token 1", "1", est.nextToken() );
assertEquals( "Token 2", "", est.nextToken() );
assertEquals( "Token 3", "", est.nextToken() );
assertEquals( "Token 4", "3", est.nextToken() );
assertEquals( "Token 5", "", est.nextToken() );
assertEquals( "Token 6", "4", est.nextToken() );
}
public void test3()
{
EnhancedStringTokenizer est = new EnhancedStringTokenizer( "1,,,3,,4", ",", true );
assertEquals( "Token 1", "1", est.nextToken() );
assertEquals( "Token 2", ",", est.nextToken() );
assertEquals( "Token 3", "", est.nextToken() );
assertEquals( "Token 4", ",", est.nextToken() );
assertEquals( "Token 5", "", est.nextToken() );
assertEquals( "Token 6", ",", est.nextToken() );
assertEquals( "Token 7", "3", est.nextToken() );
assertEquals( "Token 8", ",", est.nextToken() );
assertEquals( "Token 9", "", est.nextToken() );
assertEquals( "Token 10", ",", est.nextToken() );
assertEquals( "Token 11", "4", est.nextToken() );
}
public void testMultipleDelim()
{
EnhancedStringTokenizer est = new EnhancedStringTokenizer( "1 2|3|4", " |", true );
assertEquals( "Token 1", "1", est.nextToken() );
assertEquals( "Token 2", " ", est.nextToken() );
assertEquals( "Token 3", "2", est.nextToken() );
assertEquals( "Token 4", "|", est.nextToken() );
assertEquals( "Token 5", "3", est.nextToken() );
assertEquals( "Token 6", "|", est.nextToken() );
assertEquals( "Token 7", "4", est.nextToken() );
assertEquals( "est.hasMoreTokens()", false, est.hasMoreTokens() );
}
public void testEmptyString()
{
EnhancedStringTokenizer est = new EnhancedStringTokenizer( "" );
assertEquals( "est.hasMoreTokens()", false, est.hasMoreTokens() );
try
{
est.nextToken();
fail();
}
catch ( Exception e )
{
}
}
public void testSimpleString()
{
EnhancedStringTokenizer est = new EnhancedStringTokenizer( "a " );
assertEquals( "Token 1", "a", est.nextToken() );
assertEquals( "Token 2", "", est.nextToken() );
assertEquals( "est.hasMoreTokens()", false, est.hasMoreTokens() );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/cli/StreamPumperTest.java 0000664 0000000 0000000 00000016345 11660305702 0030533 0 ustar 00root root 0000000 0000000 /********************************************************************************
* CruiseControl, a Continuous Integration Toolkit
* Copyright (c) 2003, ThoughtWorks, Inc.
* 651 W Washington Ave. Suite 500
* Chicago, IL 60661 USA
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* + Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* + Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* + Neither the name of ThoughtWorks, Inc., CruiseControl, nor the
* names of its contributors may be used to endorse or promote
* products derived from this software without specific prior
* written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************/
package org.codehaus.plexus.util.cli;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.List;
import junit.framework.TestCase;
/**
* @author Paul Julius
*/
public class StreamPumperTest extends TestCase
{
private String lineSeparator;
/**
* @param testName
*/
public StreamPumperTest( String testName )
{
super( testName );
}
/*
* @see TestCase#setUp()
*/
public void setUp() throws Exception
{
super.setUp();
lineSeparator = System.getProperty( "line.separator" );
}
public void testPumping()
{
String line1 = "line1";
String line2 = "line2";
String lines = line1 + "\n" + line2;
ByteArrayInputStream inputStream =
new ByteArrayInputStream( lines.getBytes() );
TestConsumer consumer = new TestConsumer();
StreamPumper pumper = new StreamPumper( inputStream, consumer );
new Thread( pumper ).run();
//Check the consumer to see if it got both lines.
assertTrue( consumer.wasLineConsumed( line1, 1000 ) );
assertTrue( consumer.wasLineConsumed( line2, 1000 ) );
}
public void testPumpingWithPrintWriter()
{
String inputString = "This a test string";
ByteArrayInputStream bais = new ByteArrayInputStream( inputString.getBytes() );
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter( sw );
StreamPumper pumper = new StreamPumper( bais, pw );
pumper.run();
pumper.flush();
System.out.println( "aaa" + sw.toString() );
assertEquals( "This a test string" + lineSeparator, sw.toString() );
pumper.close();
}
public void testPumperReadsInputStreamUntilEndEvenIfConsumerFails()
{
// the number of bytes generated should surely exceed the read buffer used by the pumper
GeneratorInputStream gis = new GeneratorInputStream( 1024 * 1024 * 4 );
StreamPumper pumper = new StreamPumper( gis, new FailingConsumer() );
pumper.run();
assertEquals( "input stream was not fully consumed, producer deadlocks", gis.size, gis.read );
assertTrue( gis.closed );
assertNotNull( pumper.getException() );
}
static class GeneratorInputStream
extends InputStream
{
final int size;
int read = 0;
boolean closed = false;
public GeneratorInputStream( int size )
{
this.size = size;
}
public int read()
throws IOException
{
if ( read < size )
{
read++;
return '\n';
}
else
{
return -1;
}
}
public void close()
throws IOException
{
closed = true;
}
}
static class FailingConsumer
implements StreamConsumer
{
public void consumeLine( String line )
{
throw new NullPointerException( "too bad, the consumer is badly implemented..." );
}
}
/**
* Used by the test to track whether a line actually got consumed or not.
*/
static class TestConsumer
implements StreamConsumer
{
private List lines = new ArrayList();
/**
* Checks to see if this consumer consumed a particular line. This method will wait up to timeout number of
* milliseconds for the line to get consumed.
*
* @param testLine Line to test for.
* @param timeout Number of milliseconds to wait for the line.
* @return true if the line gets consumed, else false.
*/
public boolean wasLineConsumed( String testLine, long timeout )
{
long start = System.currentTimeMillis();
long trialTime = 0;
do
{
if ( lines.contains( testLine ) )
{
return true;
}
// Sleep a bit.
try
{
Thread.sleep( 10 );
}
catch ( InterruptedException e )
{
// ignoring...
}
// How long have been waiting for the line?
trialTime = System.currentTimeMillis() - start;
}
while ( trialTime < timeout );
// If we got here, then the line wasn't consumed within the timeout
return false;
}
public void consumeLine( String line )
{
lines.add( line );
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/cli/shell/ 0000775 0000000 0000000 00000000000 11660305702 0025502 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/cli/shell/BourneShellTest.java 0000664 0000000 0000000 00000015616 11660305702 0031440 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.cli.shell;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.cli.Commandline;
import java.util.Arrays;
import java.util.List;
import junit.framework.TestCase;
public class BourneShellTest
extends TestCase
{
protected Shell newShell()
{
return new BourneShell();
}
public void testQuoteWorkingDirectoryAndExecutable()
{
Shell sh = newShell();
sh.setWorkingDirectory( "/usr/local/bin" );
sh.setExecutable( "chmod" );
String executable = StringUtils.join( sh.getShellCommandLine( new String[]{} ).iterator(), " " );
assertEquals( "/bin/sh -c cd /usr/local/bin && chmod", executable );
}
public void testQuoteWorkingDirectoryAndExecutable_WDPathWithSingleQuotes()
{
Shell sh = newShell();
sh.setWorkingDirectory( "/usr/local/'something else'" );
sh.setExecutable( "chmod" );
String executable = StringUtils.join( sh.getShellCommandLine( new String[]{} ).iterator(), " " );
assertEquals( "/bin/sh -c cd \"/usr/local/\'something else\'\" && chmod", executable );
}
public void testQuoteWorkingDirectoryAndExecutable_WDPathWithSingleQuotes_BackslashFileSep()
{
Shell sh = newShell();
sh.setWorkingDirectory( "\\usr\\local\\'something else'" );
sh.setExecutable( "chmod" );
String executable = StringUtils.join( sh.getShellCommandLine( new String[]{} ).iterator(), " " );
assertEquals( "/bin/sh -c cd \"\\usr\\local\\\'something else\'\" && chmod", executable );
}
public void testPreserveSingleQuotesOnArgument()
{
Shell sh = newShell();
sh.setWorkingDirectory( "/usr/bin" );
sh.setExecutable( "chmod" );
String[] args = { "\'some arg with spaces\'" };
List shellCommandLine = sh.getShellCommandLine( args );
String cli = StringUtils.join( shellCommandLine.iterator(), " " );
System.out.println( cli );
assertTrue( cli.endsWith( args[0] ) );
}
public void testAddSingleQuotesOnArgumentWithSpaces()
{
Shell sh = newShell();
sh.setWorkingDirectory( "/usr/bin" );
sh.setExecutable( "chmod" );
String[] args = { "some arg with spaces" };
List shellCommandLine = sh.getShellCommandLine( args );
String cli = StringUtils.join( shellCommandLine.iterator(), " " );
System.out.println( cli );
assertTrue( cli.endsWith( "\'" + args[0] + "\'" ) );
}
public void testArgumentsWithsemicolon()
{
System.out.println( "---- semi colon tests ----" );
Shell sh = newShell();
sh.setWorkingDirectory( "/usr/bin" );
sh.setExecutable( "chmod" );
String[] args = { ";some&argwithunix$chars" };
List shellCommandLine = sh.getShellCommandLine( args );
String cli = StringUtils.join( shellCommandLine.iterator(), " " );
System.out.println( cli );
assertTrue( cli.endsWith( "\'" + args[0] + "\'" ) );
Commandline commandline = new Commandline( newShell() );
commandline.setExecutable( "chmod" );
commandline.getShell().setQuotedArgumentsEnabled( true );
commandline.createArg().setValue( "--password" );
commandline.createArg().setValue( ";password" );
String[] lines = commandline.getShellCommandline();
System.out.println( Arrays.asList( lines ) );
assertEquals( "/bin/sh", lines[0] );
assertEquals( "-c", lines[1] );
assertEquals( "chmod --password ';password'", lines[2] );
commandline = new Commandline( newShell() );
commandline.setExecutable( "chmod" );
commandline.getShell().setQuotedArgumentsEnabled( true );
commandline.createArg().setValue( "--password" );
commandline.createArg().setValue( ";password" );
lines = commandline.getShellCommandline();
System.out.println( Arrays.asList( lines ) );
assertEquals( "/bin/sh", lines[0] );
assertEquals( "-c", lines[1] );
assertEquals( "chmod --password ';password'", lines[2] );
commandline = new Commandline( new CmdShell() );
commandline.getShell().setQuotedArgumentsEnabled( true );
commandline.createArg().setValue( "--password" );
commandline.createArg().setValue( ";password" );
lines = commandline.getShellCommandline();
System.out.println( Arrays.asList( lines ) );
assertEquals( "cmd.exe", lines[0] );
assertEquals( "/X", lines[1] );
assertEquals( "/C", lines[2] );
assertEquals( "\"--password ;password\"", lines[3] );
}
public void testBourneShellQuotingCharacters()
throws Exception
{
// { ' ', '$', ';', '&', '|', '<', '>', '*', '?', '(', ')' };
// test with values http://steve-parker.org/sh/bourne.shtml Appendix B - Meta-characters and Reserved Words
Commandline commandline = new Commandline( newShell() );
commandline.setExecutable( "chmod" );
commandline.getShell().setQuotedArgumentsEnabled( true );
commandline.createArg().setValue( " " );
commandline.createArg().setValue( "|" );
commandline.createArg().setValue( "&&" );
commandline.createArg().setValue( "||" );
commandline.createArg().setValue( ";" );
commandline.createArg().setValue( ";;" );
commandline.createArg().setValue( "&" );
commandline.createArg().setValue( "()" );
commandline.createArg().setValue( "<" );
commandline.createArg().setValue( "<<" );
commandline.createArg().setValue( ">" );
commandline.createArg().setValue( ">>" );
commandline.createArg().setValue( "*" );
commandline.createArg().setValue( "?" );
commandline.createArg().setValue( "[" );
commandline.createArg().setValue( "]" );
commandline.createArg().setValue( "{" );
commandline.createArg().setValue( "}" );
commandline.createArg().setValue( "`" );
String[] lines = commandline.getShellCommandline();
System.out.println( Arrays.asList( lines ) );
assertEquals( "/bin/sh", lines[0] );
assertEquals( "-c", lines[1] );
assertEquals( "chmod ' ' '|' '&&' '||' ';' ';;' '&' '()' '<' '<<' '>' '>>' '*' '?' '[' ']' '{' '}' '`'",
lines[2] );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/dag/ 0000775 0000000 0000000 00000000000 11660305702 0024357 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/dag/CycleDetectedExceptionTest.java 0000664 0000000 0000000 00000002415 11660305702 0032444 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.dag;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
import java.util.ArrayList;
import java.util.List;
/**
* @author Jason van Zyl
* @version $Id: CycleDetectedExceptionTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class CycleDetectedExceptionTest
extends TestCase
{
public void testException()
{
final List cycle = new ArrayList();
cycle.add( "a" );
cycle.add( "b" );
cycle.add( "a" );
final CycleDetectedException e = new CycleDetectedException( "Cycle detected", cycle );
assertEquals( "Cycle detected a --> b --> a", e.getMessage() );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/dag/CycleDetectorTest.java 0000664 0000000 0000000 00000012165 11660305702 0030620 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.dag;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
import java.util.List;
/**
* @author Michal Maczka
* @version $Id: CycleDetectorTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class CycleDetectorTest extends TestCase
{
public void testCycyleDetection()
{
// No cycle
//
// a --> b --->c
//
try
{
final DAG dag1 = new DAG();
dag1.addEdge( "a", "b" );
dag1.addEdge( "b", "c" );
}
catch ( CycleDetectedException e )
{
fail( "Cycle should not be detected" );
}
//
// a --> b --->c
// ^ |
// | |
// -----------|
try
{
final DAG dag2 = new DAG();
dag2.addEdge( "a", "b" );
dag2.addEdge( "b", "c" );
dag2.addEdge( "c", "a" );
fail( "Cycle should be detected" );
}
catch ( CycleDetectedException e )
{
final List cycle = e.getCycle();
assertNotNull( "Cycle should be not null", cycle );
assertTrue( "Cycle contains 'a'", cycle.contains( "a" ) );
assertTrue( "Cycle contains 'b'", cycle.contains( "b" ) );
assertTrue( "Cycle contains 'c'", cycle.contains( "c" ) );
}
// | --> c
// a --> b
// | | --> d
// --------->
try
{
final DAG dag3 = new DAG();
dag3.addEdge( "a", "b" );
dag3.addEdge( "b", "c" );
dag3.addEdge( "b", "d" );
dag3.addEdge( "a", "d" );
}
catch ( CycleDetectedException e )
{
fail( "Cycle should not be detected" );
}
// ------------
// | |
// V | --> c
// a --> b
// | | --> d
// --------->
try
{
final DAG dag4 = new DAG();
dag4.addEdge( "a", "b" );
dag4.addEdge( "b", "c" );
dag4.addEdge( "b", "d" );
dag4.addEdge( "a", "d" );
dag4.addEdge( "c", "a" );
fail( "Cycle should be detected" );
}
catch ( CycleDetectedException e )
{
final List cycle = e.getCycle();
assertNotNull( "Cycle should be not null", cycle );
assertEquals( "Cycle contains 'a'", "a", ( String ) cycle.get( 0 ) );
assertEquals( "Cycle contains 'b'", "b", cycle.get( 1 ) );
assertEquals( "Cycle contains 'c'", "c", cycle.get( 2 ) );
assertEquals( "Cycle contains 'a'", "a", ( String ) cycle.get( 3 ) );
}
// f --> g --> h
// |
// |
// a --> b ---> c --> d
// ^ |
// | V
// ------------ e
final DAG dag5 = new DAG();
try
{
dag5.addEdge( "a", "b" );
dag5.addEdge( "b", "c" );
dag5.addEdge( "b", "f" );
dag5.addEdge( "f", "g" );
dag5.addEdge( "g", "h" );
dag5.addEdge( "c", "d" );
dag5.addEdge( "d", "e" );
dag5.addEdge( "e", "b" );
fail( "Cycle should be detected" );
}
catch ( CycleDetectedException e )
{
final List cycle = e.getCycle();
assertNotNull( "Cycle should be not null", cycle );
assertEquals( "Cycle contains 5 elements", 5, cycle.size() );
assertEquals( "Cycle contains 'b'", "b", ( String ) cycle.get( 0 ) );
assertEquals( "Cycle contains 'c'", "c", cycle.get( 1 ) );
assertEquals( "Cycle contains 'd'", "d", cycle.get( 2 ) );
assertEquals( "Cycle contains 'e'", "e", ( String ) cycle.get( 3 ) );
assertEquals( "Cycle contains 'b'", "b", ( String ) cycle.get( 4 ) );
assertTrue( "Edge exixst", dag5.hasEdge( "a", "b" ) );
assertTrue( "Edge exixst", dag5.hasEdge( "b", "c" ) );
assertTrue( "Edge exixst", dag5.hasEdge( "b", "f" ) );
assertTrue( "Edge exixst", dag5.hasEdge( "f", "g" ) );
assertTrue( "Edge exixst", dag5.hasEdge( "g", "h" ) );
assertTrue( "Edge exixst", dag5.hasEdge( "c", "d" ) );
assertTrue( "Edge exixst", dag5.hasEdge( "d", "e" ) );
assertFalse( dag5.hasEdge( "e", "b" ) );
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/dag/DAGTest.java 0000664 0000000 0000000 00000010525 11660305702 0026460 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.dag;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
/**
* @author Michal Maczka
* @version $Id: DAGTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class DAGTest
extends TestCase
{
public void testDAG()
throws CycleDetectedException
{
final DAG dag = new DAG();
dag.addVertex( "a" );
assertEquals( 1, dag.getVerticies().size() );
assertEquals( "a", dag.getVertex( "a" ).getLabel() );
dag.addVertex( "a" );
assertEquals( 1, dag.getVerticies().size() );
assertEquals( "a", dag.getVertex( "a" ).getLabel() );
dag.addVertex( "b" );
assertEquals( 2, dag.getVerticies().size() );
assertFalse( dag.hasEdge( "a", "b" ) );
assertFalse( dag.hasEdge( "b", "a" ) );
final Vertex a = dag.getVertex( "a" );
final Vertex b = dag.getVertex( "b" );
assertEquals( "a", a.getLabel() );
assertEquals( "b", b.getLabel() );
dag.addEdge( "a", "b" );
assertTrue( a.getChildren().contains( b ) );
assertTrue( b.getParents().contains( a ) );
assertTrue( dag.hasEdge( "a", "b" ) );
assertFalse( dag.hasEdge( "b", "a" ) );
dag.addEdge( "c", "d" );
assertEquals( 4, dag.getVerticies().size() );
final Vertex c = dag.getVertex( "c" );
final Vertex d = dag.getVertex( "d" );
assertEquals( "a", a.getLabel() );
assertEquals( "b", b.getLabel() );
assertEquals( "c", c.getLabel() );
assertEquals( "d", d.getLabel() );
assertFalse( dag.hasEdge( "b", "a" ) );
assertFalse( dag.hasEdge( "a", "c" ) );
assertFalse( dag.hasEdge( "a", "d" ) );
assertTrue( dag.hasEdge( "c", "d" ) );
assertFalse( dag.hasEdge( "d", "c" ) );
final Set labels = dag.getLabels();
assertEquals( 4, labels.size() );
assertTrue( labels.contains( "a" ) );
assertTrue( labels.contains( "b" ) );
assertTrue( labels.contains( "c" ) );
assertTrue( labels.contains( "d" ) );
dag.addEdge( "a", "d" );
assertTrue( a.getChildren().contains( d ) );
assertTrue( d.getParents().contains( a ) );
// "b" and "d" are children of "a"
assertEquals( 2, a.getChildren().size() );
assertTrue( a.getChildLabels().contains( "b" ) );
assertTrue( a.getChildLabels().contains( "d" ) );
// "a" and "c" are parents of "d"
assertEquals( 2, d.getParents().size() );
assertTrue( d.getParentLabels().contains( "a" ) );
assertTrue( d.getParentLabels().contains( "c" ) );
}
public void testGetPredessors()
throws CycleDetectedException
{
final DAG dag = new DAG();
dag.addEdge( "a", "b" );
//
// a --> b --> c --> e
// | | |
// | V V
// --> d <-- f --> g
// result d, g, f, c, b, a
//force order of nodes
dag.addVertex( "c" );
dag.addVertex( "d" );
dag.addEdge( "a", "b" );
dag.addEdge( "b", "c" );
dag.addEdge( "b", "d" );
dag.addEdge( "c", "d" );
dag.addEdge( "c", "e" );
dag.addEdge( "f", "d" );
dag.addEdge( "e", "f" );
dag.addEdge( "f", "g" );
final List actual = dag.getSuccessorLabels( "b" );
final List expected = new ArrayList();
expected.add( "d" );
expected.add( "g" );
expected.add( "f" );
expected.add( "e" );
expected.add( "c" );
expected.add( "b" );
assertEquals( expected, actual );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/dag/TopologicalSorterTest.java 0000664 0000000 0000000 00000010230 11660305702 0031531 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.dag;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
import java.util.ArrayList;
import java.util.List;
/**
* @author Michal Maczka
* @version $Id: TopologicalSorterTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class TopologicalSorterTest
extends TestCase
{
public void testDfs()
throws CycleDetectedException
{
// a --> b --->c
//
// result a,b,c
final DAG dag1 = new DAG();
dag1.addEdge( "a", "b" );
dag1.addEdge( "b", "c" );
final List expected1 = new ArrayList();
expected1.add( "c" );
expected1.add( "b" );
expected1.add( "a" );
final List actual1 = TopologicalSorter.sort( dag1 );
assertEquals( "Order is different then expected", expected1, actual1 );
//
// a <-- b <---c
//
// result c, b, a
final DAG dag2 = new DAG();
dag2.addVertex( "a" );
dag2.addVertex( "b" );
dag2.addVertex( "c" );
dag2.addEdge( "b", "a" );
dag2.addEdge( "c", "b" );
final List expected2 = new ArrayList();
expected2.add( "a" );
expected2.add( "b" );
expected2.add( "c" );
final List actual2 = TopologicalSorter.sort( dag2 );
assertEquals( "Order is different then expected", expected2, actual2 );
//
// a --> b --> c --> e
// | | |
// | V V
// --> d <-- f --> g
// result d, g, f, c, b, a
final DAG dag3 = new DAG();
// force order of nodes in the graph
dag3.addVertex( "a" );
dag3.addVertex( "b" );
dag3.addVertex( "c" );
dag3.addVertex( "d" );
dag3.addVertex( "e" );
dag3.addVertex( "f" );
dag3.addEdge( "a", "b" );
dag3.addEdge( "b", "c" );
dag3.addEdge( "b", "d" );
dag3.addEdge( "c", "d" );
dag3.addEdge( "c", "e" );
dag3.addEdge( "f", "d" );
dag3.addEdge( "e", "f" );
dag3.addEdge( "f", "g" );
final List expected3 = new ArrayList();
expected3.add( "d" );
expected3.add( "g" );
expected3.add( "f" );
expected3.add( "e" );
expected3.add( "c" );
expected3.add( "b" );
expected3.add( "a" );
final List actual3 = TopologicalSorter.sort( dag3 );
assertEquals( "Order is different then expected", expected3, actual3 );
//
// a --> b --> c --> e
// | | |
// | V V
// --> d <-- f
// result d, f, e, c, b, a
final DAG dag4 = new DAG();
// force order of nodes in the graph
dag4.addVertex( "f" );
dag4.addVertex( "e" );
dag4.addVertex( "d" );
dag4.addVertex( "c" );
dag4.addVertex( "a" );
dag4.addVertex( "b" );
dag4.addEdge( "a", "b" );
dag4.addEdge( "b", "c" );
dag4.addEdge( "b", "d" );
dag4.addEdge( "c", "d" );
dag4.addEdge( "c", "e" );
dag4.addEdge( "f", "d" );
dag4.addEdge( "e", "f" );
final List expected4 = new ArrayList();
expected4.add( "d" );
expected4.add( "f" );
expected4.add( "e" );
expected4.add( "c" );
expected4.add( "b" );
expected4.add( "a" );
final List actual4 = TopologicalSorter.sort( dag4 );
assertEquals( "Order is different then expected", expected4, actual4 );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/dag/VertexTest.java 0000664 0000000 0000000 00000002756 11660305702 0027351 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.dag;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
/**
* @author Michal Maczka
* @version $Id: VertexTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class VertexTest extends TestCase
{
public void testVertex()
{
final Vertex vertex1 = new Vertex( "a" );
assertEquals( "a", vertex1.getLabel() );
assertEquals( 0, vertex1.getChildren().size() );
assertEquals( 0, vertex1.getChildLabels().size() );
final Vertex vertex2 = new Vertex( "b" );
assertEquals( "b", vertex2.getLabel() );
vertex1.addEdgeTo( vertex2 );
assertEquals( 1, vertex1.getChildren().size() );
assertEquals( 1, vertex1.getChildLabels().size() );
assertEquals( vertex2, vertex1.getChildren().get( 0 ) );
assertEquals( "b", vertex1.getChildLabels().get( 0 ) );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/introspection/ 0000775 0000000 0000000 00000000000 11660305702 0026524 5 ustar 00root root 0000000 0000000 ReflectionValueExtractorTest.java 0000664 0000000 0000000 00000020472 11660305702 0035140 0 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/introspection package org.codehaus.plexus.util.introspection;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.Assert;
import junit.framework.TestCase;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
/**
* @author Jason van Zyl
* @version $Id: ReflectionValueExtractorTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class ReflectionValueExtractorTest
extends TestCase
{
private Project project;
protected void setUp()
throws Exception
{
super.setUp();
Dependency dependency1 = new Dependency();
dependency1.setArtifactId("dep1");
Dependency dependency2 = new Dependency();
dependency2.setArtifactId("dep2");
project = new Project();
project.setModelVersion( "4.0.0" );
project.setGroupId( "org.apache.maven" );
project.setArtifactId( "maven-core" );
project.setName( "Maven" );
project.setVersion( "2.0-SNAPSHOT" );
project.setScm( new Scm() );
project.getScm().setConnection( "scm-connection" );
project.addDependency( dependency1 );
project.addDependency( dependency2 );
project.setBuild( new Build() );
}
public void testValueExtraction()
throws Exception
{
// ----------------------------------------------------------------------
// Top level values
// ----------------------------------------------------------------------
assertEquals( "4.0.0", ReflectionValueExtractor.evaluate( "project.modelVersion", project ) );
assertEquals( "org.apache.maven", ReflectionValueExtractor.evaluate( "project.groupId", project ) );
assertEquals( "maven-core", ReflectionValueExtractor.evaluate( "project.artifactId", project ) );
assertEquals( "Maven", ReflectionValueExtractor.evaluate( "project.name", project ) );
assertEquals( "2.0-SNAPSHOT", ReflectionValueExtractor.evaluate( "project.version", project ) );
// ----------------------------------------------------------------------
// SCM
// ----------------------------------------------------------------------
assertEquals( "scm-connection", ReflectionValueExtractor.evaluate( "project.scm.connection", project ) );
// ----------------------------------------------------------------------
// Dependencies
// ----------------------------------------------------------------------
List dependencies = (List) ReflectionValueExtractor.evaluate( "project.dependencies", project );
Assert.assertNotNull( dependencies );
Assert.assertEquals( 2, dependencies.size() );
// ----------------------------------------------------------------------
// Dependencies - using index notation
// ----------------------------------------------------------------------
// List
Dependency dependency = (Dependency)ReflectionValueExtractor.evaluate( "project.dependencies[0]", project );
Assert.assertNotNull( dependency );
Assert.assertTrue( "dep1".equals(dependency.getArtifactId()) );
String artifactId = (String)ReflectionValueExtractor.evaluate( "project.dependencies[1].artifactId", project );
Assert.assertTrue( "dep2".equals(artifactId) );
// Array
dependency = (Dependency)ReflectionValueExtractor.evaluate( "project.dependenciesAsArray[0]", project );
Assert.assertNotNull( dependency );
Assert.assertTrue( "dep1".equals(dependency.getArtifactId()) );
artifactId = (String)ReflectionValueExtractor.evaluate( "project.dependenciesAsArray[1].artifactId", project );
Assert.assertTrue( "dep2".equals(artifactId) );
// Map
dependency = (Dependency)ReflectionValueExtractor.evaluate( "project.dependenciesAsMap(dep1)", project );
Assert.assertNotNull( dependency );
Assert.assertTrue( "dep1".equals(dependency.getArtifactId()) );
artifactId = (String)ReflectionValueExtractor.evaluate( "project.dependenciesAsMap(dep2).artifactId", project );
Assert.assertTrue( "dep2".equals(artifactId) );
// ----------------------------------------------------------------------
// Build
// ----------------------------------------------------------------------
Build build = (Build) ReflectionValueExtractor.evaluate( "project.build", project );
Assert.assertNotNull( build );
}
public void testValueExtractorWithAInvalidExpression()
throws Exception
{
Assert.assertNull( ReflectionValueExtractor.evaluate( "project.foo", project ) );
Assert.assertNull( ReflectionValueExtractor.evaluate( "project.dependencies[10]", project ) );
Assert.assertNull( ReflectionValueExtractor.evaluate( "project.dependencies[0].foo", project ) );
}
public static class Project
{
private String modelVersion;
private String groupId;
private Scm scm;
private List dependencies = new ArrayList();
private Build build;
private String artifactId;
private String name;
private String version;
public void setModelVersion( String modelVersion )
{
this.modelVersion = modelVersion;
}
public void setGroupId( String groupId )
{
this.groupId = groupId;
}
public void setScm( Scm scm )
{
this.scm = scm;
}
public void addDependency( Dependency dependency )
{
this.dependencies.add( dependency );
}
public void setBuild( Build build )
{
this.build = build;
}
public void setArtifactId( String artifactId )
{
this.artifactId = artifactId;
}
public void setName( String name )
{
this.name = name;
}
public void setVersion( String version )
{
this.version = version;
}
public Scm getScm()
{
return scm;
}
public String getModelVersion()
{
return modelVersion;
}
public String getGroupId()
{
return groupId;
}
public List getDependencies()
{
return dependencies;
}
public Build getBuild()
{
return build;
}
public String getArtifactId()
{
return artifactId;
}
public String getName()
{
return name;
}
public String getVersion()
{
return version;
}
public Dependency[] getDependenciesAsArray()
{
return (Dependency[]) getDependencies().toArray( new Dependency[0]);
}
public Map getDependenciesAsMap()
{
Map ret = new HashMap();
for ( Iterator it = getDependencies().iterator(); it.hasNext();)
{
Dependency dep = (Dependency)it.next();
ret.put( dep.getArtifactId(), dep );
}
return ret;
}
}
public static class Build
{
}
public static class Dependency
{
private String artifactId;
public String getArtifactId()
{
return artifactId;
}
public void setArtifactId(String id)
{
artifactId = id;
}
}
public static class Scm
{
private String connection;
public void setConnection( String connection )
{
this.connection = connection;
}
public String getConnection()
{
return connection;
}
}
} plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/reflection/ 0000775 0000000 0000000 00000000000 11660305702 0025756 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/reflection/ReflectorTest.java 0000664 0000000 0000000 00000004177 11660305702 0031417 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.reflection;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
/**
* @author Jörg Schaible
* @version $Id: ReflectorTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class ReflectorTest
extends TestCase
{
private Project project;
private Reflector reflector;
protected void setUp()
throws Exception
{
super.setUp();
project = new Project();
project.setModelVersion( "1.0.0" );
project.setVersion( "42" );
reflector = new Reflector();
}
public void testObjectPropertyFromName()
throws Exception
{
assertEquals( "1.0.0", reflector.getObjectProperty( project, "modelVersion" ) );
}
public void testObjectPropertyFromBean()
throws Exception
{
assertEquals( "Foo", reflector.getObjectProperty( project, "name" ) );
}
public void testObjectPropertyFromField()
throws Exception
{
assertEquals( "42", reflector.getObjectProperty( project, "version" ) );
}
public static class Project
{
private String model;
private String name;
private String version;
public void setModelVersion( String modelVersion )
{
this.model = modelVersion;
}
public void setVersion( String version )
{
this.version = version;
}
public String modelVersion()
{
return model;
}
public String getName()
{
return "Foo";
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/xml/ 0000775 0000000 0000000 00000000000 11660305702 0024424 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/xml/PrettyPrintXMLWriterTest.java 0000664 0000000 0000000 00000014544 11660305702 0032221 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.StringWriter;
import javax.swing.text.html.HTML.Tag;
import org.codehaus.plexus.util.StringUtils;
import junit.framework.TestCase;
/**
* Test of {@link PrettyPrintXMLWriter}
*
* @author Vincent Siveton
* @version $Id: PrettyPrintXMLWriterTest.java 8660 2010-03-05 21:50:36Z hboutemy $
*/
public class PrettyPrintXMLWriterTest
extends TestCase
{
StringWriter w;
PrettyPrintXMLWriter writer;
/** {@inheritDoc} */
protected void setUp()
throws Exception
{
super.setUp();
initWriter();
}
/** {@inheritDoc} */
protected void tearDown()
throws Exception
{
super.tearDown();
writer = null;
w = null;
}
private void initWriter()
{
w = new StringWriter();
writer = new PrettyPrintXMLWriter( w );
}
public void testDefaultPrettyPrintXMLWriter()
{
writer.startElement( Tag.HTML.toString() );
writeXhtmlHead( writer );
writeXhtmlBody( writer );
writer.endElement(); // Tag.HTML
assertEquals( expectedResult( PrettyPrintXMLWriter.LS ), w.toString() );
}
public void testPrettyPrintXMLWriterWithGivenLineSeparator()
{
writer.setLineSeparator( "\n" );
writer.startElement( Tag.HTML.toString() );
writeXhtmlHead( writer );
writeXhtmlBody( writer );
writer.endElement(); // Tag.HTML
assertEquals( expectedResult( "\n" ), w.toString() );
}
public void testPrettyPrintXMLWriterWithGivenLineIndenter()
{
writer.setLineIndenter( " " );
writer.startElement( Tag.HTML.toString() );
writeXhtmlHead( writer );
writeXhtmlBody( writer );
writer.endElement(); // Tag.HTML
assertEquals( expectedResult( " ", PrettyPrintXMLWriter.LS ), w.toString() );
}
public void testEscapeXmlAttribute()
{
// Windows
writer.startElement( Tag.DIV.toString() );
writer.addAttribute( "class", "sect\r\nion" );
writer.endElement(); // Tag.DIV
assertEquals( "", w.toString() );
// Mac
initWriter();
writer.startElement( Tag.DIV.toString() );
writer.addAttribute( "class", "sect\rion" );
writer.endElement(); // Tag.DIV
assertEquals( "", w.toString() );
// Unix
initWriter();
writer.startElement( Tag.DIV.toString() );
writer.addAttribute( "class", "sect\nion" );
writer.endElement(); // Tag.DIV
assertEquals( "", w.toString() );
}
private void writeXhtmlHead( XMLWriter writer )
{
writer.startElement( Tag.HEAD.toString() );
writer.startElement( Tag.TITLE.toString() );
writer.writeText( "title" );
writer.endElement(); // Tag.TITLE
writer.startElement( Tag.META.toString() );
writer.addAttribute( "name", "author" );
writer.addAttribute( "content", "Author" );
writer.endElement(); // Tag.META
writer.startElement( Tag.META.toString() );
writer.addAttribute( "name", "date" );
writer.addAttribute( "content", "Date" );
writer.endElement(); // Tag.META
writer.endElement(); // Tag.HEAD
}
private void writeXhtmlBody( XMLWriter writer )
{
writer.startElement( Tag.BODY.toString() );
writer.startElement( Tag.P.toString() );
writer.writeText( "Paragraph 1, line 1. Paragraph 1, line 2." );
writer.endElement(); // Tag.P
writer.startElement( Tag.DIV.toString() );
writer.addAttribute( "class", "section" );
writer.startElement( Tag.H2.toString() );
writer.writeText( "Section title" );
writer.endElement(); // Tag.H2
writer.endElement(); // Tag.DIV
writer.endElement(); // Tag.BODY
}
private String expectedResult( String lineSeparator )
{
return expectedResult( " ", lineSeparator );
}
private String expectedResult( String lineIndenter, String lineSeparator )
{
StringBuffer expected = new StringBuffer();
expected.append( "" ).append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 1 ) ).append( "" ).append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 2 ) ).append( "title " )
.append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 2 ) )
.append( "" ).append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 2 ) ).append( "" )
.append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 1 ) ).append( "" ).append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 1 ) ).append( "" ).append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 2 ) )
.append( "Paragraph 1, line 1. Paragraph 1, line 2.
" ).append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 2 ) ).append( "" )
.append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 3 ) ).append( "Section title
" )
.append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 2 ) ).append( "" ).append( lineSeparator );
expected.append( StringUtils.repeat( lineIndenter, 1 ) ).append( "" ).append( lineSeparator );
expected.append( "" );
return expected.toString();
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/xml/XmlStreamReaderTest.java 0000664 0000000 0000000 00000015575 11660305702 0031203 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import org.codehaus.plexus.util.IOUtil;
import junit.framework.ComparisonFailure;
import junit.framework.TestCase;
public class XmlStreamReaderTest
extends TestCase
{
/** french */
private static final String TEXT_LATIN1 = "eacute: \u00E9";
/** greek */
private static final String TEXT_LATIN7 = "alpha: \u03B1";
/** euro support */
private static final String TEXT_LATIN15 = "euro: \u20AC";
/** japanese */
private static final String TEXT_EUC_JP = "hiragana A: \u3042";
/** Unicode: support everything */
private static final String TEXT_UNICODE =
TEXT_LATIN1 + ", " +
TEXT_LATIN7 + ", " +
TEXT_LATIN15 + ", " +
TEXT_EUC_JP;
/** see http://unicode.org/faq/utf_bom.html#BOM */
private static final byte[] BOM_UTF8 = { (byte)0xEF, (byte)0xBB, (byte)0xBF };
private static final byte[] BOM_UTF16BE = { (byte)0xFE, (byte)0xFF };
private static final byte[] BOM_UTF16LE = { (byte)0xFF, (byte)0xFE };
private static final byte[] BOM_UTF32BE = { (byte)0x00, (byte)0x00, (byte)0xFF, (byte)0xFE };
private static final byte[] BOM_UTF32LE = { (byte)0xFF, (byte)0xFE, (byte)0x00, (byte)0x00 };
private static String createXmlContent( String text, String encoding )
{
String xmlDecl = "";
if ( encoding != null )
{
xmlDecl = "";
}
String xml = xmlDecl + "\n" + text + " ";
return xml;
}
private static void checkXmlContent( String xml, String encoding )
throws IOException
{
checkXmlContent( xml, encoding, null );
}
private static void checkXmlContent( String xml, String encoding, byte[] bom )
throws IOException
{
byte[] xmlContent = xml.getBytes( encoding );
InputStream in = new ByteArrayInputStream( xmlContent );
if ( bom != null )
{
in = new SequenceInputStream( new ByteArrayInputStream( bom ), in );
}
XmlStreamReader reader = new XmlStreamReader( in );
assertEquals( encoding, reader.getEncoding() );
String result = IOUtil.toString( reader );
assertEquals( xml, result );
}
private static void checkXmlStreamReader( String text, String encoding, String effectiveEncoding )
throws IOException
{
checkXmlStreamReader( text, encoding, effectiveEncoding, null );
}
private static void checkXmlStreamReader( String text, String encoding )
throws IOException
{
checkXmlStreamReader( text, encoding, encoding, null );
}
private static void checkXmlStreamReader( String text, String encoding, byte[] bom )
throws IOException
{
checkXmlStreamReader( text, encoding, encoding, bom );
}
private static void checkXmlStreamReader( String text, String encoding, String effectiveEncoding, byte[] bom )
throws IOException
{
String xml = createXmlContent( text, encoding );
checkXmlContent( xml, effectiveEncoding, bom );
}
public void testNoXmlHeader()
throws IOException
{
String xml = "text with no XML header ";
checkXmlContent( xml, "UTF-8" );
checkXmlContent( xml, "UTF-8", BOM_UTF8 );
}
public void testDefaultEncoding()
throws IOException
{
checkXmlStreamReader( TEXT_UNICODE, null, "UTF-8" );
checkXmlStreamReader( TEXT_UNICODE, null, "UTF-8", BOM_UTF8 );
}
public void testUTF8Encoding()
throws IOException
{
checkXmlStreamReader( TEXT_UNICODE, "UTF-8" );
checkXmlStreamReader( TEXT_UNICODE, "UTF-8", BOM_UTF8 );
}
public void testUTF16Encoding()
throws IOException
{
checkXmlStreamReader( TEXT_UNICODE, "UTF-16", "UTF-16BE", null );
checkXmlStreamReader( TEXT_UNICODE, "UTF-16", "UTF-16LE", BOM_UTF16LE );
checkXmlStreamReader( TEXT_UNICODE, "UTF-16", "UTF-16BE", BOM_UTF16BE );
}
public void testUTF16BEEncoding()
throws IOException
{
checkXmlStreamReader( TEXT_UNICODE, "UTF-16BE" );
}
public void testUTF16LEEncoding()
throws IOException
{
checkXmlStreamReader( TEXT_UNICODE, "UTF-16LE" );
}
public void testLatin1Encoding()
throws IOException
{
checkXmlStreamReader( TEXT_LATIN1, "ISO-8859-1" );
}
public void testLatin7Encoding()
throws IOException
{
checkXmlStreamReader( TEXT_LATIN7, "ISO-8859-7" );
}
public void testLatin15Encoding()
throws IOException
{
checkXmlStreamReader( TEXT_LATIN15, "ISO-8859-15" );
}
public void testEUC_JPEncoding()
throws IOException
{
checkXmlStreamReader( TEXT_EUC_JP, "EUC-JP" );
}
public void testEBCDICEncoding()
throws IOException
{
checkXmlStreamReader( "simple text in EBCDIC", "CP1047" );
}
public void testInappropriateEncoding()
throws IOException
{
try
{
checkXmlStreamReader( TEXT_UNICODE, "ISO-8859-2" );
fail( "Check should have failed, since some characters are not available in the specified encoding" );
}
catch ( ComparisonFailure cf )
{
// expected failure, since the encoding does not contain some characters
}
}
public void testEncodingAttribute()
throws IOException
{
String xml = "" + text + " ";
return xml;
}
private static void checkXmlContent( String xml, String encoding )
throws IOException
{
ByteArrayOutputStream out = new ByteArrayOutputStream();
XmlStreamWriter writer = new XmlStreamWriter( out );
writer.write( xml );
writer.close();
byte[] xmlContent = out.toByteArray();
String result = new String( xmlContent, encoding );
assertEquals( xml, result );
}
private static void checkXmlWriter( String text, String encoding )
throws IOException
{
String xml = createXmlContent( text, encoding );
String effectiveEncoding = ( encoding == null ) ? "UTF-8" : encoding;
checkXmlContent( xml, effectiveEncoding );
}
public void testNoXmlHeader()
throws IOException
{
String xml = "text with no XML header ";
checkXmlContent( xml, "UTF-8" );
}
public void testEmpty()
throws IOException
{
ByteArrayOutputStream out = new ByteArrayOutputStream();
XmlStreamWriter writer = new XmlStreamWriter( out );
writer.flush();
writer.write( "" );
writer.flush();
writer.write( "." );
writer.flush();
writer.close();
}
public void testDefaultEncoding()
throws IOException
{
checkXmlWriter( TEXT_UNICODE, null );
}
public void testUTF8Encoding()
throws IOException
{
checkXmlWriter( TEXT_UNICODE, "UTF-8" );
}
public void testUTF16Encoding()
throws IOException
{
checkXmlWriter( TEXT_UNICODE, "UTF-16" );
}
public void testUTF16BEEncoding()
throws IOException
{
checkXmlWriter( TEXT_UNICODE, "UTF-16BE" );
}
public void testUTF16LEEncoding()
throws IOException
{
checkXmlWriter( TEXT_UNICODE, "UTF-16LE" );
}
public void testLatin1Encoding()
throws IOException
{
checkXmlWriter( TEXT_LATIN1, "ISO-8859-1" );
}
public void testLatin7Encoding()
throws IOException
{
checkXmlWriter( TEXT_LATIN7, "ISO-8859-7" );
}
public void testLatin15Encoding()
throws IOException
{
checkXmlWriter( TEXT_LATIN15, "ISO-8859-15" );
}
public void testEUC_JPEncoding()
throws IOException
{
checkXmlWriter( TEXT_EUC_JP, "EUC-JP" );
}
public void testEBCDICEncoding()
throws IOException
{
checkXmlWriter( "simple text in EBCDIC", "CP1047" );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/xml/XmlUtilTest.java 0000664 0000000 0000000 00000011234 11660305702 0027526 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import junit.framework.TestCase;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.WriterFactory;
/**
* Test the {@link XmlUtil} class.
*
* @author Vincent Siveton
* @version $Id: XmlUtilTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class XmlUtilTest
extends TestCase
{
private static final File basedir = new File( new File( "" ).getAbsolutePath() );
/** {@inheritDoc} */
protected void setUp()
throws Exception
{
super.setUp();
}
/** {@inheritDoc} */
protected void tearDown()
throws Exception
{
super.tearDown();
}
public void testPrettyFormatInputStreamOutputStream()
throws Exception
{
File testDocument = new File( basedir, "src/test/resources/testDocument.xhtml" );
assertTrue( testDocument.exists() );
InputStream is = null;
OutputStream os = null;
try
{
is = new FileInputStream( testDocument );
os = new FileOutputStream( new File( basedir, "target/test/prettyFormatTestDocumentOutputStream.xml" ) );
assertNotNull( is );
assertNotNull( os );
XmlUtil.prettyFormat( is, os );
}
finally
{
IOUtil.close( is );
IOUtil.close( os );
}
}
public void testPrettyFormatReaderWriter()
throws Exception
{
File testDocument = new File( basedir, "src/test/resources/testDocument.xhtml" );
assertTrue( testDocument.exists() );
Reader reader = null;
Writer writer = null;
try
{
reader = ReaderFactory.newXmlReader( testDocument );
writer = WriterFactory.newXmlWriter( new File( basedir, "target/test/prettyFormatTestDocumentWriter.xml" ) );
assertNotNull( reader );
assertNotNull( writer );
XmlUtil.prettyFormat( reader, writer );
}
finally
{
IOUtil.close( reader );
IOUtil.close( writer );
}
}
public void testPrettyFormatString()
throws Exception
{
File testDocument = new File( basedir, "src/test/resources/testDocument.xhtml" );
assertTrue( testDocument.exists() );
Reader reader = null;
Writer writer = null;
String content;
try
{
reader = ReaderFactory.newXmlReader( testDocument );
content = IOUtil.toString( reader );
reader = ReaderFactory.newXmlReader( testDocument );
writer = new StringWriter();
XmlUtil.prettyFormat( reader, writer );
}
finally
{
IOUtil.close( reader );
IOUtil.close( writer );
}
assertNotNull( content );
int countEOL = StringUtils.countMatches( content, XmlUtil.DEFAULT_LINE_SEPARATOR );
assertTrue( countEOL < StringUtils.countMatches( writer.toString(), XmlUtil.DEFAULT_LINE_SEPARATOR ) );
}
public void testPrettyFormatReaderWriter2()
throws Exception
{
File testDocument = new File( basedir, "src/test/resources/test.xdoc.xhtml" );
assertTrue( testDocument.exists() );
Reader reader = null;
Writer writer = null;
try
{
reader = ReaderFactory.newXmlReader( testDocument );
writer = WriterFactory.newXmlWriter( new File( basedir, "target/test/prettyFormatTestXdocWriter.xml" ) );
assertNotNull( reader );
assertNotNull( writer );
XmlUtil.prettyFormat( reader, writer );
}
finally
{
IOUtil.close( reader );
IOUtil.close( writer );
}
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/xml/XmlWriterUtilTest.java 0000664 0000000 0000000 00000044570 11660305702 0030734 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;
import java.io.Writer;
import junit.framework.TestCase;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.WriterFactory;
/**
* @author Vincent Siveton
* @version $Id: XmlWriterUtilTest.java 8660 2010-03-05 21:50:36Z hboutemy $
*/
public class XmlWriterUtilTest
extends TestCase
{
private OutputStream output;
private Writer writer;
private XMLWriter xmlWriter;
/** {@inheritDoc} */
protected void setUp()
throws Exception
{
super.setUp();
output = new ByteArrayOutputStream();
writer = WriterFactory.newXmlWriter( output );
xmlWriter = new PrettyPrintXMLWriter( writer );
}
/** {@inheritDoc} */
protected void tearDown()
throws Exception
{
super.tearDown();
xmlWriter = null;
writer = null;
output = null;
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeLineBreak(org.codehaus.plexus.util.xml.XMLWriter)}.
*
* @throws Exception if any
*/
public void testWriteLineBreakXMLWriter()
throws Exception
{
XmlWriterUtil.writeLineBreak( xmlWriter );
writer.close();
assertTrue( StringUtils.countMatches( output.toString(), XmlWriterUtil.LS ) == 1 );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeLineBreak(org.codehaus.plexus.util.xml.XMLWriter, int)}.
*
* @throws Exception if any
*/
public void testWriteLineBreakXMLWriterInt()
throws Exception
{
XmlWriterUtil.writeLineBreak( xmlWriter, 10 );
writer.close();
assertTrue( StringUtils.countMatches( output.toString(), XmlWriterUtil.LS ) == 10 );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeLineBreak(org.codehaus.plexus.util.xml.XMLWriter, int, int)}.
*
* @throws Exception if any
*/
public void testWriteLineBreakXMLWriterIntInt()
throws Exception
{
XmlWriterUtil.writeLineBreak( xmlWriter, 10, 2 );
writer.close();
assertTrue( StringUtils.countMatches( output.toString(), XmlWriterUtil.LS ) == 10 );
assertTrue( StringUtils.countMatches( output.toString(), StringUtils
.repeat( " ", 2 * XmlWriterUtil.DEFAULT_INDENTATION_SIZE ) ) == 1 );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeLineBreak(org.codehaus.plexus.util.xml.XMLWriter, int, int, int)}.
*
* @throws Exception if any
*/
public void testWriteLineBreakXMLWriterIntIntInt()
throws Exception
{
XmlWriterUtil.writeLineBreak( xmlWriter, 10, 2, 4 );
writer.close();
assertTrue( StringUtils.countMatches( output.toString(), XmlWriterUtil.LS ) == 10 );
assertTrue( StringUtils.countMatches( output.toString(), StringUtils.repeat( " ", 2 * 4 ) ) == 1 );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeCommentLineBreak(org.codehaus.plexus.util.xml.XMLWriter)}.
*
* @throws Exception if any
*/
public void testWriteCommentLineBreakXMLWriter()
throws Exception
{
XmlWriterUtil.writeCommentLineBreak( xmlWriter );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == XmlWriterUtil.DEFAULT_COLUMN_LINE - 1 + XmlWriterUtil.LS.length() );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeCommentLineBreak(org.codehaus.plexus.util.xml.XMLWriter, int)}.
*
* @throws Exception if any
*/
public void testWriteCommentLineBreakXMLWriterInt()
throws Exception
{
XmlWriterUtil.writeCommentLineBreak( xmlWriter, 20 );
writer.close();
assertEquals( output.toString(), "" + XmlWriterUtil.LS );
tearDown();
setUp();
XmlWriterUtil.writeCommentLineBreak( xmlWriter, 10 );
writer.close();
assertEquals( output.toString(), output.toString(), "" + XmlWriterUtil.LS );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeComment(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String)}.
*
* @throws Exception if any
*/
public void testWriteCommentXMLWriterString()
throws Exception
{
XmlWriterUtil.writeComment( xmlWriter, "hello" );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == XmlWriterUtil.DEFAULT_COLUMN_LINE - 1 + XmlWriterUtil.LS.length() );
tearDown();
setUp();
XmlWriterUtil.writeComment( xmlWriter,
"hellooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo" );
writer.close();
sb = new StringBuffer();
sb.append( "" )
.append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() >= XmlWriterUtil.DEFAULT_COLUMN_LINE );
tearDown();
setUp();
XmlWriterUtil.writeComment( xmlWriter, "hello\nworld" );
writer.close();
sb = new StringBuffer();
sb.append( "" ).append( XmlWriterUtil.LS );
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == 2 * ( XmlWriterUtil.DEFAULT_COLUMN_LINE - 1 + XmlWriterUtil.LS.length() ) );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeComment(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String, int)}.
*
* @throws Exception if any
*/
public void testWriteCommentXMLWriterStringInt()
throws Exception
{
String indent = StringUtils.repeat( " ", 2 * XmlWriterUtil.DEFAULT_INDENTATION_SIZE );
XmlWriterUtil.writeComment( xmlWriter, "hello", 2 );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( indent );
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == XmlWriterUtil.DEFAULT_COLUMN_LINE - 1 + XmlWriterUtil.LS.length() + 2
* XmlWriterUtil.DEFAULT_INDENTATION_SIZE );
tearDown();
setUp();
XmlWriterUtil.writeComment( xmlWriter, "hello\nworld", 2 );
writer.close();
sb = new StringBuffer();
sb.append( indent );
sb.append( "" ).append( XmlWriterUtil.LS );
sb.append( indent );
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == 2 * ( XmlWriterUtil.DEFAULT_COLUMN_LINE - 1 + XmlWriterUtil.LS.length() ) + 2 * indent.length() );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeComment(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String, int, int)}.
*
* @throws Exception if any
*/
public void testWriteCommentXMLWriterStringIntInt()
throws Exception
{
String repeat = StringUtils.repeat( " ", 2 * 4 );
XmlWriterUtil.writeComment( xmlWriter, "hello", 2, 4 );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( repeat );
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == XmlWriterUtil.DEFAULT_COLUMN_LINE - 1 + XmlWriterUtil.LS.length() + 2 * 4 );
tearDown();
setUp();
XmlWriterUtil.writeComment( xmlWriter, "hello\nworld", 2, 4 );
writer.close();
sb = new StringBuffer();
sb.append( repeat );
sb.append( "" ).append( XmlWriterUtil.LS );
sb.append( repeat );
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == 2 * ( XmlWriterUtil.DEFAULT_COLUMN_LINE - 1 + XmlWriterUtil.LS.length() ) + 2 * repeat.length() );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeComment(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String, int, int, int)}.
*
* @throws Exception if any
*/
public void testWriteCommentXMLWriterStringIntIntInt()
throws Exception
{
String indent = StringUtils.repeat( " ", 2 * 4 );
XmlWriterUtil.writeComment( xmlWriter, "hello", 2, 4, 50 );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( indent );
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == 50 - 1 + XmlWriterUtil.LS.length() + 2 * 4 );
tearDown();
setUp();
XmlWriterUtil.writeComment( xmlWriter, "hello", 2, 4, 10 );
writer.close();
sb = new StringBuffer();
sb.append( indent );
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() >= 10 + 2 * 4 );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeCommentText(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String, int)}.
*
* @throws Exception if any
*/
public void testWriteCommentTextXMLWriterStringInt()
throws Exception
{
XmlWriterUtil.writeCommentText( xmlWriter, "hello", 0 );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( XmlWriterUtil.LS );
sb.append( "" ).append( XmlWriterUtil.LS );
sb.append( "" ).append( XmlWriterUtil.LS );
sb.append( "" ).append( XmlWriterUtil.LS );
sb.append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == 3 * ( 80 - 1 + XmlWriterUtil.LS.length() ) + 2 * XmlWriterUtil.LS.length() );
tearDown();
setUp();
String indent = StringUtils.repeat( " ", 2 * 2 );
XmlWriterUtil.writeCommentText( xmlWriter, "hello world with end of line\n and "
+ "loooooooooooooooooooooooooooooooooooooooooooooooooooooonnnnnnnnnnong line", 2 );
writer.close();
sb = new StringBuffer();
sb.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" )
.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" )
.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" )
.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" )
.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" )
.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" )
.append( XmlWriterUtil.LS );
sb.append( XmlWriterUtil.LS );
sb.append( indent );
assertEquals( output.toString(), sb.toString() );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeCommentText(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String, int, int)}.
*
* @throws Exception if any
*/
public void testWriteCommentTextXMLWriterStringIntInt()
throws Exception
{
String indent = StringUtils.repeat( " ", 2 * 4 );
XmlWriterUtil.writeCommentText( xmlWriter, "hello", 2, 4 );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" )
.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" )
.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" )
.append( XmlWriterUtil.LS );
sb.append( XmlWriterUtil.LS );
sb.append( indent );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == 3 * ( 80 - 1 + XmlWriterUtil.LS.length() ) + 4 * 2 * 4 + 2 * XmlWriterUtil.LS.length() );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeCommentText(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String, int, int, int)}.
*
* @throws Exception if any
*/
public void testWriteCommentTextXMLWriterStringIntIntInt()
throws Exception
{
String indent = StringUtils.repeat( " ", 2 * 4 );
XmlWriterUtil.writeCommentText( xmlWriter, "hello", 2, 4, 50 );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( XmlWriterUtil.LS );
sb.append( indent ).append( "" ).append( XmlWriterUtil.LS );
sb.append( indent ).append( "" ).append( XmlWriterUtil.LS );
sb.append( indent ).append( "" ).append( XmlWriterUtil.LS );
sb.append( XmlWriterUtil.LS );
sb.append( indent );
assertEquals( output.toString(), sb.toString() );
assertTrue( output.toString().length() == 3 * ( 50 - 1 + XmlWriterUtil.LS.length() ) + 4 * 2 * 4 + 2 * XmlWriterUtil.LS.length() );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeComment(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String)}.
*
* @throws Exception if any
*/
public void testWriteCommentNull()
throws Exception
{
XmlWriterUtil.writeComment( xmlWriter, null );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeComment(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String)}.
*
* @throws Exception if any
*/
public void testWriteCommentShort()
throws Exception
{
XmlWriterUtil.writeComment( xmlWriter, "This is a short text" );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
}
/**
* Test method for {@link org.codehaus.plexus.util.xml.XmlWriterUtil#writeComment(org.codehaus.plexus.util.xml.XMLWriter, java.lang.String)}.
*
* @throws Exception if any
*/
public void testWriteCommentLong()
throws Exception
{
XmlWriterUtil.writeComment( xmlWriter, "Maven is a software project management and comprehension tool. "
+ "Based on the concept of a project object model (POM), Maven can manage a project's build, reporting "
+ "and documentation from a central piece of information." );
writer.close();
StringBuffer sb = new StringBuffer();
sb.append( "" ).append( XmlWriterUtil.LS );
sb.append( "" ).append( XmlWriterUtil.LS );
sb.append( "" ).append( XmlWriterUtil.LS );
sb.append( "" ).append( XmlWriterUtil.LS );
assertEquals( output.toString(), sb.toString() );
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/xml/Xpp3DomBuilderTest.java 0000664 0000000 0000000 00000020011 11660305702 0030722 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import junit.framework.TestCase;
import org.codehaus.plexus.util.xml.pull.MXParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParser;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
/**
* Test the Xpp3DomBuilder.
*
* @author Brett Porter
* @version $Id: Xpp3DomBuilderTest.java 8010 2009-01-07 12:59:50Z vsiveton $
*/
public class Xpp3DomBuilderTest
extends TestCase
{
private static final String LS = System.getProperty("line.separator");
public void testBuildFromReader()
throws Exception
{
String domString = createDomString();
Xpp3Dom dom = Xpp3DomBuilder.build( new StringReader( domString ) );
Xpp3Dom expectedDom = createExpectedDom();
assertEquals( "check DOMs match", expectedDom, dom );
}
public void testBuildTrimming()
throws Exception
{
String domString = createDomString();
Xpp3Dom dom = Xpp3DomBuilder.build( new StringReader( domString ), true );
assertEquals( "test with trimming on", "element1", dom.getChild( "el1" ).getValue() );
dom = Xpp3DomBuilder.build( new StringReader( domString ), false );
assertEquals( "test with trimming off", " element1\n ", dom.getChild( "el1" ).getValue() );
}
public void testBuildFromXpp3Dom()
throws Exception
{
Xpp3Dom expectedDom = createExpectedDom();
Xpp3Dom dom = null;
XmlPullParser parser = new MXParser();
String domString = "" + createDomString() + " " + createDomString();
try
{
Xpp3DomBuilder.build( new StringReader( domString ) );
}
catch ( XmlPullParserException expected )
{
// correct
assertTrue( true );
}
catch ( IOException expected )
{
// this will do too
assertTrue( true );
}
}
public void testEscapingInContent()
throws IOException, XmlPullParserException
{
Xpp3Dom dom = Xpp3DomBuilder.build( new StringReader( getEncodedString() ) );
assertEquals( "Check content value", "\"text\"", dom.getChild( "el" ).getValue() );
assertEquals( "Check content value", "\"text\"", dom.getChild( "ela" ).getValue() );
assertEquals( "Check content value", "\"text\"", dom.getChild( "elb" ).getValue() );
StringWriter w = new StringWriter();
Xpp3DomWriter.write( w, dom );
assertEquals( "Compare stringified DOMs", getExpectedString(), w.toString() );
}
public void testEscapingInAttributes()
throws IOException, XmlPullParserException
{
String s = getAttributeEncodedString();
Xpp3Dom dom = Xpp3DomBuilder.build( new StringReader( s ) );
assertEquals( "Check attribute value", "", dom.getChild( "el" ).getAttribute( "att" ) );
StringWriter w = new StringWriter();
Xpp3DomWriter.write( w, dom );
String newString = w.toString();
assertEquals( "Compare stringified DOMs", newString, s );
}
private static String getAttributeEncodedString()
{
StringBuffer domString = new StringBuffer();
domString.append( "" );
domString.append( LS );
domString.append( " bar " );
domString.append( LS );
domString.append( " " );
return domString.toString();
}
private static String getEncodedString()
{
StringBuffer domString = new StringBuffer();
domString.append( "\n" );
domString.append( " \"text\" \n" );
domString.append( " \"text\"]]> \n" );
domString.append( " <b>"text"</b> \n" );
domString.append( " " );
return domString.toString();
}
private static String getExpectedString()
{
StringBuffer domString = new StringBuffer();
domString.append( "" );
domString.append( LS );
domString.append( " "text" " );
domString.append( LS );
domString.append( " <b>"text"</b> " );
domString.append( LS );
domString.append( " <b>"text"</b> " );
domString.append( LS );
domString.append( " " );
return domString.toString();
}
//
// HELPER METHODS
//
private static String createDomString()
{
StringBuffer buf = new StringBuffer();
buf.append( "\n" );
buf.append( " element1\n \n" );
buf.append( " \n" );
buf.append( " element3 \n" );
buf.append( " \n" );
buf.append( " \n" );
return buf.toString();
}
private static Xpp3Dom createExpectedDom()
{
Xpp3Dom expectedDom = new Xpp3Dom( "root" );
Xpp3Dom el1 = new Xpp3Dom( "el1" );
el1.setValue( "element1" );
expectedDom.addChild( el1 );
Xpp3Dom el2 = new Xpp3Dom( "el2" );
el2.setAttribute( "att2", "attribute2\nnextline" );
expectedDom.addChild( el2 );
Xpp3Dom el3 = new Xpp3Dom( "el3" );
el3.setAttribute( "att3", "attribute3" );
el3.setValue( "element3" );
el2.addChild( el3 );
Xpp3Dom el4 = new Xpp3Dom( "el4" );
el4.setValue( "" );
expectedDom.addChild( el4 );
Xpp3Dom el5 = new Xpp3Dom( "el5" );
expectedDom.addChild( el5 );
return expectedDom;
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/xml/Xpp3DomTest.java 0000664 0000000 0000000 00000022220 11660305702 0027417 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import java.io.IOException;
import java.io.StringReader;
import java.util.HashMap;
import junit.framework.TestCase;
public class Xpp3DomTest
extends TestCase
{
public void testShouldPerformAppendAtFirstSubElementLevel()
{
// create the dominant DOM
Xpp3Dom t1 = new Xpp3Dom( "top" );
t1.setAttribute( Xpp3Dom.CHILDREN_COMBINATION_MODE_ATTRIBUTE, Xpp3Dom.CHILDREN_COMBINATION_APPEND );
Xpp3Dom t1s1 = new Xpp3Dom( "topsub1" );
t1s1.setValue( "t1s1Value" );
t1.addChild( t1s1 );
// create the recessive DOM
Xpp3Dom t2 = new Xpp3Dom( "top" );
Xpp3Dom t2s1 = new Xpp3Dom( "topsub1" );
t2s1.setValue( "t2s1Value" );
t2.addChild( t2s1 );
// merge and check results.
Xpp3Dom result = Xpp3Dom.mergeXpp3Dom( t1, t2 );
assertEquals( 2, result.getChildren( "topsub1" ).length );
}
public void testShouldOverrideAppendAndDeepMerge()
{
// create the dominant DOM
Xpp3Dom t1 = new Xpp3Dom( "top" );
t1.setAttribute( Xpp3Dom.CHILDREN_COMBINATION_MODE_ATTRIBUTE, Xpp3Dom.CHILDREN_COMBINATION_APPEND );
Xpp3Dom t1s1 = new Xpp3Dom( "topsub1" );
t1s1.setValue( "t1s1Value" );
t1.addChild( t1s1 );
// create the recessive DOM
Xpp3Dom t2 = new Xpp3Dom( "top" );
Xpp3Dom t2s1 = new Xpp3Dom( "topsub1" );
t2s1.setValue( "t2s1Value" );
t2.addChild( t2s1 );
// merge and check results.
Xpp3Dom result = Xpp3Dom.mergeXpp3Dom( t1, t2, Boolean.TRUE );
assertEquals( 1, result.getChildren( "topsub1" ).length );
}
public void testShouldPerformSelfOverrideAtTopLevel()
{
// create the dominant DOM
Xpp3Dom t1 = new Xpp3Dom( "top" );
t1.setAttribute( "attr", "value" );
t1.setAttribute( Xpp3Dom.SELF_COMBINATION_MODE_ATTRIBUTE, Xpp3Dom.SELF_COMBINATION_OVERRIDE );
// create the recessive DOM
Xpp3Dom t2 = new Xpp3Dom( "top" );
t2.setAttribute( "attr2", "value2" );
t2.setValue( "t2Value" );
// merge and check results.
Xpp3Dom result = Xpp3Dom.mergeXpp3Dom( t1, t2 );
assertEquals( 2, result.getAttributeNames().length );
assertNull( result.getValue() );
}
public void testShouldMergeValuesAtTopLevelByDefault()
{
// create the dominant DOM
Xpp3Dom t1 = new Xpp3Dom( "top" );
t1.setAttribute( "attr", "value" );
// create the recessive DOM
Xpp3Dom t2 = new Xpp3Dom( "top" );
t2.setAttribute( "attr2", "value2" );
t2.setValue( "t2Value" );
// merge and check results.
Xpp3Dom result = Xpp3Dom.mergeXpp3Dom( t1, t2 );
// this is still 2, since we're not using the merge-control attribute.
assertEquals( 2, result.getAttributeNames().length );
assertEquals( result.getValue(), t2.getValue() );
}
public void testShouldMergeValuesAtTopLevel()
{
// create the dominant DOM
Xpp3Dom t1 = new Xpp3Dom( "top" );
t1.setAttribute( "attr", "value" );
t1.setAttribute( Xpp3Dom.SELF_COMBINATION_MODE_ATTRIBUTE, Xpp3Dom.SELF_COMBINATION_MERGE );
// create the recessive DOM
Xpp3Dom t2 = new Xpp3Dom( "top" );
t2.setAttribute( "attr2", "value2" );
t2.setValue( "t2Value" );
// merge and check results.
Xpp3Dom result = Xpp3Dom.mergeXpp3Dom( t1, t2 );
assertEquals( 3, result.getAttributeNames().length );
assertEquals( result.getValue(), t2.getValue() );
}
public void testNullAttributeNameOrValue()
{
Xpp3Dom t1 = new Xpp3Dom( "top" );
try
{
t1.setAttribute( "attr", null );
fail( "null attribute values shouldn't be allowed" );
}
catch ( NullPointerException e )
{
}
t1.toString();
try
{
t1.setAttribute( null, "value" );
fail( "null attribute names shouldn't be allowed" );
}
catch ( NullPointerException e )
{
}
t1.toString();
}
public void testEquals()
{
Xpp3Dom dom = new Xpp3Dom( "top" );
assertEquals( dom, dom );
assertFalse( dom.equals( null ) );
assertFalse( dom.equals( new Xpp3Dom( (String) null ) ) );
}
public void testEqualsIsNullSafe()
throws XmlPullParserException, IOException
{
String testDom = "- one
- two
- one
- two
- three
- one
- two
- three
- test
x y " );
buf.append( LS );
buf.append( " element1 " );
buf.append( LS );
buf.append( " " );
buf.append( LS );
buf.append( " element3 " );
buf.append( LS );
buf.append( " " );
buf.append( LS );
buf.append( " " );
buf.append( LS );
if ( escape )
{
buf.append( " element7" + LS + "&"'<> " );
}
else
{
buf.append( " element7"+ LS + "&\"\'<> " );
}
buf.append( LS );
buf.append( " " );
buf.append( LS );
buf.append( " " );
return buf.toString();
}
private Xpp3Dom createXpp3Dom()
{
Xpp3Dom dom = new Xpp3Dom( "root" );
Xpp3Dom el1 = new Xpp3Dom( "el1" );
el1.setValue( "element1" );
dom.addChild( el1 );
Xpp3Dom el2 = new Xpp3Dom( "el2" );
el2.setAttribute( "att2", "attribute2\nnextline" );
dom.addChild( el2 );
Xpp3Dom el3 = new Xpp3Dom( "el3" );
el3.setAttribute( "att3", "attribute3" );
el3.setValue( "element3" );
el2.addChild( el3 );
Xpp3Dom el4 = new Xpp3Dom( "el4" );
el4.setValue( "" );
dom.addChild( el4 );
Xpp3Dom el5 = new Xpp3Dom( "el5" );
dom.addChild( el5 );
// test escaping
Xpp3Dom el6 = new Xpp3Dom( "el6" );
el6.setAttribute( "att6", "attribute6\n&\"'<>" );
dom.addChild( el6 );
Xpp3Dom el7 = new Xpp3Dom( "el7" );
el7.setValue( "element7\n&\"\'<>" );
el6.addChild( el7 );
return dom;
}
}
plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/xml/pull/ 0000775 0000000 0000000 00000000000 11660305702 0025400 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/java/org/codehaus/plexus/util/xml/pull/MXParserTest.java 0000664 0000000 0000000 00000011555 11660305702 0030613 0 ustar 00root root 0000000 0000000 package org.codehaus.plexus.util.xml.pull;
/*
* Copyright The Codehaus Foundation.
*
* Licensed 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
*
* 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
* limitations under the License.
*/
import java.io.StringReader;
import junit.framework.TestCase;
/**
* @author Trygve Laugstøl
* @version $Id: MXParserTest.java 8237 2009-05-28 22:57:46Z vsiveton $
*/
public class MXParserTest
extends TestCase
{
public void testHexadecimalEntities()
throws Exception
{
MXParser parser = new MXParser();
parser.defineEntityReplacementText( "test", "replacement" );
String input = "A ";
parser.setInput( new StringReader( input ) );
assertEquals( XmlPullParser.START_TAG, parser.next() );
assertEquals( XmlPullParser.TEXT, parser.next() );
assertEquals( "A", parser.getText() );
assertEquals( XmlPullParser.END_TAG, parser.next() );
}
public void testDecimalEntities()
throws Exception
{
MXParser parser = new MXParser();
parser.defineEntityReplacementText( "test", "replacement" );
String input = "A ";
parser.setInput( new StringReader( input ) );
assertEquals( XmlPullParser.START_TAG, parser.next() );
assertEquals( XmlPullParser.TEXT, parser.next() );
assertEquals( "A", parser.getText() );
assertEquals( XmlPullParser.END_TAG, parser.next() );
}
public void testPredefinedEntities()
throws Exception
{
MXParser parser = new MXParser();
parser.defineEntityReplacementText( "test", "replacement" );
String input = "<>&'" ";
parser.setInput( new StringReader( input ) );
assertEquals( XmlPullParser.START_TAG, parser.next() );
assertEquals( XmlPullParser.TEXT, parser.next() );
assertEquals( "<>&'\"", parser.getText() );
assertEquals( XmlPullParser.END_TAG, parser.next() );
}
public void testCustomEntities()
throws Exception
{
MXParser parser = new MXParser();
String input = "&myentity; ";
parser.setInput( new StringReader( input ) );
parser.defineEntityReplacementText( "myentity", "replacement" );
assertEquals( XmlPullParser.START_TAG, parser.next() );
assertEquals( XmlPullParser.TEXT, parser.next() );
assertEquals( "replacement", parser.getText() );
assertEquals( XmlPullParser.END_TAG, parser.next() );
parser = new MXParser();
input = "&myCustom; ";
parser.setInput( new StringReader( input ) );
parser.defineEntityReplacementText( "fo", "A" );
parser.defineEntityReplacementText( "myCustom", "&fo;" );
assertEquals( XmlPullParser.START_TAG, parser.next() );
assertEquals( XmlPullParser.TEXT, parser.next() );
assertEquals( "A", parser.getText() );
assertEquals( XmlPullParser.END_TAG, parser.next() );
}
public void testUnicodeEntities()
throws Exception
{
MXParser parser = new MXParser();
String input = "𝟭 ";
parser.setInput( new StringReader( input ) );
assertEquals( XmlPullParser.START_TAG, parser.nextToken() );
assertEquals( XmlPullParser.ENTITY_REF, parser.nextToken() );
assertEquals( "\uD835\uDFED", parser.getText() );
assertEquals( XmlPullParser.END_TAG, parser.nextToken() );
parser = new MXParser();
input = "ř ";
parser.setInput( new StringReader( input ) );
assertEquals( XmlPullParser.START_TAG, parser.nextToken() );
assertEquals( XmlPullParser.ENTITY_REF, parser.nextToken() );
assertEquals( "\u0159", parser.getText() );
assertEquals( XmlPullParser.END_TAG, parser.nextToken() );
}
public void testProcessingInstruction()
throws Exception
{
String input = "nnn ";
MXParser parser = new MXParser();
parser.setInput( new StringReader( input ) );
assertEquals( XmlPullParser.PROCESSING_INSTRUCTION, parser.nextToken() );
assertEquals( XmlPullParser.START_TAG, parser.nextToken() );
assertEquals( XmlPullParser.TEXT, parser.nextToken() );
assertEquals( XmlPullParser.END_TAG, parser.nextToken() );
}
}
plexus-utils2-2.0.5/src/test/resources/ 0000775 0000000 0000000 00000000000 11660305702 0020036 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/dir-layout-copy/ 0000775 0000000 0000000 00000000000 11660305702 0023077 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/dir-layout-copy/dir1/ 0000775 0000000 0000000 00000000000 11660305702 0023736 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/dir-layout-copy/dir1/foo.txt 0000664 0000000 0000000 00000000015 11660305702 0025256 0 ustar 00root root 0000000 0000000 nothing here
plexus-utils2-2.0.5/src/test/resources/directory-scanner/ 0000775 0000000 0000000 00000000000 11660305702 0023471 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directory-scanner/foo/ 0000775 0000000 0000000 00000000000 11660305702 0024254 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directory-scanner/foo/bar/ 0000775 0000000 0000000 00000000000 11660305702 0025020 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directory-scanner/foo/bar/munchy.txt 0000664 0000000 0000000 00000000000 11660305702 0027052 0 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directorywalker/ 0000775 0000000 0000000 00000000000 11660305702 0023250 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directorywalker/directory1/ 0000775 0000000 0000000 00000000000 11660305702 0025335 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directorywalker/directory1/file1.txt 0000664 0000000 0000000 00000000000 11660305702 0027064 0 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directorywalker/directory2/ 0000775 0000000 0000000 00000000000 11660305702 0025336 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directorywalker/directory2/directory21/ 0000775 0000000 0000000 00000000000 11660305702 0027505 5 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directorywalker/directory2/directory21/file21.txt 0000664 0000000 0000000 00000000000 11660305702 0031316 0 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directorywalker/directory2/file2.txt 0000664 0000000 0000000 00000000000 11660305702 0027066 0 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/directorywalker/file.txt 0000664 0000000 0000000 00000000000 11660305702 0024716 0 ustar 00root root 0000000 0000000 plexus-utils2-2.0.5/src/test/resources/test.txt 0000664 0000000 0000000 00000000016 11660305702 0021553 0 ustar 00root root 0000000 0000000 This is a test plexus-utils2-2.0.5/src/test/resources/test.xdoc.xhtml 0000664 0000000 0000000 00000010764 11660305702 0023037 0 ustar 00root root 0000000 0000000
Title
Paragraph 1, line 1. Paragraph 1, line 2.
Paragraph 2, line 1. Paragraph 2, line 2.
Section title
Sub-section title
Sub-sub-section title
Sub-sub-sub-section
Sub-sub-sub-sub-section
- List item 1.
- List item 2.
Paragraph contained in list item 2.
- Sub-list item 1.
- Sub-list item 2.
- List item 3. Force end of list:
Verbatim text not contained in list item 3
- Numbered item 1.
- Numbered item A.
- Numbered item B.
- Numbered item 2.
List numbering schemes: [[1]], [[a]], [[A]], [[i]], [[I]].
-
Defined term 1
- of definition list.
-
Defined term 2
- of definition list.
Verbatim text
in a box
--- instead of +-- suppresses the box around verbatim text.
Centered
cell 1,1
Left-aligned
cell 1,2
Right-aligned
cell 1,3
cell 2,1
cell 2,2
cell 2,3
Table caption
No grid, no caption:
cell
cell
cell
cell
Horizontal line:
New page.
Italic font. Bold font. Monospaced font.
Anchor.
Link to Anchor.
Link to http://www.pixware.fr.
Link to showing alternate text.
Link to Pixware home page.
Force line
break.
Non breaking space.
Escaped special characters:
~
=
-
+
*
[
]
<
>
{
}
\
Copyright symbol: ©©©.
plexus-utils2-2.0.5/src/test/resources/testDocument.xhtml 0000664 0000000 0000000 00000006131 11660305702 0023573 0 ustar 00root root 0000000 0000000 Title Paragraph 1, line 1. Paragraph 1, line 2.
Paragraph 2, line 1. Paragraph 2, line 2.
Section title
Sub-section title
Sub-sub-section title
Sub-sub-sub-section title
Sub-sub-sub-sub-section title
- List item 1.
- List item 2.
Paragraph contained in list item 2.
- Sub-list item 1.
- Sub-list item 2.
- List item 3. Force end of list:
Verbatim text not contained in list item 3
- Numbered item 1.
- Numbered item A.
- Numbered item B.
- Numbered item 2.
List numbering schemes: [[1]], [[a]], [[A]], [[i]], [[I]].
- Defined term 1
- of definition list.
- Defined term 2
- of definition list.
Verbatim text
in a box
--- instead of +-- suppresses the box around verbatim text.
Figure caption
Table caption Centered
cell 1,1 Left-aligned
cell 1,2 Right-aligned
cell 1,3 cell Bold2,1 cell 2,2 cell 2,3
No grid, no caption:
cell cell cell cell
header header cell cell
Horizontal line:
New page.
Italic font. Bold font. Monospaced font.
Anchor. Link to Anchor. Link to http://www.pixware.fr. Link to showing alternate text. Link to Pixware home page.
Force line
break.
Non breaking space.
Escaped special characters:
~
=
-
+
*
[
]
<
>
{
}
\
Copyright symbol: ©, ©, ©.