transport/test/aaChannelTest.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) 2010 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 "aaChannelTest.h"
  23
  24 #include "nsIFile.h"
  25 #include "nsIThreadManager.h"
  26 #include "nsIThread.h"
  27 #include "nsServiceManagerUtils.h"
  28 #include "nsStringAPI.h"
  29 #include "nsCOMPtr.h"
  30 #include "nsAutoPtr.h"
  31 #include "nsMimeTypes.h"
  32 #include "nsILoadGroup.h"
  33
  34 #include "aaTransportTestUtils.h"
  35 #include "nsTestUtils.h"
  36 #include "nsITestRunner.h"
  37 #include "aaSqliteChannel.h"
  38
  39 static const nsCAutoString kCreateTestTable = NS_LITERAL_CSTRING(
  40     "CREATE TABLE test(id INTEGER PRIMARY KEY AUTOINCREMENT, "
  41     "tag CHAR(20) UNIQUE)"
  42     );
  43 static const nsCAutoString kInsertTestRow1 = NS_LITERAL_CSTRING(
  44     "INSERT INTO test(tag) VALUES('row1')"
  45     );
  46
  47
  48 static const nsCAutoString kTransportContentType =
  49   NS_LITERAL_CSTRING("text/dbxml");
  50 static const nsCAutoString kTestContentType =
  51   NS_LITERAL_CSTRING(TEXT_XML);
  52
  53 /********************aaChannelObserver*****************************/
  54
  55 class aaChannelObserver : public nsIStreamListener
  56 {
  57 public:
  58   aaChannelObserver(nsITestRunner* aRunner)
  59     : mState(DEFAULT)
  60     , mRunner(aRunner) {}
  61   NS_DECL_ISUPPORTS
  62   NS_DECL_NSIREQUESTOBSERVER
  63   NS_DECL_NSISTREAMLISTENER
  64
  65   enum EState {
  66     START = 0x00,
  67     DATA,
  68     STOP,
  69     DEFAULT = 0xFF
  70   };
  71   nsresult Wait(EState aEventType = STOP);
  72 protected:
  73   virtual ~aaChannelObserver() {}
  74
  75   nsITestRunner* PickRunner() { return mRunner; }
  76 private:
  77
  78   EState mState;
  79   nsCOMPtr<nsITestRunner> mRunner;
  80 };
  81
  82 NS_IMPL_ISUPPORTS2(aaChannelObserver,
  83                    nsIRequestObserver,
  84                    nsIStreamListener)
  85
  86 NS_IMETHODIMP
  87 aaChannelObserver::OnStartRequest(nsIRequest *aRequest, nsISupports *aContext)
  88 {
  89   NS_TEST_BEGIN(mRunner);
  90   NS_TEST_ASSERT_MSG(DEFAULT == mState,
  91       "[channel test] onStartRequest is not called first");
  92   mState = START;
  93   return NS_OK;
  94 }
  95
  96 NS_IMETHODIMP
  97 aaChannelObserver::OnStopRequest(nsIRequest *aRequest, nsISupports *aContext,
  98     nsresult aStatusCode)
  99 {
 100   NS_TEST_BEGIN(mRunner);
 101   NS_TEST_ASSERT_MSG(DATA == mState || START == mState,
 102       "[channel test] onStopRequest is not called last");
 103   mState = STOP;
 104   return NS_OK;
 105 }
 106
 107 NS_IMETHODIMP
 108 aaChannelObserver::OnDataAvailable(nsIRequest *aRequest, nsISupports *aContext,
 109     nsIInputStream *aInputStream, PRUint32 aOffset, PRUint32 aCount)
 110 {
 111   NS_TEST_BEGIN(mRunner);
 112   NS_TEST_ASSERT_MSG(DATA == mState || START == mState,
 113       "[channel test] onDataAvailable is not called after onStartRequest");
 114   mState = DATA;
 115   return NS_OK;
 116 }
 117
 118 nsresult
 119 aaChannelObserver::Wait(EState aEventType)
 120 {
 121   nsresult rv = NS_OK;
 122
 123   nsCOMPtr<nsIThreadManager> thManager =
 124     do_GetService("@mozilla.org/thread-manager;1", &rv);
 125   NS_ENSURE_SUCCESS(rv, rv);
 126
 127   nsCOMPtr<nsIThread> currThread;
 128   rv = thManager->GetCurrentThread(getter_AddRefs(currThread));
 129   NS_ENSURE_SUCCESS(rv, rv);
 130
 131   while (aEventType != mState)
 132   {
 133     PRBool fProcessed = PR_FALSE;
 134     rv = currThread->ProcessNextEvent(PR_TRUE, &fProcessed);
 135     NS_ENSURE_SUCCESS(rv, rv);
 136   }
 137
 138   return NS_OK;
 139 }
 140
 141 /********************aaAttributeCheckObserver*****************************/
 142 class aaAttributeCheckObserver : public aaChannelObserver
 143 {
 144 public:
 145   aaAttributeCheckObserver(nsITestRunner *aRunner, nsISupports *aOwner)
 146     : aaChannelObserver(aRunner)
 147     , mOwner(aOwner) {}
 148   NS_DECL_ISUPPORTS_INHERITED
 149   NS_DECL_NSISTREAMLISTENER
 150   NS_DECL_NSIREQUESTOBSERVER
 151 private:
 152   virtual ~aaAttributeCheckObserver() {}
 153   nsresult checkAttributes(nsIRequest *aRequest);
 154
 155   nsCOMPtr<nsISupports> mOwner;
 156 };
 157
 158 NS_IMPL_ISUPPORTS_INHERITED0(aaAttributeCheckObserver,
 159     aaChannelObserver)
 160
 161 NS_IMETHODIMP
 162 aaAttributeCheckObserver::OnStartRequest(nsIRequest *aRequest,
 163     nsISupports *aContext)
 164 {
 165   checkAttributes(aRequest);
 166   return aaChannelObserver::OnStartRequest(aRequest, aContext);
 167 }
 168
 169 NS_IMETHODIMP
 170 aaAttributeCheckObserver::OnStopRequest(nsIRequest *aRequest,
 171     nsISupports *aContext, nsresult aStatusCode)
 172 {
 173   checkAttributes(aRequest);
 174   return aaChannelObserver::OnStopRequest(aRequest, aContext, aStatusCode);
 175 }
 176
 177 NS_IMETHODIMP
 178 aaAttributeCheckObserver::OnDataAvailable(nsIRequest *aRequest,
 179     nsISupports *aContext, nsIInputStream *aInputStream,
 180     PRUint32 aOffset, PRUint32 aCount)
 181 {
 182   checkAttributes(aRequest);
 183   return aaChannelObserver::OnDataAvailable(aRequest, aContext, aInputStream,
 184       aOffset, aCount);
 185 }
 186
 187 nsresult
 188 aaAttributeCheckObserver::checkAttributes(nsIRequest *aRequest)
 189 {
 190   NS_TEST_BEGIN(PickRunner());
 191
 192   nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
 193   NS_TEST_ASSERT_MSG(channel, "[channel test] request is not a channel");
 194
 195   if (channel)
 196   {
 197     nsresult rv = NS_OK;
 198     nsCOMPtr<nsISupports> channelOwner;
 199     rv = channel->GetOwner(getter_AddRefs(channelOwner));
 200     NS_TEST_ASSERT_OK(rv);
 201
 202     NS_TEST_ASSERT_MSG(mOwner.get() == channelOwner.get(),
 203         "[channel test] owner is not strong refferenced");
 204
 205     nsCAutoString contentType;
 206     rv = channel->GetContentType(contentType);
 207     NS_TEST_ASSERT_OK(rv);
 208
 209     NS_TEST_ASSERT_MSG(contentType.Equals(kTransportContentType),
 210         "[channel test] content type is not text/dbxml");
 211   }
 212
 213   return NS_OK;
 214 }
 215
 216 /********************aaContentTypeObserver*****************************/
 217 class aaContentTypeObserver : public aaChannelObserver
 218 {
 219 public:
 220   aaContentTypeObserver(nsITestRunner *aRunner,
 221       const nsACString& aNewContentType)
 222     : aaChannelObserver(aRunner)
 223     , mNewContentType(aNewContentType) {}
 224   NS_DECL_ISUPPORTS_INHERITED
 225   NS_DECL_NSISTREAMLISTENER
 226   NS_DECL_NSIREQUESTOBSERVER
 227 private:
 228   virtual ~aaContentTypeObserver() {}
 229   nsresult checkContentType(nsIRequest *aRequest,
 230       const nsACString& aContentType);
 231
 232   nsCAutoString mNewContentType;
 233 };
 234
 235 NS_IMPL_ISUPPORTS_INHERITED0(aaContentTypeObserver,
 236     aaChannelObserver)
 237
 238 NS_IMETHODIMP
 239 aaContentTypeObserver::OnStartRequest(nsIRequest *aRequest,
 240     nsISupports *aContext)
 241 {
 242   checkContentType(aRequest, kTransportContentType);
 243   return aaChannelObserver::OnStartRequest(aRequest, aContext);
 244 }
 245
 246 NS_IMETHODIMP
 247 aaContentTypeObserver::OnStopRequest(nsIRequest *aRequest,
 248     nsISupports *aContext, nsresult aStatusCode)
 249 {
 250   checkContentType(aRequest, mNewContentType);
 251   return aaChannelObserver::OnStopRequest(aRequest, aContext, aStatusCode);
 252 }
 253
 254 NS_IMETHODIMP
 255 aaContentTypeObserver::OnDataAvailable(nsIRequest *aRequest,
 256     nsISupports *aContext, nsIInputStream *aInputStream,
 257     PRUint32 aOffset, PRUint32 aCount)
 258 {
 259   checkContentType(aRequest, mNewContentType);
 260   return aaChannelObserver::OnDataAvailable(aRequest, aContext, aInputStream,
 261       aOffset, aCount);
 262 }
 263
 264 nsresult
 265 aaContentTypeObserver::checkContentType(nsIRequest *aRequest,
 266     const nsACString& aContentType)
 267 {
 268   NS_TEST_BEGIN(PickRunner());
 269
 270   nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
 271   NS_TEST_ASSERT_MSG(channel, "[channel test] request is not a channel");
 272
 273   if (channel)
 274   {
 275     nsresult rv = NS_OK;
 276     nsCAutoString contentType;
 277     rv = channel->GetContentType(contentType);
 278     NS_TEST_ASSERT_OK(rv);
 279
 280     NS_TEST_ASSERT_MSG(contentType.Equals(aContentType),
 281         "[channel test] content type is not right");
 282   }
 283
 284   return NS_OK;
 285 }
 286
 287 /********************aaTestLoadGroup***************************/
 288 class aaTestLoadGroup : public nsILoadGroup
 289 {
 290 public:
 291   aaTestLoadGroup() {}
 292   NS_DECL_ISUPPORTS
 293   NS_DECL_NSILOADGROUP
 294   NS_DECL_NSIREQUEST
 295
 296   nsIRequest* PickRequest() { return mRequest.get(); }
 297 private:
 298   ~aaTestLoadGroup() {}
 299
 300   nsCOMPtr<nsIRequest> mRequest;
 301 };
 302
 303 NS_IMPL_ISUPPORTS2(aaTestLoadGroup,
 304     nsILoadGroup, nsIRequest)
 305
 306 /* attribute nsIRequestObserver groupObserver; */
 307 NS_IMETHODIMP
 308 aaTestLoadGroup::GetGroupObserver(nsIRequestObserver **aGroupObserver)
 309 {
 310   return NS_ERROR_NOT_IMPLEMENTED;
 311 }
 312 NS_IMETHODIMP
 313 aaTestLoadGroup::SetGroupObserver(nsIRequestObserver *aGroupObserver)
 314 {
 315   return NS_ERROR_NOT_IMPLEMENTED;
 316 }
 317
 318 /* attribute nsIRequest defaultLoadRequest; */
 319 NS_IMETHODIMP
 320 aaTestLoadGroup::GetDefaultLoadRequest(nsIRequest **aDefaultLoadRequest)
 321 {
 322   return NS_ERROR_NOT_IMPLEMENTED;
 323 }
 324 NS_IMETHODIMP
 325 aaTestLoadGroup::SetDefaultLoadRequest(nsIRequest *aDefaultLoadRequest)
 326 {
 327   return NS_ERROR_NOT_IMPLEMENTED;
 328 }
 329
 330 /* void addRequest (in nsIRequest aRequest, in nsISupports aContext); */
 331 NS_IMETHODIMP
 332 aaTestLoadGroup::AddRequest(nsIRequest *aRequest, nsISupports *aContext)
 333 {
 334   NS_ENSURE_ARG_POINTER(aRequest);
 335   mRequest = aRequest;
 336   return NS_OK;
 337 }
 338
 339 /* void removeRequest (in nsIRequest aRequest, in nsISupports aContext, in
 340  * nsresult aStatus); */
 341 NS_IMETHODIMP
 342 aaTestLoadGroup::RemoveRequest(nsIRequest *aRequest, nsISupports *aContext,
 343   nsresult aStatus)
 344 {
 345   NS_ENSURE_ARG_POINTER(aRequest);
 346   NS_ENSURE_TRUE(aRequest == mRequest.get(), NS_ERROR_FAILURE);
 347   mRequest = nsnull;
 348   return NS_OK;
 349 }
 350
 351 /* readonly attribute nsISimpleEnumerator requests; */
 352 NS_IMETHODIMP
 353 aaTestLoadGroup::GetRequests(nsISimpleEnumerator **aRequests)
 354 {
 355   return NS_ERROR_NOT_IMPLEMENTED;
 356 }
 357
 358 /* readonly attribute unsigned long activeCount; */
 359 NS_IMETHODIMP
 360 aaTestLoadGroup::GetActiveCount(PRUint32 *aActiveCount)
 361 {
 362   return NS_ERROR_NOT_IMPLEMENTED;
 363 }
 364
 365 /* attribute nsIInterfaceRequestor notificationCallbacks; */
 366 NS_IMETHODIMP
 367 aaTestLoadGroup::GetNotificationCallbacks(
 368   nsIInterfaceRequestor **aNotificationCallbacks)
 369 {
 370   return NS_ERROR_NOT_IMPLEMENTED;
 371 }
 372 NS_IMETHODIMP
 373 aaTestLoadGroup::SetNotificationCallbacks(
 374     nsIInterfaceRequestor *aNotificationCallbacks)
 375 {
 376   return NS_ERROR_NOT_IMPLEMENTED;
 377 }
 378
 379 /* readonly attribute AUTF8String name; */
 380 NS_IMETHODIMP
 381 aaTestLoadGroup::GetName(nsACString & aName)
 382 {
 383   return NS_ERROR_NOT_IMPLEMENTED;
 384 }
 385
 386 /* boolean isPending (); */
 387 NS_IMETHODIMP
 388 aaTestLoadGroup::IsPending(PRBool *_retval NS_OUTPARAM)
 389 {
 390   return NS_ERROR_NOT_IMPLEMENTED;
 391 }
 392
 393 /* readonly attribute nsresult status; */
 394 NS_IMETHODIMP
 395 aaTestLoadGroup::GetStatus(nsresult *aStatus)
 396 {
 397   return NS_ERROR_NOT_IMPLEMENTED;
 398 }
 399
 400 /* void cancel (in nsresult aStatus); */
 401 NS_IMETHODIMP
 402 aaTestLoadGroup::Cancel(nsresult aStatus)
 403 {
 404   return NS_ERROR_NOT_IMPLEMENTED;
 405 }
 406
 407 /* void suspend (); */
 408 NS_IMETHODIMP
 409 aaTestLoadGroup::Suspend()
 410 {
 411   return NS_ERROR_NOT_IMPLEMENTED;
 412 }
 413
 414 /* void resume (); */
 415 NS_IMETHODIMP
 416 aaTestLoadGroup::Resume()
 417 {
 418   return NS_ERROR_NOT_IMPLEMENTED;
 419 }
 420
 421 /* attribute nsILoadGroup loadGroup; */
 422 NS_IMETHODIMP
 423 aaTestLoadGroup::GetLoadGroup(nsILoadGroup * *aLoadGroup)
 424 {
 425   return NS_ERROR_NOT_IMPLEMENTED;
 426 }
 427 NS_IMETHODIMP
 428 aaTestLoadGroup::SetLoadGroup(nsILoadGroup * aLoadGroup)
 429 {
 430   return NS_ERROR_NOT_IMPLEMENTED;
 431 }
 432
 433 /* attribute nsLoadFlags loadFlags; */
 434 NS_IMETHODIMP
 435 aaTestLoadGroup::GetLoadFlags(nsLoadFlags *aLoadFlags)
 436 {
 437   return NS_ERROR_NOT_IMPLEMENTED;
 438 }
 439 NS_IMETHODIMP
 440 aaTestLoadGroup::SetLoadFlags(nsLoadFlags aLoadFlags)
 441 {
 442   return NS_ERROR_NOT_IMPLEMENTED;
 443 }
 444
 445 /********************aaChannelTest*****************************/
 446
 447 aaChannelTest::aaChannelTest()
 448 {
 449 }
 450
 451 NS_IMPL_ISUPPORTS1(aaChannelTest, nsITest)
 452
 453 NS_IMETHODIMP
 454 aaChannelTest::Test(nsITestRunner *aRunner)
 455 {
 456   nsresult rv = NS_OK;
 457   NS_TEST_BEGIN(aRunner);
 458
 459   nsCOMPtr<nsIFile> file;
 460   rv = AA_NewTempFile(getter_AddRefs(file),
 461       NS_LITERAL_CSTRING("transport.sqlite"), PR_TRUE);
 462   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 463
 464   rv = testChannelAttributes(aRunner, file);
 465   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 466
 467   rv = testChannelContentType(aRunner, file);
 468   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 469
 470   return NS_OK;
 471 }
 472
 473 nsresult
 474 aaChannelTest::testChannelAttributes(nsITestRunner *aRunner, nsIFile *aFile)
 475 {
 476   nsresult rv = NS_OK;
 477   NS_ENSURE_ARG_POINTER(aFile);
 478
 479   NS_TEST_BEGIN(aRunner);
 480
 481   nsCOMPtr<nsIURI> dbURI;
 482   rv = AA_NewFileURIWithSql(getter_AddRefs(dbURI), aFile, kCreateTestTable);
 483   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 484
 485   nsRefPtr<aaSqliteChannel> channel = new aaSqliteChannel(dbURI);
 486   rv = channel ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 487   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 488
 489   nsCOMPtr<nsIChannel> iChannel;
 490   rv = channel->QueryInterface(NS_GET_IID(nsIChannel),
 491       getter_AddRefs(iChannel));
 492   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 493
 494   nsCOMPtr<nsIURI> channelURI;
 495   rv = iChannel->GetURI(getter_AddRefs(channelURI));
 496   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 497
 498   PRBool fEqual = PR_FALSE;
 499   rv = channelURI->Equals(dbURI, &fEqual);
 500   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 501   NS_TEST_ASSERT_MSG(fEqual,
 502       "[channel test] channel uri is not equal to db uri");
 503
 504   rv = iChannel->GetOriginalURI(getter_AddRefs(channelURI));
 505   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 506
 507   rv = channelURI->Equals(dbURI, &fEqual);
 508   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 509   NS_TEST_ASSERT_MSG(fEqual,
 510       "[channel test] channel original uri is not equal to db uri");
 511
 512   nsCOMPtr<nsISupports> owner = do_QueryInterface(this, &rv);
 513   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 514
 515   rv = iChannel->SetOwner(owner);
 516   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 517
 518   nsCOMPtr<nsISupports> channelOwner;
 519   rv = iChannel->GetOwner(getter_AddRefs(channelOwner));
 520   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 521
 522   NS_TEST_ASSERT_MSG(owner.get() == channelOwner.get(),
 523       "[channel test] owner is not strong refferenced");
 524
 525   nsCAutoString contentType;
 526   rv = iChannel->GetContentType(contentType);
 527   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 528   NS_TEST_ASSERT_MSG(contentType.Equals(kTransportContentType),
 529     "[channel test] content type is not equal to text/dbxml");
 530
 531   nsRefPtr<aaAttributeCheckObserver> observer =
 532     new aaAttributeCheckObserver(aRunner, owner);
 533   rv = observer ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 534   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 535
 536   rv = aRunner->ArmTimer(500);
 537   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 538
 539   nsrefcnt channelRefCount = iChannel->AddRef() - 1;
 540   rv = iChannel->AsyncOpen(observer, nsnull);
 541   NS_TEST_ASSERT_OK(rv);
 542   if (NS_FAILED(rv)) {
 543     (void) aRunner->MarkTestEnd(this);
 544     NS_ENSURE_SUCCESS(rv, rv);
 545   }
 546
 547   rv = iChannel->AsyncOpen(observer, nsnull);
 548   NS_TEST_ASSERT_MSG(NS_FAILED(rv),
 549       "[channel test] channel can be reopenned");
 550   rv = NS_OK;
 551
 552   rv = iChannel->GetContentType(contentType);
 553   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 554   NS_TEST_ASSERT_MSG(contentType.Equals(kTransportContentType),
 555       "[channel test] content type is not text/dbxml");
 556
 557   rv = observer->Wait();
 558   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 559
 560   NS_TEST_ASSERT_MSG(channelRefCount == iChannel->Release(),
 561       "[channel test] invalid channel life support");
 562
 563   rv = iChannel->GetOwner(getter_AddRefs(channelOwner));
 564   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 565
 566   NS_TEST_ASSERT_MSG(owner.get() == channelOwner.get(),
 567       "[channel test] owner is not strong refferenced");
 568   (void) aRunner->MarkTestEnd(this);
 569
 570   return NS_OK;
 571 }
 572
 573 nsresult
 574 aaChannelTest::testChannelContentType(nsITestRunner *aRunner, nsIFile *aFile)
 575 {
 576   nsresult rv = NS_OK;
 577   NS_ENSURE_ARG_POINTER(aFile);
 578
 579   NS_TEST_BEGIN(aRunner);
 580
 581   nsCOMPtr<nsIURI> dbURI;
 582   rv = AA_NewFileURIWithSql(getter_AddRefs(dbURI), aFile, kInsertTestRow1);
 583   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 584
 585   nsCOMPtr<nsIChannel> iChannel = new aaSqliteChannel(dbURI);
 586   rv = iChannel ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 587   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 588
 589   rv = iChannel->SetLoadFlags(nsIChannel::LOAD_FROM_CACHE);
 590   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 591
 592   nsLoadFlags flags;
 593   rv = iChannel->GetLoadFlags(&flags);
 594   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 595   NS_TEST_ASSERT_MSG(flags == nsIChannel::LOAD_FROM_CACHE,
 596       "[channel test] content type is not empty");
 597
 598   nsCAutoString contentType;
 599   rv = iChannel->GetContentType(contentType);
 600   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 601   NS_TEST_ASSERT_MSG(contentType.Equals(kTransportContentType),
 602     "[channel test] content type does not equal to text/dbxml");
 603
 604   rv = iChannel->SetContentType(kTestContentType);
 605   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 606
 607   rv = iChannel->GetContentType(contentType);
 608   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 609   NS_TEST_ASSERT_MSG(contentType.Equals(kTransportContentType),
 610     "[channel test] content type does not equal to text/dbxml");
 611
 612   nsRefPtr<aaContentTypeObserver> observer =
 613     new aaContentTypeObserver(aRunner, kTestContentType);
 614   rv = observer ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 615   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 616
 617   rv = aRunner->ArmTimer(500);
 618   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 619
 620   nsCOMPtr<aaTestLoadGroup> loadGroup = new aaTestLoadGroup();
 621   rv = loadGroup ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
 622   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 623
 624   rv = iChannel->SetLoadGroup(loadGroup);
 625   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 626
 627   PRBool isPending = PR_FALSE;
 628   rv = iChannel->IsPending(&isPending);
 629   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 630   NS_TEST_ASSERT_MSG(!isPending,
 631       "[channel test] channel is pending");
 632
 633   rv = iChannel->AsyncOpen(observer, nsnull);
 634   NS_TEST_ASSERT_OK(rv);
 635   if (NS_FAILED(rv)) {
 636     (void) aRunner->MarkTestEnd(this);
 637     NS_ENSURE_SUCCESS(rv, rv);
 638   }
 639
 640   nsresult channelStatus;
 641   rv = iChannel->GetStatus(&channelStatus);
 642   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 643   NS_TEST_ASSERT_OK(channelStatus);
 644
 645   rv = iChannel->IsPending(&isPending);
 646   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 647   NS_TEST_ASSERT_MSG(isPending,
 648       "[channel test] channel is not pending");
 649   NS_TEST_ASSERT_MSG(loadGroup->PickRequest(),
 650       "[channel test] ichannel is not set to load group");
 651
 652   rv = iChannel->GetContentType(contentType);
 653   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 654   NS_TEST_ASSERT_MSG(contentType.Equals(kTransportContentType),
 655       "[channel test] content type is not text/dbxml");
 656
 657   rv = iChannel->SetContentType(kTestContentType);
 658   NS_TEST_ASSERT_MSG(NS_FAILED(rv),
 659       "[channel test] content type can be set before OnStartRequest");
 660   rv = NS_OK;
 661
 662   rv = observer->Wait(aaChannelObserver::START);
 663   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 664
 665   rv = iChannel->SetContentType(kTestContentType);
 666   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 667
 668   rv = observer->Wait();
 669   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 670
 671   rv = iChannel->GetStatus(&channelStatus);
 672   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 673   NS_TEST_ASSERT_OK(channelStatus);
 674
 675   NS_TEST_ASSERT_MSG(!loadGroup->PickRequest(),
 676       "[channel test] ichannel is not cleared to load group");
 677
 678   rv = iChannel->GetContentType(contentType);
 679   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 680   NS_TEST_ASSERT_MSG(contentType.Equals(kTestContentType),
 681       "[channel test] content type is not text/xml");
 682
 683   rv = iChannel->IsPending(&isPending);
 684   NS_TEST_ASSERT_OK(rv); NS_ENSURE_SUCCESS(rv, rv);
 685   NS_TEST_ASSERT_MSG(!isPending,
 686       "[channel test] channel is pending");
 687   (void) aRunner->MarkTestEnd(this);
 688
 689   return NS_OK;
 690 }
 691