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