qadevOOo/runner/basicrunner/basichelper/DocumentHandler.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: DocumentHandler.java,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 package basicrunner.basichelper;
  31
  32 import com.sun.star.lang.XInitialization;
  33 import com.sun.star.lang.XSingleServiceFactory;
  34 import com.sun.star.lang.XServiceInfo;
  35 import com.sun.star.lang.XTypeProvider;
  36 import com.sun.star.uno.Type;
  37 import com.sun.star.xml.sax.XDocumentHandler;
  38 import com.sun.star.container.XNameAccess;
  39 import com.sun.star.container.NoSuchElementException;
  40 import java.util.Vector;
  41 import util.XMLTools.Tag;
  42 import util.XMLTools;
  43 import java.io.StringWriter;
  44 import java.io.PrintWriter;
  45
  46 /**
  47  * This class provides a handler of the BASIC test document.
  48  * @see com.sun.star.lang.XSingleServiceFactory
  49  * @see com.sun.star.lang.XServiceInfo
  50  */
  51 public class DocumentHandler implements XServiceInfo, XSingleServiceFactory {
  52     /** The service name of this class **/
  53     static final String __serviceName = "basichelper.DocumentHandler";
  54     /** The actual handler of the document **/
  55     static DocumentHandlerImpl oDocumentHandler = null;
  56     /** A string writer **/
  57     private StringWriter writer;
  58     /** The log writer (just a wrapper around <code>writer</code>) **/
  59     private PrintWriter log;
  60
  61     /**
  62      * Create an instance of the document handler.
  63      * @param args A boolean value as <codde>args[0]</code> determines,
  64      *             if checked XML data is printed to the log.
  65      *             Default is false.
  66      * @return The document handler
  67      */
  68     public Object createInstanceWithArguments(Object[] args) {
  69         boolean printXML = false;
  70         if (args != null && args.length!=0 && args[0] instanceof Boolean)
  71             printXML = ((Boolean)args[0]).booleanValue();
  72         writer = new StringWriter();
  73         log = new PrintWriter(writer);
  74         oDocumentHandler = new DocumentHandlerImpl(log, printXML, writer);
  75         return oDocumentHandler;
  76     }
  77
  78     /**
  79      * Create an instance of the document handler.
  80      * @return The document handler
  81      */
  82     public Object createInstance() {
  83         return createInstanceWithArguments(null);
  84     }
  85
  86     /** Get the unique id for this implementation
  87      * @return The id.
  88      */
  89     public byte[] getImplementationId() {
  90         return toString().getBytes();
  91     }
  92
  93     /** Get all implemented types.
  94      * @return The implemented UNO types.
  95      */
  96     public Type[] getTypes() {
  97         Class interfaces[] = getClass().getInterfaces();
  98         Type types[] = new Type[interfaces.length];
  99         for(int i = 0; i < interfaces.length; ++ i)
 100             types[i] = new Type(interfaces[i]);
 101         return types;
 102     }
 103
 104     /** Is this servioce supported?
 105      * @param name The service name.
 106      * @return True, if the service is supported.
 107      */
 108     public boolean supportsService(String name) {
 109         return __serviceName.equals(name);
 110     }
 111
 112     /**
 113      * Get all supported service names.
 114      * @return All supported servcices.
 115      */
 116     public String[] getSupportedServiceNames() {
 117         return new String[] {__serviceName};
 118     }
 119
 120     /**
 121      * Get the implementation name of this class.
 122      * @return The implementation name.
 123      */
 124     public String getImplementationName() {
 125         return getClass().getName();
 126     }
 127 }
 128
 129 /**
 130  * The actual implementation of the document handler
 131  * @see util.XMLTools.XMLChecker
 132  * @see com.sun.star.lang.XInitialization
 133  * @see com.sun.star.xml.sax.XDocumentHandler
 134  * @see com.sun.star.container.XNameAccess
 135  * @see com.sun.star.lang.XTypeProvider
 136  */
 137 class DocumentHandlerImpl extends XMLTools.XMLChecker
 138                         implements XInitialization, XDocumentHandler,
 139                                                 XNameAccess, XTypeProvider {
 140     /** A string writer **/
 141     private StringWriter writer;
 142
 143     /**
 144      * Constructor
 145      * @param log_ A log writer.
 146      * @param printXML Should XML data be printed to the log?
 147      * @param logWriter A wrapper around <code>log_</code> for convenience.
 148      */
 149     public DocumentHandlerImpl(PrintWriter log_,
 150                                     boolean printXML, StringWriter logWriter) {
 151         super(log_, printXML);
 152         writer = logWriter;
 153     }
 154
 155     /**
 156      * Initialize this class with rules.
 157      * @param parm1 An array of filter rules:
 158      *              <code>processAction()</code> is called for every rule.
 159      * @throws com.sun.star.uno.Exception for an incorrect rule.
 160      */
 161     public void initialize(Object[] parm1) throws com.sun.star.uno.Exception {
 162         if (!(parm1[0] instanceof Object[])) return;
 163         for (int i=0; i<parm1.length; i++) {
 164             processActionForXMLChecker((Object[])parm1[i]);
 165         }
 166     }
 167
 168     /**
 169     * Method processes all filters received from basic tests.
 170     * Called by initialize().
 171     * @param filterRule An array building one filter rule.
 172     * @throws com.sun.star.uno.Exception for an incorrect rule.
 173     */
 174     private void processActionForXMLChecker(Object[] filterRule)
 175                                         throws com.sun.star.uno.Exception {
 176         int arrLen = filterRule.length;
 177         String oTagName;
 178         Object[] oTags;
 179         Object[] oTag;
 180         int tagsNum = arrLen-1;
 181         Vector allTags = new Vector();
 182         String CDATA = "";
 183         String action = "";
 184
 185         // First element of rule is RuleName and should be String
 186         if (!(filterRule[0] instanceof String)) {
 187             throw new com.sun.star.uno.Exception("Error: incorrect filter rule "+
 188             "received from basic test! Rule name must be a String.");
 189         } else {
 190             action = (String) filterRule[0];
 191         }
 192
 193         // Searching for character data and defining amount of tags received.
 194         for (int j=1; j<arrLen; j++) {
 195             if ( (filterRule[j] instanceof String) && (j != 1) ) {
 196                 CDATA = (String) filterRule[j];
 197                 tagsNum--;
 198             }
 199         }
 200
 201         // Adding received tags to internal array.
 202         oTags = new Object[tagsNum];
 203         for (int j=1; j<=tagsNum; j++) {
 204             if (filterRule[j] instanceof Object[]) {
 205                 oTags[j-1] = (Object[]) filterRule[j];
 206             }
 207         }
 208
 209         // Process all received tags for a given filter rule
 210         for (int i=0; i<oTags.length; i++) {
 211             if (oTags[i] instanceof Object[]) {
 212                 oTag = (Object[]) oTags[i];
 213                 oTagName = (String) oTag[0];
 214             } else if (oTags[i] instanceof Object) {
 215                 oTag = new Object[1];
 216                 oTag[0] = (Object) oTags[i];
 217                 oTagName = (String) oTag[0];
 218             } else {
 219                 throw new com.sun.star.uno.Exception("Error: invalid tag "+
 220                                     "received from basic test! Check tag "
 221                                     +i+" in rule '"+action+"'.");
 222             }
 223
 224             // Action for constructor Tag(TagName, attrName, attrValue)
 225             if (oTag.length == 3) {
 226                 if ((oTag[1] instanceof String)&&(oTag[2] instanceof String)) {
 227                     allTags.add(new Tag(oTagName,
 228                                     (String) oTag[1], (String) oTag[2]));
 229                 } else {
 230                     throw new com.sun.star.uno.Exception("Error: invalid tag '"+
 231                                     oTagName+"' received from basic test!");
 232                 }
 233
 234             // Action for constructors:
 235             // Tag(TagName, String[][] attrValues )
 236             // Tag(TagName, String[] attrNames)
 237             // Tag(TagName, String attrName)
 238             //
 239             } else if (oTag.length == 2) {
 240                 if (oTag[1] instanceof String[][]) {
 241                     allTags.add(new Tag(oTagName, (String[][]) oTag[1]));
 242                 } else if (oTag[1] instanceof String[]) {
 243                     allTags.add(new Tag(oTagName, (String[]) oTag[1]));
 244                 } else if (oTag[1] instanceof String) {
 245                     allTags.add(new Tag(oTagName, (String) oTag[1]));
 246                 } else {
 247                     throw new com.sun.star.uno.Exception("Error: invalid tag '"+
 248                     oTagName+"' received from basic test!");
 249                 }
 250
 251             // Action for constructor Tag(TagName)
 252             } else if (oTag.length == 1) {
 253                 if (oTag[0] instanceof String) {
 254                     allTags.add(new Tag(oTagName));
 255                 } else {
 256                     throw new com.sun.star.uno.Exception("Error: invalid tag '"+
 257                     oTagName+"' received from basic test!");
 258                 }
 259             } else {
 260                 throw new com.sun.star.uno.Exception("Error: invalid tag '"+
 261                 oTagName+"' received from basic test!");
 262             }
 263         }
 264
 265         // Adding tags to XMLChecker
 266         if ( action.equals((String)"TagExists") ) {
 267             for (int i=0; i<allTags.size(); i++) {
 268                 addTag((Tag)allTags.get(i));
 269             }
 270         } else if (action.equals((String)"TagEnclosed")) {
 271             addTagEnclosed((Tag) allTags.get(0), (Tag) allTags.get(1));
 272         } else if (action.equals((String)"CharsEnclosed")) {
 273             addCharactersEnclosed(CDATA, (Tag) allTags.get(0));
 274         } else {
 275             throw new com.sun.star.uno.Exception("Error: incorrect rule name '"+
 276             action+"' received from basic test!");
 277         }
 278     }
 279
 280     /**
 281      * Get the names of the elements.
 282      * @return element names.
 283      */
 284     public String[] getElementNames() {
 285         return new String[]{"XMLCode", "XMLIsCorrect"};
 286     }
 287
 288     /**
 289      * Is this an element?
 290      * @param name Element name.
 291      * @return true, if <code>name>/code> is the name of an element.
 292      */
 293     public boolean hasByName(String name) {
 294         return (name.equals("XMLCode") || name.equals("XMLIsCorrect"));
 295     }
 296
 297     /**
 298      * Get an element by its name.
 299      * @param name The element name.
 300      * @return The element with the specified <code>name</code>.
 301      * @throws NoSuchElementException Is thrown, if name does not exist.
 302      */
 303     public Object getByName(String name) throws NoSuchElementException{
 304         if (name.equals("XMLIsCorrect"))
 305             return new Boolean(this.check());
 306         else if (name.equals("XMLCode")) {
 307             return writer.getBuffer().toString();
 308         } else
 309             throw new NoSuchElementException();
 310     }
 311
 312     /**
 313      * Are there any elements?
 314      * @return Always true.
 315      */
 316     public boolean hasElements() {
 317         return true;
 318     }
 319
 320     /**
 321      * Get the element type.
 322      * @return The type.
 323      */
 324     public Type getElementType() {
 325         return new Type(Object.class);
 326     }
 327
 328     /**
 329      * Get a unique id for this implementation.
 330      * @return The id.
 331      */
 332     public byte[] getImplementationId() {
 333         return toString().getBytes();
 334     }
 335
 336     /**
 337      * Return all implemented types of this class.
 338      * @return The implemented UNO types.
 339      */
 340     public Type[] getTypes() {
 341         Class interfaces[] = getClass().getInterfaces();
 342         Type types[] = new Type[interfaces.length];
 343         for(int i = 0; i < interfaces.length; ++ i)
 344             types[i] = new Type(interfaces[i]);
 345         return types;
 346     }
 347 }