storage/base/test/aaStorageTest.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,2008 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 "xpcom-config.h"
  23
  24 #include "nsCOMPtr.h"
  25 #include "nsEmbedString.h"
  26 #include "nsIGenericFactory.h"
  27 #include "nsComponentManagerUtils.h"
  28 #include "nsIMutableArray.h"
  29 #include "nsCOMArray.h"
  30 #include "nsArrayUtils.h"
  31
  32 /* Unfrozen API */
  33 #include "nsIStringEnumerator.h"
  34 #include "nsAutoPtr.h"
  35 #include "nsTestUtils.h"
  36 #include "nsITest.h"
  37 #include "nsITestRunner.h"
  38 #include "mozIStorageConnection.h"
  39
  40 /* Project includes */
  41 #include "aaAmountUtils.h"
  42 #include "aaIEntity.h"
  43 #include "aaIResource.h"
  44 #include "aaIFlow.h"
  45 #include "aaIFact.h"
  46 #include "aaIState.h"
  47 #include "aaIEvent.h"
  48 #include "aaSession.h"
  49 #include "aaManager.h"
  50 #include "aaBaseLoaders.h"
  51 #include "aaSaveDispatcher.h"
  52 #include "aaFilter.h"
  53 #include "aaSaveEntity.h"
  54 #include "aaLoadEntity.h"
  55 #include "aaSaveResource.h"
  56 #include "aaLoadResource.h"
  57 #include "aaSaveFlow.h"
  58 #include "aaLoadFlow.h"
  59 #include "aaSaveEvent.h"
  60 #include "aaLoadFlowStates.h"
  61 #include "aaTestConsts.h"
  62
  63 #define AA_STORAGE_TEST_CID \
  64 {0x1e7c924e, 0x872d, 0x4c4e, {0xb8, 0x1c, 0x58, 0xd9, 0x66, 0x4a, 0xe9, 0xd1}}
  65 #define AA_STORAGE_TEST_CONTRACT_ID "@aasii.org/storage/unit;1"
  66
  67 PRBool testState(nsITestRunner *cxxUnitTestRunner, aaIFact *node,
  68     PRInt64 flowId, PRInt64 resourceId, double sum);
  69
  70 class aaStorageTest: public nsITest
  71 {
  72 public:
  73   aaStorageTest():mSubtest(0) {;}
  74   virtual ~aaStorageTest() {;}
  75   NS_DECL_ISUPPORTS
  76   NS_DECL_NSITEST
  77 private:
  78   PRUint32 mSubtest;
  79   nsCOMPtr<aaISession> mSession;
  80   nsCOMPtr<aaILoadQuery> mEntitySet;
  81   nsCOMPtr<aaILoadQuery> mResourceSet;
  82   nsCOMPtr<aaILoadQuery> mFlowSet;
  83
  84   nsresult testSession(nsITestRunner *aTestRunner);
  85   nsresult testSaveDispatcher(nsITestRunner *aTestRunner);
  86   nsresult testFilter(nsITestRunner *aTestRunner);
  87   nsresult testSaveEntity(nsITestRunner *aTestRunner);
  88   nsresult testLoadEntity(nsITestRunner *aTestRunner);
  89   nsresult testSaveResource(nsITestRunner *aTestRunner);
  90   nsresult testLoadResource(nsITestRunner *aTestRunner);
  91   nsresult testSaveFlow(nsITestRunner *aTestRunner);
  92   nsresult testLoadFlow(nsITestRunner *aTestRunner);
  93   nsresult testSaveEvent(nsITestRunner *aTestRunner);
  94   nsresult testLoadFlowStates(nsITestRunner *aTestRunner);
  95   nsresult testUpdateEvent(nsITestRunner *aTestRunner);
  96   nsresult testReplaceEvent(nsITestRunner *aTestRunner);
  97   nsresult testDeleteEvent(nsITestRunner *aTestRunner);
  98   nsresult testStopEvent(nsITestRunner *aTestRunner);
  99   nsresult testJunkEvent(nsITestRunner *aTestRunner);
 100 };
 101
 102 NS_IMPL_ISUPPORTS1(aaStorageTest,
 103                    nsITest)
 104
 105 /* nsITest */
 106 NS_IMETHODIMP
 107 aaStorageTest::Test(nsITestRunner *aTestRunner)
 108 {
 109   testSession(aTestRunner);
 110   testSaveDispatcher(aTestRunner);
 111   testFilter(aTestRunner);
 112   testSaveEntity(aTestRunner);
 113   testLoadEntity(aTestRunner);
 114   testSaveResource(aTestRunner);
 115   testLoadResource(aTestRunner);
 116   testSaveFlow(aTestRunner);
 117   testLoadFlow(aTestRunner);
 118   testSaveEvent(aTestRunner);
 119   testLoadFlowStates(aTestRunner);
 120   testUpdateEvent(aTestRunner);
 121   testReplaceEvent(aTestRunner);
 122   testDeleteEvent(aTestRunner);
 123   testStopEvent(aTestRunner);
 124   testJunkEvent(aTestRunner);
 125   mSession = nsnull;
 126   return NS_OK;
 127 }
 128
 129 /* Private methods */
 130 nsresult
 131 aaStorageTest::testSession(nsITestRunner *aTestRunner)
 132 {
 133   NS_TEST_BEGIN(aTestRunner);
 134   nsresult rv;
 135   nsCOMPtr<aaIManager> manager =
 136     do_CreateInstance(AA_MANAGER_CONTRACT_ID, &rv);
 137   NS_TEST_ASSERT_OK(rv);
 138   NS_ENSURE_SUCCESS(rv, rv);
 139   manager->Backup("backup.sqlite");
 140
 141   mSession = do_CreateInstance(AA_SESSION_CONTRACT_ID);
 142   NS_TEST_ASSERT_MSG(mSession, "aaSession instance creation" );
 143
 144   aaSession *session = static_cast<aaSession *>(mSession.get());
 145   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 146
 147   NS_TEST_ASSERT_MSG( session->mConnection, "session.connection failed" );
 148
 149   return NS_OK;
 150 }
 151
 152 nsresult
 153 aaStorageTest::testSaveDispatcher(nsITestRunner *aTestRunner)
 154 {
 155   NS_TEST_BEGIN(aTestRunner);
 156   nsresult rv;
 157
 158   nsCOMPtr<aaIHandler> saver(do_CreateInstance(
 159         AA_SAVEDISPATCHER_CONTRACT_ID, mSession, &rv));
 160   NS_TEST_ASSERT_MSG(saver, "'saveDispatcher' instance creation" );
 161   NS_ENSURE_SUCCESS(rv, rv);
 162
 163   return NS_OK;
 164 }
 165
 166 nsresult
 167 aaStorageTest::testFilter(nsITestRunner *aTestRunner)
 168 {
 169   NS_TEST_BEGIN(aTestRunner);
 170   nsresult rv;
 171
 172   nsCOMPtr<aaIFilter> filter(do_CreateInstance(
 173         AA_FILTER_CONTRACT_ID, &rv));
 174   NS_TEST_ASSERT_MSG(filter, "[filter] instance creation" );
 175   NS_ENSURE_SUCCESS(rv, rv);
 176
 177   return NS_OK;
 178 }
 179
 180 nsresult
 181 aaStorageTest::testSaveEntity(nsITestRunner *aTestRunner)
 182 {
 183   NS_TEST_BEGIN(aTestRunner);
 184   nsresult rv;
 185
 186   aaSession *session = static_cast<aaSession *>(mSession.get());
 187   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 188
 189   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 190         AA_SAVEENTITY_CONTRACT_ID, session->mConnection, &rv));
 191   NS_TEST_ASSERT_MSG(saver, "'saveEntity' instance creation" );
 192   NS_ENSURE_SUCCESS(rv, rv);
 193
 194   nsCOMPtr<aaIEntity> node(do_CreateInstance("@aasii.org/base/entity;1"));
 195   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 196
 197   node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_1));
 198   rv = saver->Save(node, nsnull);
 199   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' insertion" );
 200
 201   node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_2));
 202   rv = saver->Save(node, nsnull);
 203   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' second insertion" );
 204
 205   node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_3));
 206   rv = saver->Save(node, nsnull);
 207   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' third insertion" );
 208
 209   node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_4));
 210   rv = saver->Save(node, nsnull);
 211   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' forth insertion" );
 212
 213   return NS_OK;
 214 }
 215
 216 nsresult
 217 aaStorageTest::testLoadEntity(nsITestRunner *aTestRunner)
 218 {
 219   NS_TEST_BEGIN(aTestRunner);
 220   nsresult rv;
 221
 222   aaSession *session = static_cast<aaSession *>(mSession.get());
 223   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 224
 225   nsCOMPtr<aaILoadQuery> loader(do_CreateInstance(
 226         AA_LOADENTITY_CONTRACT_ID, session->mConnection, &rv));
 227   NS_TEST_ASSERT_MSG(loader, "'loadEntity' instance creation" );
 228   NS_ENSURE_SUCCESS(rv, rv);
 229
 230   rv = loader->Load();
 231   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadEntity' load" );
 232   mEntitySet = loader;
 233
 234   PRUint32 count;
 235   mEntitySet->GetLength(&count);
 236   NS_TEST_ASSERT_MSG(count == 4, "'loadEntity' flow count is wrong");
 237
 238   nsCOMPtr<aaIEntity> node(do_QueryElementAt(mEntitySet, 0, &rv));
 239   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadEntity' first item read" );
 240
 241   nsEmbedString tag;
 242   node->GetTag(tag);
 243   NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_ENTITY_TAG_1)),
 244         "'loadEntity' first item read differ from inserted" );
 245
 246   PRInt64 id;
 247   node->GetId(&id);
 248   NS_TEST_ASSERT_MSG(id == 1, "'loadEntity' wrong first item id");
 249
 250   return NS_OK;
 251 }
 252
 253 nsresult
 254 aaStorageTest::testSaveResource(nsITestRunner *aTestRunner)
 255 {
 256   NS_TEST_BEGIN(aTestRunner);
 257   nsresult rv;
 258
 259   aaSession *session = static_cast<aaSession *>(mSession.get());
 260   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 261
 262   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 263         AA_SAVERESOURCE_CONTRACT_ID, session->mConnection, &rv));
 264   NS_TEST_ASSERT_MSG(saver, "'saveResource' instance creation" );
 265   NS_ENSURE_SUCCESS(rv, rv);
 266
 267   nsCOMPtr<aaIResource> node(do_CreateInstance("@aasii.org/base/resource;1"));
 268   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 269
 270   node->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_1));
 271   rv = saver->Save(node, nsnull);
 272   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveResource' insertion" );
 273
 274   node->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_2));
 275   rv = saver->Save(node, nsnull);
 276   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveResource' second insertion" );
 277
 278   return NS_OK;
 279 }
 280
 281 nsresult
 282 aaStorageTest::testLoadResource(nsITestRunner *aTestRunner)
 283 {
 284   NS_TEST_BEGIN(aTestRunner);
 285   nsresult rv;
 286
 287   aaSession *session = static_cast<aaSession *>(mSession.get());
 288   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 289
 290   nsCOMPtr<aaILoadQuery> loader(do_CreateInstance(
 291         AA_LOADRESOURCE_CONTRACT_ID, session->mConnection, &rv));
 292   NS_TEST_ASSERT_MSG(loader, "'loadResource' instance creation" );
 293   NS_ENSURE_SUCCESS(rv, rv);
 294
 295   rv = loader->Load();
 296   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadResource' load" );
 297   mResourceSet = loader;
 298
 299   nsCOMPtr<aaIResource> node(do_QueryElementAt(mResourceSet, 0, &rv));
 300   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadResource' first item not read" );
 301
 302   nsEmbedString tag;
 303   node->GetTag(tag);
 304   NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_1)),
 305         "'loadResource' first item read differs from inserted" );
 306
 307   return NS_OK;
 308 }
 309
 310 nsresult
 311 aaStorageTest::testSaveFlow(nsITestRunner *aTestRunner)
 312 {
 313   NS_TEST_BEGIN(aTestRunner);
 314   nsresult rv;
 315
 316   aaSession *session = static_cast<aaSession *>(mSession.get());
 317   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 318
 319   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 320         AA_SAVEFLOW_CONTRACT_ID, session->mConnection, &rv));
 321   NS_TEST_ASSERT_MSG(saver, "'saveflow' instance creation" );
 322   NS_ENSURE_SUCCESS(rv, rv);
 323
 324   nsCOMPtr<aaIFlow> node(do_CreateInstance("@aasii.org/base/flow;1"));
 325   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 326
 327   nsCOMPtr<aaIResource> share(do_QueryElementAt(mResourceSet,1));
 328   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet,0));
 329
 330   nsCOMPtr<aaIEntity> entity(do_QueryElementAt(mEntitySet, 1));
 331   node->SetEntity(entity);
 332   node->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_1));
 333   node->SetGiveResource(share);
 334   node->SetTakeResource(rub);
 335   node->SetRate(AA_FLOW_SHARE_RATE);
 336   node->SetLimit(AA_EVENT_AMOUNT_1 / AA_FLOW_SHARE_RATE);
 337   rv = saver->Save(node, nsnull);
 338   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveFlow' 1st insertion" );
 339
 340   entity = do_QueryElementAt(mEntitySet, 2);
 341   node->SetEntity(entity);
 342   node->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_3));
 343   node->SetGiveResource(share);
 344   node->SetTakeResource(rub);
 345   node->SetRate(AA_FLOW_SHARE_RATE);
 346   node->SetLimit(AA_EVENT_AMOUNT_2 / AA_FLOW_SHARE_RATE);
 347   rv = saver->Save(node, nsnull);
 348   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveFlow' 2nd insertion" );
 349
 350   entity = do_QueryElementAt(mEntitySet, 3);
 351   node->SetEntity(entity);
 352   node->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_5));
 353   node->SetGiveResource(rub);
 354   node->SetTakeResource(rub);
 355   node->SetRate(1.0);
 356   node->SetLimit(0.0);
 357   rv = saver->Save(node, nsnull);
 358   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveFlow' 3rd insertion" );
 359
 360   return NS_OK;
 361 }
 362
 363 nsresult
 364 aaStorageTest::testLoadFlow(nsITestRunner *aTestRunner)
 365 {
 366   NS_TEST_BEGIN(aTestRunner);
 367   nsresult rv;
 368
 369   aaSession *session = static_cast<aaSession *>(mSession.get());
 370   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 371
 372   mFlowSet = do_CreateInstance(AA_LOADFLOW_CONTRACT_ID, session->mConnection,
 373       &rv);
 374   NS_TEST_ASSERT_MSG(mFlowSet, "'loadFlow' instance creation" );
 375   NS_ENSURE_SUCCESS(rv, rv);
 376
 377   rv = mFlowSet->Load();
 378   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadFlow' load" );
 379
 380   nsCOMPtr<aaIFlow> node(do_QueryElementAt(mFlowSet, 0, &rv));
 381   NS_TEST_ASSERT_MSG(node, "'loadFlow' first item not read" );
 382   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 383
 384   nsEmbedString tag;
 385   node->GetTag(tag);
 386   NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_FLOW_TAG_1)),
 387         "'loadFlow' first item read differs from inserted" );
 388
 389   nsCOMPtr<aaIEntity> entity;
 390   rv = node->GetEntity(getter_AddRefs( entity ));
 391   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadFlow' flow.entity read" );
 392   NS_TEST_ASSERT_MSG(entity, "'loadFlow' flow.entity read is null" );
 393   if (entity) {
 394     entity->GetTag(tag);
 395     NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_ENTITY_TAG_2)),
 396         "'loadFlow' flow.entity differs from inserted" );
 397   }
 398
 399   nsCOMPtr<aaIResource> res;
 400   rv = node->GetGiveResource(getter_AddRefs( res ));
 401   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv),
 402       "'loadFlow' flow.giveResource not read" );
 403   NS_TEST_ASSERT_MSG(res, "'loadFlow' flow.giveResource read is null" );
 404   if (res) {
 405     res->GetTag(tag);
 406     NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_2)),
 407         "'loadFlow' flow.giveResource differs from inserted" );
 408   }
 409
 410   rv = node->GetTakeResource(getter_AddRefs( res ));
 411   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv),
 412       "'loadFlow' flow.takeResource not read" );
 413   NS_TEST_ASSERT_MSG(res, "'loadFlow' flow.takeResource read is null" );
 414   if (res) {
 415     res->GetTag(tag);
 416     NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_1)),
 417         "'loadFlow' flow.takeResource differs from inserted" );
 418   }
 419
 420   double rate;
 421   rv = node->GetRate( &rate );
 422   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadFlow' flow.rate not read" );
 423   NS_TEST_ASSERT_MSG(rate == AA_FLOW_SHARE_RATE,
 424         "'loadFlow' flow.rate differs from inserted" );
 425
 426   return NS_OK;
 427 }
 428
 429 nsresult
 430 aaStorageTest::testSaveEvent(nsITestRunner *aTestRunner)
 431 {
 432   NS_TEST_BEGIN(aTestRunner);
 433   nsresult rv;
 434
 435   aaSession *session = static_cast<aaSession *>(mSession.get());
 436   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 437
 438   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 439         AA_SAVEEVENT_CONTRACT_ID, session->mConnection, &rv));
 440   NS_TEST_ASSERT_MSG(saver, "'saveEvent' instance creation" );
 441
 442   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
 443   /* Set time to 2007-08-29 */
 444   PRExplodedTime tm = {0,0,0,12,29,7,2007};
 445   node->SetTime(PR_ImplodeTime(&tm));
 446
 447   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
 448   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 449
 450   /* Fact 1 */
 451   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
 452   fact->SetAmount(AA_EVENT_AMOUNT_2);
 453   nsCOMPtr<aaIFlow> flow(do_QueryElementAt(mFlowSet,1));
 454   fact->SetTakeFrom(flow);
 455   flow = do_QueryElementAt(mFlowSet,2);
 456   fact->SetGiveTo(flow);
 457
 458   rv = block->AppendElement(fact, PR_FALSE);
 459   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[insert event] appendElement" );
 460
 461   rv = saver->Save(node, nsnull);
 462   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[insert event] saving" );
 463
 464   return NS_OK;
 465 }
 466
 467 PRBool
 468 testState(nsITestRunner *cxxUnitTestRunner, aaIState *node, PRInt64 flowId,
 469     PRInt64 resourceId, double sum)
 470 {
 471   NS_TEST_ASSERT_MSG(node, " 'state' is null");
 472   nsresult rv;
 473   PRBool equals = PR_TRUE;
 474   nsCOMPtr<aaIFlow> flow;
 475   rv = node->GetFlow(getter_AddRefs( flow ));
 476   NS_TEST_ASSERT_MSG(flow, " 'state.flow' is null");
 477   PRInt64 id;
 478   nsEmbedString tag;
 479   if (NS_LIKELY( flow )) {
 480     flow->GetId(&id);
 481     if (NS_UNLIKELY( id != flowId) ) {
 482       equals = PR_FALSE;
 483       NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.flow.id' is wrong");
 484     }
 485   } else {
 486     equals = PR_FALSE;
 487   }
 488
 489   nsCOMPtr<aaIResource> resource;
 490   rv = node->GetResource(getter_AddRefs( resource ));
 491   NS_TEST_ASSERT_MSG(resource, " 'state.resource' is null" );
 492   if (NS_LIKELY( resource )) {
 493     resource->GetId(&id);
 494     if (NS_UNLIKELY( id != resourceId) ) {
 495       equals = PR_FALSE;
 496       NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.resource.id' is wrong");
 497     }
 498   } else {
 499     equals = PR_FALSE;
 500   }
 501
 502   double amount, diff;
 503   rv = node->GetAmount(&amount);
 504   diff = amount - sum;
 505   if (! isZero(diff)) {
 506     equals = PR_FALSE;
 507     NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.amount' is wrong");
 508   }
 509
 510   return equals;
 511 }
 512
 513 nsresult
 514 aaStorageTest::testLoadFlowStates(nsITestRunner *aTestRunner)
 515 {
 516   NS_TEST_BEGIN(aTestRunner);
 517   nsresult rv;
 518
 519   aaSession *session = static_cast<aaSession *>(mSession.get());
 520   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 521
 522   session->mConnection = nsnull;
 523   session->getDatabase();
 524   nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
 525         AA_LOADFLOWSTATES_CONTRACT_ID, session->mConnection, &rv));
 526   NS_TEST_ASSERT_MSG(set, "[load states] instance creation" );
 527   NS_ENSURE_SUCCESS(rv, rv);
 528
 529   rv = set->Load();
 530   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[load states] loading" );
 531   NS_ENSURE_TRUE(set, NS_ERROR_FAILURE);
 532
 533   PRUint32 count;
 534   set->GetLength(&count);
 535   NS_TEST_ASSERT_MSG(count == 2, "[load states] wrong flow count");
 536
 537   nsCOMPtr<aaIState> node(do_QueryElementAt(set, 0, &rv));
 538   NS_TEST_ASSERT_MSG(node, "[load states 1st item not read" );
 539   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 540
 541   NS_TEST_ASSERT_MSG(testState(aTestRunner, node, 2, 2, AA_EVENT_AMOUNT_2
 542         / AA_FLOW_SHARE_RATE), "[load states] flow2 is wrong");
 543
 544   nsCOMPtr<aaIFlow> flow;
 545   nsEmbedString tag;
 546   node->GetFlow(getter_AddRefs( flow ));
 547   if (flow) {
 548     flow->GetTag(tag);
 549     NS_TEST_ASSERT_MSG( tag.Equals(NS_ConvertUTF8toUTF16(AA_FLOW_TAG_3)),
 550       "[load states] 'fact.flow.tag' is wrong" );
 551   }
 552
 553   nsCOMPtr<aaIResource> resource;
 554   node->GetResource(getter_AddRefs( resource ));
 555   if (resource) {
 556     resource->GetTag(tag);
 557     NS_TEST_ASSERT_MSG( tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_2)),
 558         "[load states] 'state.resource.tag' is wrong" );
 559   }
 560
 561   node = do_QueryElementAt(set, 1, &rv);
 562   NS_TEST_ASSERT_MSG(node, "[load states] 2nd item not read" );
 563   NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
 564
 565   NS_TEST_ASSERT_MSG(testState(aTestRunner, node, 3, 1, AA_EVENT_AMOUNT_2),
 566       "[load states] flow3 is wrong");
 567
 568   return NS_OK;
 569 }
 570
 571 nsresult
 572 aaStorageTest::testUpdateEvent(nsITestRunner *aTestRunner)
 573 {
 574   NS_TEST_BEGIN(aTestRunner);
 575   nsresult rv;
 576
 577   aaSession *session = static_cast<aaSession *>(mSession.get());
 578   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 579
 580   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 581         AA_SAVEEVENT_CONTRACT_ID, session->mConnection, &rv));
 582   NS_TEST_ASSERT_MSG(saver, "'saveEvent' instance creation" );
 583   NS_ENSURE_TRUE(saver, NS_ERROR_UNEXPECTED);
 584
 585   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
 586   /* Set time to 2007-08-29 */
 587   PRExplodedTime tm = {0,0,0,12,29,7,2007};
 588   node->SetTime(PR_ImplodeTime(&tm));
 589
 590   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
 591   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 592
 593   /* Fact 2 */
 594   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
 595   fact->SetAmount(AA_EVENT_AMOUNT_3);
 596   nsCOMPtr<aaIFlow> flow(do_QueryElementAt(mFlowSet,0));
 597   fact->SetTakeFrom(flow);
 598   flow = do_QueryElementAt(mFlowSet,2);
 599   fact->SetGiveTo(flow);
 600
 601   rv = block->AppendElement(fact, PR_FALSE);
 602   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update event] appending element" );
 603
 604   rv = saver->Save(node, nsnull);
 605   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update event] saving" );
 606
 607   nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
 608         AA_LOADFLOWSTATES_CONTRACT_ID, session->mConnection, &rv));
 609   NS_TEST_ASSERT_MSG(set, "[update event] creating loader" );
 610   NS_ENSURE_SUCCESS(rv, rv);
 611
 612   rv = set->Load();
 613   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update event] loading states" );
 614
 615   PRUint32 count;
 616   set->GetLength(&count);
 617   NS_TEST_ASSERT_MSG(count == 3, "[update event] wrong flow count");
 618
 619   nsCOMPtr<aaIState> state;
 620   state = do_QueryElementAt(set, 2, &rv);
 621   NS_TEST_ASSERT_MSG(state, "[update event] 3rd item not read" );
 622   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 623
 624   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 1, 2, AA_EVENT_AMOUNT_3
 625         / AA_FLOW_SHARE_RATE), "[update event] flow1 is wrong");
 626
 627   state = do_QueryElementAt(set, 1, &rv);
 628   NS_TEST_ASSERT_MSG(state, "[update event] 2nd item not read" );
 629   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 630
 631   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
 632         + AA_EVENT_AMOUNT_3), "[update event] flow3 is wrong");
 633   return NS_OK;
 634 }
 635
 636 nsresult
 637 aaStorageTest::testReplaceEvent(nsITestRunner *aTestRunner)
 638 {
 639   NS_TEST_BEGIN(aTestRunner);
 640   nsresult rv;
 641
 642   aaSession *session = static_cast<aaSession *>(mSession.get());
 643   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 644
 645   nsCOMPtr<aaIResource> vaio(do_CreateInstance("@aasii.org/base/resource;1"));
 646   NS_ENSURE_TRUE(vaio, NS_ERROR_FAILURE);
 647   vaio->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_3));
 648   session->Save(vaio, nsnull);
 649
 650   PRInt64 id;
 651   vaio->GetId( &id );
 652   NS_TEST_ASSERT_MSG(id == 3, "[replace event] unexpected 'resource.id'");
 653   NS_ENSURE_TRUE(id == 3, NS_ERROR_UNEXPECTED);
 654
 655   nsCOMPtr<aaIEntity> shop(do_CreateInstance("@aasii.org/base/entity;1"));
 656   NS_ENSURE_TRUE(shop, NS_ERROR_FAILURE);
 657   shop->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_5));
 658   session->Save(shop, nsnull);
 659
 660   shop->GetId( &id );
 661   NS_TEST_ASSERT_MSG(id == 5, "[replace event] unexpected 'entity.id'");
 662   NS_ENSURE_TRUE(id == 5, NS_ERROR_UNEXPECTED);
 663
 664   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet,0));
 665
 666   nsCOMPtr<aaIFlow> purchase(do_CreateInstance("@aasii.org/base/flow;1"));
 667   NS_ENSURE_TRUE(purchase, NS_ERROR_FAILURE);
 668   purchase->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_6));
 669   purchase->SetEntity(shop);
 670   purchase->SetGiveResource(rub);
 671   purchase->SetTakeResource(vaio);
 672   purchase->SetRate(1.0 / AA_EVENT_AMOUNT_4);
 673   purchase->SetLimit(AA_EVENT_AMOUNT_5);
 674   rv = session->Save(purchase, nsnull);
 675   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] saving flow");
 676   NS_ENSURE_SUCCESS(rv, rv);
 677
 678   purchase->GetId( &id );
 679   NS_TEST_ASSERT_MSG(id == 4, "[replace event] unexpected 'flow.id'");
 680   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 681
 682   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
 683   /* Set time to 2007-08-30 */
 684   PRExplodedTime tm = {0,0,0,12,30,7,2007};
 685   node->SetTime(PR_ImplodeTime(&tm));
 686
 687   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
 688   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 689
 690   /* Fact 3 */
 691   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
 692   fact->SetAmount(AA_EVENT_AMOUNT_4);
 693   nsCOMPtr<aaIFlow> flow(do_QueryElementAt(mFlowSet,2));
 694   fact->SetTakeFrom(flow);
 695   fact->SetGiveTo(purchase);
 696
 697   rv = block->AppendElement(fact, PR_FALSE);
 698   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] appending element" );
 699
 700   rv = session->Save(node, nsnull);
 701   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] saving" );
 702
 703   nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
 704         AA_LOADFLOWSTATES_CONTRACT_ID, session->mConnection, &rv));
 705   NS_TEST_ASSERT_MSG(set, "[replace event] creating loader" );
 706   NS_ENSURE_SUCCESS(rv, rv);
 707
 708   rv = set->Load();
 709   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] loading states" );
 710
 711   PRUint32 count;
 712   set->GetLength(&count);
 713   NS_TEST_ASSERT_MSG(count == 4, "[replace event] wrong flow count");
 714
 715   nsCOMPtr<aaIState> state;
 716   state = do_QueryElementAt(set, 2, &rv);
 717   NS_TEST_ASSERT_MSG(state, "[replace event] 2nd item not read" );
 718   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 719
 720   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
 721         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4),
 722       "[replace event] flow3 is wrong");
 723
 724   state = do_QueryElementAt(set, 3, &rv);
 725   NS_TEST_ASSERT_MSG(state, "[replace event] 4th item not read" );
 726   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 727
 728   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 4, 3, AA_EVENT_AMOUNT_5),
 729       "[replace event] flow4 is wrong");
 730   return NS_OK;
 731 }
 732
 733 nsresult
 734 aaStorageTest::testDeleteEvent(nsITestRunner *aTestRunner)
 735 {
 736   NS_TEST_BEGIN(aTestRunner);
 737   nsresult rv;
 738
 739   rv = mResourceSet->Load();
 740   NS_TEST_ASSERT_OK(rv);
 741
 742   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet, 0, &rv));
 743   NS_ENSURE_TRUE(rub, rv);
 744
 745   PRInt64 id;
 746   rub->GetId( &id );
 747   NS_TEST_ASSERT_MSG(id == 1, "[delete event] unexpected 'resource.id'");
 748   NS_ENSURE_TRUE(id == 1, NS_ERROR_UNEXPECTED);
 749
 750   nsCOMPtr<aaIResource> eur(do_CreateInstance("@aasii.org/base/resource;1"));
 751   NS_ENSURE_TRUE(eur, NS_ERROR_FAILURE);
 752   eur->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_4));
 753   mSession->Save(eur, nsnull);
 754
 755   eur->GetId( &id );
 756   NS_TEST_ASSERT_MSG(id == 4, "[delete event] unexpected 'resource.id'");
 757   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 758
 759   rv = mEntitySet->Load();
 760   NS_TEST_ASSERT_OK(rv);
 761
 762   nsCOMPtr<aaIEntity> bank(do_QueryElementAt(mEntitySet, 3, &rv));
 763   NS_ENSURE_TRUE(bank, rv);
 764
 765   bank->GetId( &id );
 766   NS_TEST_ASSERT_MSG(id == 4, "[delete event] unexpected 'entity.id'");
 767   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 768
 769   rv = mFlowSet->Load();
 770   NS_TEST_ASSERT_OK(rv);
 771
 772   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlowSet,2));
 773
 774   /* Flow for a forex deal */
 775   nsCOMPtr<aaIFlow> forex(do_CreateInstance("@aasii.org/base/flow;1"));
 776   NS_ENSURE_TRUE(forex, NS_ERROR_FAILURE);
 777   forex->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_7));
 778   forex->SetEntity(bank);
 779   forex->SetGiveResource(rub);
 780   forex->SetTakeResource(eur);
 781   forex->SetRate(1 / AA_EVENT_RATE_2);
 782   forex->SetLimit(AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2);
 783   rv = mSession->Save(forex, nsnull);
 784   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving flow");
 785   NS_ENSURE_SUCCESS(rv, rv);
 786
 787   forex->GetId( &id );
 788   NS_TEST_ASSERT_MSG(id == 5, "[delete event] unexpected 'flow.id'");
 789   NS_ENSURE_TRUE(id == 5, NS_ERROR_UNEXPECTED);
 790
 791   /* Flow for EUR in the bank */
 792   nsCOMPtr<aaIFlow> bankAccEur(do_CreateInstance("@aasii.org/base/flow;1"));
 793   NS_ENSURE_TRUE(bankAccEur, NS_ERROR_FAILURE);
 794   bankAccEur->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_8));
 795   bankAccEur->SetEntity(bank);
 796   bankAccEur->SetGiveResource(eur);
 797   bankAccEur->SetTakeResource(eur);
 798   bankAccEur->SetRate(1);
 799   bankAccEur->SetLimit(0.0);
 800   rv = mSession->Save(bankAccEur, nsnull);
 801   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving flow");
 802   NS_ENSURE_SUCCESS(rv, rv);
 803
 804   bankAccEur->GetId( &id );
 805   NS_TEST_ASSERT_MSG(id == 6, "[delete event] unexpected 'flow.id'");
 806   NS_ENSURE_TRUE(id == 6, NS_ERROR_UNEXPECTED);
 807
 808   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
 809   /* Set time to 2007-08-30 */
 810   PRExplodedTime tm = {0,0,0,12,30,7,2007};
 811   node->SetTime(PR_ImplodeTime(&tm));
 812
 813   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
 814   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 815
 816   /* Fact 4 */
 817   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
 818   fact->SetAmount(AA_EVENT_AMOUNT_6);
 819   fact->SetTakeFrom(forex);
 820   fact->SetGiveTo(bankAccEur);
 821
 822   rv = block->AppendElement(fact, PR_FALSE);
 823   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] appending element" );
 824
 825   rv = mSession->Save(node, nsnull);
 826   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving [2]" );
 827
 828   nsCOMPtr<aaILoadQuery> set;
 829   mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs( set ));
 830   NS_TEST_ASSERT_MSG(set, "[delete event] creating loader" );
 831   NS_ENSURE_SUCCESS(rv, rv);
 832
 833   rv = set->Load();
 834   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] loading states [2]" );
 835
 836   PRUint32 count;
 837   set->GetLength(&count);
 838   NS_TEST_ASSERT_MSG(count == 6, "[delete event] wrong flow count");
 839
 840   nsCOMPtr<aaIState> state;
 841   state = do_QueryElementAt(set, 2, &rv);
 842   NS_TEST_ASSERT_MSG(state, "[delete event] 2nd item not read" );
 843   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 844
 845   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
 846         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4),
 847       "[delete event] flow3 is wrong");
 848
 849   state = do_QueryElementAt(set, 4, &rv);
 850   NS_TEST_ASSERT_MSG(state, "[delete event] 4th item not read" );
 851   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 852
 853   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 5, 1, AA_EVENT_AMOUNT_6
 854         * AA_EVENT_RATE_2),
 855       "[delete event] flow5 is wrong");
 856
 857   state = do_QueryElementAt(set, 5, &rv);
 858   NS_TEST_ASSERT_MSG(state, "[delete event] 4th item not read" );
 859   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 860
 861   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 6, 4, AA_EVENT_AMOUNT_6),
 862       "[delete event] flow6 is wrong");
 863   /* Fact 4 is processed correctly */
 864
 865   node = do_CreateInstance("@aasii.org/base/event;1");
 866   /* Set time to 2007-08-30 */
 867   node->SetTime(PR_ImplodeTime(&tm));
 868
 869   block = do_QueryInterface( node );
 870   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 871
 872   /* Fact 5 */
 873   fact = do_CreateInstance("@aasii.org/base/fact;1");
 874   /* Forex deal is paid correctly */
 875   fact->SetAmount(AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2);
 876   fact->SetTakeFrom(bankAccRub);
 877   fact->SetGiveTo(forex);
 878
 879   rv = block->AppendElement(fact, PR_FALSE);
 880   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] appending element" );
 881
 882   rv = mSession->Save(node, nsnull);
 883   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving" );
 884
 885   rv = set->Load();
 886   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] loading states" );
 887
 888   set->GetLength(&count);
 889   NS_TEST_ASSERT_MSG(count == 5, "[delete event] wrong flow count");
 890
 891   state = do_QueryElementAt(set, 2, &rv);
 892   NS_TEST_ASSERT_MSG(state, "[delete event] 2nd item not read" );
 893   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 894
 895   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
 896         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
 897         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
 898       "[delete event] flow3 is wrong");
 899
 900   state = do_QueryElementAt(set, 4, &rv);
 901   NS_TEST_ASSERT_MSG(state, "[delete event] 4th item not read" );
 902   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
 903
 904   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 6, 4, AA_EVENT_AMOUNT_6),
 905       "[delete event] flow6 is wrong");
 906
 907   nsCOMPtr<aaIFilter> filter;
 908   rv = set->GetFilter(getter_AddRefs( filter ));
 909   NS_TEST_ASSERT_OK(rv);
 910   NS_ENSURE_SUCCESS(rv, rv);
 911
 912   nsCOMPtr<aaIStringFilter> strFilter(do_QueryInterface(filter, &rv));
 913   NS_ENSURE_TRUE(strFilter, rv);
 914   strFilter->SetExpression(NS_LITERAL_CSTRING(" WHERE state.id = 6"));
 915
 916   rv = set->SetFilter(filter);
 917   NS_TEST_ASSERT_OK(rv);
 918   NS_ENSURE_SUCCESS(rv, rv);
 919
 920   rv = set->Load();
 921   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] loading states" );
 922
 923   set->GetLength(&count);
 924   NS_TEST_ASSERT_MSG(count == 0, "[delete event] wrong flow count");
 925   return NS_OK;
 926 }
 927
 928 nsresult
 929 aaStorageTest::testStopEvent(nsITestRunner *aTestRunner)
 930 {
 931   NS_TEST_BEGIN(aTestRunner);
 932   nsresult rv;
 933
 934   rv = mResourceSet->Load();
 935   NS_TEST_ASSERT_OK(rv);
 936
 937   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet, 0, &rv));
 938   NS_ENSURE_TRUE(rub, rv);
 939
 940   PRInt64 id;
 941   rub->GetId( &id );
 942   NS_TEST_ASSERT_MSG(id == 1, "[stop event] unexpected 'resource.id'");
 943   NS_ENSURE_TRUE(id == 1, NS_ERROR_UNEXPECTED);
 944
 945   nsCOMPtr<aaIResource> eur(do_QueryElementAt(mResourceSet, 3, &rv));
 946   NS_ENSURE_TRUE(eur, NS_ERROR_FAILURE);
 947
 948   eur->GetId( &id );
 949   NS_TEST_ASSERT_MSG(id == 4, "[stop event] unexpected 'resource.id'");
 950   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 951
 952   rv = mEntitySet->Load();
 953   NS_TEST_ASSERT_OK(rv);
 954
 955   nsCOMPtr<aaIEntity> bank(do_QueryElementAt(mEntitySet, 3, &rv));
 956   NS_ENSURE_TRUE(bank, rv);
 957
 958   bank->GetId( &id );
 959   NS_TEST_ASSERT_MSG(id == 4, "[stop event] unexpected 'entity.id'");
 960   NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
 961
 962   rv = mFlowSet->Load();
 963   NS_TEST_ASSERT_OK(rv);
 964
 965   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlowSet,2));
 966   nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlowSet,5));
 967
 968   /* Flow for a forex deal #2*/
 969   nsCOMPtr<aaIFlow> forex(do_CreateInstance("@aasii.org/base/flow;1"));
 970   NS_ENSURE_TRUE(forex, NS_ERROR_FAILURE);
 971   forex->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_9));
 972   forex->SetEntity(bank);
 973   forex->SetGiveResource(eur);
 974   forex->SetTakeResource(rub);
 975   forex->SetRate(AA_EVENT_RATE_3);
 976   forex->SetLimit(AA_EVENT_AMOUNT_6);
 977   rv = mSession->Save(forex, nsnull);
 978   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] saving flow");
 979   NS_ENSURE_SUCCESS(rv, rv);
 980
 981   forex->GetId( &id );
 982   NS_TEST_ASSERT_MSG(id == 7, "[stop event] unexpected 'flow.id'");
 983   NS_ENSURE_TRUE(id == 7, NS_ERROR_UNEXPECTED);
 984
 985   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
 986   /* Set time to 2007-08-31 */
 987   PRExplodedTime tm = {0,0,0,12,31,7,2007};
 988   node->SetTime(PR_ImplodeTime(&tm));
 989
 990   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
 991   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
 992
 993   /* Fact 6 */
 994   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
 995   fact->SetAmount(AA_EVENT_AMOUNT_6);
 996   fact->SetTakeFrom(bankAccEur);
 997   fact->SetGiveTo(forex);
 998
 999   rv = block->AppendElement(fact, PR_FALSE);
