the combined cxts + gtest
This commit is contained in:
Vadim Pisarevsky
1
modules/ts/src/precomp.cpp
Normal file
1
modules/ts/src/precomp.cpp
Normal file
@@ -0,0 +1 @@
|
||||
#include "precomp.hpp"
|
||||
2
modules/ts/src/precomp.hpp
Normal file
2
modules/ts/src/precomp.hpp
Normal file
@@ -0,0 +1,2 @@
|
||||
#include "opencv2/ts/ts.hpp"
|
||||
#include "opencv2/core/core_c.h"
|
||||
582
modules/ts/src/ts.cpp
Normal file
582
modules/ts/src/ts.cpp
Normal file
@@ -0,0 +1,582 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of Intel Corporation may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
#include <ctype.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
#include <fcntl.h>
|
||||
#include <time.h>
|
||||
#if defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64
|
||||
#include <io.h>
|
||||
#include <windows.h>
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#include <eh.h>
|
||||
#endif
|
||||
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
namespace cvtest
|
||||
{
|
||||
|
||||
/*****************************************************************************************\
|
||||
* Exception and memory handlers *
|
||||
\*****************************************************************************************/
|
||||
|
||||
// a few platform-dependent declarations
|
||||
|
||||
#if defined WIN32 || defined _WIN32 || defined WIN64 || defined _WIN64
|
||||
#ifdef _MSC_VER
|
||||
static void setSEHTranslator( unsigned int /*u*/, EXCEPTION_POINTERS* pExp )
|
||||
{
|
||||
int code = TS::FAIL_EXCEPTION;
|
||||
switch( pExp->ExceptionRecord->ExceptionCode )
|
||||
{
|
||||
case EXCEPTION_ACCESS_VIOLATION:
|
||||
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
|
||||
case EXCEPTION_DATATYPE_MISALIGNMENT:
|
||||
case EXCEPTION_FLT_STACK_CHECK:
|
||||
case EXCEPTION_STACK_OVERFLOW:
|
||||
case EXCEPTION_IN_PAGE_ERROR:
|
||||
code = TS::FAIL_MEMORY_EXCEPTION;
|
||||
break;
|
||||
case EXCEPTION_FLT_DENORMAL_OPERAND:
|
||||
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
|
||||
case EXCEPTION_FLT_INEXACT_RESULT:
|
||||
case EXCEPTION_FLT_INVALID_OPERATION:
|
||||
case EXCEPTION_FLT_OVERFLOW:
|
||||
case EXCEPTION_FLT_UNDERFLOW:
|
||||
case EXCEPTION_INT_DIVIDE_BY_ZERO:
|
||||
case EXCEPTION_INT_OVERFLOW:
|
||||
code = TS::FAIL_ARITHM_EXCEPTION;
|
||||
break;
|
||||
case EXCEPTION_BREAKPOINT:
|
||||
case EXCEPTION_ILLEGAL_INSTRUCTION:
|
||||
case EXCEPTION_INVALID_DISPOSITION:
|
||||
case EXCEPTION_NONCONTINUABLE_EXCEPTION:
|
||||
case EXCEPTION_PRIV_INSTRUCTION:
|
||||
case EXCEPTION_SINGLE_STEP:
|
||||
code = TS::FAIL_EXCEPTION;
|
||||
}
|
||||
throw code;
|
||||
}
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#include <signal.h>
|
||||
#include <setjmp.h>
|
||||
|
||||
static const int tsSigId[] = { SIGSEGV, SIGBUS, SIGFPE, SIGILL, SIGABRT, -1 };
|
||||
|
||||
static jmp_buf tsJmpMark;
|
||||
|
||||
void signalHandler( int sig_code )
|
||||
{
|
||||
int code = TS::FAIL_EXCEPTION;
|
||||
switch( sig_code )
|
||||
{
|
||||
case SIGFPE:
|
||||
code = TS::FAIL_ARITHM_EXCEPTION;
|
||||
break;
|
||||
case SIGSEGV:
|
||||
case SIGBUS:
|
||||
code = TS::FAIL_ARITHM_EXCEPTION;
|
||||
break;
|
||||
case SIGILL:
|
||||
code = TS::FAIL_EXCEPTION;
|
||||
}
|
||||
|
||||
longjmp( tsJmpMark, code );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
// reads 16-digit hexadecimal number (i.e. 64-bit integer)
|
||||
int64 readSeed( const char* str )
|
||||
{
|
||||
int64 val = 0;
|
||||
if( str && strlen(str) == 16 )
|
||||
{
|
||||
for( int i = 0; str[i]; i++ )
|
||||
{
|
||||
int c = tolower(str[i]);
|
||||
if( !isxdigit(c) )
|
||||
return 0;
|
||||
val = val * 16 +
|
||||
(str[i] < 'a' ? str[i] - '0' : str[i] - 'a' + 10);
|
||||
}
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
||||
|
||||
/*****************************************************************************************\
|
||||
* Base Class for Tests *
|
||||
\*****************************************************************************************/
|
||||
|
||||
BaseTest::BaseTest()
|
||||
{
|
||||
ts = TS::ptr();
|
||||
test_case_count = -1;
|
||||
}
|
||||
|
||||
BaseTest::~BaseTest()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
void BaseTest::clear()
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
const CvFileNode* BaseTest::find_param( CvFileStorage* fs, const char* param_name )
|
||||
{
|
||||
CvFileNode* node = cvGetFileNodeByName(fs, 0, get_name().c_str());
|
||||
return node ? cvGetFileNodeByName( fs, node, param_name ) : 0;
|
||||
}
|
||||
|
||||
|
||||
int BaseTest::read_params( CvFileStorage* )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
bool BaseTest::can_do_fast_forward()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void BaseTest::safe_run( int start_from )
|
||||
{
|
||||
read_params( ts->get_file_storage() );
|
||||
ts->update_context( 0, -1, true );
|
||||
ts->update_context( this, -1, true );
|
||||
|
||||
if( !::testing::GTEST_FLAG(catch_exceptions) )
|
||||
run( start_from );
|
||||
else
|
||||
{
|
||||
try
|
||||
{
|
||||
#if !defined WIN32 && !defined _WIN32
|
||||
int _code = setjmp( tsJmpMark );
|
||||
if( !_code )
|
||||
run( start_from );
|
||||
else
|
||||
throw _code;
|
||||
#else
|
||||
run( start_from );
|
||||
#endif
|
||||
}
|
||||
catch (const cv::Exception& exc)
|
||||
{
|
||||
const char* errorStr = cvErrorStr(exc.code);
|
||||
char buf[1 << 16];
|
||||
|
||||
sprintf( buf, "OpenCV Error: %s (%s) in %s, file %s, line %d",
|
||||
errorStr, exc.err.c_str(), exc.func.size() > 0 ?
|
||||
exc.func.c_str() : "unknown function", exc.file.c_str(), exc.line );
|
||||
ts->printf(TS::LOG, "%s\n", buf);
|
||||
ts->set_failed_test_info( TS::FAIL_ERROR_IN_CALLED_FUNC );
|
||||
}
|
||||
catch (...)
|
||||
{
|
||||
ts->set_failed_test_info( TS::FAIL_EXCEPTION );
|
||||
}
|
||||
}
|
||||
|
||||
ts->set_gtest_status();
|
||||
}
|
||||
|
||||
|
||||
void BaseTest::run( int start_from )
|
||||
{
|
||||
int test_case_idx, count = get_test_case_count();
|
||||
int64 t_start = cvGetTickCount();
|
||||
double freq = cv::getTickFrequency();
|
||||
bool ff = can_do_fast_forward();
|
||||
int progress = 0, code;
|
||||
int64 t1 = t_start;
|
||||
|
||||
for( test_case_idx = ff && start_from >= 0 ? start_from : 0;
|
||||
count < 0 || test_case_idx < count; test_case_idx++ )
|
||||
{
|
||||
ts->update_context( this, test_case_idx, ff );
|
||||
progress = update_progress( progress, test_case_idx, count, (double)(t1 - t_start)/(freq*1000) );
|
||||
|
||||
code = prepare_test_case( test_case_idx );
|
||||
if( code < 0 || ts->get_err_code() < 0 )
|
||||
return;
|
||||
|
||||
if( code == 0 )
|
||||
continue;
|
||||
|
||||
run_func();
|
||||
|
||||
if( ts->get_err_code() < 0 )
|
||||
return;
|
||||
|
||||
if( validate_test_results( test_case_idx ) < 0 || ts->get_err_code() < 0 )
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void BaseTest::run_func(void)
|
||||
{
|
||||
assert(0);
|
||||
}
|
||||
|
||||
|
||||
int BaseTest::get_test_case_count(void)
|
||||
{
|
||||
return test_case_count;
|
||||
}
|
||||
|
||||
|
||||
int BaseTest::prepare_test_case( int )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int BaseTest::validate_test_results( int )
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int BaseTest::update_progress( int progress, int test_case_idx, int count, double dt )
|
||||
{
|
||||
int width = 60 - (int)get_name().size();
|
||||
if( count > 0 )
|
||||
{
|
||||
int t = cvRound( ((double)test_case_idx * width)/count );
|
||||
if( t > progress )
|
||||
{
|
||||
ts->printf( TS::CONSOLE, "." );
|
||||
progress = t;
|
||||
}
|
||||
}
|
||||
else if( cvRound(dt) > progress )
|
||||
{
|
||||
ts->printf( TS::CONSOLE, "." );
|
||||
progress = cvRound(dt);
|
||||
}
|
||||
|
||||
return progress;
|
||||
}
|
||||
|
||||
|
||||
BadArgTest::BadArgTest()
|
||||
{
|
||||
progress = -1;
|
||||
test_case_idx = -1;
|
||||
freq = cv::getTickFrequency();
|
||||
}
|
||||
|
||||
BadArgTest::~BadArgTest(void)
|
||||
{
|
||||
}
|
||||
|
||||
int BadArgTest::run_test_case( int expected_code, const string& _descr )
|
||||
{
|
||||
double new_t = (double)cv::getTickCount(), dt;
|
||||
if( test_case_idx < 0 )
|
||||
{
|
||||
test_case_idx = 0;
|
||||
progress = 0;
|
||||
dt = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
dt = (new_t - t)/(freq*1000);
|
||||
t = new_t;
|
||||
}
|
||||
progress = update_progress(progress, test_case_idx, 0, dt);
|
||||
|
||||
int errcount = 0;
|
||||
bool thrown = false;
|
||||
const char* descr = _descr.c_str() ? _descr.c_str() : "";
|
||||
|
||||
try
|
||||
{
|
||||
run_func();
|
||||
}
|
||||
catch(const cv::Exception& e)
|
||||
{
|
||||
thrown = true;
|
||||
if( e.code != expected_code )
|
||||
{
|
||||
ts->printf(TS::LOG, "%s (test case #%d): the error code %d is different from the expected %d\n",
|
||||
descr, test_case_idx, e.code, expected_code);
|
||||
errcount = 1;
|
||||
}
|
||||
}
|
||||
catch(...)
|
||||
{
|
||||
thrown = true;
|
||||
ts->printf(TS::LOG, "%s (test case #%d): unknown exception was thrown (the function has likely crashed)\n",
|
||||
descr, test_case_idx);
|
||||
errcount = 1;
|
||||
}
|
||||
|
||||
if(!thrown)
|
||||
{
|
||||
ts->printf(TS::LOG, "%s (test case #%d): no expected exception was thrown\n",
|
||||
descr, test_case_idx);
|
||||
errcount = 1;
|
||||
}
|
||||
test_case_idx++;
|
||||
|
||||
return errcount;
|
||||
}
|
||||
|
||||
|
||||
/*****************************************************************************************\
|
||||
* Base Class for Test System *
|
||||
\*****************************************************************************************/
|
||||
|
||||
/******************************** Constructors/Destructors ******************************/
|
||||
|
||||
TSParams::TSParams()
|
||||
{
|
||||
rng_seed = (uint64)-1;
|
||||
use_optimized = true;
|
||||
test_case_count_scale = 1;
|
||||
}
|
||||
|
||||
|
||||
TestInfo::TestInfo()
|
||||
{
|
||||
test = 0;
|
||||
code = 0;
|
||||
rng_seed = rng_seed0 = 0;
|
||||
test_case_idx = -1;
|
||||
}
|
||||
|
||||
|
||||
TS::TS()
|
||||
{
|
||||
} // ctor
|
||||
|
||||
|
||||
TS::~TS()
|
||||
{
|
||||
} // dtor
|
||||
|
||||
|
||||
string TS::str_from_code( int code )
|
||||
{
|
||||
switch( code )
|
||||
{
|
||||
case OK: return "Ok";
|
||||
case FAIL_GENERIC: return "Generic/Unknown";
|
||||
case FAIL_MISSING_TEST_DATA: return "No test data";
|
||||
case FAIL_INVALID_TEST_DATA: return "Invalid test data";
|
||||
case FAIL_ERROR_IN_CALLED_FUNC: return "cvError invoked";
|
||||
case FAIL_EXCEPTION: return "Hardware/OS exception";
|
||||
case FAIL_MEMORY_EXCEPTION: return "Invalid memory access";
|
||||
case FAIL_ARITHM_EXCEPTION: return "Arithmetic exception";
|
||||
case FAIL_MEMORY_CORRUPTION_BEGIN: return "Corrupted memblock (beginning)";
|
||||
case FAIL_MEMORY_CORRUPTION_END: return "Corrupted memblock (end)";
|
||||
case FAIL_MEMORY_LEAK: return "Memory leak";
|
||||
case FAIL_INVALID_OUTPUT: return "Invalid function output";
|
||||
case FAIL_MISMATCH: return "Unexpected output";
|
||||
case FAIL_BAD_ACCURACY: return "Bad accuracy";
|
||||
case FAIL_HANG: return "Infinite loop(?)";
|
||||
case FAIL_BAD_ARG_CHECK: return "Incorrect handling of bad arguments";
|
||||
default:
|
||||
;
|
||||
}
|
||||
return "Generic/Unknown";
|
||||
}
|
||||
|
||||
/************************************** Running tests **********************************/
|
||||
|
||||
void TS::init( const string& modulename )
|
||||
{
|
||||
char* datapath_dir = getenv("OPENCV_TEST_DATA_PATH");
|
||||
|
||||
if( datapath_dir )
|
||||
{
|
||||
char buf[1024];
|
||||
size_t l = strlen(datapath_dir);
|
||||
bool haveSlash = l > 0 && (datapath_dir[l-1] == '/' || datapath_dir[l-1] == '\\');
|
||||
sprintf( buf, "%s%s%s/", datapath_dir, haveSlash ? "" : "/", modulename.c_str() );
|
||||
data_path = string(buf);
|
||||
}
|
||||
|
||||
if( ::testing::GTEST_FLAG(catch_exceptions) )
|
||||
{
|
||||
cvSetErrMode( CV_ErrModeParent );
|
||||
cvRedirectError( cvStdErrReport );
|
||||
#if defined WIN32 || defined _WIN32
|
||||
#ifdef _MSC_VER
|
||||
_set_se_translator( SEHTranslator );
|
||||
#endif
|
||||
#else
|
||||
for( int i = 0; tsSigId[i] >= 0; i++ )
|
||||
signal( tsSigId[i], signalHandler );
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
cvSetErrMode( CV_ErrModeLeaf );
|
||||
cvRedirectError( cvGuiBoxReport );
|
||||
#if defined WIN32 || defined _WIN32
|
||||
#ifdef _MSC_VER
|
||||
_set_se_translator( 0 );
|
||||
#endif
|
||||
#else
|
||||
for( int i = 0; tsSigId[i] >= 0; i++ )
|
||||
signal( tsSigId[i], SIG_DFL );
|
||||
#endif
|
||||
}
|
||||
|
||||
if( params.use_optimized == 0 )
|
||||
cv::setUseOptimized(false);
|
||||
|
||||
rng = RNG(params.rng_seed);
|
||||
}
|
||||
|
||||
|
||||
void TS::set_gtest_status()
|
||||
{
|
||||
int code = get_err_code();
|
||||
if( code >= 0 )
|
||||
return SUCCEED();
|
||||
|
||||
char seedstr[32];
|
||||
sprintf(seedstr, "%08x%08x", (unsigned)(current_test_info.rng_seed>>32),
|
||||
(unsigned)(current_test_info.rng_seed));
|
||||
|
||||
string logs = "";
|
||||
if( !output_buf[SUMMARY_IDX].empty() )
|
||||
logs += "\n-----------------------------------\n\tSUM: " + output_buf[SUMMARY_IDX];
|
||||
if( !output_buf[LOG_IDX].empty() )
|
||||
logs += "\n-----------------------------------\n\tLOG: " + output_buf[LOG_IDX];
|
||||
if( !output_buf[CONSOLE_IDX].empty() )
|
||||
logs += "\n-----------------------------------\n\tCONSOLE: " + output_buf[CONSOLE_IDX];
|
||||
logs += "\n-----------------------------------\n";
|
||||
|
||||
FAIL() << "\n\tfailure reason: " << str_from_code(code) <<
|
||||
"\n\ttest case #" << current_test_info.test_case_idx <<
|
||||
"\n\tseed: " << seedstr << logs;
|
||||
}
|
||||
|
||||
|
||||
CvFileStorage* TS::get_file_storage() { return 0; }
|
||||
|
||||
void TS::update_context( BaseTest* test, int test_case_idx, bool update_ts_context )
|
||||
{
|
||||
if( current_test_info.test != test )
|
||||
{
|
||||
for( int i = 0; i <= CONSOLE_IDX; i++ )
|
||||
output_buf[i] = string();
|
||||
rng = RNG(params.rng_seed);
|
||||
current_test_info.rng_seed0 = current_test_info.rng_seed = rng.state;
|
||||
}
|
||||
|
||||
current_test_info.test = test;
|
||||
current_test_info.test_case_idx = test_case_idx;
|
||||
current_test_info.code = 0;
|
||||
cvSetErrStatus( CV_StsOk );
|
||||
if( update_ts_context )
|
||||
current_test_info.rng_seed = rng.state;
|
||||
}
|
||||
|
||||
|
||||
void TS::set_failed_test_info( int fail_code )
|
||||
{
|
||||
if( current_test_info.code >= 0 )
|
||||
current_test_info.code = fail_code;
|
||||
}
|
||||
|
||||
#if defined _MSC_VER && _MSC_VER < 1400
|
||||
#undef vsnprintf
|
||||
#define vsnprintf _vsnprintf
|
||||
#endif
|
||||
|
||||
void TS::vprintf( int streams, const char* fmt, va_list l )
|
||||
{
|
||||
char str[1 << 14];
|
||||
vsnprintf( str, sizeof(str)-1, fmt, l );
|
||||
|
||||
for( int i = 0; i < MAX_IDX; i++ )
|
||||
if( (streams & (1 << i)) )
|
||||
{
|
||||
output_buf[i] += std::string(str);
|
||||
// in the new GTest-based framework we do not use
|
||||
// any output files (except for the automatically generated xml report).
|
||||
// if a test fails, all the buffers are printed, so we do not want to duplicate the information and
|
||||
// thus only add the new information to a single buffer and return from the function.
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void TS::printf( int streams, const char* fmt, ... )
|
||||
{
|
||||
if( streams )
|
||||
{
|
||||
va_list l;
|
||||
va_start( l, fmt );
|
||||
vprintf( streams, fmt, l );
|
||||
va_end( l );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
TS ts;
|
||||
TS* TS::ptr() { return &ts; }
|
||||
|
||||
}
|
||||
|
||||
/* End of file. */
|
||||
358
modules/ts/src/ts_arrtest.cpp
Normal file
358
modules/ts/src/ts_arrtest.cpp
Normal file
@@ -0,0 +1,358 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// Intel License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * The name of Intel Corporation may not be used to endorse or promote products
|
||||
// derived from this software without specific prior written permission.
|
||||
//
|
||||
// This software is provided by the copyright holders and contributors "as is" and
|
||||
// any express or implied warranties, including, but not limited to, the implied
|
||||
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
||||
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
||||
// indirect, incidental, special, exemplary, or consequential damages
|
||||
// (including, but not limited to, procurement of substitute goods or services;
|
||||
// loss of use, data, or profits; or business interruption) however caused
|
||||
// and on any theory of liability, whether in contract, strict liability,
|
||||
// or tort (including negligence or otherwise) arising in any way out of
|
||||
// the use of this software, even if advised of the possibility of such damage.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#include "precomp.hpp"
|
||||
|
||||
namespace cvtest
|
||||
{
|
||||
|
||||
static const int default_test_case_count = 500;
|
||||
static const int default_max_log_array_size = 9;
|
||||
|
||||
ArrayTest::ArrayTest()
|
||||
{
|
||||
test_case_count = default_test_case_count;
|
||||
|
||||
iplimage_allowed = true;
|
||||
cvmat_allowed = true;
|
||||
optional_mask = false;
|
||||
min_log_array_size = 0;
|
||||
max_log_array_size = default_max_log_array_size;
|
||||
element_wise_relative_error = true;
|
||||
|
||||
test_array.resize(MAX_ARR);
|
||||
}
|
||||
|
||||
|
||||
ArrayTest::~ArrayTest()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
|
||||
|
||||
void ArrayTest::clear()
|
||||
{
|
||||
for( size_t i = 0; i < test_array.size(); i++ )
|
||||
{
|
||||
for( size_t j = 0; j < test_array[i].size(); j++ )
|
||||
cvRelease( &test_array[i][j] );
|
||||
}
|
||||
BaseTest::clear();
|
||||
}
|
||||
|
||||
|
||||
int ArrayTest::read_params( CvFileStorage* fs )
|
||||
{
|
||||
int code = BaseTest::read_params( fs );
|
||||
if( code < 0 )
|
||||
return code;
|
||||
|
||||
min_log_array_size = cvReadInt( find_param( fs, "min_log_array_size" ), min_log_array_size );
|
||||
max_log_array_size = cvReadInt( find_param( fs, "max_log_array_size" ), max_log_array_size );
|
||||
test_case_count = cvReadInt( find_param( fs, "test_case_count" ), test_case_count );
|
||||
test_case_count = cvRound( test_case_count*ts->get_test_case_count_scale() );
|
||||
|
||||
min_log_array_size = clipInt( min_log_array_size, 0, 20 );
|
||||
max_log_array_size = clipInt( max_log_array_size, min_log_array_size, 20 );
|
||||
test_case_count = clipInt( test_case_count, 0, 100000 );
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
|
||||
void ArrayTest::get_test_array_types_and_sizes( int /*test_case_idx*/, vector<vector<Size> >& sizes, vector<vector<int> >& types )
|
||||
{
|
||||
RNG& rng = ts->get_rng();
|
||||
Size size;
|
||||
double val;
|
||||
size_t i, j;
|
||||
|
||||
val = randReal(rng) * (max_log_array_size - min_log_array_size) + min_log_array_size;
|
||||
size.width = cvRound( exp(val*CV_LOG2) );
|
||||
val = randReal(rng) * (max_log_array_size - min_log_array_size) + min_log_array_size;
|
||||
size.height = cvRound( exp(val*CV_LOG2) );
|
||||
|
||||
for( i = 0; i < test_array.size(); i++ )
|
||||
{
|
||||
size_t sizei = test_array[i].size();
|
||||
for( j = 0; j < sizei; j++ )
|
||||
{
|
||||
sizes[i][j] = size;
|
||||
types[i][j] = CV_8UC1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static const int icvTsTypeToDepth[] =
|
||||
{
|
||||
IPL_DEPTH_8U, IPL_DEPTH_8S, IPL_DEPTH_16U, IPL_DEPTH_16S,
|
||||
IPL_DEPTH_32S, IPL_DEPTH_32F, IPL_DEPTH_64F
|
||||
};
|
||||
|
||||
|
||||
int ArrayTest::prepare_test_case( int test_case_idx )
|
||||
{
|
||||
int code = 1;
|
||||
size_t max_arr = test_array.size();
|
||||
vector<vector<Size> > sizes(max_arr);
|
||||
vector<vector<Size> > whole_sizes(max_arr);
|
||||
vector<vector<int> > types(max_arr);
|
||||
size_t i, j;
|
||||
RNG& rng = ts->get_rng();
|
||||
bool is_image = false;
|
||||
|
||||
for( i = 0; i < max_arr; i++ )
|
||||
{
|
||||
size_t sizei = std::max(test_array[i].size(), (size_t)1);
|
||||
sizes[i].resize(sizei);
|
||||
types[i].resize(sizei);
|
||||
whole_sizes[i].resize(sizei);
|
||||
}
|
||||
|
||||
get_test_array_types_and_sizes( test_case_idx, sizes, types );
|
||||
|
||||
for( i = 0; i < max_arr; i++ )
|
||||
{
|
||||
size_t sizei = test_array[i].size();
|
||||
for( j = 0; j < sizei; j++ )
|
||||
{
|
||||
unsigned t = randInt(rng);
|
||||
bool create_mask = true, use_roi = false;
|
||||
CvSize size = sizes[i][j], whole_size = size;
|
||||
CvRect roi = {0,0,0,0};
|
||||
|
||||
is_image = !cvmat_allowed ? true : iplimage_allowed ? (t & 1) != 0 : false;
|
||||
create_mask = (t & 6) == 0; // ~ each of 3 tests will use mask
|
||||
use_roi = (t & 8) != 0;
|
||||
if( use_roi )
|
||||
{
|
||||
whole_size.width += randInt(rng) % 10;
|
||||
whole_size.height += randInt(rng) % 10;
|
||||
}
|
||||
|
||||
cvRelease( &test_array[i][j] );
|
||||
if( size.width > 0 && size.height > 0 &&
|
||||
types[i][j] >= 0 && (i != MASK || create_mask) )
|
||||
{
|
||||
if( use_roi )
|
||||
{
|
||||
roi.width = size.width;
|
||||
roi.height = size.height;
|
||||
if( whole_size.width > size.width )
|
||||
roi.x = randInt(rng) % (whole_size.width - size.width);
|
||||
|
||||
if( whole_size.height > size.height )
|
||||
roi.y = randInt(rng) % (whole_size.height - size.height);
|
||||
}
|
||||
|
||||
if( is_image )
|
||||
{
|
||||
test_array[i][j] = cvCreateImage( whole_size,
|
||||
icvTsTypeToDepth[CV_MAT_DEPTH(types[i][j])], CV_MAT_CN(types[i][j]) );
|
||||
if( use_roi )
|
||||
cvSetImageROI( (IplImage*)test_array[i][j], roi );
|
||||
}
|
||||
else
|
||||
{
|
||||
test_array[i][j] = cvCreateMat( whole_size.height, whole_size.width, types[i][j] );
|
||||
if( use_roi )
|
||||
{
|
||||
CvMat submat, *mat = (CvMat*)test_array[i][j];
|
||||
cvGetSubRect( test_array[i][j], &submat, roi );
|
||||
submat.refcount = mat->refcount;
|
||||
*mat = submat;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
test_mat.resize(test_array.size());
|
||||
for( i = 0; i < max_arr; i++ )
|
||||
{
|
||||
size_t sizei = test_array[i].size();
|
||||
test_mat[i].resize(sizei);
|
||||
for( j = 0; j < sizei; j++ )
|
||||
{
|
||||
CvArr* arr = test_array[i][j];
|
||||
test_mat[i][j] = cv::cvarrToMat(arr);
|
||||
if( !test_mat[i][j].empty() )
|
||||
fill_array( test_case_idx, i, j, test_mat[i][j] );
|
||||
}
|
||||
}
|
||||
|
||||
return code;
|
||||
}
|
||||
|
||||
|
||||
void ArrayTest::get_minmax_bounds( int i, int /*j*/, int type, Scalar& low, Scalar& high )
|
||||
{
|
||||
double l, u;
|
||||
int depth = CV_MAT_DEPTH(type);
|
||||
|
||||
if( i == MASK )
|
||||
{
|
||||
l = -2;
|
||||
u = 2;
|
||||
}
|
||||
else if( depth < CV_32S )
|
||||
{
|
||||
l = getMinVal(type);
|
||||
u = getMaxVal(type);
|
||||
}
|
||||
else
|
||||
{
|
||||
u = depth == CV_32S ? 1000000 : 1000.;
|
||||
l = -u;
|
||||
}
|
||||
|
||||
low = Scalar::all(l);
|
||||
high = Scalar::all(u);
|
||||
}
|
||||
|
||||
|
||||
void ArrayTest::fill_array( int /*test_case_idx*/, int i, int j, Mat& arr )
|
||||
{
|
||||
if( i == REF_INPUT_OUTPUT )
|
||||
cvtest::copy( test_mat[INPUT_OUTPUT][j], arr, Mat() );
|
||||
else if( i == INPUT || i == INPUT_OUTPUT || i == MASK )
|
||||
{
|
||||
Scalar low, high;
|
||||
|
||||
get_minmax_bounds( i, j, arr.type(), low, high );
|
||||
randUni( ts->get_rng(), arr, low, high );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
double ArrayTest::get_success_error_level( int /*test_case_idx*/, int i, int j )
|
||||
{
|
||||
int elem_depth = CV_MAT_DEPTH(cvGetElemType(test_array[i][j]));
|
||||
assert( i == OUTPUT || i == INPUT_OUTPUT );
|
||||
return elem_depth < CV_32F ? 0 : elem_depth == CV_32F ? FLT_EPSILON*100: DBL_EPSILON*5000;
|
||||
}
|
||||
|
||||
|
||||
void ArrayTest::prepare_to_validation( int /*test_case_idx*/ )
|
||||
{
|
||||
assert(0);
|
||||
}
|
||||
|
||||
|
||||
int ArrayTest::validate_test_results( int test_case_idx )
|
||||
{
|
||||
static const char* arr_names[] = { "input", "input/output", "output",
|
||||
"ref input/output", "ref output",
|
||||
"temporary", "mask" };
|
||||
size_t i, j;
|
||||
prepare_to_validation( test_case_idx );
|
||||
|
||||
for( i = 0; i < 2; i++ )
|
||||
{
|
||||
int i0 = i == 0 ? OUTPUT : INPUT_OUTPUT;
|
||||
int i1 = i == 0 ? REF_OUTPUT : REF_INPUT_OUTPUT;
|
||||
size_t sizei = test_array[i0].size();
|
||||
|
||||
assert( sizei == test_array[i1].size() );
|
||||
for( j = 0; j < sizei; j++ )
|
||||
{
|
||||
double err_level;
|
||||
vector<int> idx;
|
||||
double max_diff = 0;
|
||||
int code;
|
||||
char msg[100];
|
||||
|
||||
if( !test_array[i1][j] )
|
||||
continue;
|
||||
|
||||
err_level = get_success_error_level( test_case_idx, i0, j );
|
||||
code = cmpEps( test_mat[i0][j], test_mat[i1][j], &max_diff, err_level, &idx, element_wise_relative_error );
|
||||
|
||||
switch( code )
|
||||
{
|
||||
case -1:
|
||||
sprintf( msg, "Too big difference (=%g)", max_diff );
|
||||
code = TS::FAIL_BAD_ACCURACY;
|
||||
break;
|
||||
case -2:
|
||||
strcpy( msg, "Invalid output" );
|
||||
code = TS::FAIL_INVALID_OUTPUT;
|
||||
break;
|
||||
case -3:
|
||||
strcpy( msg, "Invalid output in the reference array" );
|
||||
code = TS::FAIL_INVALID_OUTPUT;
|
||||
break;
|
||||
default:
|
||||
continue;
|
||||
}
|
||||
string idxstr = vec2str(", ", &idx[0], idx.size());
|
||||
|
||||
ts->printf( TS::LOG, "%s in %s array %d at (%s)", msg, arr_names[i0], j, idxstr.c_str() );
|
||||
|
||||
for( i0 = 0; i0 < (int)test_array.size(); i0++ )
|
||||
{
|
||||
size_t sizei0 = test_array[i0].size();
|
||||
if( i0 == REF_INPUT_OUTPUT || i0 == OUTPUT || i0 == TEMP )
|
||||
continue;
|
||||
for( i1 = 0; i1 < (int)sizei0; i1++ )
|
||||
{
|
||||
const Mat& arr = test_mat[i0][i1];
|
||||
if( !arr.empty() )
|
||||
{
|
||||
string sizestr = vec2str(", ", &arr.size[0], arr.dims);
|
||||
ts->printf( TS::LOG, "%s array %d type=%sC%d, size=(%s)\n",
|
||||
arr_names[i0], i1, getTypeName(arr.depth()),
|
||||
arr.channels(), sizestr.c_str() );
|
||||
}
|
||||
}
|
||||
}
|
||||
ts->set_failed_test_info( code );
|
||||
return code;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/* End of file. */
|
||||
2899
modules/ts/src/ts_func.cpp
Normal file
2899
modules/ts/src/ts_func.cpp
Normal file
File diff suppressed because it is too large
Load Diff
8510
modules/ts/src/ts_gtest.cpp
Normal file
8510
modules/ts/src/ts_gtest.cpp
Normal file
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user