[xpunit] Rename from 'cxxunit' and switch to mozbuild (bug #114)
[abstract.git] / storage / aaStorageTest.cpp
bloba4ede5d6d34f6c305065f262f11c3eb16325d490
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim:set ts=2 sw=2 sts=2 et cindent tw=79 ft=cpp: */
3 /*
4 * Copyright (C) 2007 Sergey Yanovich <ynvich@gmail.com>
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.
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.
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.
22 #include <abstract/aacore.h>
24 #include "nsCOMPtr.h"
25 #include "nsEmbedString.h"
26 #include "nsIGenericFactory.h"
27 #include "nsComponentManagerUtils.h"
28 #include "nsIMutableArray.h"
29 #include "nsCOMArray.h"
30 #include "nsArrayUtils.h"
32 /* Unfrozen API */
33 #include "unstable/nsIStringEnumerator.h"
34 #include "unstable/nsAutoPtr.h"
35 #include <abstract/cxxunit/nsTestUtils.h>
36 #include <abstract/cxxunit/nsITest.h>
37 #include <abstract/cxxunit/nsITestRunner.h>
38 #include <unstable/mozIStorageConnection.h>
40 /* Project includes */
41 #include <abstract/base/aaIEntity.h>
42 #include <abstract/base/aaIResource.h>
43 #include <abstract/base/aaIFlow.h>
44 #include <abstract/base/aaIFact.h>
45 #include <abstract/base/aaIState.h>
46 #include <abstract/base/aaIEvent.h>
47 #include <abstract/base/aaIHandler.h>
48 #include <abstract/storage/aaISession.h>
49 #include <abstract/storage/aaISaveQuery.h>
50 #include <abstract/storage/aaILoadQuery.h>
51 #include <abstract/storage/aaIFilter.h>
52 #include "aaSession.h"
53 #include <abstract/storage/aaBaseLoaders.h>
54 #include "aaSaveDispatcher.h"
55 #include "aaFilter.h"
56 #include "aaSaveEntity.h"
57 #include "aaLoadEntity.h"
58 #include "aaSaveResource.h"
59 #include "aaLoadResource.h"
60 #include "aaSaveFlow.h"
61 #include "aaLoadFlow.h"
62 #include "aaSaveEvent.h"
63 #include "aaLoadFlowStates.h"
64 #include <abstract/storage/aaTestConsts.h>
66 #define AA_STORAGE_TEST_CID \
67 {0x1e7c924e, 0x872d, 0x4c4e, {0xb8, 0x1c, 0x58, 0xd9, 0x66, 0x4a, 0xe9, 0xd1}}
68 #define AA_STORAGE_TEST_CONTRACT_ID "@aasii.org/storage/unit;1"
70 PRBool testState(nsITestRunner *cxxUnitTestRunner, aaIFact *node,
71 PRInt64 flowId, PRInt64 resourceId, double sum);
73 class aaStorageTest: public nsITest,
74 public nsIUTF8StringEnumerator
76 public:
77 aaStorageTest():mSubtest(0) {;}
78 virtual ~aaStorageTest() {;}
79 NS_DECL_ISUPPORTS
80 NS_DECL_NSITEST
81 NS_DECL_NSIUTF8STRINGENUMERATOR
82 private:
83 PRUint32 mSubtest;
84 nsCOMPtr<aaISession> mSession;
85 nsCOMPtr<aaILoadQuery> mEntitySet;
86 nsCOMPtr<aaILoadQuery> mResourceSet;
87 nsCOMPtr<aaILoadQuery> mFlowSet;
89 nsresult testSession(nsITestRunner *aTestRunner);
90 nsresult testSaveDispatcher(nsITestRunner *aTestRunner);
91 nsresult testFilter(nsITestRunner *aTestRunner);
92 nsresult testSaveEntity(nsITestRunner *aTestRunner);
93 nsresult testLoadEntity(nsITestRunner *aTestRunner);
94 nsresult testSaveResource(nsITestRunner *aTestRunner);
95 nsresult testLoadResource(nsITestRunner *aTestRunner);
96 nsresult testSaveFlow(nsITestRunner *aTestRunner);
97 nsresult testLoadFlow(nsITestRunner *aTestRunner);
98 nsresult testSaveEvent(nsITestRunner *aTestRunner);
99 nsresult testLoadFlowStates(nsITestRunner *aTestRunner);
100 nsresult testUpdateEvent(nsITestRunner *aTestRunner);
101 nsresult testReplaceEvent(nsITestRunner *aTestRunner);
102 nsresult testDeleteEvent(nsITestRunner *aTestRunner);
103 nsresult testStopEvent(nsITestRunner *aTestRunner);
104 nsresult testJunkEvent(nsITestRunner *aTestRunner);
107 NS_IMPL_ISUPPORTS2(aaStorageTest,
108 nsITest,
109 nsIUTF8StringEnumerator);
111 /* nsITest */
112 NS_IMETHODIMP
113 aaStorageTest::Test(nsITestRunner *aTestRunner)
115 testSession(aTestRunner);
116 testSaveDispatcher(aTestRunner);
117 testFilter(aTestRunner);
118 testSaveEntity(aTestRunner);
119 testLoadEntity(aTestRunner);
120 testSaveResource(aTestRunner);
121 testLoadResource(aTestRunner);
122 testSaveFlow(aTestRunner);
123 testLoadFlow(aTestRunner);
124 testSaveEvent(aTestRunner);
125 testLoadFlowStates(aTestRunner);
126 testUpdateEvent(aTestRunner);
127 testReplaceEvent(aTestRunner);
128 testDeleteEvent(aTestRunner);
129 testStopEvent(aTestRunner);
130 testJunkEvent(aTestRunner);
131 return NS_OK;
135 /* nsIUTF8tringEnumerator */
136 static const char* subtests[] =
138 "@aasii.org/storage/unit-account;1"
140 #define subtestCount (sizeof(subtests) / sizeof(char*))
142 NS_IMETHODIMP
143 aaStorageTest::HasMore(PRBool *aHasMore)
145 NS_ENSURE_ARG_POINTER(aHasMore);
146 *aHasMore = (mSubtest < subtestCount);
147 return NS_OK;
150 NS_IMETHODIMP
151 aaStorageTest::GetNext(nsACString &aContractID)
153 NS_ENSURE_TRUE(mSubtest < subtestCount, NS_ERROR_FAILURE);
154 aContractID.Assign( subtests[mSubtest++] );
155 return NS_OK;
158 /* Private methods */
159 nsresult
160 aaStorageTest::testSession(nsITestRunner *aTestRunner)
162 NS_TEST_BEGIN(aTestRunner);
163 mSession = do_CreateInstance(AA_SESSION_CONTRACT_ID);
164 NS_TEST_ASSERT_MSG(mSession, "aaSession instance creation" );
166 aaSession *session = static_cast<aaSession *>(mSession.get());
167 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
169 NS_TEST_ASSERT_MSG( session->mConnection, "session.connection failed" );
171 return NS_OK;
174 nsresult
175 aaStorageTest::testSaveDispatcher(nsITestRunner *aTestRunner)
177 NS_TEST_BEGIN(aTestRunner);
178 nsresult rv;
180 nsCOMPtr<aaIHandler> saver(do_CreateInstance(
181 AA_SAVEDISPATCHER_CONTRACT_ID, mSession, &rv));
182 NS_TEST_ASSERT_MSG(saver, "'saveDispatcher' instance creation" );
183 NS_ENSURE_SUCCESS(rv, rv);
185 return NS_OK;
188 nsresult
189 aaStorageTest::testFilter(nsITestRunner *aTestRunner)
191 NS_TEST_BEGIN(aTestRunner);
192 nsresult rv;
194 nsCOMPtr<aaIFilter> filter(do_CreateInstance(
195 AA_FILTER_CONTRACT_ID, &rv));
196 NS_TEST_ASSERT_MSG(filter, "[filter] instance creation" );
197 NS_ENSURE_SUCCESS(rv, rv);
199 return NS_OK;
202 nsresult
203 aaStorageTest::testSaveEntity(nsITestRunner *aTestRunner)
205 NS_TEST_BEGIN(aTestRunner);
206 nsresult rv;
208 aaSession *session = static_cast<aaSession *>(mSession.get());
209 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
211 nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
212 AA_SAVEENTITY_CONTRACT_ID, session->mConnection, &rv));
213 NS_TEST_ASSERT_MSG(saver, "'saveEntity' instance creation" );
214 NS_ENSURE_SUCCESS(rv, rv);
216 nsCOMPtr<aaIEntity> node(do_CreateInstance("@aasii.org/base/entity;1"));
217 NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
219 node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_1));
220 rv = saver->Save(node, nsnull);
221 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' insertion" );
223 node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_2));
224 rv = saver->Save(node, nsnull);
225 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' second insertion" );
227 node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_3));
228 rv = saver->Save(node, nsnull);
229 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' third insertion" );
231 node->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_4));
232 rv = saver->Save(node, nsnull);
233 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveEntity' forth insertion" );
235 return NS_OK;
238 nsresult
239 aaStorageTest::testLoadEntity(nsITestRunner *aTestRunner)
241 NS_TEST_BEGIN(aTestRunner);
242 nsresult rv;
244 aaSession *session = static_cast<aaSession *>(mSession.get());
245 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
247 nsCOMPtr<aaILoadQuery> loader(do_CreateInstance(
248 AA_LOADENTITY_CONTRACT_ID, session->mConnection, &rv));
249 NS_TEST_ASSERT_MSG(loader, "'loadEntity' instance creation" );
250 NS_ENSURE_SUCCESS(rv, rv);
252 rv = loader->Load();
253 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadEntity' load" );
254 mEntitySet = loader;
256 PRUint32 count;
257 mEntitySet->GetLength(&count);
258 NS_TEST_ASSERT_MSG(count == 4, "'loadEntity' flow count is wrong");
260 nsCOMPtr<aaIEntity> node(do_QueryElementAt(mEntitySet, 0, &rv));
261 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadEntity' first item read" );
263 nsEmbedString tag;
264 node->GetTag(tag);
265 NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_ENTITY_TAG_1)),
266 "'loadEntity' first item read differ from inserted" );
268 PRInt64 id;
269 node->GetId(&id);
270 NS_TEST_ASSERT_MSG(id == 1, "'loadEntity' wrong first item id");
272 return NS_OK;
275 nsresult
276 aaStorageTest::testSaveResource(nsITestRunner *aTestRunner)
278 NS_TEST_BEGIN(aTestRunner);
279 nsresult rv;
281 aaSession *session = static_cast<aaSession *>(mSession.get());
282 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
284 nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
285 AA_SAVERESOURCE_CONTRACT_ID, session->mConnection, &rv));
286 NS_TEST_ASSERT_MSG(saver, "'saveResource' instance creation" );
287 NS_ENSURE_SUCCESS(rv, rv);
289 nsCOMPtr<aaIResource> node(do_CreateInstance("@aasii.org/base/resource;1"));
290 NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
292 node->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_1));
293 rv = saver->Save(node, nsnull);
294 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveResource' insertion" );
296 node->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_2));
297 rv = saver->Save(node, nsnull);
298 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveResource' second insertion" );
300 return NS_OK;
303 nsresult
304 aaStorageTest::testLoadResource(nsITestRunner *aTestRunner)
306 NS_TEST_BEGIN(aTestRunner);
307 nsresult rv;
309 aaSession *session = static_cast<aaSession *>(mSession.get());
310 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
312 nsCOMPtr<aaILoadQuery> loader(do_CreateInstance(
313 AA_LOADRESOURCE_CONTRACT_ID, session->mConnection, &rv));
314 NS_TEST_ASSERT_MSG(loader, "'loadResource' instance creation" );
315 NS_ENSURE_SUCCESS(rv, rv);
317 rv = loader->Load();
318 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadResource' load" );
319 mResourceSet = loader;
321 nsCOMPtr<aaIResource> node(do_QueryElementAt(mResourceSet, 0, &rv));
322 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadResource' first item not read" );
324 nsEmbedString tag;
325 node->GetTag(tag);
326 NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_1)),
327 "'loadResource' first item read differs from inserted" );
329 return NS_OK;
332 nsresult
333 aaStorageTest::testSaveFlow(nsITestRunner *aTestRunner)
335 NS_TEST_BEGIN(aTestRunner);
336 nsresult rv;
338 aaSession *session = static_cast<aaSession *>(mSession.get());
339 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
341 nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
342 AA_SAVEFLOW_CONTRACT_ID, session->mConnection, &rv));
343 NS_TEST_ASSERT_MSG(saver, "'saveflow' instance creation" );
344 NS_ENSURE_SUCCESS(rv, rv);
346 nsCOMPtr<aaIFlow> node(do_CreateInstance("@aasii.org/base/flow;1"));
347 NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
349 nsCOMPtr<aaIResource> share(do_QueryElementAt(mResourceSet,1));
350 nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet,0));
352 nsCOMPtr<aaIEntity> entity(do_QueryElementAt(mEntitySet, 1));
353 node->SetEntity(entity);
354 node->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_1));
355 node->SetGiveResource(share);
356 node->SetTakeResource(rub);
357 node->SetRate(AA_FLOW_SHARE_RATE);
358 node->SetLimit(AA_EVENT_AMOUNT_1 / AA_FLOW_SHARE_RATE);
359 rv = saver->Save(node, nsnull);
360 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveFlow' 1st insertion" );
362 entity = do_QueryElementAt(mEntitySet, 2);
363 node->SetEntity(entity);
364 node->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_3));
365 node->SetGiveResource(share);
366 node->SetTakeResource(rub);
367 node->SetRate(AA_FLOW_SHARE_RATE);
368 node->SetLimit(AA_EVENT_AMOUNT_2 / AA_FLOW_SHARE_RATE);
369 rv = saver->Save(node, nsnull);
370 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveFlow' 2nd insertion" );
372 entity = do_QueryElementAt(mEntitySet, 3);
373 node->SetEntity(entity);
374 node->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_5));
375 node->SetGiveResource(rub);
376 node->SetTakeResource(rub);
377 node->SetRate(1.0);
378 node->SetLimit(0.0);
379 rv = saver->Save(node, nsnull);
380 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'saveFlow' 3rd insertion" );
382 return NS_OK;
385 nsresult
386 aaStorageTest::testLoadFlow(nsITestRunner *aTestRunner)
388 NS_TEST_BEGIN(aTestRunner);
389 nsresult rv;
391 aaSession *session = static_cast<aaSession *>(mSession.get());
392 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
394 mFlowSet = do_CreateInstance(AA_LOADFLOW_CONTRACT_ID, session->mConnection,
395 &rv);
396 NS_TEST_ASSERT_MSG(mFlowSet, "'loadFlow' instance creation" );
397 NS_ENSURE_SUCCESS(rv, rv);
399 rv = mFlowSet->Load();
400 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadFlow' load" );
402 nsCOMPtr<aaIFlow> node(do_QueryElementAt(mFlowSet, 0, &rv));
403 NS_TEST_ASSERT_MSG(node, "'loadFlow' first item not read" );
404 NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
406 nsEmbedString tag;
407 node->GetTag(tag);
408 NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_FLOW_TAG_1)),
409 "'loadFlow' first item read differs from inserted" );
411 nsCOMPtr<aaIEntity> entity;
412 rv = node->GetEntity(getter_AddRefs( entity ));
413 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadFlow' flow.entity read" );
414 NS_TEST_ASSERT_MSG(entity, "'loadFlow' flow.entity read is null" );
415 if (entity) {
416 entity->GetTag(tag);
417 NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_ENTITY_TAG_2)),
418 "'loadFlow' flow.entity differs from inserted" );
421 nsCOMPtr<aaIResource> res;
422 rv = node->GetGiveResource(getter_AddRefs( res ));
423 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv),
424 "'loadFlow' flow.giveResource not read" );
425 NS_TEST_ASSERT_MSG(res, "'loadFlow' flow.giveResource read is null" );
426 if (res) {
427 res->GetTag(tag);
428 NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_2)),
429 "'loadFlow' flow.giveResource differs from inserted" );
432 rv = node->GetTakeResource(getter_AddRefs( res ));
433 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv),
434 "'loadFlow' flow.takeResource not read" );
435 NS_TEST_ASSERT_MSG(res, "'loadFlow' flow.takeResource read is null" );
436 if (res) {
437 res->GetTag(tag);
438 NS_TEST_ASSERT_MSG(tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_1)),
439 "'loadFlow' flow.takeResource differs from inserted" );
442 double rate;
443 rv = node->GetRate( &rate );
444 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "'loadFlow' flow.rate not read" );
445 NS_TEST_ASSERT_MSG(rate == AA_FLOW_SHARE_RATE,
446 "'loadFlow' flow.rate differs from inserted" );
448 return NS_OK;
451 nsresult
452 aaStorageTest::testSaveEvent(nsITestRunner *aTestRunner)
454 NS_TEST_BEGIN(aTestRunner);
455 nsresult rv;
457 aaSession *session = static_cast<aaSession *>(mSession.get());
458 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
460 nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
461 AA_SAVEEVENT_CONTRACT_ID, session->mConnection, &rv));
462 NS_TEST_ASSERT_MSG(saver, "'saveEvent' instance creation" );
464 nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
465 /* Set time to 2007-08-29 */
466 PRExplodedTime tm = {0,0,0,12,29,7,2007};
467 node->SetTime(PR_ImplodeTime(&tm));
469 nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
470 NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
472 /* Fact 1 */
473 nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
474 fact->SetAmount(AA_EVENT_AMOUNT_2);
475 nsCOMPtr<aaIFlow> flow(do_QueryElementAt(mFlowSet,1));
476 fact->SetTakeFrom(flow);
477 flow = do_QueryElementAt(mFlowSet,2);
478 fact->SetGiveTo(flow);
480 rv = block->AppendElement(fact, PR_FALSE);
481 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[insert event] appendElement" );
483 rv = saver->Save(node, nsnull);
484 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[insert event] saving" );
486 return NS_OK;
489 PRBool
490 testState(nsITestRunner *cxxUnitTestRunner, aaIState *node, PRInt64 flowId,
491 PRInt64 resourceId, double sum)
493 NS_TEST_ASSERT_MSG(node, " 'state' is null");
494 nsresult rv;
495 PRBool equals = PR_TRUE;
496 nsCOMPtr<aaIFlow> flow;
497 rv = node->GetFlow(getter_AddRefs( flow ));
498 NS_TEST_ASSERT_MSG(flow, " 'state.flow' is null");
499 PRInt64 id;
500 nsEmbedString tag;
501 if (NS_LIKELY( flow )) {
502 flow->GetId(&id);
503 if (NS_UNLIKELY( id != flowId) ) {
504 equals = PR_FALSE;
505 NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.flow.id' is wrong");
507 } else {
508 equals = PR_FALSE;
511 nsCOMPtr<aaIResource> resource;
512 rv = node->GetResource(getter_AddRefs( resource ));
513 NS_TEST_ASSERT_MSG(resource, " 'state.resource' is null" );
514 if (NS_LIKELY( resource )) {
515 resource->GetId(&id);
516 if (NS_UNLIKELY( id != resourceId) ) {
517 equals = PR_FALSE;
518 NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.resource.id' is wrong");
520 } else {
521 equals = PR_FALSE;
524 double amount, diff;
525 rv = node->GetAmount(&amount);
526 diff = amount - sum;
527 if (! isZero(diff)) {
528 equals = PR_FALSE;
529 NS_TEST_ASSERT_MSG(PR_FALSE, " 'state.amount' is wrong");
532 return equals;
535 nsresult
536 aaStorageTest::testLoadFlowStates(nsITestRunner *aTestRunner)
538 NS_TEST_BEGIN(aTestRunner);
539 nsresult rv;
541 aaSession *session = static_cast<aaSession *>(mSession.get());
542 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
544 session->mConnection = nsnull;
545 session->getDatabase();
546 nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
547 AA_LOADFLOWSTATES_CONTRACT_ID, session->mConnection, &rv));
548 NS_TEST_ASSERT_MSG(set, "[load states] instance creation" );
549 NS_ENSURE_SUCCESS(rv, rv);
551 rv = set->Load();
552 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[load states] loading" );
553 NS_ENSURE_TRUE(set, NS_ERROR_FAILURE);
555 PRUint32 count;
556 set->GetLength(&count);
557 NS_TEST_ASSERT_MSG(count == 2, "[load states] wrong flow count");
559 nsCOMPtr<aaIState> node(do_QueryElementAt(set, 0, &rv));
560 NS_TEST_ASSERT_MSG(node, "[load states 1st item not read" );
561 NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
563 NS_TEST_ASSERT_MSG(testState(aTestRunner, node, 2, 2, AA_EVENT_AMOUNT_2
564 / AA_FLOW_SHARE_RATE), "[load states] flow2 is wrong");
566 nsCOMPtr<aaIFlow> flow;
567 nsEmbedString tag;
568 node->GetFlow(getter_AddRefs( flow ));
569 if (flow) {
570 flow->GetTag(tag);
571 NS_TEST_ASSERT_MSG( tag.Equals(NS_ConvertUTF8toUTF16(AA_FLOW_TAG_3)),
572 "[load states] 'fact.flow.tag' is wrong" );
575 nsCOMPtr<aaIResource> resource;
576 node->GetResource(getter_AddRefs( resource ));
577 if (resource) {
578 resource->GetTag(tag);
579 NS_TEST_ASSERT_MSG( tag.Equals(NS_ConvertUTF8toUTF16(AA_RESOURCE_TAG_2)),
580 "[load states] 'state.resource.tag' is wrong" );
583 node = do_QueryElementAt(set, 1, &rv);
584 NS_TEST_ASSERT_MSG(node, "[load states] 2nd item not read" );
585 NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
587 NS_TEST_ASSERT_MSG(testState(aTestRunner, node, 3, 1, AA_EVENT_AMOUNT_2),
588 "[load states] flow3 is wrong");
590 return NS_OK;
593 nsresult
594 aaStorageTest::testUpdateEvent(nsITestRunner *aTestRunner)
596 NS_TEST_BEGIN(aTestRunner);
597 nsresult rv;
599 aaSession *session = static_cast<aaSession *>(mSession.get());
600 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
602 nsCOMPtr<aaISaveQuery> saver(do_CreateInstance(
603 AA_SAVEEVENT_CONTRACT_ID, session->mConnection, &rv));
604 NS_TEST_ASSERT_MSG(saver, "'saveEvent' instance creation" );
605 NS_ENSURE_TRUE(saver, NS_ERROR_UNEXPECTED);
607 nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
608 /* Set time to 2007-08-29 */
609 PRExplodedTime tm = {0,0,0,12,29,7,2007};
610 node->SetTime(PR_ImplodeTime(&tm));
612 nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
613 NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
615 /* Fact 2 */
616 nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
617 fact->SetAmount(AA_EVENT_AMOUNT_3);
618 nsCOMPtr<aaIFlow> flow(do_QueryElementAt(mFlowSet,0));
619 fact->SetTakeFrom(flow);
620 flow = do_QueryElementAt(mFlowSet,2);
621 fact->SetGiveTo(flow);
623 rv = block->AppendElement(fact, PR_FALSE);
624 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update event] appending element" );
626 rv = saver->Save(node, nsnull);
627 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update event] saving" );
629 nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
630 AA_LOADFLOWSTATES_CONTRACT_ID, session->mConnection, &rv));
631 NS_TEST_ASSERT_MSG(set, "[update event] creating loader" );
632 NS_ENSURE_SUCCESS(rv, rv);
634 rv = set->Load();
635 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[update event] loading states" );
637 PRUint32 count;
638 set->GetLength(&count);
639 NS_TEST_ASSERT_MSG(count == 3, "[update event] wrong flow count");
641 nsCOMPtr<aaIState> state;
642 state = do_QueryElementAt(set, 2, &rv);
643 NS_TEST_ASSERT_MSG(state, "[update event] 3rd item not read" );
644 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
646 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 1, 2, AA_EVENT_AMOUNT_3
647 / AA_FLOW_SHARE_RATE), "[update event] flow1 is wrong");
649 state = do_QueryElementAt(set, 1, &rv);
650 NS_TEST_ASSERT_MSG(state, "[update event] 2nd item not read" );
651 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
653 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
654 + AA_EVENT_AMOUNT_3), "[update event] flow3 is wrong");
655 return NS_OK;
658 nsresult
659 aaStorageTest::testReplaceEvent(nsITestRunner *aTestRunner)
661 NS_TEST_BEGIN(aTestRunner);
662 nsresult rv;
664 aaSession *session = static_cast<aaSession *>(mSession.get());
665 NS_ENSURE_TRUE(session, NS_ERROR_UNEXPECTED);
667 nsCOMPtr<aaIResource> vaio(do_CreateInstance("@aasii.org/base/resource;1"));
668 NS_ENSURE_TRUE(vaio, NS_ERROR_FAILURE);
669 vaio->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_3));
670 session->Save(vaio, nsnull);
672 PRInt64 id;
673 vaio->GetId( &id );
674 NS_TEST_ASSERT_MSG(id == 3, "[replace event] unexpected 'resource.id'");
675 NS_ENSURE_TRUE(id == 3, NS_ERROR_UNEXPECTED);
677 nsCOMPtr<aaIEntity> shop(do_CreateInstance("@aasii.org/base/entity;1"));
678 NS_ENSURE_TRUE(shop, NS_ERROR_FAILURE);
679 shop->SetTag(NS_LITERAL_STRING(AA_ENTITY_TAG_5));
680 session->Save(shop, nsnull);
682 shop->GetId( &id );
683 NS_TEST_ASSERT_MSG(id == 5, "[replace event] unexpected 'entity.id'");
684 NS_ENSURE_TRUE(id == 5, NS_ERROR_UNEXPECTED);
686 nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet,0));
688 nsCOMPtr<aaIFlow> purchase(do_CreateInstance("@aasii.org/base/flow;1"));
689 NS_ENSURE_TRUE(purchase, NS_ERROR_FAILURE);
690 purchase->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_6));
691 purchase->SetEntity(shop);
692 purchase->SetGiveResource(rub);
693 purchase->SetTakeResource(vaio);
694 purchase->SetRate(1.0 / AA_EVENT_AMOUNT_4);
695 purchase->SetLimit(AA_EVENT_AMOUNT_5);
696 rv = session->Save(purchase, nsnull);
697 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] saving flow");
698 NS_ENSURE_SUCCESS(rv, rv);
700 purchase->GetId( &id );
701 NS_TEST_ASSERT_MSG(id == 4, "[replace event] unexpected 'flow.id'");
702 NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
704 nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
705 /* Set time to 2007-08-30 */
706 PRExplodedTime tm = {0,0,0,12,30,7,2007};
707 node->SetTime(PR_ImplodeTime(&tm));
709 nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
710 NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
712 /* Fact 3 */
713 nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
714 fact->SetAmount(AA_EVENT_AMOUNT_4);
715 nsCOMPtr<aaIFlow> flow(do_QueryElementAt(mFlowSet,2));
716 fact->SetTakeFrom(flow);
717 fact->SetGiveTo(purchase);
719 rv = block->AppendElement(fact, PR_FALSE);
720 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] appending element" );
722 rv = session->Save(node, nsnull);
723 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] saving" );
725 nsCOMPtr<aaILoadQuery> set(do_CreateInstance(
726 AA_LOADFLOWSTATES_CONTRACT_ID, session->mConnection, &rv));
727 NS_TEST_ASSERT_MSG(set, "[replace event] creating loader" );
728 NS_ENSURE_SUCCESS(rv, rv);
730 rv = set->Load();
731 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[replace event] loading states" );
733 PRUint32 count;
734 set->GetLength(&count);
735 NS_TEST_ASSERT_MSG(count == 4, "[replace event] wrong flow count");
737 nsCOMPtr<aaIState> state;
738 state = do_QueryElementAt(set, 2, &rv);
739 NS_TEST_ASSERT_MSG(state, "[replace event] 2nd item not read" );
740 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
742 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
743 + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4),
744 "[replace event] flow3 is wrong");
746 state = do_QueryElementAt(set, 3, &rv);
747 NS_TEST_ASSERT_MSG(state, "[replace event] 4th item not read" );
748 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
750 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 4, 3, AA_EVENT_AMOUNT_5),
751 "[replace event] flow4 is wrong");
752 return NS_OK;
755 nsresult
756 aaStorageTest::testDeleteEvent(nsITestRunner *aTestRunner)
758 NS_TEST_BEGIN(aTestRunner);
759 nsresult rv;
761 rv = mResourceSet->Load();
762 NS_TEST_ASSERT_OK(rv);
764 nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet, 0, &rv));
765 NS_ENSURE_TRUE(rub, rv);
767 PRInt64 id;
768 rub->GetId( &id );
769 NS_TEST_ASSERT_MSG(id == 1, "[delete event] unexpected 'resource.id'");
770 NS_ENSURE_TRUE(id == 1, NS_ERROR_UNEXPECTED);
772 nsCOMPtr<aaIResource> eur(do_CreateInstance("@aasii.org/base/resource;1"));
773 NS_ENSURE_TRUE(eur, NS_ERROR_FAILURE);
774 eur->SetTag(NS_LITERAL_STRING(AA_RESOURCE_TAG_4));
775 mSession->Save(eur, nsnull);
777 eur->GetId( &id );
778 NS_TEST_ASSERT_MSG(id == 4, "[delete event] unexpected 'resource.id'");
779 NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
781 rv = mEntitySet->Load();
782 NS_TEST_ASSERT_OK(rv);
784 nsCOMPtr<aaIEntity> bank(do_QueryElementAt(mEntitySet, 3, &rv));
785 NS_ENSURE_TRUE(bank, rv);
787 bank->GetId( &id );
788 NS_TEST_ASSERT_MSG(id == 4, "[delete event] unexpected 'entity.id'");
789 NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
791 rv = mFlowSet->Load();
792 NS_TEST_ASSERT_OK(rv);
794 nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlowSet,2));
796 /* Flow for a forex deal */
797 nsCOMPtr<aaIFlow> forex(do_CreateInstance("@aasii.org/base/flow;1"));
798 NS_ENSURE_TRUE(forex, NS_ERROR_FAILURE);
799 forex->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_7));
800 forex->SetEntity(bank);
801 forex->SetGiveResource(rub);
802 forex->SetTakeResource(eur);
803 forex->SetRate(1 / AA_EVENT_RATE_2);
804 forex->SetLimit(AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2);
805 rv = mSession->Save(forex, nsnull);
806 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving flow");
807 NS_ENSURE_SUCCESS(rv, rv);
809 forex->GetId( &id );
810 NS_TEST_ASSERT_MSG(id == 5, "[delete event] unexpected 'flow.id'");
811 NS_ENSURE_TRUE(id == 5, NS_ERROR_UNEXPECTED);
813 /* Flow for EUR in the bank */
814 nsCOMPtr<aaIFlow> bankAccEur(do_CreateInstance("@aasii.org/base/flow;1"));
815 NS_ENSURE_TRUE(bankAccEur, NS_ERROR_FAILURE);
816 bankAccEur->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_8));
817 bankAccEur->SetEntity(bank);
818 bankAccEur->SetGiveResource(eur);
819 bankAccEur->SetTakeResource(eur);
820 bankAccEur->SetRate(1);
821 bankAccEur->SetLimit(0.0);
822 rv = mSession->Save(bankAccEur, nsnull);
823 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving flow");
824 NS_ENSURE_SUCCESS(rv, rv);
826 bankAccEur->GetId( &id );
827 NS_TEST_ASSERT_MSG(id == 6, "[delete event] unexpected 'flow.id'");
828 NS_ENSURE_TRUE(id == 6, NS_ERROR_UNEXPECTED);
830 nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
831 /* Set time to 2007-08-30 */
832 PRExplodedTime tm = {0,0,0,12,30,7,2007};
833 node->SetTime(PR_ImplodeTime(&tm));
835 nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
836 NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
838 /* Fact 4 */
839 nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
840 fact->SetAmount(AA_EVENT_AMOUNT_6);
841 fact->SetTakeFrom(forex);
842 fact->SetGiveTo(bankAccEur);
844 rv = block->AppendElement(fact, PR_FALSE);
845 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] appending element" );
847 rv = mSession->Save(node, nsnull);
848 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving [2]" );
850 nsCOMPtr<aaILoadQuery> set;
851 mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs( set ));
852 NS_TEST_ASSERT_MSG(set, "[delete event] creating loader" );
853 NS_ENSURE_SUCCESS(rv, rv);
855 rv = set->Load();
856 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] loading states [2]" );
858 PRUint32 count;
859 set->GetLength(&count);
860 NS_TEST_ASSERT_MSG(count == 6, "[delete event] wrong flow count");
862 nsCOMPtr<aaIState> state;
863 state = do_QueryElementAt(set, 2, &rv);
864 NS_TEST_ASSERT_MSG(state, "[delete event] 2nd item not read" );
865 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
867 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
868 + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4),
869 "[delete event] flow3 is wrong");
871 state = do_QueryElementAt(set, 4, &rv);
872 NS_TEST_ASSERT_MSG(state, "[delete event] 4th item not read" );
873 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
875 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 5, 1, AA_EVENT_AMOUNT_6
876 * AA_EVENT_RATE_2),
877 "[delete event] flow5 is wrong");
879 state = do_QueryElementAt(set, 5, &rv);
880 NS_TEST_ASSERT_MSG(state, "[delete event] 4th item not read" );
881 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
883 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 6, 4, AA_EVENT_AMOUNT_6),
884 "[delete event] flow6 is wrong");
885 /* Fact 4 is processed correctly */
887 node = do_CreateInstance("@aasii.org/base/event;1");
888 /* Set time to 2007-08-30 */
889 node->SetTime(PR_ImplodeTime(&tm));
891 block = do_QueryInterface( node );
892 NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
894 /* Fact 5 */
895 fact = do_CreateInstance("@aasii.org/base/fact;1");
896 /* Forex deal is paid correctly */
897 fact->SetAmount(AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2);
898 fact->SetTakeFrom(bankAccRub);
899 fact->SetGiveTo(forex);
901 rv = block->AppendElement(fact, PR_FALSE);
902 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] appending element" );
904 rv = mSession->Save(node, nsnull);
905 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] saving" );
907 rv = set->Load();
908 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] loading states" );
910 set->GetLength(&count);
911 NS_TEST_ASSERT_MSG(count == 5, "[delete event] wrong flow count");
913 state = do_QueryElementAt(set, 2, &rv);
914 NS_TEST_ASSERT_MSG(state, "[delete event] 2nd item not read" );
915 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
917 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
918 + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
919 - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
920 "[delete event] flow3 is wrong");
922 state = do_QueryElementAt(set, 4, &rv);
923 NS_TEST_ASSERT_MSG(state, "[delete event] 4th item not read" );
924 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
926 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 6, 4, AA_EVENT_AMOUNT_6),
927 "[delete event] flow6 is wrong");
929 nsCOMPtr<aaIFilter> filter;
930 rv = set->GetFilter(getter_AddRefs( filter ));
931 NS_TEST_ASSERT_OK(rv);
932 NS_ENSURE_SUCCESS(rv, rv);
934 nsCOMPtr<aaIStringFilter> strFilter(do_QueryInterface(filter, &rv));
935 NS_ENSURE_TRUE(strFilter, rv);
936 strFilter->SetExpression(NS_LITERAL_CSTRING(" WHERE state.id = 6"));
938 rv = set->SetFilter(filter);
939 NS_TEST_ASSERT_OK(rv);
940 NS_ENSURE_SUCCESS(rv, rv);
942 rv = set->Load();
943 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[delete event] loading states" );
945 set->GetLength(&count);
946 NS_TEST_ASSERT_MSG(count == 0, "[delete event] wrong flow count");
947 return NS_OK;
950 nsresult
951 aaStorageTest::testStopEvent(nsITestRunner *aTestRunner)
953 NS_TEST_BEGIN(aTestRunner);
954 nsresult rv;
956 rv = mResourceSet->Load();
957 NS_TEST_ASSERT_OK(rv);
959 nsCOMPtr<aaIResource> rub(do_QueryElementAt(mResourceSet, 0, &rv));
960 NS_ENSURE_TRUE(rub, rv);
962 PRInt64 id;
963 rub->GetId( &id );
964 NS_TEST_ASSERT_MSG(id == 1, "[stop event] unexpected 'resource.id'");
965 NS_ENSURE_TRUE(id == 1, NS_ERROR_UNEXPECTED);
967 nsCOMPtr<aaIResource> eur(do_QueryElementAt(mResourceSet, 3, &rv));
968 NS_ENSURE_TRUE(eur, NS_ERROR_FAILURE);
970 eur->GetId( &id );
971 NS_TEST_ASSERT_MSG(id == 4, "[stop event] unexpected 'resource.id'");
972 NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
974 rv = mEntitySet->Load();
975 NS_TEST_ASSERT_OK(rv);
977 nsCOMPtr<aaIEntity> bank(do_QueryElementAt(mEntitySet, 3, &rv));
978 NS_ENSURE_TRUE(bank, rv);
980 bank->GetId( &id );
981 NS_TEST_ASSERT_MSG(id == 4, "[stop event] unexpected 'entity.id'");
982 NS_ENSURE_TRUE(id == 4, NS_ERROR_UNEXPECTED);
984 rv = mFlowSet->Load();
985 NS_TEST_ASSERT_OK(rv);
987 nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlowSet,2));
988 nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlowSet,5));
990 /* Flow for a forex deal #2*/
991 nsCOMPtr<aaIFlow> forex(do_CreateInstance("@aasii.org/base/flow;1"));
992 NS_ENSURE_TRUE(forex, NS_ERROR_FAILURE);
993 forex->SetTag(NS_LITERAL_STRING(AA_FLOW_TAG_9));
994 forex->SetEntity(bank);
995 forex->SetGiveResource(eur);
996 forex->SetTakeResource(rub);
997 forex->SetRate(AA_EVENT_RATE_3);
998 forex->SetLimit(AA_EVENT_AMOUNT_6);
999 rv = mSession->Save(forex, nsnull);
1000 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] saving flow");
1001 NS_ENSURE_SUCCESS(rv, rv);
1003 forex->GetId( &id );
1004 NS_TEST_ASSERT_MSG(id == 7, "[stop event] unexpected 'flow.id'");
1005 NS_ENSURE_TRUE(id == 7, NS_ERROR_UNEXPECTED);
1007 nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
1008 /* Set time to 2007-08-31 */
1009 PRExplodedTime tm = {0,0,0,12,31,7,2007};
1010 node->SetTime(PR_ImplodeTime(&tm));
1012 nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
1013 NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
1015 /* Fact 6 */
1016 nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
1017 fact->SetAmount(AA_EVENT_AMOUNT_6);
1018 fact->SetTakeFrom(bankAccEur);
1019 fact->SetGiveTo(forex);
1021 rv = block->AppendElement(fact, PR_FALSE);
1022 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] appending element" );
1024 rv = mSession->Save(node, nsnull);
1025 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] saving" );
1027 nsCOMPtr<aaILoadQuery> set;
1028 mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs( set ));
1029 NS_TEST_ASSERT_MSG(set, "[stop event] creating loader" );
1030 NS_ENSURE_SUCCESS(rv, rv);
1032 rv = set->Load();
1033 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] loading states" );
1035 PRUint32 count;
1036 set->GetLength(&count);
1037 NS_TEST_ASSERT_MSG(count == 5, "[stop event] wrong flow count");
1039 nsCOMPtr<aaIState> state;
1040 state = do_QueryElementAt(set, 2, &rv);
1041 NS_TEST_ASSERT_MSG(state, "[stop event] 2nd item not read" );
1042 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1044 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
1045 + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1046 - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
1047 "[stop event] flow3 is wrong");
1049 state = do_QueryElementAt(set, 4, &rv);
1050 NS_TEST_ASSERT_MSG(state, "[stop event] 4th item not read" );
1051 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1053 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 7, 1, AA_EVENT_AMOUNT_6
1054 * AA_EVENT_RATE_3),
1055 "[stop event] flow7 is wrong");
1056 /* Forex deal #2 is paid correctly */
1058 nsCOMPtr<aaIFilter> filter;
1059 rv = set->GetFilter(getter_AddRefs( filter ));
1060 NS_TEST_ASSERT_OK(rv);
1061 NS_ENSURE_SUCCESS(rv, rv);
1063 nsCOMPtr<aaIStringFilter> strFilter(do_QueryInterface(filter, &rv));
1064 NS_ENSURE_TRUE(strFilter, rv);
1065 strFilter->SetExpression(NS_LITERAL_CSTRING(" WHERE state.flow_id = 6\
1066 AND state.paid = 2454344"));
1068 rv = set->SetFilter(filter);
1069 NS_TEST_ASSERT_OK(rv);
1070 NS_ENSURE_SUCCESS(rv, rv);
1072 rv = set->Load();
1073 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[stop event] loading states" );
1075 set->GetLength(&count);
1076 NS_TEST_ASSERT_MSG(count == 1, "[stop event] wrong flow count");
1078 state = do_QueryElementAt(set, 0, &rv);
1079 NS_TEST_ASSERT_MSG(state, "[stop event] item not read" );
1080 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1082 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 6, 4, AA_EVENT_AMOUNT_6),
1083 "[stop event] flow6 is wrong");
1084 return NS_OK;
1087 nsresult
1088 aaStorageTest::testJunkEvent(nsITestRunner *aTestRunner)
1090 NS_TEST_BEGIN(aTestRunner);
1091 nsresult rv;
1093 rv = mFlowSet->Load();
1094 NS_TEST_ASSERT_OK(rv);
1096 nsCOMPtr<aaIFlow> bankAccRub(do_QueryElementAt(mFlowSet,2));
1097 nsCOMPtr<aaIFlow> bankAccEur(do_QueryElementAt(mFlowSet,5));
1099 nsCOMPtr<aaIEvent> node(do_CreateInstance("@aasii.org/base/event;1"));
1100 /* Set time to 2007-08-31 */
1101 PRExplodedTime tm = {0,0,0,12,31,7,2007};
1102 node->SetTime(PR_ImplodeTime(&tm));
1104 nsCOMPtr<nsIMutableArray> block(do_QueryInterface( node ));
1105 NS_ENSURE_TRUE(block, NS_ERROR_UNEXPECTED);
1107 /* Junk Fact */
1108 nsCOMPtr<aaIFact> fact(do_CreateInstance("@aasii.org/base/fact;1"));
1109 fact->SetAmount(1);
1110 fact->SetTakeFrom(bankAccEur);
1111 fact->SetGiveTo(bankAccRub);
1113 rv = block->AppendElement(fact, PR_FALSE);
1114 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[junk event] appending element" );
1116 rv = mSession->Save(node, nsnull);
1117 NS_TEST_ASSERT_MSG(NS_FAILED(rv), "[junk event] saving" );
1119 nsCOMPtr<aaILoadQuery> set;
1120 mSession->CreateQuery(AA_LOADFLOWSTATES_CONTRACT_ID, getter_AddRefs( set ));
1121 NS_TEST_ASSERT_MSG(set, "[junk event] creating loader" );
1122 NS_ENSURE_TRUE(set, rv);
1124 rv = set->Load();
1125 NS_TEST_ASSERT_MSG(NS_SUCCEEDED(rv), "[junk event] loading states" );
1127 PRUint32 count;
1128 set->GetLength(&count);
1129 NS_TEST_ASSERT_MSG(count == 5, "[junk event] wrong flow count");
1131 nsCOMPtr<aaIState> state;
1132 state = do_QueryElementAt(set, 2, &rv);
1133 NS_TEST_ASSERT_MSG(state, "[junk event] 2nd item not read" );
1134 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1136 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 3, 1, AA_EVENT_AMOUNT_2
1137 + AA_EVENT_AMOUNT_3 - AA_EVENT_AMOUNT_4
1138 - AA_EVENT_AMOUNT_6 * AA_EVENT_RATE_2),
1139 "[junk event] flow3 is wrong");
1141 state = do_QueryElementAt(set, 4, &rv);
1142 NS_TEST_ASSERT_MSG(state, "[junk event] 4th item not read" );
1143 NS_ENSURE_TRUE(state, NS_ERROR_FAILURE);
1145 NS_TEST_ASSERT_MSG(testState(aTestRunner, state, 7, 1, AA_EVENT_AMOUNT_6
1146 * AA_EVENT_RATE_3),
1147 "[junk event] flow7 is wrong");
1148 /* Forex deal #2 is paid correctly */
1150 return NS_OK;
1153 NS_GENERIC_FACTORY_CONSTRUCTOR(aaStorageTest)
1155 static const nsModuleComponentInfo kComponents[] =
1158 "Storage Module Unit Test",
1159 AA_STORAGE_TEST_CID,
1160 AA_STORAGE_TEST_CONTRACT_ID,
1161 aaStorageTestConstructor
1164 NS_IMPL_NSGETMODULE(aabase, kComponents)