1000   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] appending element" );
1001
1002   rv = mSession->Save(node, nsnull);
1003   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] saving" );
1004
1005   nsCOMPtr<aaILoadQuery> set;
1006   mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs( set ));
1007   NS_TEST_ASSERT_MSG(set, "[stop event] creating loader" );
1008   NS_ENSURE_SUCCESS(rv, rv);
1009
1010   rv = set->Load();
1011   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] loading states" );
1012
1013   PRUint32 count;
1014   set->GetLength(&count);
1015   NS_TEST_ASSERT_MSG(count == 5, "[stop event] wrong flow count");
1016
1017   nsCOMPtr<aaIState> state;
1018   state = do_QueryElementAt(set, 2, &rv);
1019   NS_TEST_ASSERT_MSG(state, "[stop event] 2nd item not read" );
1020   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1021
1022   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
1023         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1024         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
1025       "[stop event] flow3 is wrong");
1026
1027   state = do_QueryElementAt(set, 4, &rv);
1028   NS_TEST_ASSERT_MSG(state, "[stop event] 4th item not read" );
1029   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1030
1031   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 7, 1, AA_EVENT_AMOUNT_6
1032         * AA_EVENT_RATE_3),
1033       "[stop event] flow7 is wrong");
1034   /* Forex deal #2 is paid correctly */
1035
1036   nsCOMPtr<aaIFilter> filter;
1037   rv = set->GetFilter(getter_AddRefs( filter ));
1038   NS_TEST_ASSERT_OK(rv);
1039   NS_ENSURE_SUCCESS(rv, rv);
1040
1041   nsCOMPtr<aaIStringFilter> strFilter(do_QueryInterface(filter, &rv));
1042   NS_ENSURE_TRUE(strFilter, rv);
1043   strFilter->SetExpression(NS_LITERAL_CSTRING(" WHERE state.flow_id = 6\
1044         AND state.paid = 2454344"));
1045
1046   rv = set->SetFilter(filter);
1047   NS_TEST_ASSERT_OK(rv);
1048   NS_ENSURE_SUCCESS(rv, rv);
1049
1050   rv = set->Load();
1051   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] loading states" );
1052
1053   set->GetLength(&count);
1054   NS_TEST_ASSERT_MSG(count == 1, "[stop event] wrong flow count");
1055
1056   state = do_QueryElementAt(set, 0, &rv);
1057   NS_TEST_ASSERT_MSG(state, "[stop event] item not read" );
1058   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1059
1060   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 6, 4, AA_EVENT_AMOUNT_6),
1061       "[stop event] flow6 is wrong");
1062   return NS_OK;
1063 }
1064
1065 nsresult
1066 aaStorageTest::testJunkEvent(nsITestRunner *aTestRunner)
1067 {
1068   NS_TEST_BEGIN(aTestRunner);
1069   nsresult rv;
1070
1071   rv = mFlowSet->Load();
1072   NS_TEST_ASSERT_OK(rv);
1073
1074   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlowSet,2));
1075   nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlowSet,5));
1076
1077   nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
1078   /* Set time to 2007-08-31 */
1079   PRExplodedTime tm = {0,0,0,12,31,7,2007};
1080   node->SetTime(PR_ImplodeTime(&tm));
1081
1082   nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
1083   NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
1084
1085   /* Junk Fact */
1086   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
1087   fact->SetAmount(1);
1088   fact->SetTakeFrom(bankAccEur);
1089   fact->SetGiveTo(bankAccRub);
1090
1091   rv = block->AppendElement(fact, PR_FALSE);
1092   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[junk event] appending element" );
1093
1094   rv = mSession->Save(node, nsnull);
1095   NS_TEST_ASSERT_MSG(NS_FAILED(rv), "[junk event] saving" );
1096
1097   nsCOMPtr<aaILoadQuery> set;
1098   mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs( set ));
1099   NS_TEST_ASSERT_MSG(set, "[junk event] creating loader" );
1100   NS_ENSURE_TRUE(set, rv);
1101
1102   rv = set->Load();
1103   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[junk event] loading states" );
1104
1105   PRUint32 count;
1106   set->GetLength(&count);
1107   NS_TEST_ASSERT_MSG(count == 5, "[junk event] wrong flow count");
1108
1109   nsCOMPtr<aaIState> state;
1110   state = do_QueryElementAt(set, 2, &rv);
1111   NS_TEST_ASSERT_MSG(state, "[junk event] 2nd item not read" );
1112   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1113
1114   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
1115         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1116         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
1117       "[junk event] flow3 is wrong");
1118
1119   state = do_QueryElementAt(set, 4, &rv);
1120   NS_TEST_ASSERT_MSG(state, "[junk event] 4th item not read" );
1121   NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1122
1123   NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 7, 1, AA_EVENT_AMOUNT_6
1124         * AA_EVENT_RATE_3),
1125       "[junk event] flow7 is wrong");
1126   /* Forex deal #2 is paid correctly */
1127
1128   return NS_OK;
1129 }
1130
1131 NS_GENERIC_FACTORY_CONSTRUCTOR(aaStorageTest)
1132
1133 static const nsModuleComponentInfo kComponents[] =
1134 {
1135   {
1136     "Storage Module Unit Test",
1137     AA_STORAGE_TEST_CID,
1138     AA_STORAGE_TEST_CONTRACT_ID,
1139     aaStorageTestConstructor
1140   }
1141 };
1142 NS_IMPL_NSGETMODULE(aabase, kComponents)
1143