base/aaBaseTest.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent tw=79 ft=cpp: */
   3 /*
   4  * Copyright (C) 2007 Sergey Yanovich <ynvich@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License as
   8  * published by the Free Software Foundation; either version 2 of the
   9  * License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public
  17  * License along with this program; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22 #include <abstract/aacore.h>
  23
  24 #include <stdio.h>
  25 #include "nsStringAPI.h"
  26 #include "nsIGenericFactory.h"
  27 #include "nsComponentManagerUtils.h"
  28 #include "nsEmbedString.h"
  29 #include "nsIMutableArray.h"
  30 #include "nsCOMArray.h"
  31 #include "nsMemory.h"
  32 #include "nsIClassInfoImpl.h"
  33
  34 /* Unfrozen API */
  35 #include <abstract/cxxunit/nsTestUtils.h>
  36 #include <abstract/cxxunit/nsITest.h>
  37 #include <abstract/cxxunit/nsITestRunner.h>
  38
  39 /* Project includes */
  40 #include <abstract/base/aaIEntity.h>
  41 #include <abstract/base/aaIResource.h>
  42 #include <abstract/base/aaIFlow.h>
  43 #include <abstract/base/aaIFact.h>
  44 #include <abstract/base/aaIBalance.h>
  45 #include <abstract/base/aaIEvent.h>
  46 #include <abstract/base/aaIHandler.h>
  47 #include <abstract/base/aaITransaction.h>
  48 #include "aaResource.h"
  49 #include "aaEntity.h"
  50 #include "aaFlow.h"
  51 #include "aaFact.h"
  52 #include "aaState.h"
  53 #include "aaEvent.h"
  54 #include "aaIncomeFlow.h"
  55
  56 #define AA_BASE_TEST_CID \
  57 {0x502c6e1e, 0x42c4, 0x46b1, {0xa4, 0x7b, 0x19, 0x42, 0x8a, 0xd6, 0x75, 0x58}}
  58 #define AA_BASE_TEST_CONTRACT_ID "@aasii.org/base/unit;1"
  59
  60 NS_DECL_CLASSINFO(aaResource)
  61 NS_DECL_CLASSINFO(aaEvent)
  62
  63 class aaBaseTest: public nsITest,
  64                   public aaIHandler
  65 {
  66 public:
  67   aaBaseTest() {;}
  68   virtual ~aaBaseTest() {;}
  69   NS_DECL_ISUPPORTS
  70   NS_DECL_NSITEST
  71   NS_DECL_AAIHANDLER
  72 private:
  73 #define AA_BASE_TEST_ENTITY   1
  74 #define AA_BASE_TEST_RESOURCE   2
  75 #define AA_BASE_TEST_FLOW     4
  76 #define AA_BASE_TEST_FACT     8
  77 #define AA_BASE_TEST_EVENT   16
  78 #define AA_BASE_TEST_ACCOUNT 32
  79   PRUint32 mPackQueries;
  80   PRUint32 mPackParam;
  81
  82   nsresult testEntity(nsITestRunner *aTestRunner);
  83   nsresult testResource(nsITestRunner *aTestRunner);
  84   nsresult testFlow(nsITestRunner *aTestRunner);
  85   nsresult testFact(nsITestRunner *aTestRunner);
  86   nsresult testState(nsITestRunner *aTestRunner);
  87   nsresult testEvent(nsITestRunner *aTestRunner);
  88   nsresult testIncomeFlow(nsITestRunner *aTestRunner);
  89 };
  90
  91 NS_IMETHODIMP
  92 aaBaseTest::Test(nsITestRunner *aTestRunner)
  93 {
  94   nsITestRunner *cxxUnitTestRunner = aTestRunner;
  95   NS_TEST_ASSERT_OK(testEntity(aTestRunner));
  96   NS_TEST_ASSERT_OK(testResource(aTestRunner));
  97   NS_TEST_ASSERT_OK(testFlow(aTestRunner));
  98   NS_TEST_ASSERT_OK(testEvent(aTestRunner));
  99   NS_TEST_ASSERT_OK(testFact(aTestRunner));
 100   NS_TEST_ASSERT_OK(testState(aTestRunner));
 101   NS_TEST_ASSERT_OK(testIncomeFlow(aTestRunner));
 102   return NS_OK;
 103 }
 104
 105 NS_IMPL_ISUPPORTS1(aaBaseTest, nsITest);
 106
 107 NS_GENERIC_FACTORY_CONSTRUCTOR(aaBaseTest)
 108
 109 static const nsModuleComponentInfo components[] =
 110 {
 111   { "Base Module Unit Test",
 112     AA_BASE_TEST_CID,
 113     AA_BASE_TEST_CONTRACT_ID,
 114     aaBaseTestConstructor }
 115 };
 116
 117 NS_IMPL_NSGETMODULE(aabaset, components)
 118
 119 /* aaIHandler */
 120 NS_IMETHODIMP
 121 aaBaseTest::HandleEntity(aaIEntity *aEntity)
 122 {
 123   mPackQueries |= AA_BASE_TEST_ENTITY;
 124   if (aEntity)
 125     mPackParam |= AA_BASE_TEST_ENTITY;
 126   return NS_OK;
 127 }
 128
 129 NS_IMETHODIMP
 130 aaBaseTest::HandleResource(aaIResource *aResource)
 131 {
 132   mPackQueries |= AA_BASE_TEST_RESOURCE;
 133   if (aResource)
 134     mPackParam |= AA_BASE_TEST_RESOURCE;
 135   return NS_OK;
 136 }
 137
 138 NS_IMETHODIMP
 139 aaBaseTest::HandleFlow(aaIFlow *aFlow)
 140 {
 141   mPackQueries |= AA_BASE_TEST_FLOW;
 142   if (aFlow)
 143     mPackParam |= AA_BASE_TEST_FLOW;
 144   return NS_OK;
 145 }
 146
 147 NS_IMETHODIMP
 148 aaBaseTest::HandleFact(aaIFact *aFact)
 149 {
 150   mPackQueries |= AA_BASE_TEST_FACT;
 151   if (aFact)
 152     mPackParam |= AA_BASE_TEST_FACT;
 153   return NS_OK;
 154 }
 155
 156 NS_IMETHODIMP
 157 aaBaseTest::HandleEvent(aaIEvent *aEvent)
 158 {
 159   mPackQueries |= AA_BASE_TEST_EVENT;
 160   if (aEvent)
 161     mPackParam |= AA_BASE_TEST_EVENT;
 162   return NS_OK;
 163 }
 164
 165 NS_IMETHODIMP
 166 aaBaseTest::HandleQuote(aaIQuote *aQuote)
 167 {
 168   return NS_OK;
 169 }
 170
 171 NS_IMETHODIMP
 172 aaBaseTest::HandleTransaction(aaITransaction *aTransaction)
 173 {
 174   return NS_OK;
 175 }
 176
 177 /* Private methods */
 178 nsresult
 179 aaBaseTest::testEntity(nsITestRunner *aTestRunner)
 180 {
 181   NS_TEST_BEGIN( aTestRunner );
 182   nsresult rv;
 183   nsCOMPtr<aaIEntity> entity(do_CreateInstance(AA_ENTITY_CONTRACT_ID, &rv));
 184   NS_TEST_ASSERT_MSG(entity, "aaEntity instance creation" );
 185   NS_ENSURE_SUCCESS(rv, rv);
 186   nsCOMPtr<aaIDataNode> item(do_QueryInterface(entity, &rv));
 187   NS_TEST_ASSERT_MSG(item, "aaEntity aaIDataNode interface" );
 188   NS_ENSURE_SUCCESS(rv, rv);
 189
 190   mPackParam = mPackQueries = 0;
 191   rv = item->Accept(this);
 192   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_ENTITY,
 193       "aaEntity->Accept doesn't return query" );
 194   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_ENTITY),
 195       "aaEntity->Accept returns incorrect query" );
 196   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_ENTITY,
 197       "aaEntity->Accept doesn't provide valid parameter" );
 198   NS_TEST_ASSERT_OK(rv);
 199
 200   aaEntity* raw = static_cast<aaEntity *>(entity.get());
 201   nsEmbedString wstr(NS_LITERAL_STRING("init"));
 202   NS_TEST_ASSERT_MSG(! raw->mEdited, "blank aaEntity marked edited");
 203   entity->SetTag(wstr);
 204   NS_TEST_ASSERT_MSG(! raw->mEdited, "hidden aaEntity marked edited");
 205   NS_TEST_ASSERT_MSG(! raw->mRead, "hidden aaEntity marked read");
 206   entity->GetTag(wstr);
 207   NS_TEST_ASSERT_MSG(! raw->mEdited, "read aaEntity marked edited");
 208   NS_TEST_ASSERT_MSG(raw->mRead, "read aaEntity not marked read");
 209   entity->SetTag(wstr);
 210   NS_TEST_ASSERT_MSG(! raw->mEdited, "unchanged aaEntity marked edited");
 211   entity->SetTag(NS_LITERAL_STRING("edit"));
 212   NS_TEST_ASSERT_MSG(raw->mEdited, "changed aaEntity not marked edited");
 213
 214   return NS_OK;
 215 }
 216
 217 nsresult
 218 aaBaseTest::testResource(nsITestRunner *aTestRunner)
 219 {
 220   NS_TEST_BEGIN( aTestRunner );
 221   nsresult rv;
 222   nsCOMPtr<aaIResource> resource(do_CreateInstance(AA_RESOURCE_CONTRACT_ID, &rv));
 223   NS_TEST_ASSERT_MSG(resource, "aaResource instance creation" );
 224   NS_ENSURE_SUCCESS(rv, rv);
 225   nsCOMPtr<aaIDataNode> item(do_QueryInterface(resource, &rv));
 226   NS_TEST_ASSERT_MSG(item, "aaResource aaIDataNode interface" );
 227   NS_ENSURE_SUCCESS(rv, rv);
 228
 229   mPackParam = mPackQueries = 0;
 230   rv = item->Accept(this);
 231   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_RESOURCE,
 232       "aaResource->Accept doesn't return query" );
 233   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_RESOURCE),
 234       "aaResource->Accept returns incorrect query" );
 235   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_RESOURCE,
 236       "aaResource->Accept doesn't provide valid parameter" );
 237   NS_TEST_ASSERT_OK(rv);
 238
 239   aaResource* raw = static_cast<aaResource*>(resource.get());
 240   nsEmbedString wstr(NS_LITERAL_STRING("init"));
 241   NS_TEST_ASSERT_MSG(! raw->mEdited, "blank aaResource marked edited");
 242   resource->SetTag(wstr);
 243   NS_TEST_ASSERT_MSG(! raw->mEdited, "hidden aaResource marked edited");
 244   NS_TEST_ASSERT_MSG(! raw->mRead, "hidden aaResource marked read");
 245   resource->GetTag(wstr);
 246   NS_TEST_ASSERT_MSG(! raw->mEdited, "read aaResource marked edited");
 247   NS_TEST_ASSERT_MSG(raw->mRead, "read aaResource not marked read");
 248   resource->SetTag(wstr);
 249   NS_TEST_ASSERT_MSG(! raw->mEdited, "unchanged aaResource marked edited");
 250   resource->SetTag(NS_LITERAL_STRING("edit"));
 251   NS_TEST_ASSERT_MSG(raw->mEdited, "changed aaResource not marked edited");
 252
 253   return NS_OK;
 254 }
 255
 256 nsresult
 257 aaBaseTest::testFlow(nsITestRunner *aTestRunner)
 258 {
 259   NS_TEST_BEGIN( aTestRunner );
 260   nsresult rv;
 261   nsCOMPtr<aaIFlow> resource(do_CreateInstance(AA_FLOW_CONTRACT_ID, &rv));
 262   NS_TEST_ASSERT_MSG(resource, "aaFlow instance creation" );
 263   NS_ENSURE_SUCCESS(rv, rv);
 264   nsCOMPtr<aaIDataNode> item(do_QueryInterface(resource, &rv));
 265   NS_TEST_ASSERT_MSG(item, "aaFlow aaIDataNode interface" );
 266   NS_ENSURE_SUCCESS(rv, rv);
 267
 268   mPackParam = mPackQueries = 0;
 269   rv = item->Accept(this);
 270   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_FLOW,
 271       "aaFlow->Accept doesn't return query" );
 272   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_FLOW),
 273       "aaFlow->Accept returns incorrect query" );
 274   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_FLOW,
 275       "aaFlow->Accept doesn't provide valid parameter" );
 276   NS_TEST_ASSERT_OK(rv);
 277
 278   aaFlow* raw = static_cast<aaFlow*>(resource.get());
 279   nsEmbedString wstr(NS_LITERAL_STRING("init"));
 280   NS_TEST_ASSERT_MSG(! raw->mEdited, "blank aaFlow marked edited");
 281   raw->SetTag(wstr);
 282   NS_TEST_ASSERT_MSG(! raw->mEdited, "hidden aaFlow marked edited");
 283   NS_TEST_ASSERT_MSG(! raw->mRead, "hidden aaFlow marked read");
 284   raw->GetTag(wstr);
 285   NS_TEST_ASSERT_MSG(! raw->mEdited, "read aaFlow marked edited");
 286   NS_TEST_ASSERT_MSG(raw->mRead, "read aaFlow not marked read");
 287   raw->SetTag(wstr);
 288   NS_TEST_ASSERT_MSG(! raw->mEdited, "unchanged aaFlow marked edited");
 289   raw->SetTag(NS_LITERAL_STRING("edit"));
 290   NS_TEST_ASSERT_MSG(raw->mEdited, "changed aaFlow not marked edited");
 291
 292   return NS_OK;
 293 }
 294
 295 nsresult
 296 aaBaseTest::testEvent(nsITestRunner *aTestRunner)
 297 {
 298   NS_TEST_BEGIN( aTestRunner );
 299   nsresult rv;
 300   nsCOMPtr<aaIEvent> item(do_CreateInstance(AA_EVENT_CONTRACT_ID, &rv));
 301   NS_TEST_ASSERT_MSG(item, "aaEvent instance creation" );
 302
 303   nsCOMPtr<nsIMutableArray> array(do_QueryInterface(item));
 304   NS_TEST_ASSERT_MSG(array, "aaEvent 'mutableArray' interface" );
 305
 306   mPackParam = mPackQueries = 0;
 307   rv = item->Accept(this);
 308   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_EVENT,
 309       "aaEvent->Accept doesn't return query" );
 310   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_EVENT),
 311       "aaEvent->Accept returns incorrect query" );
 312   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_EVENT,
 313       "aaEvent->Accept doesn't provide valid parameter" );
 314   NS_TEST_ASSERT_OK(rv);
 315
 316   return NS_OK;
 317 }
 318
 319 nsresult
 320 aaBaseTest::testFact(nsITestRunner *aTestRunner)
 321 {
 322   NS_TEST_BEGIN( aTestRunner );
 323   nsresult rv;
 324   nsCOMPtr<aaIFact> item(do_CreateInstance(AA_FACT_CONTRACT_ID, &rv));
 325   NS_TEST_ASSERT_MSG(item, "[fact] instance creation" );
 326
 327   mPackParam = mPackQueries = 0;
 328   rv = item->Accept(this);
 329   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_FACT,
 330       "[fact] accept doesn't return query" );
 331   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_FACT),
 332       "[fact] accept returns incorrect query" );
 333   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_FACT,
 334       "[fact] accept doesn't provide valid parameter" );
 335   NS_TEST_ASSERT_OK(rv);
 336
 337   PRInt64 eventId=0;
 338   PRTime time=0;
 339   rv = item->GetEventId( &eventId );
 340   NS_TEST_ASSERT_MSG(rv == NS_ERROR_NOT_INITIALIZED,
 341       "[fact] uninited eventId returned");
 342   rv = item->GetTime( &time );
 343   NS_TEST_ASSERT_MSG(rv == NS_ERROR_NOT_INITIALIZED,
 344       "[fact] uninited time returned");
 345
 346   nsCOMPtr<aaIEvent> event = do_CreateInstance(AA_EVENT_CONTRACT_ID);
 347   NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
 348
 349   /* Set time to 2007-08-29 */
 350   PRExplodedTime tm = {0,0,0,12,29,7,2007};
 351   event->SetTime(PR_ImplodeTime(&tm));
 352   event->SetId(1);
 353
 354   item->SetEvent(event);
 355   rv = item->GetEventId( &eventId );
 356   NS_TEST_ASSERT_MSG(eventId == 1, "[fact] wrong eventId returned");
 357   rv = item->GetTime( &time );
 358   NS_TEST_ASSERT_MSG(time == PR_ImplodeTime(&tm), "[fact] wrong time returned");
 359
 360   return NS_OK;
 361 }
 362
 363 nsresult
 364 aaBaseTest::testState(nsITestRunner *aTestRunner)
 365 {
 366   NS_TEST_BEGIN( aTestRunner );
 367   nsresult rv;
 368   nsCOMPtr<aaIState> item(do_CreateInstance(AA_STATE_CONTRACT_ID, &rv));
 369   NS_TEST_ASSERT_MSG(item, "aaState instance creation" );
 370
 371   return NS_OK;
 372 }
 373
 374 nsresult
 375 aaBaseTest::testIncomeFlow(nsITestRunner *aTestRunner)
 376 {
 377   NS_TEST_BEGIN( aTestRunner );
 378   nsresult rv;
 379   nsCOMPtr<aaIFlow> flow(do_CreateInstance(AA_INCOMEFLOW_CONTRACT_ID, &rv));
 380   NS_TEST_ASSERT_MSG(flow, "[income flow] instance creation" );
 381   NS_ENSURE_SUCCESS(rv, rv);
 382   nsCOMPtr<aaIDataNode> item(do_QueryInterface(flow, &rv));
 383   NS_TEST_ASSERT_MSG(item, "[income flow] aaIDataNode interface" );
 384   NS_ENSURE_SUCCESS(rv, rv);
 385
 386   mPackParam = mPackQueries = 0;
 387   rv = item->Accept(this);
 388   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_FLOW,
 389       "[income flow]->Accept doesn't return query" );
 390   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_FLOW),
 391       "[income flow]->Accept returns incorrect query" );
 392   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_FLOW,
 393       "[income flow]->Accept doesn't provide valid parameter" );
 394   NS_TEST_ASSERT_OK(rv);
 395
 396   nsEmbedString wstr;
 397   rv = flow->GetTag(wstr);
 398   NS_TEST_ASSERT_OK(rv);
 399   NS_TEST_ASSERT_MSG(wstr.Equals(NS_LITERAL_STRING("profit and loss")),
 400       "[income flow] wrong tag");
 401   return NS_OK;
 402 }