20181111-hight-property-codes

char* strcpy(char* dest, const char* source)
{
    char * destcopy = dest;
    if((dest == NULL) || (source == NULL))
        throw "Invalid Arguments";
    while((*dest++=*source++)!= '\0');
    return destcopy;
}

/*
    * Copyright (c) 2001,上海贝尔有限公司网络应用事业部
    * All rights reserved.
    *
    * 文件名称： filename.h
    
    * 文件标识： 见配置管理计划书
    * 摘 要： 简要描述本文件的内容
    *
    * 当前版本： 1.1
    * 作 者： 输入作者（或修改者）名字
    * 完成日期： 2001年7月20日
    *
    * 取代版本： 1.0
    * 原作者 ： 输入原作者（或修改者）名字
    * 完成日期： 2001年5月10日
    */

#define stub  fprintf(stderr, "error param in %s:%s:%d\n",  __FUNCTION__, __FILE__, __LINE__);

#define CV_MALLOC_ALIGN 16
/*!
  Aligns pointer by the certain number of bytes
  This small inline function aligns the pointer by the certian number of bytes by shifting
  it forward by 0 or a positive offset.
*/
template <typename _Tp> 
static inline _Tp* alignPtr(_Tp* ptr, int n=(int)sizeof(_Tp))
{
    return (_Tp*)(((size_t)ptr + n-1) & -n);
}
 
/*!
  Aligns buffer size by the certain number of bytes
  This small inline function aligns a buffer size by the certian number of bytes by enlarging it.
*/
static inline size_t alignSize(size_t sz, int n)
{
    assert((n & (n - 1)) == 0); // n is a power of 2
    return (sz + n-1) & -n;
}
 
void* fastMalloc( size_t size )
{
    uchar* udata = (uchar*)malloc(size + sizeof(void*) + CV_MALLOC_ALIGN);
    if(!udata)
        return OutOfMemoryError(size);
    uchar** adata = alignPtr((uchar**)udata + 1, CV_MALLOC_ALIGN);
    adata[-1] = udata;
    return adata;
}
 
void fastFree(void* ptr)
{
    if(ptr) {
        uchar* udata = ((uchar**)ptr)[-1];
        CV_DbgAssert(udata < (uchar*)ptr &&
               ((uchar*)ptr - udata) <= (ptrdiff_t)(sizeof(void*)+CV_MALLOC_ALIGN));
        free(udata);
    }
}

#include <cstdio>
#include <cstring>
///@brief 模型配置结构体
///@warning 该结构体在与did_model_set_config一起使用时，一定要先全部填充为0，再设置所需要的field。
/// set_model_config/get_model_config 是对该结构体的浅拷贝
typedef struct net_config_t {
	int  engine;
 
	///@brief each engine specific data can be passed to here, such as snpe_runtime, tensorrt_batch_size, ocl_context and so on.
	///@note each engine implementation will cast it to the corresponding runtime type, such as snpe_context_t, ppl_context_t.
	/// The lifetime of this pointer should span until create_handle finished, and the memory is managed by users.
	void* engine_context;
} net_config_t;
 
void set_net_config_t(net_config_t* config, int engine_type) {
    memset(config, 0, sizeof(net_config_t));
    int otherc[] = {1, 0, 5};
    config->engine = engine_type;
    config->engine_context = (void*)&otherc;
}
 
int main(int argc, char* argv[]) {
    net_config_t config;
    // 设置模型加载配置项
    set_net_config_t(&config, 3);
    fprintf(stderr, "config.engine %d\n", config.engine);
    int* context = (int*)config.engine_context;
    fprintf(stderr, "config.engine_context[0]=%d\n", context[0]);
    fprintf(stderr, "config.engine_context[1]=%d\n", context[1]);
    fprintf(stderr, "config.engine_context[2]=%d\n", context[2]);
    return 0;
}

// A macro to disallow copy constructor and operator=
// This should be used in the private: declarations for a class.
#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\
  type(type const &);\
  void operator=(type const &)
 
class TestFactoryBase
{
private:
  GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase);
}

class P {
public:
    P(const P &) = delete;
    P &operator =（const P &p) = delete;
};

ClassName& operator++()
{
    ++cur;
    if(cur == last)
    {
      set_node(node + 1);
      cur = first;
    }
    return *this;
}
 
ClassName operator(int)
{
   ClassName tmp = *this;
   ++*this;
   return tmp;
}

