Qt 5.8 | Qt Multimedia | Spectrum Example | test.cpp Example File

Qt 5.8.0 Reference Documentation

# test.cpp Example File

multimedia/spectrum/3rdparty/fftreal/test.cpp

      /*****************************************************************************

              test.cpp
              Copyright (c) 2005 Laurent de Soras

      --- Legal stuff ---

      This library is free software; you can redistribute it and/or
      modify it under the terms of the GNU Lesser General Public
      License as published by the Free Software Foundation; either
      version 2.1 of the License, or (at your option) any later version.

      This library is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Lesser General Public License for more details.

      You should have received a copy of the GNU Lesser General Public
      License along with this library; if not, write to the Free Software
      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

      *Tab=3***********************************************************************/

      #if defined (_MSC_VER)
              #pragma warning (4 : 4786) // "identifier was truncated to '255' characters in the debug information"
              #pragma warning (4 : 4800) // "forcing value to bool 'true' or 'false' (performance warning)"
      #endif

      /*\\\ INCLUDE FILES \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/

      #include        "test_settings.h"
      #include        "TestHelperFixLen.h"
      #include        "TestHelperNormal.h"

      #if defined (_MSC_VER)
      #include        <crtdbg.h>
      #include        <new.h>
      #endif  // _MSC_VER

      #include        <new>

      #include        <cassert>
      #include        <cstdio>

      #define TEST_

      /*\\\ FUNCTIONS \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/

      static int      TEST_perform_test_accuracy_all ();
      static int      TEST_perform_test_speed_all ();

      static void     TEST_prog_init ();
      static void     TEST_prog_end ();

      int main (int argc, char *argv [])
      {
              using namespace std;

              int                             ret_val = 0;

              TEST_prog_init ();

              try
              {
                      if (ret_val == 0)
                      {
                              ret_val = TEST_perform_test_accuracy_all ();
                      }

                      if (ret_val == 0)
                      {
                              ret_val = TEST_perform_test_speed_all ();
                      }
              }

              catch (std::exception &e)
              {
                      printf ("\n*** main(): Exception (std::exception) : %s\n", e.what ());
                      ret_val = -1;
              }

              catch (...)
              {
                      printf ("\n*** main(): Undefined exception\n");
                      ret_val = -1;
              }

              TEST_prog_end ();

              return (ret_val);
      }

      int     TEST_perform_test_accuracy_all ()
      {
         int            ret_val = 0;

              TestHelperNormal <float >::perform_test_accuracy (ret_val);
              TestHelperNormal <double>::perform_test_accuracy (ret_val);

         TestHelperFixLen < 1>::perform_test_accuracy (ret_val);
         TestHelperFixLen < 2>::perform_test_accuracy (ret_val);
         TestHelperFixLen < 3>::perform_test_accuracy (ret_val);
         TestHelperFixLen < 4>::perform_test_accuracy (ret_val);
         TestHelperFixLen < 7>::perform_test_accuracy (ret_val);
         TestHelperFixLen < 8>::perform_test_accuracy (ret_val);
         TestHelperFixLen <10>::perform_test_accuracy (ret_val);
         TestHelperFixLen <12>::perform_test_accuracy (ret_val);
         TestHelperFixLen <13>::perform_test_accuracy (ret_val);

              return (ret_val);
      }

      int     TEST_perform_test_speed_all ()
      {
         int            ret_val = 0;

      #if defined (test_settings_SPEED_TEST_ENABLED)

              TestHelperNormal <float >::perform_test_speed (ret_val);
              TestHelperNormal <double>::perform_test_speed (ret_val);

         TestHelperFixLen < 1>::perform_test_speed (ret_val);
         TestHelperFixLen < 2>::perform_test_speed (ret_val);
         TestHelperFixLen < 3>::perform_test_speed (ret_val);
         TestHelperFixLen < 4>::perform_test_speed (ret_val);
         TestHelperFixLen < 7>::perform_test_speed (ret_val);
         TestHelperFixLen < 8>::perform_test_speed (ret_val);
         TestHelperFixLen <10>::perform_test_speed (ret_val);
         TestHelperFixLen <12>::perform_test_speed (ret_val);
         TestHelperFixLen <14>::perform_test_speed (ret_val);
         TestHelperFixLen <16>::perform_test_speed (ret_val);
         TestHelperFixLen <20>::perform_test_speed (ret_val);

      #endif

         return (ret_val);
      }

      #if defined (_MSC_VER)
      static int __cdecl      TEST_new_handler_cb (size_t dummy)
      {
              throw std::bad_alloc ();
              return (0);
      }
      #endif  // _MSC_VER

      #if defined (_MSC_VER) && ! defined (NDEBUG)
      static int      __cdecl TEST_debug_alloc_hook_cb (int alloc_type, void *user_data_ptr, size_t size, int block_type, long request_nbr, const unsigned char *filename_0, int line_nbr)
      {
              if (block_type != _CRT_BLOCK)   // Ignore CRT blocks to prevent infinite recursion
              {
                      switch (alloc_type)
                      {
                      case    _HOOK_ALLOC:
                      case    _HOOK_REALLOC:
                      case    _HOOK_FREE:

                              // Put some debug code here

                              break;

                      default:
                              assert (false); // Undefined allocation type
                              break;
                      }
              }

              return (1);
      }
      #endif

      #if defined (_MSC_VER) && ! defined (NDEBUG)
      static int      __cdecl TEST_debug_report_hook_cb (int report_type, char *user_msg_0, int *ret_val_ptr)
      {
              *ret_val_ptr = 0;       // 1 to override the CRT default reporting mode

              switch (report_type)
              {
              case    _CRT_WARN:
              case    _CRT_ERROR:
              case    _CRT_ASSERT:

      // Put some debug code here

                      break;
              }

              return (*ret_val_ptr);
      }
      #endif

      static void     TEST_prog_init ()
      {
      #if defined (_MSC_VER)
              ::_set_new_handler (::TEST_new_handler_cb);
      #endif  // _MSC_VER

      #if defined (_MSC_VER) && ! defined (NDEBUG)
              {
                      const int       mode =   (1 * _CRTDBG_MODE_DEBUG)
                                                             | (1 * _CRTDBG_MODE_WNDW);
                      ::_CrtSetReportMode (_CRT_WARN, mode);
                      ::_CrtSetReportMode (_CRT_ERROR, mode);
                      ::_CrtSetReportMode (_CRT_ASSERT, mode);

                      const int       old_flags = ::_CrtSetDbgFlag (_CRTDBG_REPORT_FLAG);
                      ::_CrtSetDbgFlag (  old_flags
                                        | (1 * _CRTDBG_LEAK_CHECK_DF)
                                        | (1 * _CRTDBG_CHECK_ALWAYS_DF));
                      ::_CrtSetBreakAlloc (-1);       // Specify here a memory bloc number
                      ::_CrtSetAllocHook (TEST_debug_alloc_hook_cb);
                      ::_CrtSetReportHook (TEST_debug_report_hook_cb);

                      // Speed up I/O but breaks C stdio compatibility
      //              std::cout.sync_with_stdio (false);
      //              std::cin.sync_with_stdio (false);
      //              std::cerr.sync_with_stdio (false);
      //              std::clog.sync_with_stdio (false);
              }
      #endif  // _MSC_VER, NDEBUG
      }

      static void     TEST_prog_end ()
      {
      #if defined (_MSC_VER) && ! defined (NDEBUG)
              {
                      const int       mode =   (1 * _CRTDBG_MODE_DEBUG)
                                                             | (0 * _CRTDBG_MODE_WNDW);
                      ::_CrtSetReportMode (_CRT_WARN, mode);
                      ::_CrtSetReportMode (_CRT_ERROR, mode);
                      ::_CrtSetReportMode (_CRT_ASSERT, mode);

                      ::_CrtMemState  mem_state;
                      ::_CrtMemCheckpoint (&mem_state);
                      ::_CrtMemDumpStatistics (&mem_state);
              }
      #endif  // _MSC_VER, NDEBUG
      }

      /*\\\ EOF \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/