xpunit/xml/nsTestXmlParser.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent tw=79 ft=cpp: */
   3 /*
   4  * Copyright (C) 2007 Sergey Yanovich <ynvich@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include "nsTestXmlParser.h"
  23 #include "nsNetUtil.h"
  24 #include "nsCOMPtr.h"
  25 #include "nsParserCIID.h"
  26
  27 #include "nsIParser.h"
  28
  29 void
  30 nsTestXmlQuery::Clear()
  31 {
  32   mUrl.Truncate();
  33   mReference.Truncate();
  34   mReferenceLine = -1;
  35 }
  36
  37 static NS_DEFINE_CID(kParserCID, NS_PARSER_CID);
  38
  39 static NS_METHOD
  40 TestInputStream(nsIInputStream *inStr, void *closure, const char *buffer,
  41     PRUint32 offset, PRUint32 count, PRUint32 *countWritten)
  42 {
  43   PRBool *result = static_cast<PRBool *>(closure);
  44   *result = PR_TRUE;
  45   return NS_ERROR_ABORT;  // don't call me anymore
  46 }
  47
  48 PRBool
  49 NS_InputStreamIsBuffered(nsIInputStream *stream)
  50 {
  51   PRBool result = PR_FALSE;
  52   PRUint32 n;
  53   nsresult rv = stream->ReadSegments(TestInputStream,
  54       &result, 1, &n);
  55   return result || NS_SUCCEEDED(rv);
  56 }
  57
  58 NS_IMPL_ISUPPORTS2(nsTestXmlParser,
  59     nsIContentSink,
  60     nsIExpatSink)
  61
  62 nsresult
  63 nsTestXmlParser::Init(nsIURI* aFileUri)
  64 {
  65   nsresult rv = NS_OK;
  66   NS_ENSURE_ARG_POINTER(aFileUri);
  67   NS_ENSURE_STATE(!mFileUri);
  68
  69   mFileUri = aFileUri;
  70
  71   nsCOMPtr<nsIChannel> parserChannel;
  72   rv = NS_NewChannel(getter_AddRefs(parserChannel), mFileUri);
  73   NS_ENSURE_SUCCESS(rv, rv);
  74
  75   rv = parserChannel->SetContentType(nsDependentCString("text/xml"));
  76   NS_ENSURE_SUCCESS(rv, rv);
  77
  78   nsCOMPtr<nsIParser> parser = do_CreateInstance(kParserCID, &rv);
  79   NS_ENSURE_SUCCESS(rv, rv);
  80
  81   parser->SetContentSink(this);
  82
  83   rv = parser->Parse(mFileUri, nsnull);
  84   NS_ENSURE_SUCCESS(rv, rv);
  85
  86   nsCOMPtr<nsIInputStream> stream;
  87   rv = parserChannel->Open(getter_AddRefs(stream));
  88   NS_ENSURE_SUCCESS(rv, rv);
  89
  90   nsCOMPtr<nsIInputStream> bufferedStream;
  91   if (!NS_InputStreamIsBuffered(stream)) {
  92     rv = NS_NewBufferedInputStream(getter_AddRefs(bufferedStream),
  93         stream, 4096);
  94     NS_ENSURE_SUCCESS(rv, rv);
  95     stream = bufferedStream;
  96   }
  97
  98   nsCOMPtr<nsIStreamListener> listener = do_QueryInterface(parser, &rv);
  99   NS_ENSURE_SUCCESS(rv, rv);
 100
 101   rv = listener->OnStartRequest(parserChannel, nsnull);
 102   if (NS_FAILED(rv))
 103     parserChannel->Cancel(rv);
 104
 105   nsresult status;
 106   parserChannel->GetStatus(&status);
 107
 108   PRUint32 offset = 0;
 109   while (NS_SUCCEEDED(rv) && NS_SUCCEEDED(status)) {
 110     PRUint32 available;
 111     rv = stream->Available(&available);
 112     if (rv == NS_BASE_STREAM_CLOSED)
 113     {
 114       rv = NS_OK;
 115       available = 0;
 116     }
 117     if (NS_FAILED(rv))
 118     {
 119       parserChannel->Cancel(rv);
 120       break;
 121     }
 122     if (!available)
 123       break;
 124     rv = listener->OnDataAvailable(parserChannel, nsnull, stream,
 125           offset, available);
 126     if (NS_SUCCEEDED(rv))
 127       offset += available;
 128     else {
 129       parserChannel->Cancel(rv);
 130     }
 131     parserChannel->GetStatus(&status);
 132   }
 133   rv = listener->OnStopRequest(parserChannel, nsnull, status);
 134
 135   return NS_OK;
 136 }
 137
 138 nsresult
 139 nsTestXmlParser::GetFileURI(nsIURI** aRetFileURI)
 140 {
 141   NS_ENSURE_ARG_POINTER(aRetFileURI);
 142   NS_IF_ADDREF(*aRetFileURI = mFileUri);
 143   return NS_OK;
 144 }
 145
 146 //nsIExpatSink
 147 NS_IMETHODIMP
 148 nsTestXmlParser::HandleStartElement(const PRUnichar *aName, const
 149     PRUnichar **aAtts, PRUint32 aAttsCount, PRInt32 aIndex, PRUint32
 150     aLineNumber)
 151 {
 152   nsAutoString name(aName);
 153   if (!mTestElementStarted)
 154   {
 155     NS_ENSURE_TRUE(name.EqualsLiteral("test"), NS_ERROR_INVALID_ARG);
 156     mTestElementStarted = PR_TRUE;
 157   }
 158   else if (XML_NODE_CHILDREN == mNodeType)
 159   {
 160     NS_ENSURE_STATE(!mIsChildContract);
 161     if (name.EqualsLiteral("contract"))
 162     {
 163       mIsChildContract = PR_TRUE;
 164     }
 165   }
 166   else if (XML_NODE_QUERY == mNodeType)
 167   {
 168     NS_ENSURE_STATE(!mIsQueryUrl && !mIsQueryReference);
 169     if (name.EqualsLiteral("url"))
 170     {
 171       mIsQueryUrl = PR_TRUE;
 172     }
 173     else if (name.EqualsLiteral("reference"))
 174     {
 175       mIsQueryReference = PR_TRUE;
 176       mCurrentQuery.mReferenceLine = (PRInt32)aLineNumber;
 177     }
 178   }
 179   else
 180   {
 181     NS_ENSURE_STATE(XML_NODE_UNKNOWN == mNodeType);
 182     if (name.EqualsLiteral("cid"))
 183     {
 184       mNodeType = XML_NODE_CID;
 185     }
 186     else if (name.EqualsLiteral("contract"))
 187     {
 188       mNodeType = XML_NODE_CONTRACT;
 189     }
 190     else if (name.EqualsLiteral("name"))
 191     {
 192       mNodeType = XML_NODE_NAME;
 193     }
 194     else if (name.EqualsLiteral("children"))
 195     {
 196       mNodeType = XML_NODE_CHILDREN;
 197     }
 198     else if (name.EqualsLiteral("query"))
 199     {
 200       mNodeType = XML_NODE_QUERY;
 201       mCurrentQuery.Clear();
 202     }
 203   }
 204   return NS_OK;
 205 }
 206
 207 NS_IMETHODIMP
 208 nsTestXmlParser::HandleEndElement(const PRUnichar *aName)
 209 {
 210   NS_ENSURE_STATE(mTestElementStarted);
 211   if (XML_NODE_CHILDREN == mNodeType)
 212   {
 213     nsAutoString name(aName);
 214     if (name.EqualsLiteral("children"))
 215     {
 216       mNodeType = XML_NODE_UNKNOWN;
 217     }
 218     else
 219     {
 220       NS_ENSURE_STATE(mIsChildContract);
 221       mIsChildContract = PR_FALSE;
 222     }
 223   }
 224   else if (XML_NODE_QUERY == mNodeType)
 225   {
 226     nsAutoString name(aName);
 227     if (name.EqualsLiteral("query"))
 228     {
 229       NS_ENSURE_STATE(!mIsQueryUrl && !mIsQueryReference);
 230       mQueries.AppendElement(mCurrentQuery);
 231       mCurrentQuery.Clear();
 232       mNodeType = XML_NODE_UNKNOWN;
 233     }
 234     else if (name.EqualsLiteral("url"))
 235     {
 236       NS_ENSURE_STATE(mIsQueryUrl && !mIsQueryReference);
 237       mIsQueryUrl = PR_FALSE;
 238     }
 239     else
 240     {
 241       NS_ENSURE_STATE(mIsQueryReference && !mIsQueryUrl);
 242       mIsQueryReference = PR_FALSE;
 243     }
 244   }
 245   else
 246   {
 247     mNodeType = XML_NODE_UNKNOWN;
 248   }
 249   return NS_OK;
 250 }
 251
 252 NS_IMETHODIMP
 253 nsTestXmlParser::HandleComment(const PRUnichar *aCommentText)
 254 {
 255   return NS_ERROR_NOT_IMPLEMENTED;
 256 }
 257
 258 NS_IMETHODIMP
 259 nsTestXmlParser::HandleCDataSection(const PRUnichar *aData, PRUint32
 260     aLength)
 261 {
 262   return NS_ERROR_NOT_IMPLEMENTED;
 263 }
 264
 265 NS_IMETHODIMP
 266 nsTestXmlParser::HandleDoctypeDecl(const nsAString & aSubset, const
 267     nsAString & aName, const nsAString & aSystemId, const nsAString &
 268     aPublicId, nsISupports *aCatalogData)
 269 {
 270   return NS_ERROR_NOT_IMPLEMENTED;
 271 }
 272
 273 NS_IMETHODIMP
 274 nsTestXmlParser::HandleCharacterData(const PRUnichar *aData, PRUint32
 275     aLength)
 276 {
 277   if (XML_NODE_UNKNOWN != mNodeType)
 278   {
 279     nsCAutoString value = NS_ConvertUTF16toUTF8(aData, aLength);
 280     value.Trim("\n\r\t ");
 281     if (value.IsEmpty()) return NS_OK;
 282     switch (mNodeType)
 283     {
 284       case XML_NODE_CID:
 285         {
 286           mCID.Parse(value.get());
 287         }
 288         break;
 289       case XML_NODE_CONTRACT:
 290         mContract = value;
 291         break;
 292       case XML_NODE_NAME:
 293         mName = value;
 294         break;
 295       case XML_NODE_CHILDREN:
 296         {
 297           NS_ENSURE_STATE(mIsChildContract);
 298           mChildrens.AppendElement(value);
 299         }
 300         break;
 301       case XML_NODE_QUERY:
 302         {
 303           NS_ENSURE_STATE(mIsQueryUrl || mIsQueryReference);
 304           if (mIsQueryUrl)
 305           {
 306             mCurrentQuery.mUrl.Append(value);
 307           }
 308           else if (mIsQueryReference)
 309           {
 310             mCurrentQuery.mReference = value;
 311           }
 312         }
 313         break;
 314       default:
 315         NS_ENSURE_TRUE(PR_FALSE, NS_ERROR_INVALID_ARG);
 316         break;
 317     }
 318   }
 319   return NS_OK;
 320 }
 321
 322 NS_IMETHODIMP
 323 nsTestXmlParser::HandleProcessingInstruction(const PRUnichar
 324     *aTarget, const PRUnichar *aData)
 325 {
 326   return NS_ERROR_NOT_IMPLEMENTED;
 327 }
 328
 329 NS_IMETHODIMP
 330 nsTestXmlParser::HandleXMLDeclaration(const PRUnichar *aVersion,
 331     const PRUnichar *aEncoding, PRInt32 aStandalone)
 332 {
 333   return NS_OK;
 334 }
 335
 336 NS_IMETHODIMP
 337 nsTestXmlParser::ReportError(const PRUnichar *aErrorText, const
 338     PRUnichar *aSourceText, nsIScriptError *aError, PRBool *_retval
 339     NS_OUTPARAM)
 340 {
 341   nsAutoString error(aErrorText);
 342   printf_stderr("\nReportError: %s\n", NS_ConvertUTF16toUTF8(error).get());
 343   return NS_OK;
 344 }
 345