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
  32 /* Unfrozen API */
  33 #include <abstract/cxxunit/nsCxxUnit.h>
  34 #include <abstract/cxxunit/nsITest.h>
  35 #include <abstract/cxxunit/nsITestRunner.h>
  36
  37 /* Project includes */
  38 #include <abstract/base/aaIEntity.h>
  39 #include <abstract/base/aaIResource.h>
  40 #include <abstract/base/aaIFlow.h>
  41 #include <abstract/base/aaIFact.h>
  42 #include <abstract/base/aaIBalance.h>
  43 #include <abstract/base/aaIEvent.h>
  44 #include <abstract/base/aaIQuery.h>
  45 #include <abstract/base/aaITransaction.h>
  46 #include "aaResource.h"
  47 #include "aaEntity.h"
  48 #include "aaFlow.h"
  49 #include "aaFact.h"
  50 #include "aaState.h"
  51 #include "aaEvent.h"
  52
  53 #define AA_BASE_TEST_CID \
  54 {0x502c6e1e, 0x42c4, 0x46b1, {0xa4, 0x7b, 0x19, 0x42, 0x8a, 0xd6, 0x75, 0x58}}
  55 #define AA_BASE_TEST_CONTRACT_ID "@aasii.org/base/unit;1"
  56
  57 class aaBaseTest: public nsITest,
  58                   public aaIQuery
  59 {
  60 public:
  61   aaBaseTest();
  62   virtual ~aaBaseTest();
  63   NS_DECL_ISUPPORTS
  64   NS_DECL_NSITEST
  65   NS_DECL_AAIQUERY
  66 private:
  67 #define AA_BASE_TEST_ENTITY   1
  68 #define AA_BASE_TEST_RESOURCE   2
  69 #define AA_BASE_TEST_FLOW     4
  70 #define AA_BASE_TEST_FACT     8
  71 #define AA_BASE_TEST_EVENT   16
  72 #define AA_BASE_TEST_ACCOUNT 32
  73   PRUint32 mPackQueries;
  74   PRUint32 mPackParam;
  75
  76   nsresult testEntity(nsITestRunner *aTestRunner);
  77   nsresult testResource(nsITestRunner *aTestRunner);
  78   nsresult testFlow(nsITestRunner *aTestRunner);
  79   nsresult testFact(nsITestRunner *aTestRunner);
  80   nsresult testState(nsITestRunner *aTestRunner);
  81   nsresult testEvent(nsITestRunner *aTestRunner);
  82 };
  83
  84 aaBaseTest::aaBaseTest()
  85 {
  86 }
  87
  88 aaBaseTest::~aaBaseTest()
  89 {
  90 }
  91
  92 NS_IMPL_ISUPPORTS1(aaBaseTest, nsITest);
  93
  94 NS_IMETHODIMP
  95 aaBaseTest::Test(nsITestRunner *aTestRunner)
  96 {
  97   nsITestRunner *cxxUnitTestRunner = aTestRunner;
  98   NS_TEST_ASSERT_OK(testEntity(aTestRunner));
  99   NS_TEST_ASSERT_OK(testResource(aTestRunner));
 100   NS_TEST_ASSERT_OK(testFlow(aTestRunner));
 101   NS_TEST_ASSERT_OK(testEvent(aTestRunner));
 102   NS_TEST_ASSERT_OK(testFact(aTestRunner));
 103   NS_TEST_ASSERT_OK(testState(aTestRunner));
 104   return NS_OK;
 105 }
 106
 107
 108
 109 /* aaIQuery */
 110 NS_IMETHODIMP
 111 aaBaseTest::QueryEntity(aaIEntity *aEntity)
 112 {
 113   mPackQueries |= AA_BASE_TEST_ENTITY;
 114   if (aEntity)
 115     mPackParam |= AA_BASE_TEST_ENTITY;
 116   return NS_OK;
 117 }
 118
 119 NS_IMETHODIMP
 120 aaBaseTest::QueryResource(aaIResource *aResource)
 121 {
 122   mPackQueries |= AA_BASE_TEST_RESOURCE;
 123   if (aResource)
 124     mPackParam |= AA_BASE_TEST_RESOURCE;
 125   return NS_OK;
 126 }
 127
 128 NS_IMETHODIMP
 129 aaBaseTest::QueryFlow(aaIFlow *aFlow)
 130 {
 131   mPackQueries |= AA_BASE_TEST_FLOW;
 132   if (aFlow)
 133     mPackParam |= AA_BASE_TEST_FLOW;
 134   return NS_OK;
 135 }
 136
 137 NS_IMETHODIMP
 138 aaBaseTest::QueryFact(aaIFact *aFact)
 139 {
 140   mPackQueries |= AA_BASE_TEST_FACT;
 141   if (aFact)
 142     mPackParam |= AA_BASE_TEST_FACT;
 143   return NS_OK;
 144 }
 145
 146 NS_IMETHODIMP
 147 aaBaseTest::QueryEvent(aaIEvent *aEvent)
 148 {
 149   mPackQueries |= AA_BASE_TEST_EVENT;
 150   if (aEvent)
 151     mPackParam |= AA_BASE_TEST_EVENT;
 152   return NS_OK;
 153 }
 154
 155 NS_IMETHODIMP
 156 aaBaseTest::QueryQuote(aaIQuote *aQuote)
 157 {
 158   return NS_OK;
 159 }
 160
 161 NS_IMETHODIMP
 162 aaBaseTest::QueryTransaction(aaITransaction *aTransaction)
 163 {
 164   return NS_OK;
 165 }
 166
 167 /* Private methods */
 168 nsresult
 169 aaBaseTest::testEntity(nsITestRunner *aTestRunner)
 170 {
 171   NS_TEST_BEGIN( aTestRunner );
 172   nsresult rv;
 173   nsCOMPtr<aaIEntity> entity(do_CreateInstance(AA_ENTITY_CONTRACT_ID, &rv));
 174   NS_TEST_ASSERT_MSG(entity, "aaEntity instance creation" );
 175   NS_ENSURE_SUCCESS(rv, rv);
 176   nsCOMPtr<aaIDataNode> item(do_QueryInterface(entity, &rv));
 177   NS_TEST_ASSERT_MSG(item, "aaEntity aaIDataNode interface" );
 178   NS_ENSURE_SUCCESS(rv, rv);
 179
 180   mPackParam = mPackQueries = 0;
 181   rv = item->Accept(this);
 182   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_ENTITY,
 183       "aaEntity->Accept doesn't return query" );
 184   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_ENTITY),
 185       "aaEntity->Accept returns incorrect query" );
 186   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_ENTITY,
 187       "aaEntity->Accept doesn't provide valid parameter" );
 188   NS_TEST_ASSERT_OK(rv);
 189
 190   aaEntity* raw = static_cast<aaEntity *>(entity.get());
 191   nsEmbedString wstr(NS_LITERAL_STRING("init"));
 192   NS_TEST_ASSERT_MSG(! raw->mEdited, "blank aaEntity marked edited");
 193   entity->SetTag(wstr);
 194   NS_TEST_ASSERT_MSG(! raw->mEdited, "hidden aaEntity marked edited");
 195   NS_TEST_ASSERT_MSG(! raw->mRead, "hidden aaEntity marked read");
 196   entity->GetTag(wstr);
 197   NS_TEST_ASSERT_MSG(! raw->mEdited, "read aaEntity marked edited");
 198   NS_TEST_ASSERT_MSG(raw->mRead, "read aaEntity not marked read");
 199   entity->SetTag(wstr);
 200   NS_TEST_ASSERT_MSG(! raw->mEdited, "unchanged aaEntity marked edited");
 201   entity->SetTag(NS_LITERAL_STRING("edit"));
 202   NS_TEST_ASSERT_MSG(raw->mEdited, "changed aaEntity not marked edited");
 203
 204   return NS_OK;
 205 }
 206
 207 nsresult
 208 aaBaseTest::testResource(nsITestRunner *aTestRunner)
 209 {
 210   NS_TEST_BEGIN( aTestRunner );
 211   nsresult rv;
 212   nsCOMPtr<aaIResource> resource(do_CreateInstance(AA_RESOURCE_CONTRACT_ID, &rv));
 213   NS_TEST_ASSERT_MSG(resource, "aaResource instance creation" );
 214   NS_ENSURE_SUCCESS(rv, rv);
 215   nsCOMPtr<aaIDataNode> item(do_QueryInterface(resource, &rv));
 216   NS_TEST_ASSERT_MSG(item, "aaResource aaIDataNode interface" );
 217   NS_ENSURE_SUCCESS(rv, rv);
 218
 219   mPackParam = mPackQueries = 0;
 220   rv = item->Accept(this);
 221   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_RESOURCE,
 222       "aaResource->Accept doesn't return query" );
 223   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_RESOURCE),
 224       "aaResource->Accept returns incorrect query" );
 225   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_RESOURCE,
 226       "aaResource->Accept doesn't provide valid parameter" );
 227   NS_TEST_ASSERT_OK(rv);
 228
 229   aaResource* raw = static_cast<aaResource*>(resource.get());
 230   nsEmbedString wstr(NS_LITERAL_STRING("init"));
 231   NS_TEST_ASSERT_MSG(! raw->mEdited, "blank aaResource marked edited");
 232   resource->SetTag(wstr);
 233   NS_TEST_ASSERT_MSG(! raw->mEdited, "hidden aaResource marked edited");
 234   NS_TEST_ASSERT_MSG(! raw->mRead, "hidden aaResource marked read");
 235   resource->GetTag(wstr);
 236   NS_TEST_ASSERT_MSG(! raw->mEdited, "read aaResource marked edited");
 237   NS_TEST_ASSERT_MSG(raw->mRead, "read aaResource not marked read");
 238   resource->SetTag(wstr);
 239   NS_TEST_ASSERT_MSG(! raw->mEdited, "unchanged aaResource marked edited");
 240   resource->SetTag(NS_LITERAL_STRING("edit"));
 241   NS_TEST_ASSERT_MSG(raw->mEdited, "changed aaResource not marked edited");
 242
 243   return NS_OK;
 244 }
 245
 246 nsresult
 247 aaBaseTest::testFlow(nsITestRunner *aTestRunner)
 248 {
 249   NS_TEST_BEGIN( aTestRunner );
 250   nsresult rv;
 251   nsCOMPtr<aaIFlow> resource(do_CreateInstance(AA_FLOW_CONTRACT_ID, &rv));
 252   NS_TEST_ASSERT_MSG(resource, "aaFlaw instance creation" );
 253   NS_ENSURE_SUCCESS(rv, rv);
 254   nsCOMPtr<aaIDataNode> item(do_QueryInterface(resource, &rv));
 255   NS_TEST_ASSERT_MSG(item, "aaFlaw aaIDataNode interface" );
 256   NS_ENSURE_SUCCESS(rv, rv);
 257
 258   mPackParam = mPackQueries = 0;
 259   rv = item->Accept(this);
 260   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_FLOW,
 261       "aaFlow->Accept doesn't return query" );
 262   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_FLOW),
 263       "aaFlow->Accept returns incorrect query" );
 264   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_FLOW,
 265       "aaFlow->Accept doesn't provide valid parameter" );
 266   NS_TEST_ASSERT_OK(rv);
 267
 268   aaFlow* raw = static_cast<aaFlow*>(resource.get());
 269   nsEmbedString wstr(NS_LITERAL_STRING("init"));
 270   NS_TEST_ASSERT_MSG(! raw->mEdited, "blank aaFlaw marked edited");
 271   raw->SetTag(wstr);
 272   NS_TEST_ASSERT_MSG(! raw->mEdited, "hidden aaFlaw marked edited");
 273   NS_TEST_ASSERT_MSG(! raw->mRead, "hidden aaFlaw marked read");
 274   raw->GetTag(wstr);
 275   NS_TEST_ASSERT_MSG(! raw->mEdited, "read aaFlaw marked edited");
 276   NS_TEST_ASSERT_MSG(raw->mRead, "read aaFlaw not marked read");
 277   raw->SetTag(wstr);
 278   NS_TEST_ASSERT_MSG(! raw->mEdited, "unchanged aaFlaw marked edited");
 279   raw->SetTag(NS_LITERAL_STRING("edit"));
 280   NS_TEST_ASSERT_MSG(raw->mEdited, "changed aaFlaw not marked edited");
 281
 282   return NS_OK;
 283 }
 284
 285 nsresult
 286 aaBaseTest::testEvent(nsITestRunner *aTestRunner)
 287 {
 288   NS_TEST_BEGIN( aTestRunner );
 289   nsresult rv;
 290   nsCOMPtr<aaIEvent> item(do_CreateInstance(AA_EVENT_CONTRACT_ID, &rv));
 291   NS_TEST_ASSERT_MSG(item, "aaEvent instance creation" );
 292
 293   nsCOMPtr<nsIMutableArray> array(do_QueryInterface(item));
 294   NS_TEST_ASSERT_MSG(array, "aaEvent 'mutableArray' interface" );
 295
 296   mPackParam = mPackQueries = 0;
 297   rv = item->Accept(this);
 298   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_EVENT,
 299       "aaEvent->Accept doesn't return query" );
 300   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_EVENT),
 301       "aaEvent->Accept returns incorrect query" );
 302   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_EVENT,
 303       "aaEvent->Accept doesn't provide valid parameter" );
 304   NS_TEST_ASSERT_OK(rv);
 305
 306   return NS_OK;
 307 }
 308
 309 nsresult
 310 aaBaseTest::testFact(nsITestRunner *aTestRunner)
 311 {
 312   NS_TEST_BEGIN( aTestRunner );
 313   nsresult rv;
 314   nsCOMPtr<aaIFact> item(do_CreateInstance(AA_FACT_CONTRACT_ID, &rv));
 315   NS_TEST_ASSERT_MSG(item, "[fact] instance creation" );
 316
 317   mPackParam = mPackQueries = 0;
 318   rv = item->Accept(this);
 319   NS_TEST_ASSERT_MSG(mPackQueries & AA_BASE_TEST_FACT,
 320       "[fact] accept doesn't return query" );
 321   NS_TEST_ASSERT_MSG(!(mPackQueries & ~AA_BASE_TEST_FACT),
 322       "[fact] accept returns incorrect query" );
 323   NS_TEST_ASSERT_MSG(mPackParam & AA_BASE_TEST_FACT,
 324       "[fact] accept doesn't provide valid parameter" );
 325   NS_TEST_ASSERT_OK(rv);
 326
 327   PRInt64 eventId=0;
 328   PRTime time=0;
 329   rv = item->GetEventId( &eventId );
 330   NS_TEST_ASSERT_MSG(rv == NS_ERROR_NOT_INITIALIZED,
 331       "[fact] uninited eventId returned");
 332   rv = item->GetTime( &time );
 333   NS_TEST_ASSERT_MSG(rv == NS_ERROR_NOT_INITIALIZED,
 334       "[fact] uninited time returned");
 335
 336   nsCOMPtr<aaIEvent> event = do_CreateInstance(AA_EVENT_CONTRACT_ID);
 337   NS_ENSURE_TRUE(event, NS_ERROR_UNEXPECTED);
 338
 339   /* Set time to 2007-08-29 */
 340   PRExplodedTime tm = {0,0,0,12,29,7,2007};
 341   event->SetTime(PR_ImplodeTime(&tm));
 342   event->SetId(1);
 343
 344   item->SetEvent(event);
 345   rv = item->GetEventId( &eventId );
 346   NS_TEST_ASSERT_MSG(eventId == 1, "[fact] wrong eventId returned");
 347   rv = item->GetTime( &time );
 348   NS_TEST_ASSERT_MSG(time == PR_ImplodeTime(&tm), "[fact] wrong time returned");
 349
 350   return NS_OK;
 351 }
 352
 353 nsresult
 354 aaBaseTest::testState(nsITestRunner *aTestRunner)
 355 {
 356   NS_TEST_BEGIN( aTestRunner );
 357   nsresult rv;
 358   nsCOMPtr<aaIState> item(do_CreateInstance(AA_STATE_CONTRACT_ID, &rv));
 359   NS_TEST_ASSERT_MSG(item, "aaState instance creation" );
 360
 361   return NS_OK;
 362 }
 363
 364 NS_GENERIC_FACTORY_CONSTRUCTOR(aaBaseTest)
 365
 366 static const nsModuleComponentInfo components[] =
 367 {
 368   { "Base Module Unit Test",
 369     AA_BASE_TEST_CID,
 370     AA_BASE_TEST_CONTRACT_ID,
 371     aaBaseTestConstructor }
 372 };
 373
 374 NS_IMPL_NSGETMODULE(aabaset, components)
 375