storage/account/test/aaAccountTest.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 "nsIGenericFactory.h"
  25 #include "nsComponentManagerUtils.h"
  26 #include "nsArrayUtils.h"
  27 #include "nsStringAPI.h"
  28 #include "nsEmbedString.h"
  29 #include "nsIMutableArray.h"
  30
  31 /* Unfrozen API */
  32 #include "mozIStorageConnection.h"
  33 #include "nsTestUtils.h"
  34 #include "nsITest.h"
  35 #include "nsITestRunner.h"
  36
  37 /* Project includes */
  38 #include "nsStringUtils.h"
  39 #include "aaIResource.h"
  40 #include "aaIEntity.h"
  41 #include "aaIFact.h"
  42 #include "aaIFlow.h"
  43 #include "aaIEvent.h"
  44 #include "aaIQuote.h"
  45 #include "aaITransaction.h"
  46 #include "aaIBalance.h"
  47 #include "aaISession.h"
  48 #include "aaBaseLoaders.h"
  49 #include "aaAccountLoaders.h"
  50 #include "aaIFilter.h"
  51 #include "aaIStateFilter.h"
  52 #include "aaILoadQuery.h"
  53 #include "aaIncomeRow.h"
  54 #include "aaSaveTransaction.h"
  55 /* XXX _acc This is a temporary hack to acquire connection
  56  * It has to be replaced with a 'chart'
  57  */
  58 #include "aaSession.h"
  59 #include "aaTestConsts.h"
  60
  61 #include "aaAccountTestUtils.h"
  62 #include "aaAccountTest.h"
  63
  64 /* nsITest */
  65 NS_IMETHODIMP
  66 aaAccountTest::Test(nsITestRunner *aTestRunner)
  67 {
  68   RAII res(this);
  69   if (NS_FAILED( res.status )) {
  70     aTestRunner->AddError(nsITestRunner::errorJS, \
  71         AA_ACCOUNT_TEST_CONTRACT_ID " not initialized");
  72     return NS_ERROR_NOT_INITIALIZED;
  73   }
  74   testEmptyBalance(aTestRunner);
  75   testPendingFacts(aTestRunner);
  76   testQuote(aTestRunner);
  77   testBalanceRow(aTestRunner);
  78   testTransaction(aTestRunner);
  79   testUpdateTransaction(aTestRunner);
  80   testReplaceTransaction(aTestRunner);
  81   testFlowBalance(aTestRunner);
  82   testStateFilter(aTestRunner);
  83   testCreditTransaction(aTestRunner);
  84   testDeleteTransaction(aTestRunner);
  85   testFlowChart(aTestRunner);
  86   testIncomeRow(aTestRunner);
  87   testLoadIncome(aTestRunner);
  88   testStopTransaction(aTestRunner);
  89   testLossTransaction(aTestRunner);
  90   testSplitTransaction(aTestRunner);
  91   testGainTransaction(aTestRunner);
  92   testDirectGainsLosses(aTestRunner);
  93   return NS_OK;
  94 }
  95
  96 NS_IMPL_ISUPPORTS1(aaAccountTest, nsITest)
  97
  98 /* Helpers */
  99 PRBool
 100 testFact(nsITestRunner *cxxUnitTestRunner, aaIFact *node, PRInt64 fromFlowId,
 101     PRInt64 toFlowId, double sum)
 102 {
 103   nsresult rv;
 104   PRBool equals = PR_TRUE;
 105
 106   nsCOMPtr<aaIFlow> flow;
 107   PRInt64 id;
 108   node->GetTakeFrom(getter_AddRefs( flow ));
 109   if ( flow ) {
 110     flow->GetId( &id );
 111     if (NS_UNLIKELY( id != fromFlowId )) {
 112       equals = PR_FALSE;
 113       NS_TEST_ASSERT_MSG(PR_FALSE, "  'fact.takeFrom.id' is wrong" );
 114     }
 115   } else if (NS_UNLIKELY( fromFlowId != 0 )) {
 116     equals = PR_FALSE;
 117     NS_TEST_ASSERT_MSG(PR_FALSE, "  'fact.takeFrom.id' is wrong" );
 118   }
 119
 120   node->GetGiveTo(getter_AddRefs( flow ));
 121   if ( flow ) {
 122     flow->GetId( &id );
 123     if (NS_UNLIKELY( id != toFlowId )) {
 124       equals = PR_FALSE;
 125       NS_TEST_ASSERT_MSG(PR_FALSE, "  'fact.giveTo.id' is wrong" );
 126     }
 127   } else if (NS_UNLIKELY( toFlowId != 0 )) {
 128     equals = PR_FALSE;
 129     NS_TEST_ASSERT_MSG(PR_FALSE, "  'fact.giveTo.id' is wrong" );
 130   }
 131
 132   double amount, diff;
 133   rv = node->GetAmount(&amount);
 134   diff = amount - sum;
 135   if (diff > 0.0001 || diff < -0.0001) {
 136     equals = PR_FALSE;
 137     NS_TEST_ASSERT_MSG(PR_FALSE, "  'fact.amount' is wrong" );
 138   }
 139
 140   return equals;
 141 }
 142
 143 PRBool
 144 testBalance(nsITestRunner *cxxUnitTestRunner, aaIBalance *node, PRInt64 flowId,
 145     PRInt64 resourceId, double amount, double value, PRBool aSide)
 146 {
 147   nsresult rv;
 148   PRBool equals = PR_TRUE;
 149   if (NS_UNLIKELY( ! node )) {
 150     NS_TEST_ASSERT_MSG(PR_FALSE, "  'balance' is null");
 151     return PR_FALSE;
 152   }
 153   nsCOMPtr<aaIFlow> flow;
 154   rv = node->GetFlow(getter_AddRefs( flow ));
 155   NS_TEST_ASSERT_MSG(flow, "  'balance.flow' is null");
 156   PRInt64 id;
 157   if (NS_LIKELY( flow )) {
 158     flow->GetId(&id);
 159     if (NS_UNLIKELY( id != flowId) ) {
 160       equals = PR_FALSE;
 161       NS_TEST_ASSERT_MSG(PR_FALSE, "  'balance.flow.id' is wrong");
 162     }
 163   } else {
 164     equals = PR_FALSE;
 165   }
 166
 167   nsCOMPtr<aaIResource> resource;
 168   rv = node->GetResource(getter_AddRefs( resource ));
 169   NS_TEST_ASSERT_MSG(resource, "  'balance.resource' is null" );
 170   if (NS_LIKELY( resource )) {
 171     resource->GetId(&id);
 172     if (NS_UNLIKELY( id != resourceId) ) {
 173       nsEmbedCString msg("  'balance.resource.id' is wrong - ");
 174       AppendInt(msg, id);
 175       equals = PR_FALSE;
 176       NS_TEST_ASSERT_MSG(PR_FALSE, msg.get());
 177     }
 178   } else {
 179     equals = PR_FALSE;
 180   }
 181
 182   double sum, diff;
 183   node->GetAmount(&sum);
 184   diff = amount - sum;
 185   if (NS_UNLIKELY(diff > 0.0001 || diff < -0.0001)) {
 186     equals = PR_FALSE;
 187     NS_TEST_ASSERT_MSG(PR_FALSE, "  'balance.amount' is wrong");
 188   }
 189
 190   node->GetValue(&sum);
 191   diff = value - sum;
 192   if (NS_UNLIKELY(diff > 0.0001 || diff < -0.0001)) {
 193     equals = PR_FALSE;
 194     NS_TEST_ASSERT_MSG(PR_FALSE, "  'balance.value' is wrong");
 195   }
 196
 197   PRBool side;
 198   node->GetSide(&side);
 199   if (NS_UNLIKELY( side != aSide)) {
 200     equals = PR_FALSE;
 201     NS_TEST_ASSERT_MSG(PR_FALSE, "  'balance.side' is wrong");
 202   }
 203   return equals;
 204 }
 205
 206 PRBool
 207 testState(nsITestRunner *cxxUnitTestRunner, aaIState *node, PRInt64 flowId,
 208     PRInt64 resourceId, double sum)
 209 {
 210   NS_TEST_ASSERT_MSG(node, " 'state' is null");
 211   nsresult rv;
 212   PRBool equals = PR_TRUE;
 213   nsCOMPtr<aaIFlow> flow;
 214   rv = node->GetFlow(getter_AddRefs( flow ));
 215   NS_TEST_ASSERT_MSG(flow, " 'state.flow' is null");
 216   PRInt64 id;
 217   nsEmbedString tag;
 218   if (NS_LIKELY( flow )) {
 219     flow->GetId(&id);
 220     if (NS_UNLIKELY( id != flowId) ) {
 221       equals = PR_FALSE;
 222       NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.flow.id' is wrong");
 223     }
 224   } else {
 225     equals = PR_FALSE;
 226   }
 227
 228   nsCOMPtr<aaIResource> resource;
 229   rv = node->GetResource(getter_AddRefs( resource ));
 230   NS_TEST_ASSERT_MSG(resource, " 'state.resource' is null" );
 231   if (NS_LIKELY( resource )) {
 232     resource->GetId(&id);
 233     if (NS_UNLIKELY( id != resourceId) ) {
 234       equals = PR_FALSE;
 235       NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.resource.id' is wrong");
 236     }
 237   } else {
 238     equals = PR_FALSE;
 239   }
 240
 241   double amount, diff;
 242   rv = node->GetAmount(&amount);
 243   diff = amount - sum;
 244   if (! isZero(diff)) {
 245     equals = PR_FALSE;
 246     NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.amount' is wrong");
 247   }
 248
 249   return equals;
 250 }
 251
 252 aaAccountTest::RAII::RAII(aaAccountTest *t)
 253   :status(PR_FALSE), test(nsnull)
 254 {
 255   nsresult rv;
 256   nsCOMPtr<aaISession> session(do_CreateInstance(AA_SESSION_CONTRACT_ID, &rv));
 257   if (NS_UNLIKELY( ! session))
 258     return;
 259
 260   nsCOMPtr<aaILoadQuery> flows;
 261   rv = session->CreateQuery(AA_LOADFLOW_CONTRACT_ID, getter_AddRefs( flows ));
 262   if (NS_UNLIKELY( ! flows))
 263     return;
 264   rv = flows->Load();
 265   if (NS_FAILED(rv))
 266     return;
 267
 268   nsCOMPtr<aaILoadQuery> resources;
 269   rv = session->CreateQuery(AA_LOADRESOURCE_CONTRACT_ID,
 270       getter_AddRefs( resources ));
 271   if (NS_UNLIKELY( ! resources))
 272     return;
 273   rv = resources->Load();
 274   if (NS_FAILED(rv))
 275     return;
 276
 277   nsCOMPtr<aaILoadQuery> entities;
 278   rv = session->CreateQuery(AA_LOADENTITY_CONTRACT_ID,
 279       getter_AddRefs( entities ));
 280   if (NS_UNLIKELY( ! entities))
 281     return;
 282   rv = entities->Load();
 283   if (NS_FAILED(rv))
 284     return;
 285
 286   status = PR_TRUE;
 287   test = t;
 288   test->mSession = session;
 289   test->mFlows = flows;
 290   test->mResources = resources;
 291   test->mEntities = entities;
 292 }
 293
 294 aaAccountTest::RAII::~RAII()
 295 {
 296   cleanQuotes();
 297   test->mPendingFact = nsnull;
 298   test->mResources = nsnull;
 299   test->mFlows = nsnull;
 300   test->mEntities = nsnull;
 301   test->mSession = nsnull;
 302   test = nsnull;
 303 }
 304
 305 void
 306 aaAccountTest::RAII::cleanQuotes()
 307 {
 308   if (!test->mSession)
 309     return;
 310   aaSession *session = static_cast<aaSession *>(test->mSession.get());
 311   if (! session)
 312     return;
 313   if (session->mConnection)
 314     session->mConnection->ExecuteSimpleSQL(
 315         nsDependentCString("DELETE FROM quote WHERE 1=1"));
 316 }
 317
 318 /* Private methods */
 319 nsresult
 320 aaAccountTest::testEmptyBalance(nsITestRunner *aTestRunner)
 321 {
 322   nsresult rv;
 323   NS_TEST_BEGIN(aTestRunner);
 324   aaSession *session = static_cast<aaSession *>(mSession.get());
 325   NS_TEST_ASSERT_MSG(session, "[empty balance] 'session' cast" );
 326   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 327
 328   nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
 329         AA_LOADBALANCE_CONTRACT_ID, session->mConnection, &rv));
 330   NS_TEST_ASSERT_MSG(set, "[empty balance] query instance creation" );
 331   NS_ENSURE_TRUE(set, rv);
 332
 333   rv = set->Load();
 334   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[empty balance] loading");
 335   NS_TEST_ASSERT_MSG(set, "[empty balance] result set not loaded" );
 336   NS_ENSURE_TRUE(set, rv);
 337
 338   PRUint32 count;
 339   set->GetLength(&count);
 340   NS_TEST_ASSERT_MSG(count == 0, "[empty balance] wrong flow count");
 341
 342   return NS_OK;
 343 }
 344
 345 nsresult
 346 aaAccountTest::testPendingFacts(nsITestRunner *aTestRunner)
 347 {
 348   nsresult rv;
 349   NS_TEST_BEGIN(aTestRunner);
 350   aaSession *session = static_cast<aaSession *>(mSession.get());
 351   NS_TEST_ASSERT_MSG(session, "[pending facts] 'session' cast" );
 352   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 353
 354   nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
 355         AA_LOADPENDINGFACTS_CONTRACT_ID, session->mConnection, &rv));
 356   NS_TEST_ASSERT_MSG(set, "[pending facts] query instance creation" );
 357   NS_ENSURE_TRUE(set, rv);
 358
 359   rv = set->Load();
 360   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[pending facts] loading");
 361   NS_TEST_ASSERT_MSG(set, "[pending facts] result set not loaded" );
 362   NS_ENSURE_TRUE(set, rv);
 363
 364   PRUint32 count;
 365   set->GetLength(&count);
 366   NS_TEST_ASSERT_MSG(count == 6, "[pending facts] wrong fact count");
 367
 368   mPendingFact = do_QueryElementAt(set, 0, &rv);
 369   NS_TEST_ASSERT_MSG(mPendingFact, "[pending facts] 1st fact not loaded" );
 370
 371   NS_TEST_ASSERT_MSG(testFact(aTestRunner, mPendingFact, 2, 3,
 372         AA_EVENT_AMOUNT_2), "[pending facts] 1st fact is wrong");
 373   return NS_OK;
 374 }
 375
 376 nsresult
 377 aaAccountTest::testQuote(nsITestRunner *aTestRunner)
 378 {
 379   nsresult rv;
 380   NS_TEST_BEGIN(aTestRunner);
 381   nsCOMPtr<aaIQuote> node(do_CreateInstance("@aasii.org/base/quote;1", &rv));
 382   NS_TEST_ASSERT_MSG(node, "[quote] instance not created" );
 383   NS_ENSURE_TRUE(node, rv);
 384
 385   nsCOMPtr<aaIResource> rub = do_QueryElementAt(mResources, 0, &rv);
 386   node->SetResource( rub );
 387
 388   /* Set time to 2007-08-29 */
 389   PRExplodedTime tm = {0,0,0,12,29,7,2007};
 390   node->SetTime(PR_ImplodeTime(&tm));
 391   node->SetRate(1);
 392
 393   rv = mSession->Save( node, nsnull );
 394   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[quote] saving");
 395
 396   aaSession *session = static_cast<aaSession *>(mSession.get());
 397   NS_TEST_ASSERT_MSG(session, "[quote] 'session' cast" );
 398   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 399
 400   nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
 401         AA_LOADQUOTE_CONTRACT_ID, session->mConnection, &rv));
 402   NS_TEST_ASSERT_MSG(set, "[quote] query instance creation" );
 403   NS_ENSURE_TRUE(set, rv);
 404
 405   rv = set->Load();
 406   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[quote] loading");
 407   NS_TEST_ASSERT_MSG(set, "[quote] result set not loaded" );
 408   NS_ENSURE_TRUE(set, rv);
 409
 410   PRUint32 count;
 411   set->GetLength(&count);
 412   NS_TEST_ASSERT_MSG(count == 1, "[quote] wrong quote count");
 413
 414   nsCOMPtr<aaIQuote> quote = do_QueryElementAt(set, 0, &rv);
 415   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[quote] quering 1st quote");
 416   NS_TEST_ASSERT_MSG(quote, "[quote] 1st quote not loaded" );
 417   NS_ENSURE_TRUE(quote, NS_ERROR_FAILURE);
 418
 419   nsCOMPtr<aaIResource> obj;
 420   PRInt64 objId;
 421   PRTime time;
 422   double rate;
 423
 424   quote->GetResource(getter_AddRefs( obj ));
 425   if (NS_LIKELY( obj )) {
 426     obj->GetId( &objId );
 427     NS_TEST_ASSERT_MSG(objId == 1, "[quote] wrong resource id");
 428   } else {
 429     NS_TEST_ASSERT_MSG(obj, "[quote] resource is null");
 430   }
 431   quote->GetTime( &time );
 432   NS_TEST_ASSERT_MSG(time == PR_ImplodeTime(&tm), "[quote] wrong start time");
 433   quote->GetRate( &rate );
 434   NS_TEST_ASSERT_MSG(rate < 1.00009 && rate > 0.99991, "[quote] wrong rate");
 435
 436   return NS_OK;
 437 }
 438
 439 nsresult
 440 aaAccountTest::testBalanceRow(nsITestRunner *aTestRunner)
 441 {
 442   NS_TEST_BEGIN(aTestRunner);
 443   aaFullQuote q1;
 444   aaBalanceRow r1, r2;
 445   PRBool res;
 446
 447   /* Tesing aaBalanceRow.SetSide() */
 448   {
 449     res = r1.SetSide(q1);
 450     NS_TEST_ASSERT_MSG( !res, "[balance row] accepts side with bad type 3");
 451
 452     q1.mType = 0;
 453     res = r1.SetSide(q1);
 454     NS_TEST_ASSERT_MSG( !res, "[balance row] accepts side with bad type 0");
 455
 456     q1.mType = 1;
 457     q1.mRate = 0.5;
 458     res = r2.SetSide(q1);
 459     NS_TEST_ASSERT_MSG( res, "[balance row] side 1 not accepted");
 460     NS_TEST_ASSERT_MSG( r2.mFlowRate == q1.mRate,
 461         "[balance row] wrong flow rate");
 462     NS_TEST_ASSERT_MSG( r2.mFactSide == 0, "[balance row] wrong fact side");
 463     NS_TEST_ASSERT_MSG( r2.mSide == 1, "[balance row] wrong balance side");
 464   }
 465
 466   PRExplodedTime tm1 = {0,0,0,12,28,7,2007};
 467   PRExplodedTime tm2 = {0,0,0,12,29,7,2007};
 468   PRTime t1 = PR_ImplodeTime(&tm1);
 469   PRTime t2 = PR_ImplodeTime(&tm2);
 470   /* Tesing aaBalanceRow.SetFact() */
 471   {
 472     nsresult rv;
 473     nsCOMPtr<aaIFact> fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
 474     NS_ENSURE_TRUE(fact, rv);
 475     nsCOMPtr<aaIFlow> flow1 = do_CreateInstance("@aasii.org/base/flow;1", &rv);
 476     NS_ENSURE_TRUE(flow1, rv);
 477     nsCOMPtr<aaIEvent> event = do_CreateInstance("@aasii.org/base/event;1",
 478         &rv);
 479     NS_ENSURE_TRUE(event, rv);
 480     fact->SetGiveTo(flow1);
 481     fact->SetAmount(2.0);
 482     event->SetTime(t1);
 483     event->SetId(1);
 484     fact->SetEvent(event);
 485     res = r2.SetFact(fact);
 486     NS_TEST_ASSERT_MSG( res, "[balance row] fact not accepted");
 487     NS_TEST_ASSERT_MSG( r2.mAmount == 1, "[balance row] wrong amount");
 488     NS_TEST_ASSERT_MSG( r2.mStart == t1, "[balance row] wrong start time");
 489   }
 490
 491   double histAmnt = 0.0, histVal = 0.0;
 492   /* Testing aaBalanceRow.Merge() - Part 1
 493    * Case of increasing balance (0), same day (0), to-side (0)
 494    * Case code is 000
 495    */
 496   {
 497     r1.mFactSide = 0;
 498     r1.mSide = 1;
 499     r1.mAmount = 2;
 500     r1.mFlowRate = 0.5;
 501     r1.mValue = 4;
 502     r1.mStart = t1;
 503     r1.mPaid = 0;
 504     r1.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW | aaBalanceRow::VALUE;
 505     res = r1.Merge(r2, histAmnt, histVal);
 506     NS_TEST_ASSERT_MSG( res, "[balance row] merge type 000 failed");
 507     NS_TEST_ASSERT_MSG( histAmnt == 0.0,
 508         "[balance row] historical amount is not zero");
 509     NS_TEST_ASSERT_MSG( histVal == 0.0,
 510         "[balance row] historical value is not zero");
 511     NS_TEST_ASSERT_MSG( r2.mStatus & aaBalanceRow::CLEARED,
 512         "[balance row] consumed balance not cleared");
 513     NS_TEST_ASSERT_MSG( r2.mAmount == 0,
 514         "[balance row] consumed amount not cleared");
 515     NS_TEST_ASSERT_MSG( r2.mSink == &r1,
 516         "[balance row] consumed balance has no sink");
 517     NS_TEST_ASSERT_MSG( r1.mStatus & aaBalanceRow::UPDATE,
 518         "[balance row] updated balance has wrong status");
 519     NS_TEST_ASSERT_MSG( r1.mAmount == 3,
 520         "[balance row] updated amount is wrong");
 521     NS_TEST_ASSERT_MSG( r1.mValue == 4,
 522         "[balance row] updated value has changed");
 523
 524     r2.AddValue(2);
 525     NS_TEST_ASSERT_MSG( r1.mValue == 6,
 526         "[balance row] updated value not changed");
 527   }
 528
 529   /* Testing aaBalanceRow.Merge() - Part 2
 530    * Case of decreasing balance (1), different day (1), from-side (1)
 531    * Case code is 111
 532    */
 533   {
 534     histAmnt = 0.0, histVal = 0.0;
 535
 536     r1.mFactSide = 1;
 537     r1.mSide = 1;
 538     r1.mAmount = 3;
 539     r1.mFlowRate = 2;
 540     r1.mValue = 6;
 541     r1.mStart = t1;
 542     r1.mPaid = 0;
 543     r1.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW | aaBalanceRow::VALUE;
 544
 545     r2.mFactSide = 1;
 546     r2.mSide = 0;
 547     r2.mAmount = 4;
 548     r2.mFlowRate = 2;
 549     r2.mValue = 0;
 550     r2.mStart = t2;
 551     r2.mPaid = 0;
 552     r2.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW;
 553     r2.mSink = nsnull;
 554     res = r1.Merge(r2, histAmnt, histVal);
 555     NS_TEST_ASSERT_MSG( res, "[balance row] merge type 111 failed");
 556     NS_TEST_ASSERT_MSG( histAmnt == 2.0,
 557         "[balance row] historical amount is wrong");
 558     NS_TEST_ASSERT_MSG( histVal == 4.0,
 559         "[balance row] historical value is wrong");
 560     NS_TEST_ASSERT_MSG( r1.mStatus & aaBalanceRow::CLEARED,
 561         "[balance row] consumed balance not cleared");
 562     NS_TEST_ASSERT_MSG( r1.mAmount == 3.0,
 563         "[balance row] consumed amount changed");
 564     NS_TEST_ASSERT_MSG( r2.mSink == nsnull,
 565         "[balance row] replacing balance has sink");
 566     NS_TEST_ASSERT_MSG( r2.mAmount == 1.0,
 567         "[balance row] replacing amount is wrong");
 568     NS_TEST_ASSERT_MSG( r2.mValue == 2.0,
 569         "[balance row] replacing value is wrong");
 570   }
 571
 572   /* Testing aaBalanceRow.Merge() - Part 3
 573    * Case of decreasing balance (1), same day (0), to-side (0)
 574    * Case code is 100
 575    */
 576   {
 577     histAmnt = 0.0, histVal = 0.0;
 578
 579     r1.mFactSide = 0;
 580     r1.mSide = 0;
 581     r1.mAmount = 34950.0;
 582     r1.mFlowRate = 1 / 34.95;
 583     r1.mValue = 34950.0;
 584     r1.mStart = t1;
 585     r1.mPaid = 0;
 586     r1.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW | aaBalanceRow::VALUE;
 587
 588     r2.mFactSide = 0;
 589     r2.mSide = 1;
 590     r2.mAmount = 1000.0;
 591     r2.mFlowRate = 1 / 34.95;
 592     r2.mValue = 0;
 593     r2.mStart = t1;
 594     r2.mPaid = 0;
 595     r2.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW;
 596     r2.mSink = nsnull;
 597     res = r1.Merge(r2, histAmnt, histVal);
 598     NS_TEST_ASSERT_MSG( res, "[balance row] merge type 100 failed");
 599     NS_TEST_ASSERT_MSG( isZero( histAmnt - 34950.0),
 600         "[balance row] historical amount is wrong");
 601     NS_TEST_ASSERT_MSG( isZero( histVal - 34950.0),
 602         "[balance row] historical value is wrong");
 603     NS_TEST_ASSERT_MSG( r2.mStatus & aaBalanceRow::CLEARED,
 604         "[balance row] consumed balance not cleared");
 605     NS_TEST_ASSERT_MSG( r2.mAmount == 0,
 606         "[balance row] consumed amount not cleared");
 607     NS_TEST_ASSERT_MSG( r2.mSink == &r1,
 608         "[balance row] consumed balance has no sink");
 609     NS_TEST_ASSERT_MSG( r1.mStatus & aaBalanceRow::UPDATE,
 610         "[balance row] updated balance has wrong status");
 611     NS_TEST_ASSERT_MSG( isZero(r1.mAmount),
 612         "[balance row] updated amount is wrong");
 613     NS_TEST_ASSERT_MSG( isZero(r1.mValue),
 614         "[balance row] updated value wrong");
 615   }
 616
 617   /* Testing aaBalanceRow.Merge() - Part 4
 618    * Case of decreasing balance (1), same day (0), from-side (1), switch(1)
 619    * Case code is 1011
 620    */
 621   {
 622     histAmnt = 0.0, histVal = 0.0;
 623
 624     r1.mFactSide = 1;
 625     r1.mSide = 1;
 626     r1.mAmount = 69900.0;
 627     r1.mFlowRate = 1 / 34.95;
 628     r1.mValue = 69900.0;
 629     r1.mStart = t1;
 630     r1.mPaid = 0;
 631     r1.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW | aaBalanceRow::VALUE;
 632
 633     r2.mFactSide = 1;
 634     r2.mSide = 0;
 635     r2.mFlowRate = 1 / 34.95;
 636     r2.mAmount = (2600.0);
 637     r2.mValue = 0;
 638     r2.mStart = t1;
 639     r2.mPaid = 0;
 640     r2.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW;
 641     r2.mSink = nsnull;
 642     res = r1.Merge(r2, histAmnt, histVal);
 643     NS_TEST_ASSERT_MSG( res, "[balance row] merge type 101 failed");
 644     NS_TEST_ASSERT_MSG( isZero( histAmnt - 69900.0),
 645         "[balance row] historical amount is wrong");
 646     NS_TEST_ASSERT_MSG( isZero( histVal - 69900.0),
 647         "[balance row] historical value is wrong");
 648     NS_TEST_ASSERT_MSG( r2.mStatus & aaBalanceRow::CLEARED,
 649         "[balance row] consumed balance not cleared");
 650     NS_TEST_ASSERT_MSG( r2.mAmount == 0,
 651         "[balance row] consumed amount not cleared");
 652     NS_TEST_ASSERT_MSG( r2.mSink == &r1,
 653         "[balance row] consumed balance has no sink");
 654     NS_TEST_ASSERT_MSG( r1.mStatus & aaBalanceRow::UPDATE,
 655         "[balance row] updated balance has wrong status");
 656     NS_TEST_ASSERT_MSG( isZero(r1.mAmount - 600.0),
 657         "[balance row] updated amount is wrong");
 658     NS_TEST_ASSERT_MSG( isZero(r1.mValue),
 659         "[balance row] updated value wrong");
 660   }
 661
 662   /* Testing aaBalanceRow.Merge() - Part 5
 663    * Case of decreasing balance (1), same day (0), to-side (0), switch(1)
 664    * Case code is 1001
 665    */
 666   {
 667     histAmnt = 0.0, histVal = 0.0;
 668
 669     r1.mFactSide = 0;
 670     r1.mSide = 0;
 671     r1.mAmount = 500.0;
 672     r1.mFlowRate = 34.95;
 673     r1.mValue = 17475.0;
 674     r1.mStart = t1;
 675     r1.mPaid = 0;
 676     r1.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW | aaBalanceRow::VALUE;
 677
 678     r2.mFactSide = 0;
 679     r2.mSide = 1;
 680     r2.mFlowRate = 34.95;
 681     r2.mAmount = (600.0 * r2.mFlowRate);
 682     r2.mValue = 0;
 683     r2.mStart = t1;
 684     r2.mPaid = 0;
 685     r2.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW;
 686     r2.mSink = nsnull;
 687     res = r1.Merge(r2, histAmnt, histVal);
 688     NS_TEST_ASSERT_MSG( res, "[balance row] merge type 1001 failed");
 689     NS_TEST_ASSERT_MSG( isZero( histAmnt - 500.0),
 690         "[balance row] historical amount is wrong");
 691     NS_TEST_ASSERT_MSG( isZero( histVal - 17475.0),
 692         "[balance row] historical value is wrong");
 693     NS_TEST_ASSERT_MSG( r2.mStatus & aaBalanceRow::CLEARED,
 694         "[balance row] consumed balance not cleared");
 695     NS_TEST_ASSERT_MSG( r2.mAmount == 0,
 696         "[balance row] consumed amount not cleared");
 697     NS_TEST_ASSERT_MSG( r2.mSink == &r1,
 698         "[balance row] consumed balance has no sink");
 699     NS_TEST_ASSERT_MSG( r1.mStatus & aaBalanceRow::UPDATE,
 700         "[balance row] updated balance has wrong status");
 701     NS_TEST_ASSERT_MSG( isZero(r1.mAmount - 3495.0),
 702         "[balance row] updated amount is wrong");
 703     NS_TEST_ASSERT_MSG( isZero(r1.mValue),
 704         "[balance row] updated value wrong");
 705   }
 706
 707   /* Testing aaBalanceRow.Merge() - Part 6
 708    * Case of decreasing balance (1), same day (0), from-side (1)
 709    * Case code is 101
 710    */
 711   {
 712     histAmnt = 0.0, histVal = 0.0;
 713
 714     r1.mFactSide = 1;
 715     r1.mSide = 1;
 716     r1.mAmount = 30000.0;
 717     r1.mFlowRate = 1.0/150.0;
 718     r1.mValue = 30000.0;
 719     r1.mStart = t1;
 720     r1.mPaid = 0;
 721     r1.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW | aaBalanceRow::VALUE;
 722
 723     r2.mFactSide = 1;
 724     r2.mSide = 0;
 725     r2.mFlowRate = 1.0/150.0;
 726     r2.mAmount = (20000.0 * r2.mFlowRate);
 727     r2.mValue = 0;
 728     r2.mStart = t1;
 729     r2.mPaid = 0;
 730     r2.mStatus = aaBalanceRow::SIDE | aaBalanceRow::FLOW;
 731     r2.mSink = nsnull;
 732     res = r1.Merge(r2, histAmnt, histVal);
 733     NS_TEST_ASSERT_MSG( res, "[balance row] merge type 101 failed");
 734     NS_TEST_ASSERT_MSG( isZero( histAmnt - 20000.0),
 735         "[balance row] historical amount is wrong");
 736     NS_TEST_ASSERT_MSG( isZero( histVal - 20000.0),
 737         "[balance row] historical value is wrong");
 738     NS_TEST_ASSERT_MSG( r2.mStatus & aaBalanceRow::CLEARED,
 739         "[balance row] consumed balance not cleared");
 740     NS_TEST_ASSERT_MSG( r2.mAmount == 0,
 741         "[balance row] consumed amount not cleared");
 742     NS_TEST_ASSERT_MSG( r2.mSink == &r1,
 743         "[balance row] consumed balance has no sink");
 744     NS_TEST_ASSERT_MSG( r1.mStatus & aaBalanceRow::UPDATE,
 745         "[balance row] updated balance has wrong status");
 746     NS_TEST_ASSERT_MSG( isZero(r1.mAmount - 10000.0),
 747         "[balance row] updated amount is wrong");
 748     NS_TEST_ASSERT_MSG( isZero(r1.mValue - 10000.0),
 749         "[balance row] updated value wrong");
 750   }
 751
 752   /* Testing aaBalanceRow.AddValue() */
 753   {
 754     r1.mStatus = 0;
 755     r1.mSink = nsnull;
 756     r1.AddValue(0);
 757     NS_TEST_ASSERT_MSG(r1.mStatus == 0, "[balance row] Incorrect status");
 758   }
 759
 760   return NS_OK;
 761 }
 762
 763 nsresult
 764 aaAccountTest::testTransaction(nsITestRunner *aTestRunner)
 765 {
 766   nsresult rv;
 767   NS_TEST_BEGIN(aTestRunner);
 768   aaSession *session = static_cast<aaSession *>(mSession.get());
 769   NS_TEST_ASSERT_MSG(session, "[transaction] 'session' cast" );
 770   NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
 771
 772   nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
 773         AA_SAVETRANSACTION_CONTRACT_ID, session->mConnection, &rv));
 774   NS_TEST_ASSERT_MSG(saver, "[transaction] query instance creation" );
 775   NS_ENSURE_TRUE(saver, rv);
 776
 777   nsCOMPtr<aaITransaction> node(do_CreateInstance(
 778         "@aasii.org/base/transaction;1", &rv));
 779   NS_TEST_ASSERT_MSG(node, "[transaction] instance not created" );
 780   NS_ENSURE_TRUE(node, rv);
 781
 782   node->SetFact(mPendingFact);
 783
 784   rv = saver->Save(node, nsnull);
 785   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[transaction] saving" );
 786
 787   nsCOMPtr<aaILoadQuery> set;
 788   rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID, getter_AddRefs( set ));
 789   NS_TEST_ASSERT_MSG(set, "[transaction] result set not created" );
 790   NS_ENSURE_TRUE(set, rv);
 791   rv = set->Load();
 792   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[transaction] result set not loaded" );
 793
 794   PRUint32 count;
 795   set->GetLength(&count);
 796   NS_TEST_ASSERT_MSG(count == 2, "[transaction] wrong flow count");
 797
 798   nsCOMPtr<aaIBalance> balance(do_QueryElementAt(set, 0));
 799   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
 800         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
 801       "[transaction] flow2 is wrong");
 802
 803   balance = do_QueryElementAt(set, 1);
 804   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, AA_EVENT_AMOUNT_2,
 805         AA_EVENT_AMOUNT_2, 1), "[transaction] flow3 is wrong");
 806
 807   rv = mSession->CreateQuery(AA_LOADPENDINGFACTS_CONTRACT_ID,
 808       getter_AddRefs( set ));
 809   NS_TEST_ASSERT_MSG(set, "[transaction] fact set not created" );
 810   NS_ENSURE_TRUE(set, rv);
 811   rv = set->Load();
 812   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[transaction] fact set not loaded" );
 813
 814   set->GetLength(&count);
 815   NS_TEST_ASSERT_MSG(count == AA_TXN_COUNT - 1,
 816       "[transaction] wrong fact count");
 817
 818   mPendingFact = do_QueryElementAt(set, 0, &rv);
 819   NS_TEST_ASSERT_MSG(mPendingFact, "[transaction] pending fact not loaded" );
 820
 821   NS_TEST_ASSERT_MSG(testFact(aTestRunner, mPendingFact, 1, 3,
 822         AA_EVENT_AMOUNT_3), "[transaction] pending fact is wrong");
 823   return NS_OK;
 824 }
 825
 826 nsresult
 827 aaAccountTest::testUpdateTransaction(nsITestRunner *aTestRunner)
 828 {
 829   nsresult rv;
 830   NS_TEST_BEGIN(aTestRunner);
 831
 832   nsCOMPtr<aaITransaction> node(do_CreateInstance(
 833         "@aasii.org/base/transaction;1", &rv));
 834   NS_TEST_ASSERT_MSG(node, "[update txn] instance not created" );
 835   NS_ENSURE_TRUE(node, rv);
 836
 837   node->SetFact(mPendingFact);
 838
 839   rv = mSession->Save(node, nsnull);
 840   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update txn] saving" );
 841
 842   nsCOMPtr<aaILoadQuery> set;
 843   rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID, getter_AddRefs( set ));
 844   NS_TEST_ASSERT_MSG(set, "[update txn] result set not created" );
 845   NS_ENSURE_TRUE(set, rv);
 846   rv = set->Load();
 847   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update txn] result set not loaded" );
 848
 849   PRUint32 count;
 850   set->GetLength(&count);
 851   NS_TEST_ASSERT_MSG(count == 3, "[update txn] wrong flow count");
 852
 853   nsCOMPtr<aaIBalance> balance(do_QueryElementAt(set, 0));
 854   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
 855         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
 856       "[update txn] flow2 is wrong");
 857
 858   balance = do_QueryElementAt(set, 1);
 859   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, AA_EVENT_AMOUNT_2
 860         + AA_EVENT_AMOUNT_3, AA_EVENT_AMOUNT_2 + AA_EVENT_AMOUNT_3, 1),
 861       "[update txn] flow3 is wrong");
 862
 863   balance = do_QueryElementAt(set, 2);
 864   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
 865         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
 866       "[update txn] flow1 is wrong");
 867
 868   rv = mSession->CreateQuery(AA_LOADPENDINGFACTS_CONTRACT_ID,
 869       getter_AddRefs( set ));
 870   NS_TEST_ASSERT_MSG(set, "[update txn] fact set not created" );
 871   NS_ENSURE_TRUE(set, rv);
 872   rv = set->Load();
 873   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update txn] fact set not loaded" );
 874
 875   set->GetLength(&count);
 876   NS_TEST_ASSERT_MSG(count == AA_TXN_COUNT - 2,
 877       "[update txn] wrong fact count");
 878
 879   mPendingFact = do_QueryElementAt(set, 0, &rv);
 880   NS_TEST_ASSERT_MSG(mPendingFact, "[update txn] pending fact not loaded" );
 881
 882   NS_TEST_ASSERT_MSG(testFact(aTestRunner, mPendingFact, 3, 4,
 883         AA_EVENT_AMOUNT_4), "[update txn] pending fact is wrong");
 884   return NS_OK;
 885 }
 886
 887 nsresult
 888 aaAccountTest::testReplaceTransaction(nsITestRunner *aTestRunner)
 889 {
 890   nsresult rv;
 891   NS_TEST_BEGIN(aTestRunner);
 892
 893   nsCOMPtr<aaITransaction> node(do_CreateInstance(
 894         "@aasii.org/base/transaction;1", &rv));
 895   NS_TEST_ASSERT_MSG(node, "[replace txn] instance not created" );
 896   NS_ENSURE_TRUE(node, rv);
 897
 898   node->SetFact(mPendingFact);
 899
 900   rv = mSession->Save(node, nsnull);
 901   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace txn] saving" );
 902
 903   nsCOMPtr<aaILoadQuery> set;
 904   rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID, getter_AddRefs( set ));
 905   NS_TEST_ASSERT_MSG(set, "[replace txn] result set not created" );
 906   NS_ENSURE_TRUE(set, rv);
 907   rv = set->Load();
 908   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace txn] result set not loaded" );
 909
 910   PRUint32 count;
 911   set->GetLength(&count);
 912   NS_TEST_ASSERT_MSG(count == 4, "[replace txn] wrong flow count");
 913
 914   nsCOMPtr<aaIBalance> balance(do_QueryElementAt(set, 0));
 915   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
 916         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
 917       "[replace txn] flow2 is wrong");
 918
 919   balance = do_QueryElementAt(set, 1);
 920   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
 921         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
 922       "[replace txn] flow1 is wrong");
 923
 924   balance = do_QueryElementAt(set, 2);
 925   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, AA_EVENT_AMOUNT_2
 926         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4, AA_EVENT_AMOUNT_2
 927         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4, 1),
 928       "[replace txn] flow3 is wrong");
 929
 930   balance = do_QueryElementAt(set, 3);
 931   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
 932         AA_EVENT_AMOUNT_4, 1), "[replace txn] flow4 is wrong");
 933
 934   rv = mSession->CreateQuery(AA_LOADPENDINGFACTS_CONTRACT_ID,
 935       getter_AddRefs( set ));
 936   NS_TEST_ASSERT_MSG(set, "[replace txn] fact set not created" );
 937   NS_ENSURE_TRUE(set, rv);
 938   rv = set->Load();
 939   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace txn] fact set not loaded" );
 940
 941   set->GetLength(&count);
 942   NS_TEST_ASSERT_MSG(count == AA_TXN_COUNT - 3,
 943       "[replace txn] wrong fact count");
 944
 945   mPendingFact = do_QueryElementAt(set, 0, &rv);
 946   NS_TEST_ASSERT_MSG(mPendingFact, "[transaction] pending fact not loaded" );
 947
 948   NS_TEST_ASSERT_MSG(testFact(aTestRunner, mPendingFact, 5, 6,
 949         AA_EVENT_AMOUNT_6), "[transaction] pending fact is wrong");
 950   return NS_OK;
 951 }
 952
 953 #define AA_FB_FILTER1 " WHERE balance.flow_id=3 AND balance.start =\
 954   (SELECT MAX(start) FROM balance WHERE flow_id=3 AND start <= 2454342)\
 955   AND (balance.paid > 2454342 OR balance.paid IS NULL)"
 956
 957 nsresult
 958 aaAccountTest::testFlowBalance(nsITestRunner *aTestRunner)
 959 {
 960   nsresult rv;
 961   NS_TEST_BEGIN(aTestRunner);
 962
 963   nsCOMPtr<aaILoadQuery> set;
 964   rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID, getter_AddRefs( set ));
 965   NS_TEST_ASSERT_MSG(set, "[flow balance] result set not created" );
 966   NS_ENSURE_TRUE(set, rv);
 967
 968   nsCOMPtr<aaIStringFilter> filter(do_CreateInstance(AA_FILTER_CONTRACT_ID));
 969   filter->SetExpression(NS_LITERAL_CSTRING(AA_FB_FILTER1));
 970   set->SetFilter(filter);
 971   rv = set->Load();
 972   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[flow balance] result set not loaded" );
 973
 974   PRUint32 count;
 975   set->GetLength(&count);
 976   NS_TEST_ASSERT_MSG(count == 1, "[flow balance] wrong count");
 977
 978   nsCOMPtr<aaIBalance> balance(do_QueryElementAt(set, 0));
 979   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, AA_EVENT_AMOUNT_2
 980         + AA_EVENT_AMOUNT_3, AA_EVENT_AMOUNT_2 + AA_EVENT_AMOUNT_3, 1),
 981       "[flow balance] flow3 is wrong");
 982
 983   return NS_OK;
 984 }
 985
 986 nsresult
 987 aaAccountTest::testStateFilter(nsITestRunner *aTestRunner)
 988 {
 989   nsresult rv;
 990   NS_TEST_BEGIN(aTestRunner);
 991
 992   nsCOMPtr<aaILoadQuery> set;
 993   rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID, getter_AddRefs( set ));
 994   NS_TEST_ASSERT_MSG(set, "[state filter] result set not created" );
 995   NS_ENSURE_TRUE(set, rv);
 996
 997   nsCOMPtr<aaIStateFilter> filter =
 998     do_CreateInstance(AA_STATEFILTER_CONTRACT_ID);
 999
