coco
142 lines
4.1 KiB
C++
142 lines
4.1 KiB
C++
// Copyright (C) 2010 Davis E. King (davis@dlib.net)
|
|
// License: Boost Software License See LICENSE.txt for the full license.
|
|
|
|
#include "tester.h"
|
|
#include <dlib/svm.h>
|
|
#include <vector>
|
|
#include <sstream>
|
|
|
|
namespace
|
|
{
|
|
using namespace test;
|
|
using namespace dlib;
|
|
using namespace std;
|
|
dlib::logger dlog("test.is_same_object");
|
|
|
|
DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_booya_template, void, template booya<int>, (std::string)const);
|
|
DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_booya2_template, void, template booya2<int>, (int)const);
|
|
DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_funct_int, void, funct, (int));
|
|
DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_funct_double, void, funct, (double));
|
|
DLIB_MAKE_HAS_MEMBER_FUNCTION_TEST(has_funct_f, float, funct_f, (int));
|
|
|
|
class htest
|
|
{
|
|
public:
|
|
template <typename EXP>
|
|
void booya(std::string) const {}
|
|
|
|
template <typename EXP>
|
|
void booya2(EXP) const {}
|
|
|
|
void funct(double) {}
|
|
};
|
|
|
|
class htest2
|
|
{
|
|
public:
|
|
|
|
void funct(int) {}
|
|
|
|
float funct_f(int) { return 0;}
|
|
};
|
|
|
|
void test_metaprog()
|
|
{
|
|
DLIB_TEST(has_booya2_template<htest>::value == true);
|
|
DLIB_TEST(has_booya2_template<htest2>::value == false);
|
|
|
|
#if _MSC_VER > 1600 // there is a bug in visual studio 2010 and older that prevents this test from working
|
|
DLIB_TEST(has_booya_template<htest>::value == true);
|
|
#endif
|
|
|
|
DLIB_TEST(has_booya_template<htest2>::value == false);
|
|
|
|
DLIB_TEST(has_funct_int<htest>::value == false);
|
|
DLIB_TEST(has_funct_int<htest2>::value == true);
|
|
DLIB_TEST(has_funct_double<htest>::value == true);
|
|
DLIB_TEST(has_funct_double<htest2>::value == false);
|
|
|
|
DLIB_TEST(has_funct_f<htest>::value == false);
|
|
DLIB_TEST(has_funct_f<htest2>::value == true);
|
|
}
|
|
|
|
class is_same_object_tester : public tester
|
|
{
|
|
/*!
|
|
WHAT THIS OBJECT REPRESENTS
|
|
This object represents a unit test. When it is constructed
|
|
it adds itself into the testing framework.
|
|
!*/
|
|
public:
|
|
is_same_object_tester (
|
|
) :
|
|
tester (
|
|
"test_is_same_object", // the command line argument name for this test
|
|
"Run tests on the is_same_object function.", // the command line argument description
|
|
0 // the number of command line arguments for this test
|
|
)
|
|
{
|
|
}
|
|
|
|
struct base {};
|
|
struct derived : public base {};
|
|
|
|
template <bool truth>
|
|
void go(const base& a, const base& b)
|
|
{
|
|
DLIB_TEST( is_same_object(a,b) == truth) ;
|
|
DLIB_TEST( is_same_object(b,a) == truth) ;
|
|
}
|
|
|
|
|
|
template <bool truth>
|
|
void go2(const base& a, const derived& b)
|
|
{
|
|
DLIB_TEST( is_same_object(a,b) == truth) ;
|
|
DLIB_TEST( is_same_object(b,a) == truth) ;
|
|
}
|
|
|
|
|
|
void perform_test (
|
|
)
|
|
{
|
|
print_spinner();
|
|
|
|
int a, b;
|
|
double d;
|
|
DLIB_TEST( is_same_object(a,a) == true) ;
|
|
DLIB_TEST( is_same_object(a,b) == false) ;
|
|
DLIB_TEST( is_same_object(d,b) == false) ;
|
|
DLIB_TEST( is_same_object(d,d) == true) ;
|
|
|
|
base sb;
|
|
derived sd, sd2;
|
|
|
|
DLIB_TEST( is_same_object(sb,sd) == false) ;
|
|
DLIB_TEST( is_same_object(sd,sb) == false) ;
|
|
|
|
go<true>(sd, sd);
|
|
go<false>(sd, sd2);
|
|
go<true>(sb, sb);
|
|
go<false>(sd, sb);
|
|
|
|
go2<true>(sd, sd);
|
|
go2<false>(sd2, sd);
|
|
go2<false>(sd, sd2);
|
|
go2<false>(sb, sd);
|
|
|
|
test_metaprog();
|
|
}
|
|
};
|
|
|
|
// Create an instance of this object. Doing this causes this test
|
|
// to be automatically inserted into the testing framework whenever this cpp file
|
|
// is linked into the project. Note that since we are inside an unnamed-namespace
|
|
// we won't get any linker errors about the symbol a being defined multiple times.
|
|
is_same_object_tester a;
|
|
|
|
}
|
|
|
|
|
|
|