source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.web.test;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *   http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 /**
  23  * Utility class for creating xpath expressions
  24  */
  25 public class XPathExpressionUtil
  26 {
  27     public static final String CONTAINS = "contains";
  28
  29     public static final String AND = " and ";
  30
  31     public static final String CURRENT_NODE = "./";
  32
  33     public static final String PARENT_NODE = "../";
  34
  35     public static final String GRANDPARENT_NODE = "../../";
  36
  37     public static final String ELEMENT_ANY_LEVEL = "//";
  38
  39     public static final String TABLE_COLUMN = "td";
  40
  41     public static final String TABLE_ROW = "tr";
  42
  43     public static final String START_NODE_TEST = "[";
  44
  45     public static final String END_NODE_TEST = "]";
  46
  47     public static final String ANCHOR = "a";
  48
  49     public static final String IMG = "img";
  50
  51     public static final String LIST = "ul";
  52
  53     public static final String LINE = "li";
  54
  55     public static String getList( String[] values )
  56     {
  57         String xpathExpression = "";
  58
  59         if ( values.length > 0 )
  60         {
  61             xpathExpression += ELEMENT_ANY_LEVEL;
  62             xpathExpression += LIST;
  63             xpathExpression += START_NODE_TEST;
  64
  65             for ( int nIndex = 0; nIndex < values.length; nIndex++ )
  66             {
  67                 xpathExpression += ( ( nIndex > 0 ) ? AND : "" );
  68                 xpathExpression += contains( LINE + position( nIndex + 1 ), values[nIndex] );
  69             }
  70
  71             xpathExpression += END_NODE_TEST;
  72         }
  73
  74         return xpathExpression;
  75     }
  76
  77     /**
  78      * expression for acquiring an element in one of the table columns
  79      *
  80      * @param element the node element
  81      * @param elementIndex column index of the element, used for skipping
  82      * @param columnValues the values to be matched in each column, element column is included
  83      * @return
  84      */
  85     public static String getColumnElement( String element, int elementIndex, String[] columnValues )
  86     {
  87         return getColumnElement( element, elementIndex, null, columnValues );
  88     }
  89
  90     /**
  91      * expression for acquiring an element in one of the table columns
  92      *
  93      * @param element the node element
  94      * @param elementIndex column index of the element, used for skipping
  95      * @param elementValue the matched element value
  96      * @param columnValues the values to be matched in each column, element column is included
  97      * @return
  98      */
  99     public static String getColumnElement( String element, int elementIndex, String elementValue, String[] columnValues )
 100     {
 101         return getColumnElement( element, elementIndex, elementValue, "TEXT", columnValues );
 102     }
 103
 104     /**
 105      * expression for acquiring an element in one of the table columns
 106      *
 107      * @param element the node element
 108      * @param elementIndex column index of the element, used for skipping
 109      * @param imageName the matched image name
 110      * @param columnValues the values to be matched in each column, element column is included
 111      * @return
 112      */
 113     public static String getImgColumnElement( String element, int elementIndex, String imageName, String[] columnValues )
 114     {
 115         return getColumnElement( element, elementIndex, imageName, IMG, columnValues );
 116     }
 117
 118     /**
 119      * expression for acquiring an element in one of the table columns
 120      *
 121      * @param element the node element
 122      * @param elementIndex column index of the element, used for skipping
 123      * @param imageName the matched image name
 124      * @param columnValues the values to be matched in each column, element column is included
 125      * @return
 126      */
 127     private static String getColumnElement( String element, int elementIndex, String elementValue,
 128                                             String elementValueType, String[] columnValues )
 129     {
 130         String xpathExpression = null;
 131
 132         if ( ( columnValues != null ) && ( columnValues.length > 0 ) )
 133         {
 134             xpathExpression = ELEMENT_ANY_LEVEL + element;
 135             xpathExpression += START_NODE_TEST;
 136
 137             if ( elementValue != null )
 138             {
 139                 if ( "TEXT".equals( elementValueType ) )
 140                 {
 141                     xpathExpression += contains( elementValue );
 142                     xpathExpression += ( columnValues.length > 0 ) ? AND : "";
 143                 }
 144             }
 145
 146             // we are two levels below the table row element ( tr/td/<element> )
 147             xpathExpression += matchColumns( GRANDPARENT_NODE, columnValues, elementIndex );
 148
 149             xpathExpression += END_NODE_TEST;
 150         }
 151
 152         if ( IMG.equals( elementValueType ) )
 153         {
 154             xpathExpression += "/img[contains(@src, '" + elementValue + "')]";
 155         }
 156
 157         return xpathExpression;
 158     }
 159
 160     /**
 161      * expression for acquiring the table row that matches all column values with the same order as the list
 162      *
 163      * @param columnValues the matched list of columnValues
 164      * @return
 165      */
 166     public static String getTableRow( String[] columnValues )
 167     {
 168         String xpathExpression = null;
 169
 170         if ( ( columnValues != null ) && ( columnValues.length > 0 ) )
 171         {
 172             xpathExpression = new String( ELEMENT_ANY_LEVEL + TABLE_ROW + START_NODE_TEST );
 173             xpathExpression += matchColumns( columnValues );
 174             xpathExpression += END_NODE_TEST;
 175         }
 176
 177         return xpathExpression;
 178     }
 179
 180     private static String matchColumns( String[] columnValues )
 181     {
 182         return matchColumns( columnValues, -1 );
 183     }
 184
 185     private static String matchColumns( String[] columnValues, int skipIndex )
 186     {
 187         return matchColumns( null, columnValues, skipIndex );
 188     }
 189
 190     private static String matchColumns( String parent, String[] columnValues, int skipIndex )
 191     {
 192         String xpathExpression = "";
 193
 194         for ( int nIndex = 0; nIndex < columnValues.length; nIndex++ )
 195         {
 196             if ( ( skipIndex != nIndex ) || ( skipIndex == -1 ) )
 197             {
 198                 // prepend "and" if index > 0
 199                 xpathExpression += ( ( nIndex > 0 ) ? AND : "" );
 200                 xpathExpression += contains( parent, TABLE_COLUMN + position( nIndex + 1 ), columnValues[nIndex] );
 201             }
 202         }
 203
 204         return xpathExpression;
 205     }
 206
 207     private static String position( int nIndex )
 208     {
 209         return new String( "[" + nIndex + "]" );
 210     }
 211
 212     private static String contains( String parent, String element, String matchedString )
 213     {
 214         String finalElement = ( parent != null ) ? parent : "";
 215         finalElement += element;
 216
 217         return contains( finalElement, matchedString );
 218     }
 219
 220     private static String contains( String matchedString )
 221     {
 222         return contains( ".", matchedString );
 223     }
 224
 225     private static String contains( String axis, String matchedString )
 226     {
 227         return new String( CONTAINS + "(" + axis + "," + "'" + matchedString + "')" );
 228     }
 229
 230     private static String equals( String parent, String element, String matchedString )
 231     {
 232         String finalElement = ( parent != null ) ? parent : "";
 233         finalElement += element;
 234
 235         return equals( finalElement, matchedString );
 236     }
 237
 238     private static String equals( String axis, String matchedString )
 239     {
 240         return new String( axis + "==" + "'" + matchedString + "'" );
 241     }
 242 }