Merge remote-tracking branch 'upstream/3.4' into merge-3.4
[platform/upstream/opencv.git] / modules / ts / src / ts.cpp
1 /*M///////////////////////////////////////////////////////////////////////////////////////
2 //
3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
4 //
5 //  By downloading, copying, installing or using the software you agree to this license.
6 //  If you do not agree to this license, do not download, install,
7 //  copy or use the software.
8 //
9 //
10 //                        Intel License Agreement
11 //                For Open Source Computer Vision Library
12 //
13 // Copyright (C) 2000, Intel Corporation, all rights reserved.
14 // Third party copyrights are property of their respective owners.
15 //
16 // Redistribution and use in source and binary forms, with or without modification,
17 // are permitted provided that the following conditions are met:
18 //
19 //   * Redistribution's of source code must retain the above copyright notice,
20 //     this list of conditions and the following disclaimer.
21 //
22 //   * Redistribution's in binary form must reproduce the above copyright notice,
23 //     this list of conditions and the following disclaimer in the documentation
24 //     and/or other materials provided with the distribution.
25 //
26 //   * The name of Intel Corporation may not be used to endorse or promote products
27 //     derived from this software without specific prior written permission.
28 //
29 // This software is provided by the copyright holders and contributors "as is" and
30 // any express or implied warranties, including, but not limited to, the implied
31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
32 // In no event shall the Intel Corporation or contributors be liable for any direct,
33 // indirect, incidental, special, exemplary, or consequential damages
34 // (including, but not limited to, procurement of substitute goods or services;
35 // loss of use, data, or profits; or business interruption) however caused
36 // and on any theory of liability, whether in contract, strict liability,
37 // or tort (including negligence or otherwise) arising in any way out of
38 // the use of this software, even if advised of the possibility of such damage.
39 //
40 //M*/
41
42 #include "precomp.hpp"
43 #include "opencv2/core/core_c.h"
44
45 #include <ctype.h>
46 #include <stdarg.h>
47 #include <stdlib.h>
48 #include <fcntl.h>
49 #include <time.h>
50 #if defined _WIN32
51 #include <io.h>
52
53 #include <windows.h>
54 #undef small
55 #undef min
56 #undef max
57 #undef abs
58
59 #ifdef _MSC_VER
60 #include <eh.h>
61 #endif
62
63 #else
64 #include <unistd.h>
65 #include <signal.h>
66 #include <setjmp.h>
67 #endif
68
69 // isDirectory
70 #if defined _WIN32 || defined WINCE
71 # include <windows.h>
72 #else
73 # include <dirent.h>
74 # include <sys/stat.h>
75 #endif
76
77 #ifdef HAVE_OPENCL
78
79 #define DUMP_CONFIG_PROPERTY(propertyName, propertyValue) \
80     do { \
81         std::stringstream ssName, ssValue;\
82         ssName << propertyName;\
83         ssValue << (propertyValue); \
84         ::testing::Test::RecordProperty(ssName.str(), ssValue.str()); \
85     } while (false)
86
87 #define DUMP_MESSAGE_STDOUT(msg) \
88     do { \
89         std::cout << msg << std::endl; \
90     } while (false)
91
92 #include "opencv2/core/opencl/opencl_info.hpp"
93
94 #endif // HAVE_OPENCL
95
96 #include "opencv2/core/utility.hpp"
97 #include "opencv_tests_config.hpp"
98
99 namespace opencv_test {
100 bool required_opencv_test_namespace = false;  // compilation check for non-refactored tests
101 }
102
103 namespace cvtest
104 {
105
106 uint64 param_seed = 0x12345678; // real value is passed via parseCustomOptions function
107
108 static std::string path_join(const std::string& prefix, const std::string& subpath)
109 {
110     CV_Assert(subpath.empty() || subpath[0] != '/');
111     if (prefix.empty())
112         return subpath;
113     bool skipSlash = prefix.size() > 0 ? (prefix[prefix.size()-1] == '/' || prefix[prefix.size()-1] == '\\') : false;
114     std::string path = prefix + (skipSlash ? "" : "/") + subpath;
115     return path;
116 }
117
118
119
120 /*****************************************************************************************\
121 *                                Exception and memory handlers                            *
122 \*****************************************************************************************/
123
124 // a few platform-dependent declarations
125
126 #if defined _WIN32
127 #ifdef _MSC_VER
128 static void SEHTranslator( unsigned int /*u*/, EXCEPTION_POINTERS* pExp )
129 {
130     TS::FailureCode code = TS::FAIL_EXCEPTION;
131     switch( pExp->ExceptionRecord->ExceptionCode )
132     {
133     case EXCEPTION_ACCESS_VIOLATION:
134     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
135     case EXCEPTION_DATATYPE_MISALIGNMENT:
136     case EXCEPTION_FLT_STACK_CHECK:
137     case EXCEPTION_STACK_OVERFLOW:
138     case EXCEPTION_IN_PAGE_ERROR:
139         code = TS::FAIL_MEMORY_EXCEPTION;
140         break;
141     case EXCEPTION_FLT_DENORMAL_OPERAND:
142     case EXCEPTION_FLT_DIVIDE_BY_ZERO:
143     case EXCEPTION_FLT_INEXACT_RESULT:
144     case EXCEPTION_FLT_INVALID_OPERATION:
145     case EXCEPTION_FLT_OVERFLOW:
146     case EXCEPTION_FLT_UNDERFLOW:
147     case EXCEPTION_INT_DIVIDE_BY_ZERO:
148     case EXCEPTION_INT_OVERFLOW:
149         code = TS::FAIL_ARITHM_EXCEPTION;
150         break;
151     case EXCEPTION_BREAKPOINT:
152     case EXCEPTION_ILLEGAL_INSTRUCTION:
153     case EXCEPTION_INVALID_DISPOSITION:
154     case EXCEPTION_NONCONTINUABLE_EXCEPTION:
155     case EXCEPTION_PRIV_INSTRUCTION:
156     case EXCEPTION_SINGLE_STEP:
157         code = TS::FAIL_EXCEPTION;
158     }
159     throw code;
160 }
161 #endif
162
163 #else
164
165 static const int tsSigId[] = { SIGSEGV, SIGBUS, SIGFPE, SIGILL, SIGABRT, -1 };
166
167 static jmp_buf tsJmpMark;
168
169 static void signalHandler( int sig_code )
170 {
171     TS::FailureCode code = TS::FAIL_EXCEPTION;
172     switch( sig_code )
173     {
174     case SIGFPE:
175         code = TS::FAIL_ARITHM_EXCEPTION;
176         break;
177     case SIGSEGV:
178     case SIGBUS:
179         code = TS::FAIL_ARITHM_EXCEPTION;
180         break;
181     case SIGILL:
182         code = TS::FAIL_EXCEPTION;
183     }
184
185     longjmp( tsJmpMark, (int)code );
186 }
187
188 #endif
189
190
191 // reads 16-digit hexadecimal number (i.e. 64-bit integer)
192 int64 readSeed( const char* str )
193 {
194     int64 val = 0;
195     if( str && strlen(str) == 16 )
196     {
197         for( int i = 0; str[i]; i++ )
198         {
199             int c = tolower(str[i]);
200             if( !isxdigit(c) )
201                 return 0;
202             val = val * 16 +
203             (str[i] < 'a' ? str[i] - '0' : str[i] - 'a' + 10);
204         }
205     }
206     return val;
207 }
208
209
210 /*****************************************************************************************\
211 *                                    Base Class for Tests                                 *
212 \*****************************************************************************************/
213
214 BaseTest::BaseTest()
215 {
216     ts = TS::ptr();
217     test_case_count = -1;
218 }
219
220 BaseTest::~BaseTest()
221 {
222     clear();
223 }
224
225 void BaseTest::clear()
226 {
227 }
228
229
230 cv::FileNode BaseTest::find_param( const cv::FileStorage& fs, const char* param_name )
231 {
232     cv::FileNode node = fs[get_name()];
233     return node[param_name];
234 }
235
236
237 int BaseTest::read_params( const cv::FileStorage& )
238 {
239     return 0;
240 }
241
242
243 bool BaseTest::can_do_fast_forward()
244 {
245     return true;
246 }
247
248
249 void BaseTest::safe_run( int start_from )
250 {
251     CV_TRACE_FUNCTION();
252     ts->update_context( 0, -1, true );
253     ts->update_context( this, -1, true );
254
255     if( !::testing::GTEST_FLAG(catch_exceptions) )
256         run( start_from );
257     else
258     {
259         try
260         {
261         #if !defined _WIN32
262         int _code = setjmp( tsJmpMark );
263         if( !_code )
264             run( start_from );
265         else
266             throw TS::FailureCode(_code);
267         #else
268             run( start_from );
269         #endif
270         }
271         catch (const cv::Exception& exc)
272         {
273             const char* errorStr = cvErrorStr(exc.code);
274             char buf[1 << 16];
275
276             const char* delim = exc.err.find('\n') == cv::String::npos ? "" : "\n";
277             sprintf( buf, "OpenCV Error:\n\t%s (%s%s) in %s, file %s, line %d",
278                     errorStr, delim, exc.err.c_str(), exc.func.size() > 0 ?
279                     exc.func.c_str() : "unknown function", exc.file.c_str(), exc.line );
280             ts->printf(TS::LOG, "%s\n", buf);
281
282             ts->set_failed_test_info( TS::FAIL_ERROR_IN_CALLED_FUNC );
283         }
284         catch (const TS::FailureCode& fc)
285         {
286             std::string errorStr = TS::str_from_code(fc);
287             ts->printf(TS::LOG, "General failure:\n\t%s (%d)\n", errorStr.c_str(), fc);
288
289             ts->set_failed_test_info( fc );
290         }
291         catch (...)
292         {
293             ts->printf(TS::LOG, "Unknown failure\n");
294
295             ts->set_failed_test_info( TS::FAIL_EXCEPTION );
296         }
297     }
298
299     ts->set_gtest_status();
300 }
301
302
303 void BaseTest::run( int start_from )
304 {
305     int test_case_idx, count = get_test_case_count();
306     int64 t_start = cvGetTickCount();
307     double freq = cv::getTickFrequency();
308     bool ff = can_do_fast_forward();
309     int progress = 0, code;
310     int64 t1 = t_start;
311
312     for( test_case_idx = ff && start_from >= 0 ? start_from : 0;
313          count < 0 || test_case_idx < count; test_case_idx++ )
314     {
315         ts->update_context( this, test_case_idx, ff );
316         progress = update_progress( progress, test_case_idx, count, (double)(t1 - t_start)/(freq*1000) );
317
318         code = prepare_test_case( test_case_idx );
319         if( code < 0 || ts->get_err_code() < 0 )
320             return;
321
322         if( code == 0 )
323             continue;
324
325         run_func();
326
327         if( ts->get_err_code() < 0 )
328             return;
329
330         if( validate_test_results( test_case_idx ) < 0 || ts->get_err_code() < 0 )
331             return;
332     }
333 }
334
335
336 void BaseTest::run_func(void)
337 {
338     assert(0);
339 }
340
341
342 int BaseTest::get_test_case_count(void)
343 {
344     return test_case_count;
345 }
346
347
348 int BaseTest::prepare_test_case( int )
349 {
350     return 0;
351 }
352
353
354 int BaseTest::validate_test_results( int )
355 {
356     return 0;
357 }
358
359
360 int BaseTest::update_progress( int progress, int test_case_idx, int count, double dt )
361 {
362     int width = 60 - (int)get_name().size();
363     if( count > 0 )
364     {
365         int t = cvRound( ((double)test_case_idx * width)/count );
366         if( t > progress )
367         {
368             ts->printf( TS::CONSOLE, "." );
369             progress = t;
370         }
371     }
372     else if( cvRound(dt) > progress )
373     {
374         ts->printf( TS::CONSOLE, "." );
375         progress = cvRound(dt);
376     }
377
378     return progress;
379 }
380
381
382 BadArgTest::BadArgTest()
383 {
384     test_case_idx   = -1;
385     // oldErrorCbk     = 0;
386     // oldErrorCbkData = 0;
387 }
388
389 BadArgTest::~BadArgTest(void)
390 {
391 }
392
393 int BadArgTest::run_test_case( int expected_code, const string& _descr )
394 {
395     int errcount = 0;
396     bool thrown = false;
397     const char* descr = _descr.c_str() ? _descr.c_str() : "";
398
399     try
400     {
401         run_func();
402     }
403     catch(const cv::Exception& e)
404     {
405         thrown = true;
406         if (e.code != expected_code &&
407             e.code != cv::Error::StsError && e.code != cv::Error::StsAssert  // Exact error codes support will be dropped. Checks should provide proper text messages intead.
408         )
409         {
410             ts->printf(TS::LOG, "%s (test case #%d): the error code %d is different from the expected %d\n",
411                        descr, test_case_idx, e.code, expected_code);
412             errcount = 1;
413         }
414     }
415     catch(...)
416     {
417         thrown = true;
418         ts->printf(TS::LOG, "%s  (test case #%d): unknown exception was thrown (the function has likely crashed)\n",
419                    descr, test_case_idx);
420         errcount = 1;
421     }
422
423     if(!thrown)
424     {
425         ts->printf(TS::LOG, "%s  (test case #%d): no expected exception was thrown\n",
426                    descr, test_case_idx);
427         errcount = 1;
428     }
429     test_case_idx++;
430
431     return errcount;
432 }
433
434 /*****************************************************************************************\
435 *                                 Base Class for Test System                              *
436 \*****************************************************************************************/
437
438 /******************************** Constructors/Destructors ******************************/
439
440 TSParams::TSParams()
441 {
442     rng_seed = (uint64)-1;
443     use_optimized = true;
444     test_case_count_scale = 1;
445 }
446
447
448 TestInfo::TestInfo()
449 {
450     test = 0;
451     code = 0;
452     rng_seed = rng_seed0 = 0;
453     test_case_idx = -1;
454 }
455
456
457 TS::TS()
458 {
459 } // ctor
460
461
462 TS::~TS()
463 {
464 } // dtor
465
466
467 string TS::str_from_code( const TS::FailureCode code )
468 {
469     switch( code )
470     {
471     case OK:                           return "Ok";
472     case FAIL_GENERIC:                 return "Generic/Unknown";
473     case FAIL_MISSING_TEST_DATA:       return "No test data";
474     case FAIL_INVALID_TEST_DATA:       return "Invalid test data";
475     case FAIL_ERROR_IN_CALLED_FUNC:    return "cvError invoked";
476     case FAIL_EXCEPTION:               return "Hardware/OS exception";
477     case FAIL_MEMORY_EXCEPTION:        return "Invalid memory access";
478     case FAIL_ARITHM_EXCEPTION:        return "Arithmetic exception";
479     case FAIL_MEMORY_CORRUPTION_BEGIN: return "Corrupted memblock (beginning)";
480     case FAIL_MEMORY_CORRUPTION_END:   return "Corrupted memblock (end)";
481     case FAIL_MEMORY_LEAK:             return "Memory leak";
482     case FAIL_INVALID_OUTPUT:          return "Invalid function output";
483     case FAIL_MISMATCH:                return "Unexpected output";
484     case FAIL_BAD_ACCURACY:            return "Bad accuracy";
485     case FAIL_HANG:                    return "Infinite loop(?)";
486     case FAIL_BAD_ARG_CHECK:           return "Incorrect handling of bad arguments";
487     default:
488             ;
489     }
490     return "Generic/Unknown";
491 }
492
493 static int tsErrorCallback( int status, const char* func_name, const char* err_msg, const char* file_name, int line, TS* ts )
494 {
495     const char* delim = std::string(err_msg).find('\n') == std::string::npos ? "" : "\n";
496     ts->printf(TS::LOG, "OpenCV Error:\n\t%s (%s%s) in %s, file %s, line %d\n", cvErrorStr(status), delim, err_msg, func_name[0] != 0 ? func_name : "unknown function", file_name, line);
497     return 0;
498 }
499
500 /************************************** Running tests **********************************/
501
502 void TS::init( const string& modulename )
503 {
504     data_search_subdir.push_back(modulename);
505 #ifndef WINRT
506     char* datapath_dir = getenv("OPENCV_TEST_DATA_PATH");
507 #else
508     char* datapath_dir = OPENCV_TEST_DATA_PATH;
509 #endif
510
511     if( datapath_dir )
512     {
513         data_path = path_join(path_join(datapath_dir, modulename), "");
514     }
515
516     cv::redirectError((cv::ErrorCallback)tsErrorCallback, this);
517
518     if( ::testing::GTEST_FLAG(catch_exceptions) )
519     {
520 #if defined _WIN32
521 #ifdef _MSC_VER
522         _set_se_translator( SEHTranslator );
523 #endif
524 #else
525         for( int i = 0; tsSigId[i] >= 0; i++ )
526             signal( tsSigId[i], signalHandler );
527 #endif
528     }
529     else
530     {
531 #if defined _WIN32
532 #ifdef _MSC_VER
533         _set_se_translator( 0 );
534 #endif
535 #else
536         for( int i = 0; tsSigId[i] >= 0; i++ )
537             signal( tsSigId[i], SIG_DFL );
538 #endif
539     }
540
541     if( params.use_optimized == 0 )
542         cv::setUseOptimized(false);
543
544     rng = RNG(params.rng_seed);
545 }
546
547
548 void TS::set_gtest_status()
549 {
550     TS::FailureCode code = get_err_code();
551     if( code >= 0 )
552         return SUCCEED();
553
554     char seedstr[32];
555     sprintf(seedstr, "%08x%08x", (unsigned)(current_test_info.rng_seed>>32),
556                                 (unsigned)(current_test_info.rng_seed));
557
558     string logs = "";
559     if( !output_buf[SUMMARY_IDX].empty() )
560         logs += "\n-----------------------------------\n\tSUM: " + output_buf[SUMMARY_IDX];
561     if( !output_buf[LOG_IDX].empty() )
562         logs += "\n-----------------------------------\n\tLOG:\n" + output_buf[LOG_IDX];
563     if( !output_buf[CONSOLE_IDX].empty() )
564         logs += "\n-----------------------------------\n\tCONSOLE: " + output_buf[CONSOLE_IDX];
565     logs += "\n-----------------------------------\n";
566
567     FAIL() << "\n\tfailure reason: " << str_from_code(code) <<
568         "\n\ttest case #" << current_test_info.test_case_idx <<
569         "\n\tseed: " << seedstr << logs;
570 }
571
572
573 void TS::update_context( BaseTest* test, int test_case_idx, bool update_ts_context )
574 {
575     if( current_test_info.test != test )
576     {
577         for( int i = 0; i <= CONSOLE_IDX; i++ )
578             output_buf[i] = string();
579         rng = RNG(params.rng_seed);
580         current_test_info.rng_seed0 = current_test_info.rng_seed = rng.state;
581     }
582
583     current_test_info.test = test;
584     current_test_info.test_case_idx = test_case_idx;
585     current_test_info.code = 0;
586     cvSetErrStatus( CV_StsOk );
587     if( update_ts_context )
588         current_test_info.rng_seed = rng.state;
589 }
590
591
592 void TS::set_failed_test_info( int fail_code )
593 {
594     if( current_test_info.code >= 0 )
595         current_test_info.code = TS::FailureCode(fail_code);
596 }
597
598 #if defined _MSC_VER && _MSC_VER < 1400
599 #undef vsnprintf
600 #define vsnprintf _vsnprintf
601 #endif
602
603 void TS::vprintf( int streams, const char* fmt, va_list l )
604 {
605     char str[1 << 14];
606     vsnprintf( str, sizeof(str)-1, fmt, l );
607
608     for( int i = 0; i < MAX_IDX; i++ )
609         if( (streams & (1 << i)) )
610         {
611             output_buf[i] += std::string(str);
612             // in the new GTest-based framework we do not use
613             // any output files (except for the automatically generated xml report).
614             // if a test fails, all the buffers are printed, so we do not want to duplicate the information and
615             // thus only add the new information to a single buffer and return from the function.
616             break;
617         }
618 }
619
620
621 void TS::printf( int streams, const char* fmt, ... )
622 {
623     if( streams )
624     {
625         va_list l;
626         va_start( l, fmt );
627         vprintf( streams, fmt, l );
628         va_end( l );
629     }
630 }
631
632
633 TS* TS::ptr()
634 {
635     static TS ts;
636     return &ts;
637 }
638
639 void fillGradient(Mat& img, int delta)
640 {
641     const int ch = img.channels();
642     CV_Assert(!img.empty() && img.depth() == CV_8U && ch <= 4);
643
644     int n = 255 / delta;
645     int r, c, i;
646     for(r=0; r<img.rows; r++)
647     {
648         int kR = r % (2*n);
649         int valR = (kR<=n) ? delta*kR : delta*(2*n-kR);
650         for(c=0; c<img.cols; c++)
651         {
652             int kC = c % (2*n);
653             int valC = (kC<=n) ? delta*kC : delta*(2*n-kC);
654             uchar vals[] = {uchar(valR), uchar(valC), uchar(200*r/img.rows), uchar(255)};
655             uchar *p = img.ptr(r, c);
656             for(i=0; i<ch; i++) p[i] = vals[i];
657         }
658     }
659 }
660
661 void smoothBorder(Mat& img, const Scalar& color, int delta)
662 {
663     const int ch = img.channels();
664     CV_Assert(!img.empty() && img.depth() == CV_8U && ch <= 4);
665
666     Scalar s;
667     uchar *p = NULL;
668     int n = 100/delta;
669     int nR = std::min(n, (img.rows+1)/2), nC = std::min(n, (img.cols+1)/2);
670
671     int r, c, i;
672     for(r=0; r<nR; r++)
673     {
674         double k1 = r*delta/100., k2 = 1-k1;
675         for(c=0; c<img.cols; c++)
676         {
677             p = img.ptr(r, c);
678             for(i=0; i<ch; i++) s[i] = p[i];
679             s = s * k1 + color * k2;
680             for(i=0; i<ch; i++) p[i] = uchar(s[i]);
681         }
682         for(c=0; c<img.cols; c++)
683         {
684             p = img.ptr(img.rows-r-1, c);
685             for(i=0; i<ch; i++) s[i] = p[i];
686             s = s * k1 + color * k2;
687             for(i=0; i<ch; i++) p[i] = uchar(s[i]);
688         }
689     }
690
691     for(r=0; r<img.rows; r++)
692     {
693         for(c=0; c<nC; c++)
694         {
695             double k1 = c*delta/100., k2 = 1-k1;
696             p = img.ptr(r, c);
697             for(i=0; i<ch; i++) s[i] = p[i];
698             s = s * k1 + color * k2;
699             for(i=0; i<ch; i++) p[i] = uchar(s[i]);
700         }
701         for(c=0; c<n; c++)
702         {
703             double k1 = c*delta/100., k2 = 1-k1;
704             p = img.ptr(r, img.cols-c-1);
705             for(i=0; i<ch; i++) s[i] = p[i];
706             s = s * k1 + color * k2;
707             for(i=0; i<ch; i++) p[i] = uchar(s[i]);
708         }
709     }
710 }
711
712
713 bool test_ipp_check = false;
714
715 void checkIppStatus()
716 {
717     if (test_ipp_check)
718     {
719         int status = cv::ipp::getIppStatus();
720         EXPECT_LE(0, status) << cv::ipp::getIppErrorLocation().c_str();
721     }
722 }
723
724 static bool checkTestData = false;
725 bool skipUnstableTests = false;
726 bool runBigDataTests = false;
727 int testThreads = 0;
728
729 void parseCustomOptions(int argc, char **argv)
730 {
731     const char * const command_line_keys =
732         "{ ipp test_ipp_check |false    |check whether IPP works without failures }"
733         "{ test_seed          |809564   |seed for random numbers generator }"
734         "{ test_threads       |-1       |the number of worker threads, if parallel execution is enabled}"
735         "{ skip_unstable      |false    |skip unstable tests }"
736         "{ test_bigdata       |false    |run BigData tests (>=2Gb) }"
737         "{ test_require_data  |false    |fail on missing non-required test data instead of skip}"
738         "{ h   help           |false    |print help info                          }";
739
740     cv::CommandLineParser parser(argc, argv, command_line_keys);
741     if (parser.get<bool>("help"))
742     {
743         std::cout << "\nAvailable options besides google test option: \n";
744         parser.printMessage();
745     }
746
747     test_ipp_check = parser.get<bool>("test_ipp_check");
748     if (!test_ipp_check)
749 #ifndef WINRT
750         test_ipp_check = getenv("OPENCV_IPP_CHECK") != NULL;
751 #else
752         test_ipp_check = false;
753 #endif
754
755     param_seed = parser.get<unsigned int>("test_seed");
756
757     testThreads = parser.get<int>("test_threads");
758
759     skipUnstableTests = parser.get<bool>("skip_unstable");
760     runBigDataTests = parser.get<bool>("test_bigdata");
761     checkTestData = parser.get<bool>("test_require_data");
762 }
763
764
765 static bool isDirectory(const std::string& path)
766 {
767 #if defined _WIN32 || defined WINCE
768     WIN32_FILE_ATTRIBUTE_DATA all_attrs;
769 #ifdef WINRT
770     wchar_t wpath[MAX_PATH];
771     size_t copied = mbstowcs(wpath, path.c_str(), MAX_PATH);
772     CV_Assert((copied != MAX_PATH) && (copied != (size_t)-1));
773     BOOL status = ::GetFileAttributesExW(wpath, GetFileExInfoStandard, &all_attrs);
774 #else
775     BOOL status = ::GetFileAttributesExA(path.c_str(), GetFileExInfoStandard, &all_attrs);
776 #endif
777     DWORD attributes = all_attrs.dwFileAttributes;
778     return status && ((attributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
779 #else
780     struct stat s;
781     if (0 != stat(path.c_str(), &s))
782         return false;
783     return S_ISDIR(s.st_mode);
784 #endif
785 }
786
787 void addDataSearchPath(const std::string& path)
788 {
789     if (isDirectory(path))
790         TS::ptr()->data_search_path.push_back(path);
791 }
792 void addDataSearchSubDirectory(const std::string& subdir)
793 {
794     TS::ptr()->data_search_subdir.push_back(subdir);
795 }
796
797 static std::string findData(const std::string& relative_path, bool required, bool findDirectory)
798 {
799 #define TEST_TRY_FILE_WITH_PREFIX(prefix) \
800 { \
801     std::string path = path_join(prefix, relative_path); \
802     /*printf("Trying %s\n", path.c_str());*/ \
803     if (findDirectory) \
804     { \
805         if (isDirectory(path)) \
806             return path; \
807     } \
808     else \
809     { \
810         FILE* f = fopen(path.c_str(), "rb"); \
811         if(f) { \
812             fclose(f); \
813             return path; \
814         } \
815     } \
816 }
817
818     const std::vector<std::string>& search_path = TS::ptr()->data_search_path;
819     for(size_t i = search_path.size(); i > 0; i--)
820     {
821         const std::string& prefix = search_path[i - 1];
822         TEST_TRY_FILE_WITH_PREFIX(prefix);
823     }
824
825     const std::vector<std::string>& search_subdir = TS::ptr()->data_search_subdir;
826
827 #ifndef WINRT
828     char* datapath_dir = getenv("OPENCV_TEST_DATA_PATH");
829 #else
830     char* datapath_dir = OPENCV_TEST_DATA_PATH;
831 #endif
832
833     std::string datapath;
834     if (datapath_dir)
835     {
836         datapath = datapath_dir;
837         //CV_Assert(isDirectory(datapath) && "OPENCV_TEST_DATA_PATH is specified but it doesn't exist");
838         if (isDirectory(datapath))
839         {
840             for(size_t i = search_subdir.size(); i > 0; i--)
841             {
842                 const std::string& subdir = search_subdir[i - 1];
843                 std::string prefix = path_join(datapath, subdir);
844                 TEST_TRY_FILE_WITH_PREFIX(prefix);
845             }
846         }
847     }
848 #ifdef OPENCV_TEST_DATA_INSTALL_PATH
849     datapath = path_join("./", OPENCV_TEST_DATA_INSTALL_PATH);
850     if (isDirectory(datapath))
851     {
852         for(size_t i = search_subdir.size(); i > 0; i--)
853         {
854             const std::string& subdir = search_subdir[i - 1];
855             std::string prefix = path_join(datapath, subdir);
856             TEST_TRY_FILE_WITH_PREFIX(prefix);
857         }
858     }
859 #ifdef OPENCV_INSTALL_PREFIX
860     else
861     {
862         datapath = path_join(OPENCV_INSTALL_PREFIX, OPENCV_TEST_DATA_INSTALL_PATH);
863         if (isDirectory(datapath))
864         {
865             for(size_t i = search_subdir.size(); i > 0; i--)
866             {
867                 const std::string& subdir = search_subdir[i - 1];
868                 std::string prefix = path_join(datapath, subdir);
869                 TEST_TRY_FILE_WITH_PREFIX(prefix);
870             }
871         }
872     }
873 #endif
874 #endif
875     const char* type = findDirectory ? "directory" : "data file";
876     if (required || checkTestData)
877         CV_Error(cv::Error::StsError, cv::format("OpenCV tests: Can't find required %s: %s", type, relative_path.c_str()));
878     throw SkipTestException(cv::format("OpenCV tests: Can't find %s: %s", type, relative_path.c_str()));
879 }
880
881 std::string findDataFile(const std::string& relative_path, bool required)
882 {
883     return findData(relative_path, required, false);
884 }
885
886 std::string findDataDirectory(const std::string& relative_path, bool required)
887 {
888     return findData(relative_path, required, true);
889 }
890
891 inline static std::string getSnippetFromConfig(const std::string & start, const std::string & end)
892 {
893     const std::string buildInfo = cv::getBuildInformation();
894     size_t pos1 = buildInfo.find(start);
895     if (pos1 != std::string::npos)
896     {
897         pos1 += start.length();
898         pos1 = buildInfo.find_first_not_of(" \t\n\r", pos1);
899     }
900     size_t pos2 = buildInfo.find(end, pos1);
901     if (pos2 != std::string::npos)
902     {
903         pos2 = buildInfo.find_last_not_of(" \t\n\r", pos2);
904     }
905     if (pos1 != std::string::npos && pos2 != std::string::npos && pos1 < pos2)
906     {
907         return buildInfo.substr(pos1, pos2 - pos1 + 1);
908     }
909     return std::string();
910 }
911
912 inline static void recordPropertyVerbose(const std::string & property,
913                                          const std::string & msg,
914                                          const std::string & value,
915                                          const std::string & build_value = std::string())
916 {
917     ::testing::Test::RecordProperty(property, value);
918     std::cout << msg << ": " << (value.empty() ? std::string("N/A") : value) << std::endl;
919     if (!build_value.empty())
920     {
921         ::testing::Test::RecordProperty(property + "_build", build_value);
922         if (build_value != value)
923             std::cout << "WARNING: build value differs from runtime: " << build_value << endl;
924     }
925 }
926
927 inline static void recordPropertyVerbose(const std::string& property, const std::string& msg,
928                                          const char* value, const char* build_value = NULL)
929 {
930     return recordPropertyVerbose(property, msg,
931         value ? std::string(value) : std::string(),
932         build_value ? std::string(build_value) : std::string());
933 }
934
935 #ifdef _DEBUG
936 #define CV_TEST_BUILD_CONFIG "Debug"
937 #else
938 #define CV_TEST_BUILD_CONFIG "Release"
939 #endif
940
941 void SystemInfoCollector::OnTestProgramStart(const testing::UnitTest&)
942 {
943     std::cout << "CTEST_FULL_OUTPUT" << std::endl; // Tell CTest not to discard any output
944     recordPropertyVerbose("cv_version", "OpenCV version", cv::getVersionString(), CV_VERSION);
945     recordPropertyVerbose("cv_vcs_version", "OpenCV VCS version", getSnippetFromConfig("Version control:", "\n"));
946     recordPropertyVerbose("cv_build_type", "Build type", getSnippetFromConfig("Configuration:", "\n"), CV_TEST_BUILD_CONFIG);
947     recordPropertyVerbose("cv_compiler", "Compiler", getSnippetFromConfig("C++ Compiler:", "\n"));
948     recordPropertyVerbose("cv_parallel_framework", "Parallel framework", cv::currentParallelFramework());
949     recordPropertyVerbose("cv_cpu_features", "CPU features", cv::getCPUFeaturesLine());
950 #ifdef HAVE_IPP
951     recordPropertyVerbose("cv_ipp_version", "Intel(R) IPP version", cv::ipp::useIPP() ? cv::ipp::getIppVersion() :  "disabled");
952 #endif
953 #ifdef HAVE_OPENCL
954     cv::dumpOpenCLInformation();
955 #endif
956 }
957
958 } //namespace cvtest
959
960 /* End of file. */