testinfo.h

Go to the documentation of this file.

#ifndef CPPUT_TESTINFO_H_INCLUDED
# define CPPUT_TESTINFO_H_INCLUDED

# include <cpput/forwards.h>
# include <cpput/message.h>
# include <cpptl/intrusiveptr.h>
# include <json/value.h>
# include <stdexcept>

namespace CppUT {


   class CPPUT_API AbortingAssertionException : public std::runtime_error
   {
   public:
      AbortingAssertionException( const std::string &message )
         : std::runtime_error( "AbortingAssertionException:\n" + message )
      {
      }

      virtual ~AbortingAssertionException() throw()
      {
      }
   };


   class CPPUT_API SkipTestException : public std::runtime_error
   {
   public:
      SkipTestException()
         : std::runtime_error( "SkipTestException" )
      {
      }

      virtual ~SkipTestException() throw()
      {
      }
   };


   class CPPUT_API UndeclaredResourceException : public std::runtime_error
   {
   public:
      UndeclaredResourceException( const std::string &resourceName )
         : std::runtime_error( "UndeclaredResourceException: " + resourceName )
      {
      }

      virtual ~UndeclaredResourceException() throw()
      {
      }
   };

   class SourceLocation
   {
   public:
      SourceLocation( const char *file = 0,
                      unsigned int line =0 )
         : file_( file )
         , line_( line )
      {
      }

      void clear()
      {
         file_ = 0;
         line_ = 0;
      }

      bool isValid() const
      {
         return file_ != 0;
      }

      const char *file_;
      unsigned int line_;
   };

   class CPPUT_API Assertion
   {
   public:
      enum Kind
      {
         fault = 1,
         assertion = 2
      };

      Assertion( Kind kind = assertion,
                 const SourceLocation &sourceLocation = SourceLocation() );

      void setLocation( const SourceLocation &location );
      const SourceLocation &location() const;

      void setKind( Kind kind_ );
      Kind kind() const;

      void setIgnoredFailure();
      bool isIgnoredFailure() const;

      void setMessages( const Message &messages );
      const Message &messages() const;

      void setTestDataType( const std::string &type );
      std::string testDataType() const;

      void setTestData( const std::string &name,
                        const Json::Value &value,
                        const std::string &type = "basic" );

      const Json::Value &testData() const;

      std::string toString() const;

   private:
      Message messages_;
      Json::Value testData_;
      CppTL::ConstString testDataType_;
      SourceLocation location_;
      Kind kind_;
      bool isIgnoredFailure_;
   };


   class CPPUT_API TestStatus
   {
   public:
      enum Status
      {
         passed = 1,
         skipped,
         failed
      };

      TestStatus( Status status = passed );

      void setStatus( Status status );

      Status status() const;

      bool hasFailed() const;
      bool hasPassed() const;
      bool wasSkipped() const;

      void setStatistics( const std::string &name,
                          const Json::Value &value );
      //Json::Value getStatistics( const std::string &name );

      void addSpecific( const std::string &type,
                        const Json::Value &value );

      int assertionCount() const;
      int failedAssertionCount() const;
      int ignoredFailureCount() const;

      void increaseAssertionCount( int delta = 1 );
      void increaseFailedAssertionCount( int delta = 1 );
      void increaseIgnoredFailureCount( int delta = 1 );
   private:
      Json::Value statistics_;
      Json::Value specifics_;
      Status status_;
      unsigned int assertionCount_;
      unsigned int failedAssertionCount_;
      unsigned int ignoredFailureCount_;
   };


   class CheckerResult
   {
   public:
      CheckerResult()
         : status_( TestStatus::passed )
         , message_( "" )
      {
      }

      void setFailed()
      {
         status_ = TestStatus::failed;
      }

      void compose( const CheckerResult &other )
      {
         switch ( status_ )
         {
         case TestStatus::failed:
         case TestStatus::passed:
            if ( other.status_ != TestStatus::passed )
               status_ = other.status_;
            break;
         case TestStatus::skipped:
            break;
         default:
            CPPTL_DEBUG_ASSERT_UNREACHABLE;
         }
         message_.extend( other.message_ );
      }

      TestStatus::Status status_;
      Message message_;
   };
   
   namespace Impl {

