vtkTestingOutputWindow.h

Go to the documentation of this file.

/*==============================================================================

  Program: 3D Slicer

  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

==============================================================================*/

#ifndef __vtkTestingOutputWindow_h
#define __vtkTestingOutputWindow_h

#include "vtkAddon.h"

#include "vtkObject.h"
#include "vtkOutputWindow.h"
#include "vtkLoggingMacros.h" // for vtkInfoWithoutObjectMacro

class VTK_ADDON_EXPORT vtkTestingOutputWindow : public vtkOutputWindow
{
public:
  vtkTypeMacro(vtkTestingOutputWindow, vtkOutputWindow);
  static vtkTestingOutputWindow* New();
  
  // Gets a pointer to the singleton testing output window instance.
  // If the current VTK output window is not vtkTestingOutputWindow type then
  // it changes the output window to that.
  static vtkTestingOutputWindow* GetInstance();

  virtual void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  virtual void DisplayText(const char* text) VTK_OVERRIDE;
  virtual void DisplayErrorText(const char* text) VTK_OVERRIDE;
  virtual void DisplayWarningText(const char* text) VTK_OVERRIDE;
  virtual void DisplayGenericWarningText(const char* text) VTK_OVERRIDE;
  virtual void DisplayDebugText(const char* text) VTK_OVERRIDE;

  // Sets number of warning and error messages to zero
  virtual void ResetNumberOfLoggedMessages();
  
  // Number of any logged messages
  vtkGetMacro(NumberOfLoggedMessages, int);
  vtkSetMacro(NumberOfLoggedMessages, int);
  
  // Number of logged warning or generic warning messages
  vtkGetMacro(NumberOfLoggedWarningMessages, int);
  vtkSetMacro(NumberOfLoggedWarningMessages, int);

  // Number of logged error messages
  vtkGetMacro(NumberOfLoggedErrorMessages, int);
  vtkSetMacro(NumberOfLoggedErrorMessages, int);
  
  // Returns the sum of warning and error messages logged
  int GetNumberOfLoggedWarningErrorMessages();
  
protected:
  vtkTestingOutputWindow(); 
  virtual ~vtkTestingOutputWindow(); 
  
  int NumberOfLoggedWarningMessages;
  int NumberOfLoggedErrorMessages;
  int NumberOfLoggedMessages;

private:
  vtkTestingOutputWindow(const vtkTestingOutputWindow&);  // Not implemented.
  void operator=(const vtkTestingOutputWindow&);  // Not implemented.
};


// Convenience macros:

#define TESTING_OUTPUT_INIT() vtkTestingOutputWindow::GetInstance();

#define TESTING_OUTPUT_RESET() vtkTestingOutputWindow::GetInstance()->ResetNumberOfLoggedMessages();

#define TESTING_OUTPUT_ASSERT_MESSAGES(expectedNumberOfMessages) \
  { \
  int actualNumberOfMessages = vtkTestingOutputWindow::GetInstance()->GetNumberOfLoggedMessages(); \
  if (actualNumberOfMessages != expectedNumberOfMessages) \
    { \
    std::cerr << "Assertion failed in " << __FILE__ << ":" << __LINE__ << " - expected " << expectedNumberOfMessages \
      << " messages, got " << actualNumberOfMessages << std::endl; \
    exit(EXIT_FAILURE); \
    } \
  };

#define TESTING_OUTPUT_ASSERT_WARNINGS(expectedNumberOfMessages) \
  { \
  int actualNumberOfMessages = vtkTestingOutputWindow::GetInstance()->GetNumberOfLoggedWarningMessages(); \
  if (actualNumberOfMessages != expectedNumberOfMessages) \
    { \
    std::cerr << "Assertion failed in " << __FILE__ << ":" << __LINE__ << " - expected " << expectedNumberOfMessages \
      << " warnings messages, got " << actualNumberOfMessages << std::endl; \
    exit(EXIT_FAILURE); \
    } \
  };

