Qt 4.8: test.cpp Example File (demos/spectrum/3rdparty/fftreal/test.cpp)

Qt Reference Documentation

- Qt 4.8
- ALL VERSIONS

- A
- A
- A
- Print

# test.cpp Example File

demos/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 \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/