const unsigned int blob_len = u32Num * u32Chn * u32Height;
	for (size_t i = 0; i < blob_len; ++i) {
		size_t j = 0;
		for (; j <= u32Width - 4; j += 4) {
			dataDstBlob[j] = (dst_type)(ps32Ptr[j] * NNIE_DATA_SCALE_INV);
			dataDstBlob[j + 1] = (dst_type)(ps32Ptr[j + 1] * NNIE_DATA_SCALE_INV);
			dataDstBlob[j + 2] = (dst_type)(ps32Ptr[j + 2] * NNIE_DATA_SCALE_INV);
			dataDstBlob[j + 3] = (dst_type)(ps32Ptr[j + 3] * NNIE_DATA_SCALE_INV);
		}
		for (; j < u32Width; ++j) {
			dataDstBlob[j] = (dst_type)(ps32Ptr[j] * NNIE_DATA_SCALE_INV);
		}
		dataDstBlob += u32Width;
		ps32Ptr += blob->u32Stride / getElemSize(blob->enType);
	}

#include <iostream>
#include <bitset>
using namespace std;
void increment(std::bitset<5>& bset)
{
    for (int i = 0; i < 5; ++i)
    {
        if(bset[i] == 1)
            bset[i] = 0;
        else
        {
            bset[i] = 1;
            break;
        }
    }
 
}
void method_1(){
    for (int i = 0; i < 32; ++i) {
        std::bitset<5> bset(i);
        std::cout << bset << std::endl;
    }
}
int main(int argc, char const *argv[]){
    std::bitset<5> bset(0);
    for (int i = 0; i < 32; ++i) {
        std::cout << bset << std::endl;
        increment(bset);
    }
    
    return 0;
}

template <typename T>
struct xxx
{
  returnType operator()(const T& x)
  {
    return returnType;
  }
}
 
 
template<typename T>  
class display  
{  
public:  
    void operator()(const T &x)  
    {  
        cout<<x<<" ";   
    }   
};

#include <stdio.h>  
#include <stdlib.h>  
//int sort_function( const void *a, const void *b);  
int sort_function( const void *a, const void *b)  
{     
    return *(int*)a-*(int*)b;  
}  
  
int main()  
{  
     
   int list[5] = { 54, 21, 11, 67, 22 };  
   qsort((void *)list, 5, sizeof(list[0]), sort_function);//起始地址，个数，元素大小，回调函数   
   int  x;  
   for (x = 0; x < 5; x++)  
          printf("%i\n", list[x]);  
                    
   return 0;  
}

#include <iostream>  
#include <numeric>  
#include <vector>   
#include <functional>   
using namespace std;  
  
int main()  
{  
    int ia[]={1,2,3,4,5};  
    vector<int> iv(ia,ia+5);  
    cout<<accumulate(iv.begin(),iv.end(),1,multiplies<int>())<<endl;   
      
    cout<<multiplies<int>()(3,5)<<endl;  
      
    modulus<int>  modulusObj;  
    cout<<modulusObj(3,5)<<endl; // 3   
    return 0;   
}

#include <iostream>  
#include <algorithm>  
#include <vector>   
  
using namespace std;  
  
template <class T>   
class display  
{  
public:  
    void operator()(const T &x)  
    {  
        cout<<x<<" ";   
    }   
};  
  
int main()  
{  
    int ia[]={1,5,4,3,2};  
    vector<int> iv(ia,ia+5);  
    sort(iv.begin(),iv.end(),greater<int>());  
    for_each(iv.begin(),iv.end(),display<int>());   
    return 0;   
}

//A.h
#ifndef A_H
#define A_H
class A
{
private:
　　int _a;
public:
　　A( int a );
　　~A( );
　　void add( int a );
　　int getA( );
};
#endif
A.cpp
#include "A.h"
A::A( int a ){
　　this->_a = a;
}
A::~A( ){
}
void A::add( int a ){
　　this->_a += a;
}
int A::getA( ){
　　return this->_a;
}

// 　A_test.cpp
#include "A.h"
#include <gtest/gtest.h>
class A_test : public testing::Test {
protected:
　　A* _p_a;
　　virtual void SetUp( ){　　　//初始化函数
　　　　this->_p_a = new A( 1 );
　　}
　　virtual void TearDown( ){　 //清理函数
　　　　delete this->_p_a;
　　}
};
//第一个测试，参数A_test是上面的那个类，第二个参数FirstAdd是测试名称
TEST_F( A_test,FirstAdd ){　　　　
　　EXPECT_EQ( 1,_p_a->getA( ) );
　　_p_a->add( 3 );
　　EXPECT_EQ( 4,_p_a->getA( ) );
}
 
//第二个测试
TEST_F( A_test,SecondAdd ){
　　EXPECT_EQ( 1,_p_a->getA( ) );
　　_p_a->add( 5 );
　　EXPECT_EQ( 6,_p_a->getA( ) );
}
 
/*
上面的两个测试都是在SetUp函数执行后的状态下执行，也就是说在执行任意一个TEST_F时 _p_a->_a 的值都是初始值1
*/

#include <gtest/gtest.h>
 
int main(int argc, char * argv[])
{
　　testing::InitGoogleTest(&argc, argv);
　　return RUN_ALL_TESTS();
}

#include <unistd.h>
#include <sys/time.h>
#include <time.h>
 