      class CheckerLineLocation
      {
      public:
         const CheckerResult *result_;
         unsigned long line_;
      };

      struct FileLocationMarker {};


      class CheckerFileLocation
      {
      public:
         const CheckerLineLocation *lineData_;
         const char *file_;
      };

      class AssertionTrigger
      {
      public:
         static AssertionTrigger aborting;
         static AssertionTrigger checking;

         AssertionTrigger &operator +=( const CheckerFileLocation &fileLocation );
      };

   } // end of namespace Impl


   # define CPPUT_BEGIN_ASSERTION_MACRO() \
      CppUT::Impl::AssertionTrigger::aborting += (const CppUT::Impl::FileLocationMarker *)__FILE__ + __LINE__ / 

   # define CPPUT_BEGIN_CHECKING_MACRO() \
      CppUT::Impl::AssertionTrigger::checking += (const CppUT::Impl::FileLocationMarker *)__FILE__ + __LINE__ / 



   class CPPUT_API TestResultUpdater : public CppTL::IntrusiveCount
   {
   public:
      virtual ~TestResultUpdater()
      {
      }

      virtual void addResultLog( const Json::Value &log ) = 0;

      virtual void addResultAssertion( const Assertion &assertion ) = 0;
   };

   enum AssertionType
   {
      abortingAssertion = 1,   
      checkingAssertion        
   };

   enum AbortingAssertionMode
   {
      fastAbortingAssertion = 1,
      richAbortingAssertion
   };

   class TestInfo : public CppTL::IntrusiveCount
      // @todo inherit CppTL::NonCopyable
   {
   public:
      class CPPUT_API ScopedContextOverride
      {
      public:
         ScopedContextOverride();

         ~ScopedContextOverride();

      protected:
         TestInfoPtr context_;
      };

      class CPPUT_API IgnoreFailureScopedContextOverride : public ScopedContextOverride
                                                         , private TestResultUpdater
      {
      public:
         IgnoreFailureScopedContextOverride( bool &assertionFailed );

         ~IgnoreFailureScopedContextOverride();

      private: // overridden from TestResultUpdater
         virtual void addResultLog( const Json::Value &log );

         virtual void addResultAssertion( const Assertion &assertion );

      private:
         Assertion *assertion_;
         bool &assertionFailed_;
      };

      friend class IgnoreFailureScopedContextOverride;


      static TestInfo &threadInstance();

      TestInfo();

      void setTestResultUpdater( TestResultUpdater &updater );
      void removeTestResultUpdater();

      void startNewTest();

      void addResource( const AcquiredResourceHandlePtr &resource );

      void discardTestResources();

      Resource &getResource( const ResourceName &name );

      TestStatus &testStatus();

      void handleAssertion( const char *file, 
                            unsigned int line, 
                            const CheckerResult &result,
                            bool isAbortingAssertion );

      void handleUnexpectedException( const Assertion &fault );

      void setAbortingAssertionMode( AbortingAssertionMode mode );

      void log( const Json::Value &log );

   private:
      typedef std::map<ResourceName,AcquiredResourceHandlePtr> Resources;
      Resources resources_;
      TestStatus testStatus_;
      Assertion currentAssertion_;
      AssertionType assertionType_;
      AbortingAssertionMode abortingAssertionMode_;
      TestResultUpdater *updater_;
   };

   Resource &CPPUT_API getResource( const ResourceName &name );

   void CPPUT_API log( const Json::Value &log );

   void CPPUT_API log( const std::string &log );

   void CPPUT_API log( const char *log );

   void CPPUT_API log( const CppTL::ConstString &log );

} // namespace CppUT


inline CppUT::Impl::CheckerLineLocation operator /( unsigned long line, const CppUT::CheckerResult &result )
{
   CppUT::Impl::CheckerLineLocation lineData;
   lineData.result_ = &result;
   lineData.line_ = line;
   return lineData;
}


inline CppUT::Impl::CheckerFileLocation operator +( const CppUT::Impl::FileLocationMarker *file, const CppUT::Impl::CheckerLineLocation &lineData )
{
   CppUT::Impl::CheckerFileLocation fileData;
   fileData.file_ = (const char *)file;
   fileData.lineData_ = &lineData;
   return fileData;
}



#endif // CPPUT_TESTINFO_H_INCLUDED