1000   nsCOMPtr<aaIFlow> bank = do_QueryElementAt(mFlows, 2);
1001   filter->SetFlow( bank );
1002
1003   /* Set date to 2007-08-29 */
1004   PRExplodedTime tm = {0,0,0,12,29,7,2007};
1005   filter->SetDate(PR_ImplodeTime(&tm));
1006
1007   set->SetFilter(filter);
1008   rv = set->Load();
1009   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[state filter] result set not loaded" );
1010
1011   PRUint32 count;
1012   set->GetLength(&count);
1013   NS_TEST_ASSERT_MSG(count == 1, "[state filter] wrong count");
1014
1015   nsCOMPtr<aaIBalance> balance(do_QueryElementAt(set, 0));
1016   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, AA_EVENT_AMOUNT_2
1017         + AA_EVENT_AMOUNT_3, AA_EVENT_AMOUNT_2 + AA_EVENT_AMOUNT_3, 1),
1018       "[state filter] flow3 is wrong");
1019
1020   return NS_OK;
1021 }
1022
1023 nsresult
1024 aaAccountTest::testCreditTransaction(nsITestRunner *aTestRunner)
1025 {
1026   nsresult rv;
1027   NS_TEST_BEGIN(aTestRunner);
1028
1029   nsCOMPtr<aaITransaction> node(do_CreateInstance(
1030         "@aasii.org/base/transaction;1", &rv));
1031   NS_TEST_ASSERT_MSG(node, "[credit txn] instance not created" );
1032   NS_ENSURE_TRUE(node, rv);
1033
1034   node->SetFact(mPendingFact);
1035
1036   rv = mSession->Save(node, nsnull);
1037   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[credit txn] saving" );
1038
1039   nsCOMPtr<aaILoadQuery> set;
1040   rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID, getter_AddRefs( set ));
1041   NS_TEST_ASSERT_MSG(set, "[credit txn] result set not created" );
1042   NS_ENSURE_TRUE(set, rv);
1043   rv = set->Load();
1044   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[credit txn] result set not loaded" );
1045
1046   PRUint32 count;
1047   set->GetLength(&count);
1048   NS_TEST_ASSERT_MSG(count == 6, "[credit txn] wrong flow count");
1049
1050   nsCOMPtr<aaIBalance> balance(do_QueryElementAt(set, 0));
1051   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
1052         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
1053       "[credit txn] flow2 is wrong");
1054
1055   balance = do_QueryElementAt(set, 1);
1056   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
1057         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
1058       "[credit txn] flow1 is wrong");
1059
1060   balance = do_QueryElementAt(set, 2);
1061   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, AA_EVENT_AMOUNT_2
1062         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4, AA_EVENT_AMOUNT_2
1063         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4, 1),
1064       "[credit txn] flow3 is wrong");
1065
1066   balance = do_QueryElementAt(set, 3);
1067   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
1068         AA_EVENT_AMOUNT_4, 1), "[credit txn] flow4 is wrong");
1069
1070   balance = do_QueryElementAt(set, 4);
1071   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 5, 1, AA_EVENT_AMOUNT_6
1072         * AA_EVENT_RATE_2, AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2, 0),
1073       "[credit txn] flow5 is wrong");
1074
1075   balance = do_QueryElementAt(set, 5);
1076   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4, AA_EVENT_AMOUNT_6,
1077         AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2, 1), "[credit txn] flow6 is wrong");
1078
1079   rv = mSession->CreateQuery(AA_LOADPENDINGFACTS_CONTRACT_ID,
1080       getter_AddRefs( set ));
1081   NS_TEST_ASSERT_MSG(set, "[credit txn] fact set not created" );
1082   NS_ENSURE_TRUE(set, rv);
1083   rv = set->Load();
1084   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[credit txn] fact set not loaded" );
1085
1086   set->GetLength(&count);
1087   NS_TEST_ASSERT_MSG(count == AA_TXN_COUNT - 4,
1088       "[credit txn] wrong fact count");
1089
1090   mPendingFact = do_QueryElementAt(set, 0, &rv);
1091   NS_TEST_ASSERT_MSG(mPendingFact, "[transaction] pending fact not loaded" );
1092
1093   NS_TEST_ASSERT_MSG(testFact(aTestRunner, mPendingFact, 3, 5,
1094         AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
1095       "[transaction] pending fact is wrong");
1096   return NS_OK;
1097 }
1098
1099 nsresult
1100 aaAccountTest::testDeleteTransaction(nsITestRunner *aTestRunner)
1101 {
1102   nsresult rv;
1103   NS_TEST_BEGIN(aTestRunner);
1104
1105   nsCOMPtr<aaITransaction> node(do_CreateInstance(
1106         "@aasii.org/base/transaction;1", &rv));
1107   NS_TEST_ASSERT_MSG(node, "[delete txn] instance not created" );
1108   NS_ENSURE_TRUE(node, rv);
1109
1110   node->SetFact(mPendingFact);
1111
1112   rv = mSession->Save(node, nsnull);
1113   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete txn] saving" );
1114
1115   nsCOMPtr<aaILoadQuery> list;
1116   rv = mSession->CreateQuery(AA_LOADFACTLIST_CONTRACT_ID,
1117       getter_AddRefs( list ));
1118   NS_TEST_ASSERT_MSG(list, "[delete txn] list not created" );
1119   NS_ENSURE_TRUE(list, rv);
1120   nsCOMPtr<aaIStringFilter> filter(do_CreateInstance(AA_FILTER_CONTRACT_ID));
1121   filter->SetExpression(NS_LITERAL_CSTRING(" WHERE transfer._ROWID_=5"));
1122   list->SetFilter(filter);
1123   rv = list->Load();
1124   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete txn] list not loaded" );
1125
1126   PRUint32 count = 0;
1127   rv = list->GetLength(&count);
1128   NS_TEST_ASSERT_OK(rv);
1129   NS_TEST_ASSERT_MSG(count == 1, "[delete txn] wrong fact count");
1130
1131   nsCOMPtr<aaITransaction> txn = do_QueryElementAt(list, 0);
1132   NS_TEST_ASSERT_MSG(txn, "[delete txn] transaction not loaded");
1133   if (NS_LIKELY(txn)) {
1134     NS_TEST_ASSERT_MSG(testFact(aTestRunner, txn->PickFact(), 3, 5,
1135           AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
1136         "[delete txn] new fact is wrong");
1137     NS_TEST_ASSERT_MSG(txn->PickValue() == AA_EVENT_AMOUNT_6
1138         * AA_EVENT_RATE_2, "[delete txn] wrong value stored");
1139   }
1140
1141   nsCOMPtr<aaILoadQuery> set;
1142   rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID, getter_AddRefs( set ));
1143   NS_TEST_ASSERT_MSG(set, "[delete txn] result set not created" );
1144   NS_ENSURE_TRUE(set, rv);
1145   rv = set->Load();
1146   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete txn] result set not loaded" );
1147
1148   count = 0;
1149   set->GetLength(&count);
1150   NS_TEST_ASSERT_MSG(count == 5, "[delete txn] wrong flow count");
1151
1152   nsCOMPtr<aaIBalance> balance(do_QueryElementAt(set, 0));
1153   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
1154         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
1155       "[delete txn] flow2 is wrong");
1156
1157   balance = do_QueryElementAt(set, 1);
1158   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
1159         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
1160       "[delete txn] flow1 is wrong");
1161
1162   balance = do_QueryElementAt(set, 2);
1163   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, AA_EVENT_AMOUNT_2
1164         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1165         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2, AA_EVENT_AMOUNT_2
1166         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1167         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2, 1),
1168       "[delete txn] flow3 is wrong");
1169
1170   balance = do_QueryElementAt(set, 3);
1171   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
1172         AA_EVENT_AMOUNT_4, 1), "[delete txn] flow4 is wrong");
1173
1174   balance = do_QueryElementAt(set, 4);
1175   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4, AA_EVENT_AMOUNT_6,
1176         AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2, 1), "[delete txn] flow6 is wrong");
1177
1178   rv = mSession->CreateQuery(AA_LOADPENDINGFACTS_CONTRACT_ID,
1179       getter_AddRefs( set ));
1180   NS_TEST_ASSERT_MSG(set, "[delete txn] fact set not created" );
1181   NS_ENSURE_TRUE(set, rv);
1182   rv = set->Load();
1183   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete txn] fact set not loaded" );
1184
1185   set->GetLength(&count);
1186   NS_TEST_ASSERT_MSG(count == AA_TXN_COUNT - 5,
1187       "[delete txn] wrong fact count");
1188
1189   mPendingFact = do_QueryElementAt(set, 0, &rv);
1190   NS_TEST_ASSERT_MSG(mPendingFact, "[delete txn] pending fact not loaded" );
1191
1192   NS_TEST_ASSERT_MSG(testFact(aTestRunner, mPendingFact, 6, 7,
1193         AA_EVENT_AMOUNT_6),
1194       "[transaction] pending fact is wrong");
1195   return NS_OK;
1196 }
1197
1198 nsresult
1199 aaAccountTest::testFlowChart(nsITestRunner *aTestRunner)
1200 {
1201   nsresult rv;
1202   NS_TEST_BEGIN(aTestRunner);
1203
1204   nsCOMPtr<aaILoadQuery> list;
1205   rv = mSession->CreateQuery(AA_LOADFLOWCHART_CONTRACT_ID,
1206       getter_AddRefs( list ));
1207   NS_TEST_ASSERT_MSG(list, "[flow chart] list not created" );
1208   NS_ENSURE_TRUE(list, rv);
1209   rv = list->Load();
1210   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[flow chart] list not loaded" );
1211
1212   PRUint32 count = 0;
1213   rv = list->GetLength(&count);
1214   NS_TEST_ASSERT_OK(rv);
1215
1216   nsCOMPtr<aaIFlow> flow = do_QueryElementAt(list, count - 1, &rv);
1217   NS_TEST_ASSERT_MSG(flow, "[flow chart] tested flow not loaded");
1218   NS_ENSURE_TRUE(flow, rv);
1219
1220   nsEmbedString wstr;
1221   rv = flow->GetTag(wstr);
1222   NS_TEST_ASSERT_OK(rv);
1223   NS_TEST_ASSERT_MSG(wstr.Equals(NS_LITERAL_STRING("profit and loss")),
1224       "[flow chart] wrong flow tag");
1225   return NS_OK;
1226 }
1227
1228 nsresult
1229 aaAccountTest::testIncomeRow(nsITestRunner *aTestRunner)
1230 {
1231   NS_TEST_BEGIN(aTestRunner);
1232   aaIncomeRow income;
1233   NS_TEST_ASSERT_MSG(income.mStatus == 0, "[income row] wrong initial status");
1234
1235   PRBool res = income.Update(1, 1.0);
1236   NS_TEST_ASSERT_MSG(res, "[income row] updating a new object");
1237   NS_TEST_ASSERT_MSG(income.mStatus == aaIncomeRow::NEW,
1238       "[income row] wrong status of a new object");
1239   NS_TEST_ASSERT_MSG(income.mValue == 1.0,
1240       "[income row] wrong value stored to a new object");
1241   NS_TEST_ASSERT_MSG(income.mSide == 0,
1242       "[income row] wrong side in a new object");
1243
1244   income.mStatus = aaIncomeRow::LOADED;
1245   income.mStart = 2;
1246   res = income.Update(1, 2.0);
1247   NS_TEST_ASSERT_MSG(!res, "[income row] new object accepting bad input");
1248   NS_TEST_ASSERT_MSG(income.mStatus == aaIncomeRow::BROKEN,
1249       "[income row] wrong status of a new object");
1250   NS_TEST_ASSERT_MSG(income.mValue == 1.0,
1251       "[income row] wrong value stored to a new object");
1252
1253   income.mStatus = aaIncomeRow::LOADED;
1254   income.mStart = 2;
1255   res = income.Update(2, 2.0);
1256   NS_TEST_ASSERT_MSG(res, "[income row] updating a loaded object");
1257   NS_TEST_ASSERT_MSG(income.mStatus == aaIncomeRow::UPDATE,
1258       "[income row] wrong status of an updated object");
1259   NS_TEST_ASSERT_MSG(income.mValue == 3.0,
1260       "[income row] wrong value stored to an updated object");
1261   NS_TEST_ASSERT_MSG(income.mSide == 0,
1262       "[income row] wrong side in a updated object");
1263
1264   income.mStatus = aaIncomeRow::LOADED;
1265   income.mStart = 2;
1266   res = income.Update(2, -4.0);
1267   NS_TEST_ASSERT_MSG(res, "[income row] reverting a loaded object");
1268   NS_TEST_ASSERT_MSG(income.mStatus == aaIncomeRow::UPDATE,
1269       "[income row] wrong status of an reverted object");
1270   NS_TEST_ASSERT_MSG(income.mValue == 1.0,
1271       "[income row] wrong value stored to an reverted object");
1272   NS_TEST_ASSERT_MSG(income.mSide == 1,
1273       "[income row] wrong side in a reverted object");
1274
1275   income.mStatus = aaIncomeRow::LOADED;
1276   res = income.Update(3, 4.0);
1277   NS_TEST_ASSERT_MSG(res, "[income row] replacing a loaded object");
1278   NS_TEST_ASSERT_MSG(income.mStatus == aaIncomeRow::REPLACE,
1279       "[income row] wrong status of an replacing object");
1280   NS_TEST_ASSERT_MSG(income.mValue == 3.0,
1281       "[income row] wrong value stored to an replacing object");
1282   NS_TEST_ASSERT_MSG(income.mSide == 0,
1283       "[income row] wrong side in a replacing object");
1284   NS_TEST_ASSERT_MSG(income.mStart == 3,
1285       "[income row] wrong start of a replacing object");
1286   NS_TEST_ASSERT_MSG(income.mPaid == 2,
1287       "[income row] wrong end of a replaced object");
1288   return NS_OK;
1289 }
1290
1291 nsresult
1292 aaAccountTest::testLoadIncome(nsITestRunner *aTestRunner)
1293 {
1294   nsresult rv;
1295   NS_TEST_BEGIN(aTestRunner);
1296
1297   nsCOMPtr<aaILoadQuery> loader;
1298   rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
1299       getter_AddRefs( loader ));
1300   NS_TEST_ASSERT_MSG(loader, "[load income] loader not created" );
1301   NS_ENSURE_TRUE(loader, rv);
1302   rv = loader->Load();
1303   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[load income] loader not loaded" );
1304
1305   PRUint32 count = 0;
1306   rv = loader->GetLength(&count);
1307   NS_TEST_ASSERT_OK(rv);
1308   NS_TEST_ASSERT_MSG(count == 0, "[load income] wrong line count");
1309
1310   return NS_OK;
1311 }
1312
1313 nsresult
1314 aaAccountTest::testStopTransaction(nsITestRunner *aTestRunner)
1315 {
1316   nsresult rv;
1317   NS_TEST_BEGIN(aTestRunner);
1318
1319   nsCOMPtr<aaITransaction> node(do_CreateInstance(
1320         "@aasii.org/base/transaction;1", &rv));
1321   NS_TEST_ASSERT_MSG(node, "[stop txn] instance not created" );
1322   NS_ENSURE_TRUE(node, rv);
1323
1324   node->SetFact(mPendingFact);
1325
1326   rv = mSession->Save(node, nsnull);
1327   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop txn] saving" );
1328
1329   nsCOMPtr<aaILoadQuery> list;
1330   rv = mSession->CreateQuery(AA_LOADFACTLIST_CONTRACT_ID,
1331       getter_AddRefs( list ));
1332   NS_TEST_ASSERT_MSG(list, "[stop txn] list not created" );
1333   NS_ENSURE_TRUE(list, rv);
1334
1335   nsCOMPtr<aaIStringFilter> filter(do_CreateInstance(AA_FILTER_CONTRACT_ID));
1336   filter->SetExpression(NS_LITERAL_CSTRING(" WHERE transfer._ROWID_=6"));
1337   list->SetFilter(filter);
1338   rv = list->Load();
1339   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop txn] list not loaded" );
1340
1341   PRUint32 count = 0;
1342   rv = list->GetLength(&count);
1343   NS_TEST_ASSERT_OK(rv);
1344   NS_TEST_ASSERT_MSG(count == 1, "[stop txn] wrong fact count");
1345
1346   nsCOMPtr<aaITransaction> txn = do_QueryElementAt(list, 0);
1347   NS_TEST_ASSERT_MSG(txn, "[stop txn] transaction not loaded");
1348   if (NS_LIKELY(txn)) {
1349     NS_TEST_ASSERT_MSG(testFact(aTestRunner, txn->PickFact(), 6, 7,
1350           AA_EVENT_AMOUNT_6),
1351         "[stop txn] new fact is wrong");
1352     NS_TEST_ASSERT_MSG(txn->PickValue() == AA_EVENT_AMOUNT_6
1353         * AA_EVENT_RATE_2, "[stop txn] wrong value stored");
1354     NS_TEST_ASSERT_MSG(txn->PickHasEarnings(),
1355         "[stop txn] wrong earnings status");
1356     NS_TEST_ASSERT_MSG(isZero(txn->PickEarnings() - AA_EVENT_AMOUNT_6
1357         * (AA_EVENT_RATE_3 - AA_EVENT_RATE_2)),
1358         "[stop txn] wrong earnings stored");
1359   }
1360
1361   nsCOMPtr<aaILoadQuery> set;
1362   rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID, getter_AddRefs( set ));
1363   NS_TEST_ASSERT_MSG(set, "[stop txn] result set not created" );
1364   NS_ENSURE_TRUE(set, rv);
1365   rv = set->Load();
1366   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop txn] result set not loaded" );
1367
1368   count = 0;
1369   set->GetLength(&count);
1370   NS_TEST_ASSERT_MSG(count == 5, "[stop txn] wrong flow count");
1371
1372   nsCOMPtr<aaIBalance> balance(do_QueryElementAt(set, 0));
1373   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
1374         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
1375       "[stop txn] flow2 is wrong");
1376
1377   balance = do_QueryElementAt(set, 1);
1378   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
1379         / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
1380       "[stop txn] flow1 is wrong");
1381
1382   balance = do_QueryElementAt(set, 2);
1383   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, AA_EVENT_AMOUNT_2
1384         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1385         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2, AA_EVENT_AMOUNT_2
1386         + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1387         - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2, 1),
1388       "[stop txn] flow3 is wrong");
1389
1390   balance = do_QueryElementAt(set, 3);
1391   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
1392         AA_EVENT_AMOUNT_4, 1), "[stop txn] flow4 is wrong");
1393
1394   balance = do_QueryElementAt(set, 4);
1395   NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 7, 1, AA_EVENT_AMOUNT_6
1396         * AA_EVENT_RATE_3, AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_3, 1),
1397       "[stop txn] flow7 is wrong");
1398
1399   nsCOMPtr<aaILoadQuery> incomeSet;
1400   rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
1401       getter_AddRefs( incomeSet ));
1402   NS_TEST_ASSERT_MSG(incomeSet, "[stop txn] income set not created" );
1403   NS_ENSURE_TRUE(incomeSet, rv);
1404   rv = incomeSet->Load();
1405   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop txn] income set not loaded" );
1406
1407   count = 0;
1408   incomeSet->GetLength(&count);
1409   NS_TEST_ASSERT_MSG(count == 1, "[stop txn] wrong income count");
1410
1411   mProfit = 0.0;
1412   balance = do_QueryElementAt(incomeSet, 0);
1413   NS_TEST_ASSERT_MSG(balance, "[stop txn] income not loaded" );
1414   if (NS_LIKELY(balance)) {
1415     mProfit = AA_EVENT_AMOUNT_6 * (AA_EVENT_RATE_3 - AA_EVENT_RATE_2);
1416     NS_TEST_ASSERT_MSG(isZero(balance->PickValue() - mProfit),
1417       "[stop txn] wrong income saved");
1418   }
1419
1420   rv = mSession->CreateQuery(AA_LOADPENDINGFACTS_CONTRACT_ID,
1421       getter_AddRefs( set ));
1422   NS_TEST_ASSERT_MSG(set, "[stop txn] fact set not created" );
1423   NS_ENSURE_TRUE(set, rv);
1424   rv = set->Load();
1425   NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop txn] fact set not loaded" );
1426
1427   set->GetLength(&count);
1428   NS_TEST_ASSERT_MSG(count == AA_TXN_COUNT - 6,
1429       "[stop txn] wrong fact count");
1430
1431   return NS_OK;
1432 }
1433
1434 nsresult
1435 aaAccountTest::testLossTransaction(nsITestRunner *aTestRunner)
1436 {
1437   nsresult rv;
1438   NS_TEST_BEGIN(aTestRunner);
1439   nsCOMPtr<aaIEntity> bank = do_QueryElementAt(mEntities, 3, &rv);
1440   NS_ENSURE_TRUE(bank, rv);
1441
1442   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResources, 0, &rv));
1443   nsCOMPtr<aaIResource> eur(do_QueryElementAt(mResources, 3, &rv));
1444
1445   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlows,2));
1446   nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlows,5));
1447
1448   nsCOMPtr<aaIFlow> forex(do_QueryElementAt(mFlows, 6));
1449   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1", &rv));
1450   nsCOMPtr<aaIEvent> event(do_CreateInstance("@aasii.org/base/event;1"));
1451   nsCOMPtr<aaITransaction> txn(do_CreateInstance(
1452         "@aasii.org/base/transaction;1", &rv));
1453
1454   PRUint32 count = 0;
1455   PRInt64 id = 0;
1456   nsCOMPtr<aaILoadQuery> set;
1457   nsCOMPtr<aaIBalance> balance;
1458   /* Settle forex deal #2 */
1459   {
1460     /* Set time to 2007-09-03 */
1461     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
1462     PRExplodedTime tm = {0,0,0,12,3,8,2007};
1463     event->SetTime(PR_ImplodeTime(&tm));
1464
1465     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
1466     NS_ENSURE_TRUE(block, rv);
1467
1468     /* Fact 7 */
1469     NS_ENSURE_TRUE(fact, rv);
1470     fact->SetAmount(AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_3);
1471     fact->SetTakeFrom(forex);
1472     fact->SetGiveTo(bankAccRub);
1473
1474     rv = block->AppendElement(fact, PR_FALSE);
1475     NS_TEST_ASSERT_OK(rv);
1476
1477     rv = mSession->Save(event, nsnull);
1478     NS_TEST_ASSERT_OK(rv);
1479
1480     NS_ENSURE_TRUE(txn, rv);
1481     txn->SetFact(fact);
1482
1483     rv = mSession->Save(txn, nsnull);
1484     NS_TEST_ASSERT_OK(rv);
1485
1486     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
1487         getter_AddRefs(set));
1488     NS_TEST_ASSERT_OK(rv);
1489     NS_ENSURE_TRUE(set, rv);
1490     rv = set->Load();
1491     NS_TEST_ASSERT_OK(rv);
1492
1493     set->GetLength(&count);
1494     NS_TEST_ASSERT_MSG(count == 4, "[loss txn] [fact 7] wrong flow count");
1495
1496     balance = do_QueryElementAt(set, 0);
1497     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
1498           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
1499         "[loss txn] [fact 7] flow2 is wrong");
1500
1501     balance = do_QueryElementAt(set, 1);
1502     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
1503           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
1504         "[loss txn] [fact 7] flow1 is wrong");
1505
1506     balance = do_QueryElementAt(set, 2);
1507     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
1508           AA_EVENT_AMOUNT_4, 1), "[loss txn] [fact 7] flow4 is wrong");
1509
1510     mRubs = AA_EVENT_AMOUNT_2 + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1511       + AA_EVENT_AMOUNT_6 * (AA_EVENT_RATE_3 - AA_EVENT_RATE_2);
1512     balance = do_QueryElementAt(set, 3);
1513     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
1514           1), "[loss txn] [fact 7] flow3 is wrong");
1515   }
1516
1517   /* Create flow for forex deal #3 */
1518   {
1519     forex = do_CreateInstance("@aasii.org/base/flow;1");
1520     NS_ENSURE_TRUE(forex, NS_ERROR_FAILURE);
1521     forex->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_10));
1522     forex->SetEntity(bank);
1523     forex->SetGiveResource(rub);
1524     forex->SetTakeResource(eur);
1525     forex->SetRate(1 / AA_EVENT_RATE_4);
1526     forex->SetLimit(AA_EVENT_AMOUNT_7);
1527     rv = mSession->Save(forex, nsnull);
1528     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[loss event] [deal 3] saving flow");
1529     NS_ENSURE_SUCCESS(rv, rv);
1530
1531     forex->GetId( &id );
1532     NS_TEST_ASSERT_MSG(id == 8, "[loss event] [deal 3] unexpected 'flow.id'");
1533     NS_ENSURE_TRUE(id == 8, NS_ERROR_UNEXPECTED);
1534   }
1535
1536   /* Pay forex deal #3 */
1537   {
1538     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
1539     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
1540     /* Set time to 2007-09-03 */
1541     PRExplodedTime tm = {0,0,0,12,3,8,2007};
1542     event->SetTime(PR_ImplodeTime(&tm));
1543
1544     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
1545     NS_ENSURE_TRUE(block, rv);
1546
1547     /* Fact 8 */
1548     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
1549     NS_ENSURE_TRUE(fact, rv);
1550     fact->SetAmount(AA_EVENT_AMOUNT_7 * AA_EVENT_RATE_4);
1551     fact->SetTakeFrom(bankAccRub);
1552     fact->SetGiveTo(forex);
1553
1554     rv = block->AppendElement(fact, PR_FALSE);
1555     NS_TEST_ASSERT_OK(rv);
1556
1557     rv = mSession->Save(event, nsnull);
1558     NS_TEST_ASSERT_OK(rv);
1559
1560     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
1561     NS_ENSURE_TRUE(txn, rv);
1562     txn->SetFact(fact);
1563
1564     rv = mSession->Save(txn, nsnull);
1565     NS_TEST_ASSERT_OK(rv);
1566
1567     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
1568         getter_AddRefs(set));
1569     NS_TEST_ASSERT_OK(rv);
1570     NS_ENSURE_TRUE(set, rv);
1571     rv = set->Load();
1572     NS_TEST_ASSERT_OK(rv);
1573
1574     set->GetLength(&count);
1575     NS_TEST_ASSERT_MSG(count == 5, "[loss txn] [fact 8] wrong flow count");
1576
1577     balance = do_QueryElementAt(set, 0);
1578     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
1579           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
1580         "[loss txn] [fact 8] flow2 is wrong");
1581
1582     balance = do_QueryElementAt(set, 1);
1583     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
1584           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
1585         "[loss txn] [fact 8] flow1 is wrong");
1586
1587     balance = do_QueryElementAt(set, 2);
1588     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
1589           AA_EVENT_AMOUNT_4, 1), "[loss txn] [fact 8] flow4 is wrong");
1590
1591     mRubs -= AA_EVENT_AMOUNT_7 * AA_EVENT_RATE_4;
1592     balance = do_QueryElementAt(set, 3);
1593     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
1594           1), "[loss txn] [fact 8] flow3 is wrong");
1595
1596     balance = do_QueryElementAt(set, 4);
1597     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 8, 4,
1598           AA_EVENT_AMOUNT_7, AA_EVENT_AMOUNT_7 * AA_EVENT_RATE_4, 1),
1599         "[loss txn] [fact 8] flow8 is wrong");
1600   }
1601
1602   /* Recieve settlement from forex deal #3 */
1603   {
1604     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
1605     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
1606     /* Set time to 2007-09-04 */
1607     PRExplodedTime tm = {0,0,0,12,4,8,2007};
1608     event->SetTime(PR_ImplodeTime(&tm));
1609
1610     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
1611     NS_ENSURE_TRUE(block, rv);
1612
1613     /* Fact 9 */
1614     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
1615     NS_ENSURE_TRUE(fact, rv);
1616     fact->SetAmount(AA_EVENT_AMOUNT_7);
1617     fact->SetTakeFrom(forex);
1618     fact->SetGiveTo(bankAccEur);
1619
1620     rv = block->AppendElement(fact, PR_FALSE);
1621     NS_TEST_ASSERT_OK(rv);
1622
1623     rv = mSession->Save(event, nsnull);
1624     NS_TEST_ASSERT_OK(rv);
1625
1626     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
1627     NS_ENSURE_TRUE(txn, rv);
1628     txn->SetFact(fact);
1629
1630     rv = mSession->Save(txn, nsnull);
1631     NS_TEST_ASSERT_OK(rv);
1632
1633     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
1634         getter_AddRefs(set));
1635     NS_TEST_ASSERT_OK(rv);
1636     NS_ENSURE_TRUE(set, rv);
1637     rv = set->Load();
1638     NS_TEST_ASSERT_OK(rv);
1639
1640     set->GetLength(&count);
1641     NS_TEST_ASSERT_MSG(count == 5, "[loss txn] [fact 9] wrong flow count");
1642
1643     balance = do_QueryElementAt(set, 0);
1644     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
1645           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
1646         "[loss txn] [fact 9] flow2 is wrong");
1647
1648     balance = do_QueryElementAt(set, 1);
1649     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
1650           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
1651         "[loss txn] [fact 9] flow1 is wrong");
1652
1653     balance = do_QueryElementAt(set, 2);
1654     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
1655           AA_EVENT_AMOUNT_4, 1), "[loss txn] [fact 9] flow4 is wrong");
1656
1657     balance = do_QueryElementAt(set, 3);
1658     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
1659           1), "[loss txn] [fact 9] flow3 is wrong");
1660
1661     balance = do_QueryElementAt(set, 4);
1662     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
1663           AA_EVENT_AMOUNT_7, AA_EVENT_AMOUNT_7 * AA_EVENT_RATE_4, 1),
1664         "[loss txn] [fact 9] flow8 is wrong");
1665   }
1666
1667   nsCOMPtr<aaIFlow> office = do_CreateInstance("@aasii.org/base/flow;1");
1668   nsCOMPtr<aaIEntity> landlord = do_CreateInstance("@aasii.org/base/entity;1");
1669   nsCOMPtr<aaIResource> rent = do_CreateInstance("@aasii.org/base/resource;1");
1670   /* Create flow for office rent */
1671   {
1672     NS_ENSURE_TRUE(office, NS_ERROR_FAILURE);
1673     NS_ENSURE_TRUE(landlord, NS_ERROR_FAILURE);
1674     NS_ENSURE_TRUE(rent, NS_ERROR_FAILURE);
1675     landlord->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_6));
1676     rv = mSession->Save(landlord, nsnull);
1677     NS_TEST_ASSERT_OK(rv);
1678     NS_ENSURE_SUCCESS(rv, rv);
1679
1680     rent->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_5));
1681     rv = mSession->Save(rent, nsnull);
1682     NS_TEST_ASSERT_OK(rv);
1683     NS_ENSURE_SUCCESS(rv, rv);
1684
1685     office->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_11));
1686     office->SetEntity(landlord);
1687     office->SetGiveResource(rub);
1688     office->SetTakeResource(rent);
1689     office->SetRate(1 / AA_EVENT_RATE_6);
1690     office->SetLimit(12);
1691     rv = mSession->Save(office, nsnull);
1692     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[loss event] [office] saving flow");
1693     NS_ENSURE_SUCCESS(rv, rv);
1694
1695     office->GetId( &id );
1696     NS_TEST_ASSERT_MSG(id == 9, "[loss event] [office] unexpected 'flow.id'");
1697     NS_ENSURE_TRUE(id == 9, NS_ERROR_UNEXPECTED);
1698   }
1699
1700   nsCOMPtr<aaIFlow> finres = do_CreateInstance("@aasii.org/base/income-flow;1");
1701   nsCOMPtr<aaIState> state;
1702   /* Accrue office rent for august */
1703   {
1704     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
1705     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
1706     /* Set time to 2007-08-31 */
1707     PRExplodedTime tm = {0,0,0,12,31,7,2007};
1708     event->SetTime(PR_ImplodeTime(&tm));
1709
1710     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
1711     NS_ENSURE_TRUE(block, rv);
1712
1713     /* Fact 10 */
1714     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
1715     NS_ENSURE_TRUE(fact, rv);
1716     fact->SetAmount(1);
1717     fact->SetTakeFrom(office);
1718     fact->SetGiveTo(finres);
1719
1720     rv = block->AppendElement(fact, PR_FALSE);
1721     NS_TEST_ASSERT_OK(rv);
1722
1723     rv = mSession->Save(event, nsnull);
1724     NS_TEST_ASSERT_OK(rv);
1725
1726     mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs(set));
1727     NS_TEST_ASSERT_OK(rv);
1728     NS_ENSURE_SUCCESS(rv, rv);
1729
1730     rv = set->Load();
1731     NS_TEST_ASSERT_OK(rv);
1732
1733     set->GetLength(&count);
1734     NS_TEST_ASSERT_MSG(count == 6, "[loss event] wrong flow count");
1735
1736     state = do_QueryElementAt(set, 3, &rv);
1737     NS_TEST_ASSERT_MSG(state, "[loss event] 3nd item not read" );
1738     NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1739
1740     NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, mRubs),
1741         "[loss event] flow3 is wrong");
1742
1743     state = do_QueryElementAt(set, 5, &rv);
1744     NS_TEST_ASSERT_MSG(state, "[loss event] 5th item not read" );
1745     NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1746
1747     NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 9, 1, AA_EVENT_RATE_6),
1748         "[loss event] flow7 is wrong");
1749   }
1750
1751   /* Reflect office rent for august */
1752   {
1753     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
1754     NS_ENSURE_TRUE(txn, rv);
1755     txn->SetFact(fact);
1756
1757     rv = mSession->Save(txn, nsnull);
1758     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[loss txn] not saved");
1759
1760     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
1761         getter_AddRefs(set));
1762     NS_TEST_ASSERT_OK(rv);
1763     NS_ENSURE_TRUE(set, rv);
1764     rv = set->Load();
1765     NS_TEST_ASSERT_OK(rv);
1766
1767     set->GetLength(&count);
1768     NS_TEST_ASSERT_MSG(count == 6, "[loss txn] wrong flow count");
1769
1770     balance = do_QueryElementAt(set, 0);
1771     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
1772           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
1773         "[loss txn] flow2 is wrong");
1774
1775     balance = do_QueryElementAt(set, 1);
1776     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
1777           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
1778         "[loss txn] flow1 is wrong");
1779
1780     balance = do_QueryElementAt(set, 2);
1781     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
1782           AA_EVENT_AMOUNT_4, 1), "[loss txn] flow4 is wrong");
1783
1784     balance = do_QueryElementAt(set, 3);
1785     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
1786           1), "[loss txn] flow3 is wrong");
1787
1788     balance = do_QueryElementAt(set, 4);
1789     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
1790           AA_EVENT_AMOUNT_7, AA_EVENT_AMOUNT_7 * AA_EVENT_RATE_4, 1),
1791         "[loss txn] flow8 is wrong");
1792
1793     balance = do_QueryElementAt(set, 5);
1794     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 1,
1795           AA_EVENT_RATE_6, AA_EVENT_RATE_6, 0),
1796         "[loss txn] flow9 is wrong");
1797
1798     nsCOMPtr<aaILoadQuery> incomeSet;
1799     rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
1800         getter_AddRefs( incomeSet ));
1801     NS_TEST_ASSERT_MSG(incomeSet, "[loss txn] income set not created" );
1802     NS_ENSURE_TRUE(incomeSet, rv);
1803     rv = incomeSet->Load();
1804     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[loss txn] income set not loaded" );
1805
1806     count = 0;
1807     incomeSet->GetLength(&count);
1808     NS_TEST_ASSERT_MSG(count == 1, "[loss txn] wrong income count");
1809
1810     balance = do_QueryElementAt(incomeSet, 0);
1811     NS_TEST_ASSERT_MSG(balance, "[loss txn] income not loaded" );
1812     if (NS_LIKELY(balance)) {
1813       mProfit -= AA_EVENT_RATE_6;
1814       NS_TEST_ASSERT_MSG(isZero(balance->PickValue() + mProfit),
1815           "[loss txn] wrong income saved");
1816     }
1817   }
1818
1819   return NS_OK;
1820 }
1821
1822 nsresult
1823 aaAccountTest::testSplitTransaction(nsITestRunner *aTestRunner)
1824 {
1825   nsresult rv;
1826   NS_TEST_BEGIN(aTestRunner);
1827   nsCOMPtr<aaIEntity> bank = do_QueryElementAt(mEntities, 3, &rv);
1828   NS_ENSURE_TRUE(bank, rv);
1829
1830   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResources, 0, &rv));
1831   nsCOMPtr<aaIResource> eur(do_QueryElementAt(mResources, 3, &rv));
1832
1833   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlows,2));
1834   nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlows,5));
1835
1836   nsCOMPtr<aaIFlow> forex;
1837   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1", &rv));
1838   nsCOMPtr<aaIEvent> event(do_CreateInstance("@aasii.org/base/event;1"));
1839   nsCOMPtr<aaITransaction> txn(do_CreateInstance(
1840         "@aasii.org/base/transaction;1", &rv));
1841
1842   PRUint32 count = 0;
1843   PRInt64 id = 0;
1844   nsCOMPtr<aaILoadQuery> set;
1845   nsCOMPtr<aaIBalance> balance;
1846   /* Create flow for forex deal #4 */
1847   {
1848     forex = do_CreateInstance("@aasii.org/base/flow;1");
1849     NS_ENSURE_TRUE(forex, NS_ERROR_FAILURE);
1850     forex->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_12));
1851     forex->SetEntity(bank);
1852     forex->SetGiveResource(eur);
1853     forex->SetTakeResource(rub);
1854     forex->SetRate(AA_EVENT_RATE_5);
1855     forex->SetLimit(AA_EVENT_AMOUNT_8);
1856     rv = mSession->Save(forex, nsnull);
1857     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[split event] [deal 4] saving flow");
1858     NS_ENSURE_SUCCESS(rv, rv);
1859
1860     forex->GetId( &id );
1861     NS_TEST_ASSERT_MSG(id == 10, "[split event] [deal 4] unexpected 'flow.id'");
1862     NS_ENSURE_TRUE(id == 10, NS_ERROR_UNEXPECTED);
1863   }
1864
1865   nsCOMPtr<aaIState> state;
1866   /* Partially pay forex deal #4 */
1867   {
1868     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
1869     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
1870     /* Set time to 2007-09-05 */
1871     PRExplodedTime tm = {0,0,0,12,5,8,2007};
1872     event->SetTime(PR_ImplodeTime(&tm));
1873
1874     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
1875     NS_ENSURE_TRUE(block, rv);
1876
1877     /* Fact 11 */
1878     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
1879     NS_ENSURE_TRUE(fact, rv);
1880     fact->SetAmount(AA_EVENT_AMOUNT_9);
1881     fact->SetTakeFrom(bankAccEur);
1882     fact->SetGiveTo(forex);
1883
1884     rv = block->AppendElement(fact, PR_FALSE);
1885     NS_TEST_ASSERT_OK(rv);
1886
1887     rv = mSession->Save(event, nsnull);
1888     NS_TEST_ASSERT_OK(rv);
1889
1890     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
1891     NS_ENSURE_TRUE(txn, rv);
1892     txn->SetFact(fact);
1893
1894     rv = mSession->Save(txn, nsnull);
1895     NS_TEST_ASSERT_OK(rv);
1896
1897     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
1898         getter_AddRefs(set));
1899     NS_TEST_ASSERT_OK(rv);
1900     NS_ENSURE_TRUE(set, rv);
1901     rv = set->Load();
1902     NS_TEST_ASSERT_OK(rv);
1903
1904     set->GetLength(&count);
1905     NS_TEST_ASSERT_MSG(count == 7, "[split txn] [fact 11] wrong flow count");
1906
1907     balance = do_QueryElementAt(set, 0);
1908     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
1909           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
1910         "[split txn] [fact 11] flow2 is wrong");
1911
1912     balance = do_QueryElementAt(set, 1);
1913     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
1914           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
1915         "[split txn] [fact 11] flow1 is wrong");
1916
1917     balance = do_QueryElementAt(set, 2);
1918     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
1919           AA_EVENT_AMOUNT_4, 1), "[split txn] [fact 11] flow4 is wrong");
1920
1921     balance = do_QueryElementAt(set, 3);
1922     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
1923           1), "[split txn] [fact 11] flow3 is wrong");
1924
1925     balance = do_QueryElementAt(set, 4);
1926     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 1,
1927           AA_EVENT_RATE_6, AA_EVENT_RATE_6, 0),
1928         "[loss txn] flow9 is wrong");
1929
1930     mEuros = AA_EVENT_AMOUNT_7 - AA_EVENT_AMOUNT_9;
1931     balance = do_QueryElementAt(set, 5);
1932     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
1933           mEuros, mEuros * AA_EVENT_RATE_4, 1),
1934         "[split txn] [fact 11] flow6 is wrong");
1935
1936     balance = do_QueryElementAt(set, 6);
1937     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 10, 1,
1938           AA_EVENT_AMOUNT_9 * AA_EVENT_RATE_5,
1939           AA_EVENT_AMOUNT_9 * AA_EVENT_RATE_5, 1),
1940         "[split txn] [fact 11] flow10 is wrong");
1941
1942     nsCOMPtr<aaILoadQuery> incomeSet;
1943     rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
1944         getter_AddRefs( incomeSet ));
1945     NS_TEST_ASSERT_MSG(incomeSet, "[split txn] income set not created" );
1946     NS_ENSURE_TRUE(incomeSet, rv);
1947     rv = incomeSet->Load();
1948     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[split txn] income set not loaded" );
1949
1950     count = 0;
1951     incomeSet->GetLength(&count);
1952     NS_TEST_ASSERT_MSG(count == 1, "[split txn] wrong income count");
1953
1954     balance = do_QueryElementAt(incomeSet, 0);
1955     NS_TEST_ASSERT_MSG(balance, "[split txn] income not loaded" );
1956     if (NS_LIKELY(balance)) {
1957       mProfit += (AA_EVENT_RATE_5 - AA_EVENT_RATE_4) * AA_EVENT_AMOUNT_9;
1958       NS_TEST_ASSERT_MSG(isZero(balance->PickValue() + mProfit),
1959           "[split txn] wrong income saved");
1960     }
1961   }
1962
1963   /* Partially receive from forex deal #4 */
1964   {
1965     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
1966     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
1967     /* Set time to 2007-09-05 */
1968     PRExplodedTime tm = {0,0,0,12,5,8,2007};
1969     event->SetTime(PR_ImplodeTime(&tm));
1970
1971     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
1972     NS_ENSURE_TRUE(block, rv);
1973
1974     /* Fact 12 */
1975     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
1976     NS_ENSURE_TRUE(fact, rv);
1977     fact->SetAmount(AA_EVENT_AMOUNT_10 * AA_EVENT_RATE_5);
1978     fact->SetTakeFrom(forex);
1979     fact->SetGiveTo(bankAccRub);
1980
1981     rv = block->AppendElement(fact, PR_FALSE);
1982     NS_TEST_ASSERT_OK(rv);
1983
1984     rv = mSession->Save(event, nsnull);
1985     NS_TEST_ASSERT_OK(rv);
1986
1987     mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs(set));
1988     NS_TEST_ASSERT_OK(rv);
1989     NS_ENSURE_SUCCESS(rv, rv);
1990
1991     rv = set->Load();
1992     NS_TEST_ASSERT_OK(rv);
1993
1994     set->GetLength(&count);
1995     NS_TEST_ASSERT_MSG(count == 7, "[split event] wrong flow count");
1996
1997     state = do_QueryElementAt(set, 5, &rv);
1998     NS_TEST_ASSERT_MSG(state, "[split event] 5th item not read" );
1999     NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
2000
2001     NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 10, 4,
2002           AA_EVENT_AMOUNT_10 - AA_EVENT_AMOUNT_9),
2003         "[split event] flow7 is wrong");
2004   }
2005
2006   /* Reflect partial revenue from forex deal #4 */
2007   {
2008     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
2009     NS_ENSURE_TRUE(txn, rv);
2010     txn->SetFact(fact);
2011
2012     rv = mSession->Save(txn, nsnull);
2013     NS_TEST_ASSERT_OK(rv);
2014
2015     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
2016         getter_AddRefs(set));
2017     NS_TEST_ASSERT_OK(rv);
2018     NS_ENSURE_TRUE(set, rv);
2019     rv = set->Load();
2020     NS_TEST_ASSERT_OK(rv);
2021
2022     set->GetLength(&count);
2023     NS_TEST_ASSERT_MSG(count == 7, "[split txn] [fact 11] wrong flow count");
2024
2025     balance = do_QueryElementAt(set, 0);
2026     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
2027           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
2028         "[split txn] [fact 11] flow2 is wrong");
2029
2030     balance = do_QueryElementAt(set, 1);
2031     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
2032           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
2033         "[split txn] [fact 11] flow1 is wrong");
2034
2035     balance = do_QueryElementAt(set, 2);
2036     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
2037           AA_EVENT_AMOUNT_4, 1), "[split txn] [fact 11] flow4 is wrong");
2038
2039     balance = do_QueryElementAt(set, 3);
2040     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 1,
2041           AA_EVENT_RATE_6, AA_EVENT_RATE_6, 0),
2042         "[split txn] flow9 is wrong");
2043
2044     balance = do_QueryElementAt(set, 4);
2045     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
2046           mEuros, mEuros * AA_EVENT_RATE_4, 1),
2047         "[split txn] [fact 11] flow6 is wrong");
2048
2049     balance = do_QueryElementAt(set, 5);
2050     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 10, 4,
2051           (AA_EVENT_AMOUNT_10 - AA_EVENT_AMOUNT_9),
2052           (AA_EVENT_AMOUNT_10 - AA_EVENT_AMOUNT_9) * AA_EVENT_RATE_5, 0),
2053         "[split txn] [fact 11] flow10 is wrong");
2054
2055     mRubs += AA_EVENT_AMOUNT_10 * AA_EVENT_RATE_5;
2056     balance = do_QueryElementAt(set, 6);
2057     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
2058           1), "[split txn] [fact 11] flow3 is wrong");
2059
2060     nsCOMPtr<aaILoadQuery> incomeSet;
2061     rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
2062         getter_AddRefs( incomeSet ));
2063     NS_TEST_ASSERT_MSG(incomeSet, "[split txn] income set not created" );
2064     NS_ENSURE_TRUE(incomeSet, rv);
2065     rv = incomeSet->Load();
2066     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[split txn] income set not loaded" );
2067
2068     count = 0;
2069     incomeSet->GetLength(&count);
2070     NS_TEST_ASSERT_MSG(count == 1, "[split txn] wrong income count");
2071
2072     balance = do_QueryElementAt(incomeSet, 0);
2073     NS_TEST_ASSERT_MSG(balance, "[split txn] income not loaded" );
2074     if (NS_LIKELY(balance)) {
2075       NS_TEST_ASSERT_MSG(isZero(balance->PickValue() + mProfit),
2076           "[split txn] wrong income saved");
2077     }
2078   }
2079
2080   /* Fully pay forex deal #4 */
2081   {
2082     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
2083     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
2084     /* Set time to 2007-09-05 */
2085     PRExplodedTime tm = {0,0,0,12,5,8,2007};
2086     event->SetTime(PR_ImplodeTime(&tm));
2087
2088     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
2089     NS_ENSURE_TRUE(block, rv);
2090
2091     /* Fact 13 */
2092     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
2093     NS_ENSURE_TRUE(fact, rv);
2094     fact->SetAmount(AA_EVENT_AMOUNT_11);
2095     fact->SetTakeFrom(bankAccEur);
2096     fact->SetGiveTo(forex);
2097
2098     rv = block->AppendElement(fact, PR_FALSE);
2099     NS_TEST_ASSERT_OK(rv);
2100
2101     rv = mSession->Save(event, nsnull);
2102     NS_TEST_ASSERT_OK(rv);
2103
2104     mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs(set));
2105     NS_TEST_ASSERT_OK(rv);
2106     NS_ENSURE_SUCCESS(rv, rv);
2107
2108     rv = set->Load();
2109     NS_TEST_ASSERT_OK(rv);
2110
2111     set->GetLength(&count);
2112     NS_TEST_ASSERT_MSG(count == 7, "[split event] wrong flow count");
2113
2114     state = do_QueryElementAt(set, 5, &rv);
2115     NS_TEST_ASSERT_MSG(state, "[split event] 5th item not read" );
2116     NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
2117
2118     NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 10, 1,
2119           AA_EVENT_AMOUNT_12 * AA_EVENT_RATE_5),
2120         "[split event] flow7 is wrong");
2121   }
2122
2123   /* Reflect full payment of deal #4 */
2124   {
2125     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
2126     NS_ENSURE_TRUE(txn, rv);
2127     txn->SetFact(fact);
2128
2129     rv = mSession->Save(txn, nsnull);
2130     NS_TEST_ASSERT_OK(rv);
2131
2132     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
2133         getter_AddRefs(set));
2134     NS_TEST_ASSERT_OK(rv);
2135     NS_ENSURE_TRUE(set, rv);
2136     rv = set->Load();
2137     NS_TEST_ASSERT_OK(rv);
2138
2139     set->GetLength(&count);
2140     NS_TEST_ASSERT_MSG(count == 7, "[split txn] [fact 13] wrong flow count");
2141
2142     balance = do_QueryElementAt(set, 0);
2143     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
2144           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
2145         "[split txn] [fact 13] flow2 is wrong");
2146
2147     balance = do_QueryElementAt(set, 1);
2148     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
2149           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
2150         "[split txn] [fact 13] flow1 is wrong");
2151
2152     balance = do_QueryElementAt(set, 2);
2153     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
2154           AA_EVENT_AMOUNT_4, 1), "[split txn] [fact 13] flow4 is wrong");
2155
2156     balance = do_QueryElementAt(set, 3);
2157     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 1,
2158           AA_EVENT_RATE_6, AA_EVENT_RATE_6, 0),
2159         "[split txn] flow9 is wrong");
2160
2161     mEuros -= AA_EVENT_AMOUNT_11;
2162     balance = do_QueryElementAt(set, 4);
2163     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
2164           mEuros, mEuros * AA_EVENT_RATE_4, 1),
2165         "[split txn] [fact 13] flow6 is wrong");
2166
2167     balance = do_QueryElementAt(set, 5);
2168     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 10, 1,
2169           AA_EVENT_AMOUNT_12 * AA_EVENT_RATE_5,
2170           AA_EVENT_AMOUNT_12 * AA_EVENT_RATE_5, 1),
2171         "[split txn] [fact 13] flow10 is wrong");
2172     NS_TEST_ASSERT_MSG(balance && balance->PickAmount() == 3495.0,
2173         "[split txn] [fact 13] inprecise calculation");
2174
2175     balance = do_QueryElementAt(set, 6);
2176     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
2177           1), "[split txn] [fact 13] flow3 is wrong");
2178
2179     nsCOMPtr<aaILoadQuery> incomeSet;
2180     rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
2181         getter_AddRefs( incomeSet ));
2182     NS_TEST_ASSERT_MSG(incomeSet, "[split txn] income set not created" );
2183     NS_ENSURE_TRUE(incomeSet, rv);
2184     rv = incomeSet->Load();
2185     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[split txn] income set not loaded" );
2186
2187     count = 0;
2188     incomeSet->GetLength(&count);
2189     NS_TEST_ASSERT_MSG(count == 0, "[split txn] wrong income count");
2190     mProfit += (AA_EVENT_RATE_5 - AA_EVENT_RATE_4) * AA_EVENT_AMOUNT_11;
2191
2192   }
2193
2194   return NS_OK;
2195 }
2196
2197 nsresult
2198 aaAccountTest::testGainTransaction(nsITestRunner *aTestRunner)
2199 {
2200   nsresult rv;
2201   NS_TEST_BEGIN(aTestRunner);
2202   nsCOMPtr<aaIEntity> bank = do_QueryElementAt(mEntities, 3, &rv);
2203   NS_ENSURE_TRUE(bank, rv);
2204
2205   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResources, 0, &rv));
2206   nsCOMPtr<aaIResource> eur(do_QueryElementAt(mResources, 3, &rv));
2207
2208   mFlows->Load();
2209   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlows,2));
2210   nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlows,5));
2211   nsCOMPtr<aaIFlow> forex(do_QueryElementAt(mFlows,9));
2212   nsCOMPtr<aaIFlow> office(do_QueryElementAt(mFlows,8));
2213
2214   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1", &rv));
2215   nsCOMPtr<aaIEvent> event(do_CreateInstance("@aasii.org/base/event;1"));
2216   nsCOMPtr<aaITransaction> txn(do_CreateInstance(
2217         "@aasii.org/base/transaction;1", &rv));
2218
2219   PRUint32 count = 0;
2220   nsCOMPtr<aaILoadQuery> set;
2221   nsCOMPtr<aaIBalance> balance;
2222
2223   /* Recieve settlement from forex deal #4 */
2224   {
2225     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
2226     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
2227     /* Set time to 2007-09-05 */
2228     PRExplodedTime tm = {0,0,0,12,5,8,2007};
2229     event->SetTime(PR_ImplodeTime(&tm));
2230
2231     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
2232     NS_ENSURE_TRUE(block, rv);
2233
2234     /* Fact 14 */
2235     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
2236     NS_ENSURE_TRUE(fact, rv);
2237     fact->SetAmount(AA_EVENT_AMOUNT_12 * AA_EVENT_RATE_5);
2238     fact->SetTakeFrom(forex);
2239     fact->SetGiveTo(bankAccRub);
2240
2241     rv = block->AppendElement(fact, PR_FALSE);
2242     NS_TEST_ASSERT_OK(rv);
2243
2244     rv = mSession->Save(event, nsnull);
2245     NS_TEST_ASSERT_OK(rv);
2246
2247     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
2248     NS_ENSURE_TRUE(txn, rv);
2249     txn->SetFact(fact);
2250
2251     rv = mSession->Save(txn, nsnull);
2252     NS_TEST_ASSERT_OK(rv);
2253
2254     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
2255         getter_AddRefs(set));
2256     NS_TEST_ASSERT_OK(rv);
2257     NS_ENSURE_TRUE(set, rv);
2258     rv = set->Load();
2259     NS_TEST_ASSERT_OK(rv);
2260
2261     set->GetLength(&count);
2262     NS_TEST_ASSERT_MSG(count == 6, "[gain txn] [fact 14] wrong flow count");
2263
2264     balance = do_QueryElementAt(set, 0);
2265     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
2266           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
2267         "[gain txn] [fact 14] flow2 is wrong");
2268
2269     balance = do_QueryElementAt(set, 1);
2270     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
2271           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
2272         "[gain txn] [fact 14] flow1 is wrong");
2273
2274     balance = do_QueryElementAt(set, 2);
2275     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
2276           AA_EVENT_AMOUNT_4, 1), "[gain txn] [fact 14] flow4 is wrong");
2277
2278     balance = do_QueryElementAt(set, 3);
2279     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 1,
2280           AA_EVENT_RATE_6, AA_EVENT_RATE_6, 0),
2281         "[gain txn] flow9 is wrong");
2282
2283     balance = do_QueryElementAt(set, 4);
2284     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
2285           mEuros, mEuros * AA_EVENT_RATE_4, 1),
2286         "[gain txn] [fact 14] flow6 is wrong");
2287
2288     mRubs += AA_EVENT_AMOUNT_12 * AA_EVENT_RATE_5;
2289     balance = do_QueryElementAt(set, 5);
2290     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
2291           1), "[gain txn] [fact 14] flow3 is wrong");
2292   }
2293
2294   nsCOMPtr<aaIState> state;
2295   /* Settle office rent for Aug and prepay for Sep*/
2296   {
2297     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
2298     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
2299     /* Set time to 2007-09-05 */
2300     PRExplodedTime tm = {0,0,0,12,5,8,2007};
2301     event->SetTime(PR_ImplodeTime(&tm));
2302
2303     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
2304     NS_ENSURE_TRUE(block, rv);
2305
2306     /* Fact 15 */
2307     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
2308     NS_ENSURE_TRUE(fact, rv);
2309     fact->SetAmount(2 * AA_EVENT_RATE_6);
2310     fact->SetTakeFrom(bankAccRub);
2311     fact->SetGiveTo(office);
2312
2313     rv = block->AppendElement(fact, PR_FALSE);
2314     NS_TEST_ASSERT_OK(rv);
2315
2316     rv = mSession->Save(event, nsnull);
2317     NS_TEST_ASSERT_OK(rv);
2318
2319     mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs(set));
2320     NS_TEST_ASSERT_OK(rv);
2321     NS_ENSURE_SUCCESS(rv, rv);
2322
2323     rv = set->Load();
2324     NS_TEST_ASSERT_OK(rv);
2325
2326     set->GetLength(&count);
2327     NS_TEST_ASSERT_MSG(count == 6, "[gain event] wrong flow count");
2328
2329     state = do_QueryElementAt(set, 5, &rv);
2330     NS_TEST_ASSERT_MSG(state, "[gain event] 5th item not read" );
2331     NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
2332
2333     NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 9, 5, 1),
2334         "[gain event] flow7 is wrong");
2335   }
2336
2337   /* Reflect payment for office */
2338   {
2339     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
2340     NS_ENSURE_TRUE(txn, rv);
2341     txn->SetFact(fact);
2342
2343     rv = mSession->Save(txn, nsnull);
2344     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[gain txn] not saved");
2345
2346     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
2347         getter_AddRefs(set));
2348     NS_TEST_ASSERT_OK(rv);
2349     NS_ENSURE_TRUE(set, rv);
2350     rv = set->Load();
2351     NS_TEST_ASSERT_OK(rv);
2352
2353     set->GetLength(&count);
2354     NS_TEST_ASSERT_MSG(count == 6, "[gain txn] [fact 15] wrong flow count");
2355
2356     balance = do_QueryElementAt(set, 0);
2357     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
2358           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
2359         "[gain txn] [fact 15] flow2 is wrong");
2360
2361     balance = do_QueryElementAt(set, 1);
2362     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
2363           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
2364         "[gain txn] [fact 15] flow1 is wrong");
2365
2366     balance = do_QueryElementAt(set, 2);
2367     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
2368           AA_EVENT_AMOUNT_4, 1), "[gain txn] [fact 15] flow4 is wrong");
2369
2370     balance = do_QueryElementAt(set, 3);
2371     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
2372           mEuros, mEuros * AA_EVENT_RATE_4, 1),
2373         "[gain txn] [fact 15] flow6 is wrong");
2374
2375     mRubs -= 2 * AA_EVENT_RATE_6;
2376     balance = do_QueryElementAt(set, 4);
2377     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
2378           1), "[gain txn] [fact 15] flow3 is wrong");
2379
2380     balance = do_QueryElementAt(set, 5);
2381     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 5,
2382           1, AA_EVENT_RATE_6, 1),
2383         "[gain txn] flow9 is wrong");
2384
2385     nsCOMPtr<aaILoadQuery> incomeSet;
2386     rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
2387         getter_AddRefs( incomeSet ));
2388     NS_TEST_ASSERT_MSG(incomeSet, "[gain txn] income set not created" );
2389     NS_ENSURE_TRUE(incomeSet, rv);
2390     rv = incomeSet->Load();
2391     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[gain txn] income set not loaded" );
2392
2393     count = 0;
2394     incomeSet->GetLength(&count);
2395     NS_TEST_ASSERT_MSG(count == 0, "[gain txn] wrong income count");
2396   }
2397
2398   nsCOMPtr<aaIFlow> finres = do_CreateInstance("@aasii.org/base/income-flow;1");
2399   /* Direct monetary loss */
2400   {
2401     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
2402     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
2403     /* Set time to 2007-09-06 */
2404     PRExplodedTime tm = {0,0,0,12,6,8,2007};
2405     event->SetTime(PR_ImplodeTime(&tm));
2406
2407     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
2408     NS_ENSURE_TRUE(block, rv);
2409
2410     /* Fact 16 */
2411     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
2412     NS_ENSURE_TRUE(fact, rv);
2413     fact->SetAmount(AA_EVENT_AMOUNT_13);
2414     fact->SetTakeFrom(bankAccRub);
2415     fact->SetGiveTo(finres);
2416
2417     rv = block->AppendElement(fact, PR_FALSE);
2418     NS_TEST_ASSERT_OK(rv);
2419
2420     rv = mSession->Save(event, nsnull);
2421     NS_TEST_ASSERT_OK(rv);
2422
2423     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
2424     NS_ENSURE_TRUE(txn, rv);
2425     txn->SetFact(fact);
2426
2427     rv = mSession->Save(txn, nsnull);
2428     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[gain txn] not saved");
2429
2430     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
2431         getter_AddRefs(set));
2432     NS_TEST_ASSERT_OK(rv);
2433     NS_ENSURE_TRUE(set, rv);
2434     rv = set->Load();
2435     NS_TEST_ASSERT_OK(rv);
2436
2437     set->GetLength(&count);
2438     NS_TEST_ASSERT_MSG(count == 6, "[gain txn] wrong flow count");
2439
2440     balance = do_QueryElementAt(set, 0);
2441     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
2442           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
2443         "[gain txn] flow2 is wrong");
2444
2445     balance = do_QueryElementAt(set, 1);
2446     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
2447           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
2448         "[gain txn] flow1 is wrong");
2449
2450     balance = do_QueryElementAt(set, 2);
2451     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
2452           AA_EVENT_AMOUNT_4, 1), "[gain txn] flow4 is wrong");
2453
2454     balance = do_QueryElementAt(set, 3);
2455     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
2456           mEuros, mEuros * AA_EVENT_RATE_4, 1),
2457         "[gain txn] flow6 is wrong");
2458
2459     balance = do_QueryElementAt(set, 4);
2460     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 5,
2461           1, AA_EVENT_RATE_6, 1),
2462         "[gain txn] flow9 is wrong");
2463
2464     mRubs -= AA_EVENT_AMOUNT_13;
2465     balance = do_QueryElementAt(set, 5);
2466     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
2467           1), "[gain txn] flow3 is wrong");
2468
2469     nsCOMPtr<aaILoadQuery> incomeSet;
2470     rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
2471         getter_AddRefs( incomeSet ));
2472     NS_TEST_ASSERT_MSG(incomeSet, "[gain txn] income set not created" );
2473     NS_ENSURE_TRUE(incomeSet, rv);
2474     rv = incomeSet->Load();
2475     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[gain txn] income set not loaded" );
2476
2477     count = 0;
2478     incomeSet->GetLength(&count);
2479     NS_TEST_ASSERT_MSG(count == 1, "[gain txn] wrong income count");
2480
2481     balance = do_QueryElementAt(incomeSet, 0);
2482     NS_TEST_ASSERT_MSG(balance, "[gain txn] income not loaded" );
2483     if (NS_LIKELY(balance)) {
2484       mProfit -= AA_EVENT_AMOUNT_13;
2485       NS_TEST_ASSERT_MSG(isZero(balance->PickValue() + mProfit),
2486           "[gain txn] wrong income saved");
2487     }
2488   }
2489
2490   /* Direct monetary gain */
2491   {
2492     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
2493     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
2494     /* Set time to 2007-09-07 */
2495     PRExplodedTime tm = {0,0,0,12,7,8,2007};
2496     event->SetTime(PR_ImplodeTime(&tm));
2497
2498     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
2499     NS_ENSURE_TRUE(block, rv);
2500
2501     /* Fact 17 */
2502     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
2503     NS_ENSURE_TRUE(fact, rv);
2504     fact->SetAmount(AA_EVENT_AMOUNT_14);
2505     fact->SetTakeFrom(finres);
2506     fact->SetGiveTo(bankAccRub);
2507
2508     rv = block->AppendElement(fact, PR_FALSE);
2509     NS_TEST_ASSERT_OK(rv);
2510
2511     rv = mSession->Save(event, nsnull);
2512     NS_TEST_ASSERT_OK(rv);
2513
2514     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
2515     NS_ENSURE_TRUE(txn, rv);
2516     txn->SetFact(fact);
2517
2518     rv = mSession->Save(txn, nsnull);
2519     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[gain txn] not saved");
2520
2521     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
2522         getter_AddRefs(set));
2523     NS_TEST_ASSERT_OK(rv);
2524     NS_ENSURE_TRUE(set, rv);
2525     rv = set->Load();
2526     NS_TEST_ASSERT_OK(rv);
2527
2528     set->GetLength(&count);
2529     NS_TEST_ASSERT_MSG(count == 6, "[gain txn] wrong flow count");
2530
2531     balance = do_QueryElementAt(set, 0);
2532     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
2533           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
2534         "[gain txn] flow2 is wrong");
2535
2536     balance = do_QueryElementAt(set, 1);
2537     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
2538           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
2539         "[gain txn] flow1 is wrong");
2540
2541     balance = do_QueryElementAt(set, 2);
2542     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
2543           AA_EVENT_AMOUNT_4, 1), "[gain txn] flow4 is wrong");
2544
2545     balance = do_QueryElementAt(set, 3);
2546     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
2547           mEuros, mEuros * AA_EVENT_RATE_4, 1),
2548         "[gain txn] flow6 is wrong");
2549
2550     balance = do_QueryElementAt(set, 4);
2551     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 5,
2552           1, AA_EVENT_RATE_6, 1),
2553         "[gain txn] flow9 is wrong");
2554
2555     mRubs += AA_EVENT_AMOUNT_14;
2556     balance = do_QueryElementAt(set, 5);
2557     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
2558           1), "[gain txn] flow3 is wrong");
2559
2560     nsCOMPtr<aaILoadQuery> incomeSet;
2561     rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
2562         getter_AddRefs( incomeSet ));
2563     NS_TEST_ASSERT_MSG(incomeSet, "[gain txn] income set not created" );
2564     NS_ENSURE_TRUE(incomeSet, rv);
2565     rv = incomeSet->Load();
2566     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[gain txn] income set not loaded" );
2567
2568     count = 0;
2569     incomeSet->GetLength(&count);
2570     NS_TEST_ASSERT_MSG(count == 0, "[gain txn] wrong income count");
2571     mProfit = 0.0;
2572   }
2573   return NS_OK;
2574 }
2575
2576 nsresult
2577 aaAccountTest::testDirectGainsLosses(nsITestRunner *aTestRunner)
2578 {
2579   nsresult rv;
2580   NS_TEST_BEGIN(aTestRunner);
2581
2582   nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResources, 0, &rv));
2583   nsCOMPtr<aaIResource> eur(do_QueryElementAt(mResources, 3, &rv));
2584
2585   nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlows,2));
2586   nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlows,5));
2587   nsCOMPtr<aaIFlow> forex(do_QueryElementAt(mFlows,9));
2588
2589   nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1", &rv));
2590   nsCOMPtr<aaIEvent> event(do_CreateInstance("@aasii.org/base/event;1"));
2591   nsCOMPtr<aaITransaction> txn(do_CreateInstance(
2592         "@aasii.org/base/transaction;1", &rv));
2593   NS_ENSURE_TRUE(txn, rv);
2594
2595   PRUint32 count = 0;
2596   nsCOMPtr<aaILoadQuery> set;
2597   nsCOMPtr<aaIBalance> balance;
2598
2599   /* Receive prepayment from forex deal #4 */
2600   {
2601     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
2602     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
2603     /* Set time to 2007-09-10 */
2604     PRExplodedTime tm = {0,0,0,12,10,8,2007};
2605     event->SetTime(PR_ImplodeTime(&tm));
2606
2607     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
2608     NS_ENSURE_TRUE(block, rv);
2609
2610     /* Fact 18 */
2611     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
2612     NS_ENSURE_TRUE(fact, rv);
2613     fact->SetAmount(AA_EVENT_AMOUNT_15 * AA_EVENT_RATE_5);
2614     fact->SetTakeFrom(forex);
2615     fact->SetGiveTo(bankAccRub);
2616
2617     rv = block->AppendElement(fact, PR_FALSE);
2618     NS_TEST_ASSERT_OK(rv);
2619
2620     rv = mSession->Save(event, nsnull);
2621     NS_TEST_ASSERT_OK(rv);
2622
2623     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
2624     NS_ENSURE_TRUE(txn, rv);
2625     txn->SetFact(fact);
2626
2627     rv = mSession->Save(txn, nsnull);
2628     NS_TEST_ASSERT_OK(rv);
2629
2630     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
2631         getter_AddRefs(set));
2632     NS_TEST_ASSERT_OK(rv);
2633     NS_ENSURE_TRUE(set, rv);
2634     rv = set->Load();
2635     NS_TEST_ASSERT_OK(rv);
2636
2637     set->GetLength(&count);
2638     NS_TEST_ASSERT_MSG(count == 7, "[gain txn] [fact 18] wrong flow count");
2639
2640     balance = do_QueryElementAt(set, 0);
2641     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2, AA_EVENT_AMOUNT_2
2642           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
2643         "[gain txn] [fact 18] flow2 is wrong");
2644
2645     balance = do_QueryElementAt(set, 1);
2646     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2, AA_EVENT_AMOUNT_3
2647           / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
2648         "[gain txn] [fact 18] flow1 is wrong");
2649
2650     balance = do_QueryElementAt(set, 2);
2651     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3, AA_EVENT_AMOUNT_5,
2652           AA_EVENT_AMOUNT_4, 1), "[gain txn] [fact 18] flow4 is wrong");
2653
2654     balance = do_QueryElementAt(set, 3);
2655     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
2656           mEuros, mEuros * AA_EVENT_RATE_4, 1),
2657         "[gain txn] [fact 18] flow6 is wrong");
2658
2659     balance = do_QueryElementAt(set, 4);
2660     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 5,
2661           1, AA_EVENT_RATE_6, 1),
2662         "[gain txn] [fact 18] flow9 is wrong");
2663
2664     balance = do_QueryElementAt(set, 5);
2665     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 10, 4,
2666           AA_EVENT_AMOUNT_15, AA_EVENT_AMOUNT_15 * AA_EVENT_RATE_5, 0),
2667         "[split txn] [fact 18] flow10 is wrong");
2668
2669     mRubs += AA_EVENT_AMOUNT_15 * AA_EVENT_RATE_5;
2670     balance = do_QueryElementAt(set, 6);
2671     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
2672           1), "[gain txn] [fact 18] flow3 is wrong");
2673   }
2674
2675   nsCOMPtr<aaIFlow> finres = do_CreateInstance("@aasii.org/base/income-flow;1");
2676   /* Direct write-off - loss */
2677   {
2678     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
2679     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
2680     /* Set time to 2007-09-10 */
2681     PRExplodedTime tm = {0,0,0,12,10,8,2007};
2682     event->SetTime(PR_ImplodeTime(&tm));
2683
2684     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
2685     NS_ENSURE_TRUE(block, rv);
2686
2687     /* Fact 19 */
2688     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
2689     NS_ENSURE_TRUE(fact, rv);
2690     fact->SetAmount(AA_EVENT_AMOUNT_15);
2691     fact->SetTakeFrom(bankAccEur);
2692     fact->SetGiveTo(finres);
2693
2694     rv = block->AppendElement(fact, PR_FALSE);
2695     NS_TEST_ASSERT_OK(rv);
2696
2697     rv = mSession->Save(event, nsnull);
2698     NS_TEST_ASSERT_OK(rv);
2699
2700     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
2701     NS_ENSURE_TRUE(txn, rv);
2702     txn->SetFact(fact);
2703
2704     rv = mSession->Save(txn, nsnull);
2705     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[write-off txn] not saved");
2706
2707     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
2708         getter_AddRefs(set));
2709     NS_TEST_ASSERT_OK(rv);
2710     NS_ENSURE_TRUE(set, rv);
2711     rv = set->Load();
2712     NS_TEST_ASSERT_OK(rv);
2713
2714     set->GetLength(&count);
2715     NS_TEST_ASSERT_MSG(count == 7, "[write-off txn] wrong flow count");
2716
2717     balance = do_QueryElementAt(set, 0);
2718     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2,
2719           AA_EVENT_AMOUNT_2 / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
2720         "[write-off txn] flow2 is wrong");
2721
2722     balance = do_QueryElementAt(set, 1);
2723     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2,
2724           AA_EVENT_AMOUNT_3 / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
2725         "[write-off txn] flow1 is wrong");
2726
2727     balance = do_QueryElementAt(set, 2);
2728     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3,
2729           AA_EVENT_AMOUNT_5, AA_EVENT_AMOUNT_4, 1),
2730         "[write-off txn] flow4 is wrong");
2731
2732     balance = do_QueryElementAt(set, 3);
2733     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 5,
2734           1, AA_EVENT_RATE_6, 1),
2735         "[write-off txn] flow9 is wrong");
2736
2737     balance = do_QueryElementAt(set, 4);
2738     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 10, 4,
2739           AA_EVENT_AMOUNT_15, AA_EVENT_AMOUNT_15 * AA_EVENT_RATE_5, 0),
2740         "[split txn] [fact 18] flow10 is wrong");
2741
2742     balance = do_QueryElementAt(set, 5);
2743     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
2744           1), "[write-off txn] flow3 is wrong");
2745
2746     mEuros -= AA_EVENT_AMOUNT_15;
2747     balance = do_QueryElementAt(set, 6);
2748     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
2749           mEuros, mEuros * AA_EVENT_RATE_4, 1),
2750         "[write-off txn] flow6 is wrong");
2751
2752     nsCOMPtr<aaILoadQuery> incomeSet;
2753     rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
2754         getter_AddRefs( incomeSet ));
2755     NS_TEST_ASSERT_MSG(incomeSet, "[write-off txn] income set not created" );
2756     NS_ENSURE_TRUE(incomeSet, rv);
2757     rv = incomeSet->Load();
2758     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv),
2759         "[write-off txn] income set not loaded");
2760
2761     count = 0;
2762     incomeSet->GetLength(&count);
2763     NS_TEST_ASSERT_MSG(count == 1, "[write-off txn] wrong income count");
2764
2765     balance = do_QueryElementAt(incomeSet, 0);
2766     NS_TEST_ASSERT_MSG(balance, "[write-off txn] income not loaded" );
2767     if (NS_LIKELY(balance)) {
2768       mProfit -= AA_EVENT_AMOUNT_15 * AA_EVENT_RATE_4;
2769       NS_TEST_ASSERT_MSG(isZero(balance->PickValue() + mProfit),
2770           "[write-off txn] wrong income saved");
2771     }
2772   }
2773
2774   /* Direct write-in - gain */
2775   {
2776     event = do_CreateInstance("@aasii.org/base/event;1", &rv);
2777     NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
2778     /* Set time to 2007-09-10 */
2779     PRExplodedTime tm = {0,0,0,12,10,8,2007};
2780     event->SetTime(PR_ImplodeTime(&tm));
2781
2782     nsCOMPtr<nsIMutableArray> block(do_QueryInterface(event, &rv ));
2783     NS_ENSURE_TRUE(block, rv);
2784
2785     /* Fact 20 */
2786     fact = do_CreateInstance("@aasii.org/base/fact;1", &rv);
2787     NS_ENSURE_TRUE(fact, rv);
2788     fact->SetAmount(AA_EVENT_AMOUNT_15);
2789     fact->SetTakeFrom(finres);
2790     fact->SetGiveTo(forex);
2791
2792     rv = block->AppendElement(fact, PR_FALSE);
2793     NS_TEST_ASSERT_OK(rv);
2794
2795     rv = mSession->Save(event, nsnull);
2796     NS_TEST_ASSERT_OK(rv);
2797
2798     txn = do_CreateInstance("@aasii.org/base/transaction;1", &rv);
2799     NS_ENSURE_TRUE(txn, rv);
2800     txn->SetFact(fact);
2801
2802     rv = mSession->Save(txn, nsnull);
2803     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[write-in txn] not saved");
2804
2805     rv = mSession->CreateQuery(AA_LOADBALANCE_CONTRACT_ID,
2806         getter_AddRefs(set));
2807     NS_TEST_ASSERT_OK(rv);
2808     NS_ENSURE_TRUE(set, rv);
2809     rv = set->Load();
2810     NS_TEST_ASSERT_OK(rv);
2811
2812     set->GetLength(&count);
2813     NS_TEST_ASSERT_MSG(count == 6, "[write-in txn] wrong flow count");
2814
2815     balance = do_QueryElementAt(set, 0);
2816     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 2, 2,
2817           AA_EVENT_AMOUNT_2 / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_2, 0),
2818         "[write-in txn] flow2 is wrong");
2819
2820     balance = do_QueryElementAt(set, 1);
2821     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 1, 2,
2822           AA_EVENT_AMOUNT_3 / AA_FLOW_SHARE_RATE, AA_EVENT_AMOUNT_3, 0),
2823         "[write-in txn] flow1 is wrong");
2824
2825     balance = do_QueryElementAt(set, 2);
2826     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 4, 3,
2827           AA_EVENT_AMOUNT_5, AA_EVENT_AMOUNT_4, 1),
2828         "[write-in txn] flow4 is wrong");
2829
2830     balance = do_QueryElementAt(set, 3);
2831     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 9, 5,
2832           1, AA_EVENT_RATE_6, 1),
2833         "[write-in txn] flow9 is wrong");
2834
2835     balance = do_QueryElementAt(set, 4);
2836     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 3, 1, mRubs, mRubs,
2837           1), "[write-in txn] flow3 is wrong");
2838
2839     balance = do_QueryElementAt(set, 5);
2840     NS_TEST_ASSERT_MSG(testBalance(aTestRunner, balance, 6, 4,
2841           mEuros, mEuros * AA_EVENT_RATE_4, 1),
2842         "[write-in txn] flow6 is wrong");
2843
2844     nsCOMPtr<aaILoadQuery> incomeSet;
2845     rv = mSession->CreateQuery(AA_LOADINCOME_CONTRACT_ID,
2846         getter_AddRefs( incomeSet ));
2847     NS_TEST_ASSERT_MSG(incomeSet, "[write-in txn] income set not created" );
2848     NS_ENSURE_TRUE(incomeSet, rv);
2849     rv = incomeSet->Load();
2850     NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv),
2851         "[write-in txn] income set not loaded");
2852
2853     count = 0;
2854     incomeSet->GetLength(&count);
2855     NS_TEST_ASSERT_MSG(count == 1, "[write-in txn] wrong income count");
2856
2857     balance = do_QueryElementAt(incomeSet, 0);
2858     NS_TEST_ASSERT_MSG(balance, "[write-in txn] income not loaded" );
2859     if (NS_LIKELY(balance)) {
2860       mProfit += AA_EVENT_AMOUNT_15 * AA_EVENT_RATE_5;
2861       NS_TEST_ASSERT_MSG(isZero(balance->PickValue() - mProfit),
2862           "[write-in txn] wrong income saved");
2863     }
2864   }
2865
2866   return NS_OK;
2867 }