#define TESTING_OUTPUT_ASSERT_ERRORS(expectedNumberOfMessages) \
  { \
  int actualNumberOfMessages = vtkTestingOutputWindow::GetInstance()->GetNumberOfLoggedErrorMessages(); \
  if (actualNumberOfMessages != expectedNumberOfMessages) \
    { \
    std::cerr << "Assertion failed in " << __FILE__ << ":" << __LINE__ << " - expected " << expectedNumberOfMessages \
      << " error messages, got " << actualNumberOfMessages << std::endl; \
    exit(EXIT_FAILURE); \
    } \
  };

#define TESTING_OUTPUT_ASSERT_WARNINGS_ERRORS(expectedNumberOfMessages) \
  { \
  int actualNumberOfMessages = vtkTestingOutputWindow::GetInstance()->GetNumberOfLoggedWarningErrorMessages(); \
  if (actualNumberOfMessages != expectedNumberOfMessages) \
    { \
    std::cerr << "Assertion failed in " << __FILE__ << ":" << __LINE__ << " - expected " << expectedNumberOfMessages \
      << " error or warning messages, got " << actualNumberOfMessages << std::endl; \
    exit(EXIT_FAILURE); \
    } \
  };

#define TESTING_OUTPUT_ASSERT_WARNINGS_MINIMUM(expectedNumberOfMessages) \
  { \
  int actualNumberOfMessages = vtkTestingOutputWindow::GetInstance()->GetNumberOfLoggedWarningMessages(); \
  if (actualNumberOfMessages < expectedNumberOfMessages) \
    { \
    std::cerr << "Assertion failed in " << __FILE__ << ":" << __LINE__ << " - expected minimum " << expectedNumberOfMessages \
      << " warning messages, got " << actualNumberOfMessages << std::endl; \
    exit(EXIT_FAILURE); \
    } \
  };

#define TESTING_OUTPUT_ASSERT_ERRORS_MINIMUM(expectedNumberOfMessages) \
  { \
  int actualNumberOfMessages = vtkTestingOutputWindow::GetInstance()->GetNumberOfLoggedErrorMessages(); \
  if (actualNumberOfMessages < expectedNumberOfMessages) \
    { \
    std::cerr << "Assertion failed in " << __FILE__ << ":" << __LINE__ << " - expected minimum " << expectedNumberOfMessages \
      << " error messages, got " << actualNumberOfMessages << std::endl; \
    exit(EXIT_FAILURE); \
    } \
  };

#define TESTING_OUTPUT_ASSERT_WARNINGS_BEGIN() \
  { \
  /* Make sure there were no errors or warnings so far */ \
  TESTING_OUTPUT_ASSERT_WARNINGS_ERRORS(0); \
  vtkInfoWithoutObjectMacro("Expecting warning message(s)..."); \
  }

#define TESTING_OUTPUT_ASSERT_WARNINGS_END() \
  { \
  TESTING_OUTPUT_ASSERT_WARNINGS_MINIMUM(1); \
  vtkInfoWithoutObjectMacro("Expected warning message(s) successfully received"); \
  TESTING_OUTPUT_ASSERT_ERRORS(0); \
  TESTING_OUTPUT_RESET(); \
  }

#define TESTING_OUTPUT_ASSERT_ERRORS_BEGIN() \
  { \
  /* Make sure there were no errors or warnings so far */ \
  TESTING_OUTPUT_ASSERT_WARNINGS_ERRORS(0); \
  vtkInfoWithoutObjectMacro("Expecting warning or error message(s)..."); \
  }

#define TESTING_OUTPUT_ASSERT_ERRORS_END() \
  { \
  TESTING_OUTPUT_ASSERT_ERRORS_MINIMUM(1); \
  vtkInfoWithoutObjectMacro("Expected error message(s) successfully received"); \
  TESTING_OUTPUT_RESET(); \
  }

#define TESTING_OUTPUT_IGNORE_WARNINGS_ERRORS_BEGIN() \
  { \
  /* Make sure there were no errors or warnings so far */ \
  TESTING_OUTPUT_ASSERT_WARNINGS_ERRORS(0); \
  vtkInfoWithoutObjectMacro("Ignoring expected warning or error message(s)..."); \
  }

#define TESTING_OUTPUT_IGNORE_WARNINGS_ERRORS_END() \
  { \
  vtkInfoWithoutObjectMacro("Finished ignoring warning or error message"); \
  TESTING_OUTPUT_RESET(); \
  }


#endif