#define __TIC__()                                    \
	struct timeval __timing_start, __timing_end; \
	gettimeofday(&__timing_start, NULL);
 
#define __TOC__()                                                        \
	do {                                                             \
		gettimeofday(&__timing_end, NULL);                       \
		double __timing_gap = (__timing_end.tv_sec -     \
					       __timing_start.tv_sec) *  \
					      1000.0 +                     \
				      (__timing_end.tv_usec -    \
					       __timing_start.tv_usec) / \
					      1000.0;                    \
		fprintf(stdout, "TIME(ms): %lf\n", __timing_gap);        \
	} while (0)

//第一个测试，参数A_test是上面的那个类，第二个参数FirstAdd是测试名称
TEST(A_test, FirstAdd){　　　　
　　EXPECT_EQ( 1,_p_a->getA( ) );
　　_p_a->add( 3 );
　　EXPECT_EQ( 4,_p_a->getA( ) );
}
 
// Define this macro to 1 to omit the definition of TEST(), which
// is a generic name and clashes with some other libraries.
#if !GTEST_DONT_DEFINE_TEST
# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name)
#endif
 
#define GTEST_TEST(test_case_name, test_name)\
  GTEST_TEST_(test_case_name, test_name, \
              ::testing::Test, ::testing::internal::GetTestTypeId())

// Expands to the name of the class that implements the given test.
#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \
  test_case_name##_##test_name##_Test
 
// Helper macro for defining tests.
// 这个宏声明了一个继承自parent_class ::testing::Test的类，然后对这个类的属性test_info_进行赋值
 
#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\
class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\
 public:\
  GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\
 private:\
  virtual void TestBody();\
  static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\
  GTEST_DISALLOW_COPY_AND_ASSIGN_(\
      GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\
};\
/*这个宏声明了一个继承自parent_class ::testing::Test的类，然后对这个类的属性test_info_进行赋值*/\
::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\
  ::test_info_ =\
    ::testing::internal::MakeAndRegisterTestInfo(\
        #test_case_name, #test_name, NULL, NULL, \
        (parent_id), \
        parent_class::SetUpTestCase, \
        parent_class::TearDownTestCase, \
        new ::testing::internal::TestFactoryImpl<\
            GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\
// 实现我们的这个TestBody\
void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody()

TestInfo* MakeAndRegisterTestInfo(
    const char* test_case_name,
    const char* name,
    const char* type_param,
    const char* value_param,
    TypeId fixture_class_id,
    SetUpTestCaseFunc set_up_tc,
    TearDownTestCaseFunc tear_down_tc,
    TestFactoryBase* factory) {
  TestInfo* const test_info =
      new TestInfo(test_case_name, name, type_param, value_param,
                   fixture_class_id, factory);
  // 添加测试用例信息到UnitTestImpl的testcase_中
  GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info);
  return test_info;
}

// Finds and returns a TestCase with the given name.  If one doesn't
// exist, creates one and returns it.  It's the CALLER'S
// RESPONSIBILITY to ensure that this function is only called WHEN THE
// TESTS ARE NOT SHUFFLED.
//
// Arguments:
//
//   test_case_name: name of the test case
//   type_param:     the name of the test case's type parameter, or NULL if
//                   this is not a typed or a type-parameterized test case.
//   set_up_tc:      pointer to the function that sets up the test case
//   tear_down_tc:   pointer to the function that tears down the test case
TestCase* UnitTestImpl::GetTestCase(const char* test_case_name,
                                    const char* type_param,
                                    Test::SetUpTestCaseFunc set_up_tc,
                                    Test::TearDownTestCaseFunc tear_down_tc) {
  // Can we find a TestCase with the given name?
  const std::vector<TestCase*>::const_iterator test_case =
      std::find_if(test_cases_.begin(), test_cases_.end(),
                   TestCaseNameIs(test_case_name));
 
  if (test_case != test_cases_.end())
    return *test_case;
 
  // No.  Let's create one.
  TestCase* const new_test_case =
      new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc);
 
  // Is this a death test case?
  if (internal::UnitTestOptions::MatchesFilter(test_case_name,
                                               kDeathTestCaseFilter)) {
    // Yes.  Inserts the test case after the last death test case
    // defined so far.  This only works when the test cases haven't
    // been shuffled.  Otherwise we may end up running a death test
    // after a non-death test.
    ++last_death_test_case_;
    test_cases_.insert(test_cases_.begin() + last_death_test_case_,
                       new_test_case);
  } else {
    // No.  Appends to the end of the list.
    test_cases_.push_back(new_test_case);
  }
 
  test_case_indices_.push_back(static_cast<int>(test_case_indices_.size()));
  return new_test_case;
}

ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length";
 
for (int i = 0; i < x.size(); ++i) {
  EXPECT_EQ(x[i], y[i]) << "Vectors x and y differ at index " << i;
}