cxxunit/nsTestRunner.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 <abstract/aacore.h>
  23
  24 #include "nsXPCOM.h"
  25 #include "nsStringAPI.h"
  26 #include "nsEmbedString.h"
  27 #include "nsWeakReference.h"
  28 #include "nsIWebProgressListener.h"
  29 #include "nsIComponentManager.h"
  30 #include "nsComponentManagerUtils.h"
  31 #include "nsServiceManagerUtils.h"
  32 #include "nsIPrefBranch.h"
  33 #include "nsIWindowWatcher.h"
  34 #include "nsIDOMWindow.h"
  35 #include "nsIInterfaceRequestorUtils.h"
  36 #include "nsIWebProgress.h"
  37 #include "nsIDOMDocument.h"
  38 #include "nsIDOMElement.h"
  39 #include "nsIDOMEventTarget.h"
  40 #include "nsIDOMDocumentEvent.h"
  41 #include "nsIDOMEvent.h"
  42 #include "nsIDOMAbstractView.h"
  43
  44 /* Unfrozen interfaces */
  45 #include "unstable/nsITimer.h"
  46 #include "unstable/nsICommandLineHandler.h"
  47 #include "unstable/nsDeque.h"
  48 #include "unstable/nsAutoPtr.h"
  49 #include "unstable/nsICommandLine.h"
  50 #include "unstable/nsIWebNavigation.h"
  51 #include "unstable/nsIAppStartup.h"
  52 #include "unstable/nsIConsoleListener.h"
  53 #include "unstable/nsIConsoleService.h"
  54 #include "unstable/nsIConsoleMessage.h"
  55 #include "unstable/nsIScriptError.h"
  56 #include "unstable/jspubtd.h"
  57 #include "unstable/nsIJSContextStack.h"
  58 #include "unstable/nsIRDFService.h"
  59 #include "unstable/nsIRDFDataSource.h"
  60 #include "unstable/nsIRDFResource.h"
  61 #include "unstable/nsIDOMXULDocument.h"
  62 #include "unstable/nsIDOMXULCommandDispatcher.h"
  63 #include "unstable/nsIDOMXULCommandEvent.h"
  64 #include "unstable/nsIStringEnumerator.h"
  65
  66 /* Project includes */
  67 #include <abstract/cxxunit/nsITestRunner.h>
  68 #include <abstract/cxxunit/nsITestResult.h>
  69 #include <abstract/cxxunit/nsITest.h>
  70 #include "nstestjs.h"
  71 #include "nsTestRunner.h"
  72 #include "nsTestFailure.h"
  73
  74 #include <abstract/cxxunit/nsTestUtils.h>
  75
  76 class nsFormatJSMessage: public nsTestFailure
  77 {
  78 public:
  79   nsFormatJSMessage(nsIConsoleMessage *aMessage);
  80   nsFormatJSMessage(const char *aFile);
  81   ~nsFormatJSMessage() {;}
  82 private:
  83   nsresult parseScriptError(nsIConsoleMessage *aMessage);
  84   nsresult formatErrorMessage(nsIScriptError *error);
  85   PRBool parseException(const nsACString &aMessage);
  86   nsresult getSourceFile();
  87   nsresult parseLocalFile();
  88   nsresult parseChrome();
  89
  90   PRBool mIsChrome;
  91   nsRefPtr<nsTestRunner> mResolver;
  92 };
  93
  94
  95 /******************** nsTestRunner ***********************************/
  96 nsTestRunner* nsTestRunner::gTestRunner = nsnull;
  97
  98 nsTestRunner::nsTestRunner() : mTestTree(nsnull)
  99 {
 100   mArmed = PR_FALSE;
 101   mRunning = PR_FALSE;
 102 }
 103
 104 nsTestRunner::~nsTestRunner()
 105 {
 106 }
 107
 108 NS_IMPL_THREADSAFE_ISUPPORTS6(nsTestRunner,
 109                               nsITestRunner,
 110                               nsIConsoleListener,
 111                               nsIWebProgressListener,
 112                               nsISupportsWeakReference,
 113                               nsITimerCallback,
 114                               nsICommandLineHandler);
 115
 116 NS_IMETHODIMP
 117 nsTestRunner::MarkTestStart()
 118 {
 119   return mTestResult->MarkTestStart();
 120 }
 121
 122 NS_IMETHODIMP
 123 nsTestRunner::AddFailure(const char *aFile, PRUint32 aLine, const char *aText)
 124 {
 125   return mTestResult->AddFailure(aFile, aLine, aText, PR_FALSE);
 126 }
 127
 128 NS_IMETHODIMP
 129 nsTestRunner::AddJSFailure(const char *aText)
 130 {
 131   nsresult rv;
 132   JSContext *cx = nsnull;
 133   nsEmbedCString file;
 134
 135   if ( ! mJSStack ) {
 136     mJSStack = do_GetService("@mozilla.org/js/xpc/ContextStack;1");
 137     NS_ENSURE_TRUE(mJSStack, NS_ERROR_FAILURE);
 138   }
 139   rv = mJSStack->Peek( &cx );
 140   NS_ENSURE_TRUE(cx, NS_ERROR_FAILURE);
 141
 142   nsFormatJSMessage m(ns_test_js_caller_filename(cx));
 143
 144   return mTestResult->AddFailure(m.getFile(),
 145       ns_test_js_caller_lineno(cx) + 1, aText, PR_FALSE);
 146 }
 147
 148 NS_IMETHODIMP
 149 nsTestRunner::AddError(PRUint32 aCode, const char *aComment)
 150 {
 151   return mTestResult->AddFailure(nsnull, aCode, aComment, PR_TRUE);
 152 }
 153
 154 NS_IMETHODIMP
 155 nsTestRunner::MarkTestEnd(nsITest *aTest)
 156 {
 157   if (aTest != (nsITest *) mTestTree.Peek())
 158     return NS_ERROR_ILLEGAL_VALUE;
 159   if (mArmed) {
 160     mArmed = PR_FALSE;
 161     mTimerStop->Cancel();
 162     if(NS_FAILED(mTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT)))
 163       traverse();
 164   }
 165   return NS_OK;
 166 }
 167
 168 NS_IMETHODIMP
 169 nsTestRunner::GetTestWindow(nsIDOMWindow* *aTestWindow)
 170 {
 171   NS_ENSURE_ARG_POINTER( aTestWindow );
 172   if ( !mTestWindow ) {
 173     *aTestWindow = nsnull;
 174     return NS_ERROR_NOT_INITIALIZED;
 175   }
 176   *aTestWindow = mTestWindow;
 177   NS_ADDREF( *aTestWindow );
 178
 179   return NS_OK;
 180 }
 181
 182 NS_IMETHODIMP
 183 nsTestRunner::GetWatchWindow(nsIDOMWindow* *aWatchWindow)
 184 {
 185   NS_ENSURE_ARG_POINTER( aWatchWindow );
 186   if ( !mWatchWindow ) {
 187     *aWatchWindow = nsnull;
 188     return NS_ERROR_NOT_INITIALIZED;
 189   }
 190   *aWatchWindow = mWatchWindow;
 191   NS_ADDREF( *aWatchWindow );
 192
 193   return NS_OK;
 194 }
 195
 196 NS_IMETHODIMP
 197 nsTestRunner::SetWatchWindow(nsIDOMWindow *aWatchWindow)
 198 {
 199   nsresult rv;
 200
 201   if (mWatchWindow) {
 202     nsCOMPtr<nsIWebNavigation> web(do_GetInterface(mWatchWindow, &rv ));
 203     NS_ENSURE_SUCCESS(rv, rv);
 204
 205     nsCOMPtr<nsIWebProgress> webProgress(do_QueryInterface(web, &rv));
 206     NS_ENSURE_SUCCESS(rv, rv);
 207
 208     rv = webProgress->RemoveProgressListener(this);
 209     NS_ENSURE_SUCCESS(rv, rv);
 210   }
 211
 212   if (aWatchWindow) {
 213     nsCOMPtr<nsIWebNavigation> web(do_GetInterface(aWatchWindow, &rv ));
 214     NS_ENSURE_SUCCESS(rv, rv);
 215
 216     nsCOMPtr<nsIWebProgress> webProgress(do_QueryInterface(web, &rv));
 217     NS_ENSURE_SUCCESS(rv, rv);
 218
 219     rv = webProgress->AddProgressListener(this,
 220         nsIWebProgress::NOTIFY_STATE_WINDOW);
 221     NS_ENSURE_SUCCESS(rv, rv);
 222   }
 223   mWatchWindow = aWatchWindow;
 224
 225   return NS_OK;
 226 }
 227
 228 NS_IMETHODIMP
 229 nsTestRunner::ArmTimer()
 230 {
 231   nsresult rv;
 232   nsITest *test = (nsITest *)  mTestTree.Peek();
 233
 234   nsCOMPtr<nsITimerCallback> callback(do_QueryInterface(test, &rv));
 235   NS_ENSURE_SUCCESS(rv, rv);
 236   rv = mTimer->InitWithCallback(callback, 0, nsITimer::TYPE_ONE_SHOT);
 237   NS_ENSURE_SUCCESS(rv, rv);
 238   if (! mArmed )
 239     mRunning = PR_TRUE;
 240   return NS_OK;
 241 }
 242
 243 NS_IMETHODIMP
 244 nsTestRunner::DoCommand(const nsAString& aCommand)
 245 {
 246   nsresult rv;
 247   nsCOMPtr<nsIDOMWindow> wnd(mTestWindow);
 248   nsIDOMWindow *next;
 249   nsCOMPtr<nsIDOMDocument> doc;
 250   nsCOMPtr<nsIDOMXULDocument> xulDoc;
 251   nsCOMPtr<nsIDOMXULCommandDispatcher> dispatcher;
 252   nsCOMPtr<nsIDOMElement> element;
 253
 254   while ( wnd ) {
 255     rv = wnd->GetDocument(getter_AddRefs( doc ));
 256     NS_ENSURE_SUCCESS(rv, rv);
 257
 258     rv = doc->GetElementById(aCommand, getter_AddRefs( element ));
 259     if ( element )
 260       break;
 261
 262     xulDoc = do_QueryInterface(doc, &rv);
 263     NS_ENSURE_SUCCESS(rv, NS_ERROR_ILLEGAL_VALUE);
 264
 265     rv = xulDoc->GetCommandDispatcher(getter_AddRefs( dispatcher ));
 266     NS_ENSURE_SUCCESS(rv, rv);
 267
 268     rv = dispatcher->GetFocusedWindow( &next );
 269     NS_ENSURE_SUCCESS(rv, rv);
 270
 271     if ( wnd == next ) {
 272       wnd = nsnull;
 273     } else {
 274       wnd = getter_AddRefs( next );
 275     }
 276   }
 277
 278   NS_ENSURE_TRUE(element, NS_ERROR_ILLEGAL_VALUE);
 279
 280   PRBool isDisabled;
 281   rv = element->HasAttribute(NS_LITERAL_STRING("disabled"), &isDisabled);
 282   NS_ENSURE_SUCCESS(rv, rv);
 283   if ( isDisabled )
 284     return NS_ERROR_NOT_AVAILABLE;
 285
 286   nsCOMPtr<nsIDOMEventTarget> evtTgt(do_QueryInterface(element, &rv));
 287   NS_ENSURE_SUCCESS(rv, rv);
 288
 289   nsCOMPtr<nsIDOMDocumentEvent> docEvent(do_QueryInterface(doc, &rv));
 290   NS_ENSURE_SUCCESS(rv, rv);
 291
 292   nsCOMPtr<nsIDOMEvent> evt;
 293   rv = docEvent->CreateEvent(NS_LITERAL_STRING("XULCommandEvent"),
 294       getter_AddRefs(evt));
 295   NS_ENSURE_SUCCESS(rv, rv);
 296
 297   nsCOMPtr<nsIDOMXULCommandEvent> cmdEvt(do_QueryInterface(evt, &rv));
 298   NS_ENSURE_SUCCESS(rv, rv);
 299
 300   nsCOMPtr<nsIDOMAbstractView> view(do_QueryInterface(wnd, &rv));
 301   NS_ENSURE_SUCCESS(rv, rv);
 302
 303   rv = cmdEvt->InitCommandEvent(NS_LITERAL_STRING("command"), PR_TRUE, PR_TRUE,
 304       view, 0, 0, 0, 0, 0, nsnull);
 305   NS_ENSURE_SUCCESS(rv, rv);
 306
 307   PRBool isDefault;
 308   rv = evtTgt->DispatchEvent( evt, &isDefault );
 309   NS_ENSURE_SUCCESS(rv, rv);
 310
 311   return NS_OK;
 312 }
 313
 314 NS_IMETHODIMP
 315 nsTestRunner::Observe(nsIConsoleMessage *aMessage)
 316 {
 317   NS_ENSURE_TRUE(mTestResult, NS_ERROR_UNEXPECTED);
 318
 319   nsFormatJSMessage m(aMessage);
 320   mTestResult->AddFailure(m.getFile(), m.getLine(), m.getText(), PR_TRUE);
 321   return NS_OK;
 322 }
 323
 324 nsresult
 325 nsTestRunner::openMainWindow()
 326 {
 327   nsresult rv;
 328   nsCOMPtr<nsIConsoleService> jsConsole;
 329   nsCOMPtr<nsIPrefBranch> pref;
 330   nsEmbedCString chromeURI;
 331   nsCOMPtr<nsIWindowWatcher> ww;
 332   nsCOMPtr<nsIDOMWindow> wnd;
 333
 334   pref = do_GetService("@mozilla.org/preferences-service;1", &rv);
 335   NS_ENSURE_SUCCESS(rv, rv);
 336   rv = pref->GetCharPref("toolkit.defaultChromeURI",getter_Copies(chromeURI));
 337   NS_ENSURE_SUCCESS(rv, rv);
 338   ww = do_GetService("@mozilla.org/embedcomp/window-watcher;1", &rv);
 339   NS_ENSURE_SUCCESS(rv, rv);
 340   rv = ww->OpenWindow(0, chromeURI.get(), "_blank", "chrome,dialog=no,all",
 341       0, getter_AddRefs(wnd) );
 342   NS_ENSURE_SUCCESS(rv, rv);
 343
 344   mTestWindow = wnd;
 345   jsConsole = do_GetService("@mozilla.org/consoleservice;1", &rv);
 346   NS_ENSURE_TRUE(jsConsole, NS_OK);
 347   jsConsole->RegisterListener( this );
 348
 349   return NS_OK;
 350 }
 351
 352 void
 353 nsTestRunner::run()
 354 {
 355   if ( init() != NS_ERROR_ABORT)
 356     traverse();
 357 }
 358
 359 nsresult
 360 nsTestRunner::init()
 361 {
 362   nsresult rv;
 363   nsCOMPtr<nsIPrefBranch> pref;
 364
 365   pref = do_GetService("@mozilla.org/preferences-service;1", &rv);
 366   NS_ENSURE_SUCCESS(rv, rv);
 367   rv = pref->GetCharPref("cxxunit.firstTest",getter_Copies(mTestID));
 368   NS_ENSURE_SUCCESS(rv, rv);
 369
 370   rv = pushTest( mTestID.get() );
 371   NS_ENSURE_SUCCESS(rv, rv);
 372
 373   return runCurrentTest();
 374 }
 375
 376 nsresult
 377 nsTestRunner::pushTest(const char * aContractID)
 378 {
 379   nsresult rv;
 380   void *test;
 381   nsCOMPtr<nsIComponentManager> componentManager;
 382
 383   rv = NS_GetComponentManager(getter_AddRefs( componentManager ));
 384   NS_ENSURE_SUCCESS(rv, rv);
 385   rv = componentManager->CreateInstanceByContractID(aContractID, nsnull,
 386       NS_GET_IID(nsITest), (void **) &test);
 387   if (NS_FAILED(rv)) {
 388     AddError(nsITestRunner::errorLoad, aContractID);
 389     return rv;
 390   }
 391
 392   mTestTree.Push( (void *) test );
 393   return NS_OK;
 394 }
 395
 396 nsresult
 397 nsTestRunner::runCurrentTest()
 398 {
 399   nsITest *test = (nsITest *)  mTestTree.Peek();
 400
 401   test->Test( this );
 402   if ( mRunning || mWatchWindow ) {
 403     mRunning = PR_FALSE;
 404     mArmed = PR_TRUE;
 405     mTimerStop->InitWithCallback(this, 1000, nsITimer::TYPE_ONE_SHOT);
 406     return NS_ERROR_ABORT;
 407   }
 408
 409   return NS_OK;
 410 }
 411
 412 nsresult
 413 nsTestRunner::getNextTest(nsACString &aContractID)
 414 {
 415   nsresult rv;
 416   PRBool hasMore;
 417
 418   nsITest *test = (nsITest *)  mTestTree.Peek();
 419   NS_ENSURE_TRUE(test, NS_ERROR_UNEXPECTED);
 420
 421   nsCOMPtr<nsIUTF8StringEnumerator> testNode(do_QueryInterface(test, &rv));
 422   if (rv == NS_NOINTERFACE)
 423     return NS_ERROR_NOT_AVAILABLE;
 424   NS_ENSURE_SUCCESS(rv, rv);
 425
 426   rv = testNode->HasMore( &hasMore );
 427   NS_ENSURE_SUCCESS(rv, rv);
 428   if (! hasMore)
 429     return NS_ERROR_NOT_AVAILABLE;
 430
 431   rv = testNode->GetNext( aContractID );
 432   NS_ENSURE_SUCCESS(rv, rv);
 433
 434   return NS_OK;
 435 }
 436
 437 void
 438 nsTestRunner::traverse()
 439 {
 440   nsresult rv;
 441   nsEmbedCString nextContractID(0);
 442   nsITest *test;
 443
 444   while (mTestTree.GetSize()) {
 445
 446     rv = getNextTest( mTestID );
 447
 448     if (NS_FAILED(rv)) {
 449       test = (nsITest *) mTestTree.Pop();
 450       NS_RELEASE(test);
 451     } else {
 452       if (NS_FAILED( pushTest( mTestID.get() ) ))
 453         continue;
 454       if (NS_FAILED( runCurrentTest() ))
 455         return;
 456     }
 457   }
 458
 459   if (NS_FAILED( mTimer->InitWithFuncCallback(done, this, 0,
 460           nsITimer::TYPE_ONE_SHOT) )) {
 461     done(nsnull, this);
 462   }
 463 }
 464
 465 nsresult
 466 nsTestRunner::closeMainWindow()
 467 {
 468   nsresult rv;
 469   nsCOMPtr<nsIAppStartup> app;
 470   app = do_GetService("@mozilla.org/toolkit/app-startup;1", &rv);
 471   NS_ENSURE_SUCCESS(rv, rv);
 472   rv = app->Quit(app->eForceQuit);
 473   NS_ENSURE_SUCCESS(rv, rv);
 474   return NS_OK;
 475 }
 476
 477 void
 478 nsTestRunner::done(nsITimer *aTimer, void *aClosure)
 479 {
 480   nsTestRunner *self = static_cast<nsTestRunner*>(aClosure);
 481   nsCOMPtr<nsIConsoleService> jsConsole;
 482
 483   jsConsole = do_GetService("@mozilla.org/consoleservice;1");
 484   if (jsConsole )
 485     jsConsole->UnregisterListener( self );
 486
 487   self->closeMainWindow();
 488   self->mTestResult->Done();
 489   self->mTestResult = nsnull;
 490   self->mTimer = nsnull;
 491 }
 492
 493 NS_IMETHODIMP
 494 nsTestRunner::Handle(nsICommandLine *aCommandLine)
 495 {
 496   nsresult rv;
 497   PRBool isTest;
 498
 499   rv = aCommandLine->HandleFlag(NS_LITERAL_STRING("test"), PR_TRUE, &isTest);
 500   NS_ENSURE_SUCCESS(rv,rv);
 501   if (isTest){
 502     aCommandLine->SetPreventDefault(PR_TRUE);
 503
 504     mTimer = do_CreateInstance("@mozilla.org/timer;1");
 505     NS_ENSURE_TRUE(mTimer, NS_ERROR_ABORT);
 506
 507     mTimerStop = do_CreateInstance("@mozilla.org/timer;1");
 508     NS_ENSURE_TRUE(mTimer, NS_ERROR_ABORT);
 509
 510     mTestResult = do_CreateInstance("@aasii.org/cxxunit/testresult", &rv);
 511     NS_ENSURE_SUCCESS(rv, NS_ERROR_ABORT);
 512
 513     if (NS_FAILED( openMainWindow() )) {
 514       rv = NS_ERROR_ABORT;
 515     }
 516     run();
 517     return rv;
 518   }
 519   return NS_OK;
 520 }
 521
 522 NS_IMETHODIMP
 523 nsTestRunner::GetHelpInfo(nsACString & aHelpInfo)
 524 {
 525   aHelpInfo.Assign("  --test               Run unit test collection\n");
 526   return NS_OK;
 527 }
 528
 529 nsresult
 530 nsTestRunner::resolve(nsACString &aURL, const PRUnichar* *result)
 531 {
 532   nsresult rv;
 533   nsCOMPtr<nsIRDFService> rdfSrv;
 534   nsCOMPtr<nsIRDFResource> src, prop;
 535   nsCOMPtr<nsIRDFNode> target;
 536   nsCOMPtr<nsIRDFLiteral> targetLiteral;
 537
 538   NS_ENSURE_ARG_POINTER(result);
 539   *result = nsnull;
 540   rdfSrv = do_GetService("@mozilla.org/rdf/rdf-service;1", &rv);
 541   NS_ENSURE_SUCCESS( rv, rv );
 542
 543   if ( ! mFileMap ) {
 544     nsCOMPtr<nsIPrefBranch> pref;
 545     nsEmbedCString url;
 546
 547     pref = do_GetService("@mozilla.org/preferences-service;1", &rv);
 548     NS_ENSURE_SUCCESS(rv, rv );
 549     rv = pref->GetCharPref("cxxunit.fileMap",getter_Copies(url));
 550     NS_ENSURE_SUCCESS(rv, rv );
 551
 552     rv = rdfSrv->GetDataSourceBlocking(url.get(),
 553         getter_AddRefs( mFileMap ));
 554     NS_ENSURE_TRUE( mFileMap, rv );
 555   }
 556
 557   rv = rdfSrv->GetResource( aURL, getter_AddRefs( src ));
 558   NS_ENSURE_SUCCESS(rv, rv );
 559   rv = rdfSrv->GetResource(
 560       NS_LITERAL_CSTRING("http://www.aasii.org/AA-rdf#File"),
 561       getter_AddRefs( prop ));
 562   NS_ENSURE_SUCCESS(rv, rv );
 563
 564   rv = mFileMap->GetTarget(src, prop, PR_TRUE, getter_AddRefs( target ));
 565   if (! target)
 566     return rv;
 567   targetLiteral = do_QueryInterface( target, &rv );
 568   NS_ENSURE_TRUE( target, rv );
 569   targetLiteral->GetValueConst( result );
 570   NS_ENSURE_TRUE( target, rv );
 571
 572   return NS_OK;
 573 }
 574
 575 NS_IMETHODIMP
 576 nsTestRunner::Notify(nsITimer *timer)
 577 {
 578   if (mArmed) {
 579     mArmed = PR_FALSE;
 580     AddError(nsITestRunner::errorTimeout, mTestID.get());
 581     mTimer->Cancel();
 582   }
 583   traverse();
 584   return NS_OK;
 585 }
 586
 587 NS_IMETHODIMP
 588 nsTestRunner::OnStateChange(nsIWebProgress *aWebProgress,
 589     nsIRequest *aRequest, PRUint32 aStateFlags, nsresult aStatus)
 590 {
 591   if (! aStateFlags & nsIWebProgressListener::STATE_STOP )
 592     return NS_OK;
 593
 594   nsCOMPtr<nsIDOMWindow> wnd;
 595   aWebProgress->GetDOMWindow(getter_AddRefs( wnd ));
 596   if ( wnd != mWatchWindow  ) {
 597     return NS_OK;
 598   }
 599
 600   mWatchWindow = nsnull;
 601   aWebProgress->RemoveProgressListener( this );
 602
 603   NS_ENSURE_TRUE(mArmed, NS_ERROR_UNEXPECTED);
 604
 605   nsITest *test = (nsITest *)  mTestTree.Peek();
 606   NS_ENSURE_TRUE(test, NS_ERROR_UNEXPECTED);
 607
 608   nsCOMPtr<nsIWebProgressListener> listener(do_QueryInterface(test));
 609   NS_ENSURE_TRUE(listener, NS_ERROR_UNEXPECTED);
 610
 611   listener->OnStateChange(aWebProgress, aRequest, aStateFlags, aStatus);
 612
 613   return NS_OK;
 614 }
 615
 616 NS_IMETHODIMP
 617 nsTestRunner::OnProgressChange(nsIWebProgress *aWebProgress,
 618     nsIRequest *aRequest, PRInt32 aCurSelfProgress, PRInt32 aMaxSelfProgress,
 619     PRInt32 aCurTotalProgress, PRInt32 aMaxTotalProgress)
 620 {
 621   return NS_ERROR_NOT_IMPLEMENTED;
 622 }
 623
 624 NS_IMETHODIMP
 625 nsTestRunner::OnLocationChange(nsIWebProgress *aWebProgress,
 626     nsIRequest *aRequest, nsIURI *aLocation)
 627 {
 628   return NS_ERROR_NOT_IMPLEMENTED;
 629 }
 630
 631 NS_IMETHODIMP
 632 nsTestRunner::OnStatusChange(nsIWebProgress *aWebProgress,
 633     nsIRequest *aRequest, nsresult aStatus, const PRUnichar *aMessage)
 634 {
 635   return NS_ERROR_NOT_IMPLEMENTED;
 636 }
 637
 638 NS_IMETHODIMP
 639 nsTestRunner::OnSecurityChange(nsIWebProgress *aWebProgress,
 640     nsIRequest *aRequest, PRUint32 aState)
 641 {
 642       return NS_ERROR_NOT_IMPLEMENTED;
 643 }
 644
 645 nsTestRunner*
 646 nsTestRunner::GetTestRunner()
 647 {
 648   if ( nsTestRunner::gTestRunner == nsnull ) {
 649     nsTestRunner::gTestRunner = new nsTestRunner;
 650   }
 651
 652   if ( nsTestRunner::gTestRunner != nsnull ) {
 653     NS_ADDREF( nsTestRunner::gTestRunner );
 654   }
 655
 656   return nsTestRunner::gTestRunner;
 657 }
 658
 659 /******************** nsFormatJSMessage ***********************************/
 660 nsFormatJSMessage::nsFormatJSMessage(nsIConsoleMessage *aMessage)
 661   :mIsChrome(PR_TRUE)
 662 {
 663   if (NS_SUCCEEDED( parseScriptError( aMessage ) )) {
 664     return;
 665   }
 666   nsEmbedString wstr;
 667   aMessage->GetMessage(getter_Copies( wstr ));
 668   mFile.Assign(nsnull,0);
 669   mLine = nsITestRunner::errorNoError;
 670   mText.Assign( NS_ConvertUTF16toUTF8(wstr));
 671 }
 672
 673 nsFormatJSMessage::nsFormatJSMessage(const char *aFile)
 674   :mIsChrome(PR_TRUE)
 675 {
 676   mFile.Assign(aFile);
 677   getSourceFile();
 678 }
 679
 680 nsresult
 681 nsFormatJSMessage::parseScriptError(nsIConsoleMessage *aMessage)
 682 {
 683   nsresult rv;
 684   nsCOMPtr<nsIScriptError> error;
 685   nsEmbedString wstr;
 686
 687   error = do_QueryInterface( aMessage, &rv );
 688   if (NS_FAILED(rv))
 689     return rv;
 690
 691   rv = formatErrorMessage(error);
 692   NS_ENSURE_SUCCESS(rv, rv);
 693
 694   if (NS_FAILED( getSourceFile() )) {
 695     mFile.Assign(nsnull, 0);
 696     mLine = nsITestRunner::errorJS;
 697   }
 698   if (mFile.Length()>2 && !mIsChrome)
 699     mLine++;
 700
 701   return NS_OK;
 702 }
 703
 704 nsresult
 705 nsFormatJSMessage::formatErrorMessage(nsIScriptError *error)
 706 {
 707   nsresult rv;
 708   nsEmbedString wstr;
 709
 710   rv = error->GetErrorMessage( wstr );
 711   NS_ENSURE_SUCCESS(rv, rv);
 712
 713   nsEmbedCString text = NS_ConvertUTF16toUTF8( wstr );
 714
 715   rv = error->GetLineNumber( &mLine );
 716   if (NS_SUCCEEDED( rv  ))
 717     rv = error->GetSourceName( wstr );
 718   if (NS_SUCCEEDED( rv  ))
 719     mFile = NS_ConvertUTF16toUTF8(wstr);
 720
 721   if ( parseException(text) )
 722     return NS_OK;
 723
 724   PRUint32 flags;
 725   rv = error->GetFlags( &flags );
 726   if (NS_FAILED( rv ))
 727     flags = 0;
 728
 729   if ( flags & nsIScriptError::warningFlag ) {
 730     mText.Assign("warning: ");
 731   } else {
 732     mText.Assign("error: ");
 733   }
 734   mText.Append( text );
 735   return NS_OK;
 736 }
 737
 738 PRBool
 739 nsFormatJSMessage::parseException(const nsACString &aMessage)
 740 {
 741   const char *head, *pos, *res, *end;
 742   nsresult rv;
 743
 744   head = aMessage.BeginReading();
 745   pos = strstr(head, "[Exception... \"");
 746   if (! pos)
 747     return PR_FALSE;
 748
 749   mText.Assign("exception: ");
 750
 751   if (pos[15] == '\'') {
 752     end = strchr(&pos[16], '\'');
 753     if (end) {
 754       mText.Append(&pos[15], end - pos - 14);
 755     }
 756   } else if ( (res = strstr(&pos[15], "nsresult: \"0x")) && strlen(res) > 23) {
 757       end = strchr(&res[23], ')');
 758       if (end) {
 759         mText.Append(&res[23], end - res - 23);
 760       }
 761   } else {
 762     mText.Append(&pos[15],strlen(pos) - 16);
 763   }
 764
 765   if ( ! mFile.Length() ) {
 766     res = strstr(&pos[15],"location: \"JS frame :: ");
 767     if (!res || strlen(res) < 25)
 768       return PR_TRUE;
 769     end = strstr(&res[23], " :: ");
 770     if (! end)
 771       return PR_TRUE;
 772     mFile.Assign(Substring(&res[23], end - res - 23));
 773     res = strstr(&end[4], ":: line ");
 774     if (!res && strlen(res) < 10)
 775       return PR_TRUE;
 776     end = strchr(&res[8], '"');
 777     if (! end)
 778       return PR_TRUE;
 779     mLine = Substring(&res[8], end - res - 8).ToInteger(&rv);
 780   }
 781   return PR_TRUE;
 782 }
 783
 784 nsresult
 785 nsFormatJSMessage::getSourceFile()
 786 {
 787   if ( StringHead(mFile, 7).Equals(NS_LITERAL_CSTRING("file://")) ) {
 788     mIsChrome = PR_FALSE;
 789     return parseLocalFile();
 790   } else if (! StringHead(mFile, 9).Equals(NS_LITERAL_CSTRING("chrome://")) ) {
 791     return NS_ERROR_FILE_UNRECOGNIZED_PATH;
 792   }
 793   return parseChrome();
 794 }
 795
 796 nsresult
 797 nsFormatJSMessage::parseLocalFile()
 798 {
 799   nsEmbedCString leafName;
 800   const PRUnichar* resolved;
 801
 802   leafName = "file://";
 803   leafName += strrchr(mFile.BeginReading(), '/');
 804   if (! mResolver) {
 805     mResolver = nsTestRunner::GetTestRunner();
 806     NS_ENSURE_TRUE( mResolver, NS_OK );
 807   }
 808   mResolver->resolve( leafName, &resolved );
 809   if (! resolved )
 810     return NS_OK;
 811   if ( resolved[0] )
 812     mFile.Assign(NS_ConvertUTF16toUTF8( resolved ));
 813
 814   return NS_OK;
 815 }
 816
 817 nsresult
 818 nsFormatJSMessage::parseChrome()
 819 {
 820   nsEmbedCString head;
 821   const char *tail, *ptr = 0;
 822   PRUint32 len;
 823   const PRUnichar* resolved;
 824
 825   len = mFile.Length();
 826   tail = strrchr(mFile.BeginReading(), '/');
 827   head = StringHead(mFile, len - strlen(tail) );
 828   if (! mResolver) {
 829     mResolver = nsTestRunner::GetTestRunner();
 830     NS_ENSURE_TRUE( mResolver, NS_OK );
 831   }
 832   mResolver->resolve( head, &resolved);
 833   while( ! resolved && (head.Length() > 9) ) {
 834     ptr = strrchr(head.BeginReading(), '/');
 835     tail -= strlen(ptr);
 836     head = StringHead(mFile, len - strlen(tail) );
 837     mResolver->resolve( head, &resolved);
 838   }
 839   if (! resolved )
 840     return NS_OK;
 841
 842   head = NS_ConvertUTF16toUTF8(resolved);
 843   head += tail;
 844   mFile.Assign( head );
 845
 846   return NS_OK;
 847 }
 848