自学教程：C++ EXPECT_GE函数代码示例

TEST_F(PrintContextTest, LinkTargetSvg){    MockCanvas canvas;    setBodyInnerHTML("<svg width='100' height='100'>"        "<a xlink:href='http://www.w3.org'><rect x='20' y='20' width='50' height='50'/></a>"        "<text x='10' y='90'><a xlink:href='http://www.google.com'><tspan>google</tspan></a></text>"        "</svg>");    printSinglePage(canvas);    const Vector<MockCanvas::Operation>& operations = canvas.recordedOperations();    ASSERT_EQ(2u, operations.size());    EXPECT_EQ(MockCanvas::DrawRect, operations[0].type);    EXPECT_SKRECT_EQ(20, 20, 50, 50, operations[0].rect);    EXPECT_EQ(MockCanvas::DrawRect, operations[1].type);    EXPECT_EQ(10, operations[1].rect.x());    EXPECT_GE(90, operations[1].rect.y());}

TEST_F(DlExtTest, ReservedHint) {  void* start = mmap(nullptr, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,                     -1, 0);  ASSERT_TRUE(start != MAP_FAILED);  android_dlextinfo extinfo;  extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS_HINT;  extinfo.reserved_addr = start;  extinfo.reserved_size = LIBSIZE;  handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);  ASSERT_DL_NOTNULL(handle_);  fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));  ASSERT_DL_NOTNULL(f);  EXPECT_GE(f, start);  EXPECT_LT(reinterpret_cast<void*>(f),            reinterpret_cast<char*>(start) + LIBSIZE);  EXPECT_EQ(4, f());}

TEST_F(StackTest, stressInsertion){	using us = std::chrono::microseconds;	using clock = std::chrono::high_resolution_clock;	const int qty = 1 << 20;	stack<int, qty> t;	auto start = clock::now();	for (auto i = 0; i < qty; ++i) {		t.push(i);		ASSERT_EQ(i, t.top());	}	auto duration = std::chrono::duration_cast<us>(clock::now() - start);	EXPECT_GE(100000, duration.count());}

 ErrorStack run(thread::Thread* context) {   start_rendezvous.wait();   assorted::UniformRandom rand;   rand.set_current_seed(client_id_);   Epoch highest_commit_epoch;   xct::XctManager* xct_manager = context->get_engine()->get_xct_manager();   xct::XctId prev_xct_id;   for (int i = 0; i < kXctsPerThread; ++i) {     uint64_t account_id;     if (contended) {       account_id = rand.next_uint32() % (kBranches * kAccounts);     } else {       const uint64_t accounts_per_thread = (kBranches * kAccounts / kMaxTestThreads);       account_id = rand.next_uint32() % accounts_per_thread         + (client_id_ * accounts_per_thread);     }     uint64_t teller_id = account_id / kAccountsPerTellers;     uint64_t branch_id = account_id / kAccounts;     uint64_t history_id = client_id_ * kXctsPerThread + i;     int64_t  amount = rand.uniform_within(kAmountRangeFrom, kAmountRangeTo);     EXPECT_GE(amount, kAmountRangeFrom);     EXPECT_LE(amount, kAmountRangeTo);     while (true) {       ErrorStack error_stack = try_transaction(context, &highest_commit_epoch,         branch_id, teller_id, account_id, history_id, amount);       if (!error_stack.is_error()) {         xct::XctId xct_id = context->get_current_xct().get_id();         if (prev_xct_id.get_epoch() == xct_id.get_epoch()) {           EXPECT_LT(prev_xct_id.get_ordinal(), xct_id.get_ordinal());         }         prev_xct_id = context->get_current_xct().get_id();         break;       } else if (error_stack.get_error_code() == kErrorCodeXctRaceAbort) {         // abort and retry         if (context->get_current_xct().is_active()) {           CHECK_ERROR(xct_manager->abort_xct(context));         }       } else {         COERCE_ERROR(error_stack);       }     }   }   CHECK_ERROR(xct_manager->wait_for_commit(highest_commit_epoch));   return foedus::kRetOk; }

TEST(MonotoneCubicInterpolationTest, fitAkimaDataSet){  std::vector<double> x(11);  std::vector<double> y(11);  x[0] = 0;  y[0] = 10;  x[1] = 2;  y[1] = 10;  x[2] = 3;  y[2] = 10;  x[3] = 5;  y[3] = 10;  x[4] = 6;  y[4] = 10;  x[5] = 8;  y[5] = 10;  x[6] = 9;  y[6] = 10.5;  x[7] = 11;  y[7] = 15;  x[8] = 12;  y[8] = 50;  x[9] = 14;  y[9] = 60;  x[10] = 15;  y[10] = 85;  MonotoneCubicInterpolation interp(x, y);  EXPECT_NEAR(interp.sample(0.), 10., tol);  EXPECT_NEAR(interp.sample(2.), 10., tol);  EXPECT_NEAR(interp.sample(3.), 10., tol);  EXPECT_NEAR(interp.sample(5.), 10., tol);  EXPECT_NEAR(interp.sample(6.), 10., tol);  EXPECT_NEAR(interp.sample(8.), 10., tol);  EXPECT_NEAR(interp.sample(9.), 10.5, tol);  EXPECT_NEAR(interp.sample(11.), 15., tol);  EXPECT_NEAR(interp.sample(12.), 50., tol);  EXPECT_NEAR(interp.sample(14.), 60., tol);  EXPECT_NEAR(interp.sample(15.), 85., tol);  for (double z = 0; z <= 15.; z += .1)    EXPECT_GE(interp.sampleDerivative(z), -tol);}

TYPED_TEST(InnerProductLayerTest, TestCPU) {  LayerParameter layer_param;  Caffe::set_mode(Caffe::CPU);  layer_param.set_num_output(10);  layer_param.mutable_weight_filler()->set_type("uniform");  layer_param.mutable_bias_filler()->set_type("uniform");  layer_param.mutable_bias_filler()->set_min(1);  layer_param.mutable_bias_filler()->set_max(2);  shared_ptr<InnerProductLayer<TypeParam> > layer(      new InnerProductLayer<TypeParam>(layer_param));  layer->SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));  layer->Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));  const TypeParam* data = this->blob_top_->cpu_data();  const int count = this->blob_top_->count();  for (int i = 0; i < count; ++i) {    EXPECT_GE(data[i], 1.);  }}

////brief This implements an algorithm for the calculation of the fibonacci number that has a///linear runtime and a constant memory usage.int fibonacciConst(int n){    #ifdef TEST_RUN    EXPECT_GE(n,0)<< "A negative value" << n << "was passed to fibonacciConst";    #endif    if (n<2)        return n;    int fib1=0;    int fib2=1;    int ret=0;    for (int i=2;i<n+1;i++)    {        ret=fib1+fib2;        fib1=fib2;        fib2=ret;    }    return ret;}

TEST(ComediSysfs, CanReadMaxReadBuffer ) {    lsampl_t data;    int ret;    int subdev = 0;            int chan = 0;              int range = 0;             int aref = AREF_GROUND;    FILE *fp;    char buf[100];    int bufsize;    std::string sysfs_entry("/sys/class/comedi/comedi0/max_read_buffer_kb");    fp = fopen(sysfs_entry.c_str(),"r");    ASSERT_TRUE( fp ) << "Able to open file " << sysfs_entry << "/n";    fscanf(fp,"%d", &bufsize );    EXPECT_GE( bufsize, 0 );    comedi_close( dev );}

TEST_F(ResourceOffersTest, ResourceOfferWithMultipleSlaves){  Try<Owned<cluster::Master>> master = StartMaster();  ASSERT_SOME(master);  Owned<MasterDetector> detector = master.get()->createDetector();  vector<Owned<cluster::Slave>> slaves;  // Start 10 slaves.  for (int i = 0; i < 10; i++) {    slave::Flags flags = CreateSlaveFlags();    flags.resources = Option<std::string>("cpus:2;mem:1024");    Try<Owned<cluster::Slave>> slave = StartSlave(detector.get(), flags);    ASSERT_SOME(slave);    slaves.push_back(slave.get());  }  MockScheduler sched;  MesosSchedulerDriver driver(      &sched, DEFAULT_FRAMEWORK_INFO, master.get()->pid, DEFAULT_CREDENTIAL);  EXPECT_CALL(sched, registered(&driver, _, _))    .Times(1);  Future<vector<Offer>> offers;  EXPECT_CALL(sched, resourceOffers(&driver, _))    .WillOnce(FutureArg<1>(&offers))    .WillRepeatedly(Return()); // All 10 slaves might not be in first offer.  driver.start();  AWAIT_READY(offers);  EXPECT_NE(0u, offers.get().size());  EXPECT_GE(10u, offers.get().size());  Resources resources(offers.get()[0].resources());  EXPECT_EQ(2, resources.get<Value::Scalar>("cpus").get().value());  EXPECT_EQ(1024, resources.get<Value::Scalar>("mem").get().value());  driver.stop();  driver.join();}

TEST_F(RandomInterfaceTest, rand){    // Test range and distribution of xme_hal_random_rand()    const double safetyFactor = 2.0;    double sum = 0;    uint16_t minExpected = ((uint16_t)(numSamples / ((double)XME_HAL_RANDOM_RAND_MAX+1) / safetyFactor));    uint16_t maxExpected = ((uint16_t)(numSamples / ((double)XME_HAL_RANDOM_RAND_MAX+1) * safetyFactor));    for (uint64_t i = 0; i <= (double)numRounds*65536U; i++)    {        uint16_t r = xme_hal_random_rand();        // Prevent overflow        if (distribution[r] < 0xFFFF)        {            distribution[r]++;        }        sum += r;    }    printf("xme_hal_random_rand() test:/n");    printf("- Minimum expected value per bin: %d (should be >> 0 for the test to be effective)/n", minExpected);    printf("- Maximum expected value per bin: %d (must be <= 65535 for the test to be effective)/n", maxExpected);    for (uint64_t i = 0; i <= XME_HAL_RANDOM_RAND_MAX; i++)    {        // In a truly uniform distribution, each item would be incremented        // numSamples/(XME_HAL_RANDOM_RAND_MAX+1) times. These are safety bounds        // that should always be true, given a somehow uniform distribution.        EXPECT_GE(distribution[i], minExpected);        EXPECT_LE(distribution[i], maxExpected);    }    // Check whether mean over all random number    // is almost the mean of the interval    {        double mean = sum / (XME_HAL_RANDOM_RAND_MAX+1) / numSamples;        EXPECT_LT(0.499, mean);        EXPECT_LT(mean, 0.501);    }}

TYPED_TEST(StochasticPoolingLayerTest, TestStochasticGPU) {  Caffe::set_mode(Caffe::GPU);  Caffe::set_phase(Caffe::TRAIN);  LayerParameter layer_param;  PoolingParameter* pooling_param = layer_param.mutable_pooling_param();  pooling_param->set_kernel_size(3);  pooling_param->set_stride(2);  pooling_param->set_pool(PoolingParameter_PoolMethod_STOCHASTIC);  PoolingLayer<TypeParam> layer(layer_param);  layer.SetUp(this->blob_bottom_vec_, &(this->blob_top_vec_));  layer.Forward(this->blob_bottom_vec_, &(this->blob_top_vec_));  // Check if the output is correct - it should do random sampling  const TypeParam* bottom_data = this->blob_bottom_->cpu_data();  const TypeParam* top_data = this->blob_top_->cpu_data();  TypeParam total = 0;  for (int n = 0; n < this->blob_top_->num(); ++n) {    for (int c = 0; c < this->blob_top_->channels(); ++c) {      for (int ph = 0; ph < this->blob_top_->height(); ++ph) {        for (int pw = 0; pw < this->blob_top_->width(); ++pw) {          TypeParam pooled = top_data[this->blob_top_->offset(n, c, ph, pw)];          total += pooled;          int hstart = ph * 2;          int hend = min(hstart + 3, this->blob_bottom_->height());          int wstart = pw * 2;          int wend = min(wstart + 3, this->blob_bottom_->width());          bool has_equal = false;          for (int h = hstart; h < hend; ++h) {            for (int w = wstart; w < wend; ++w) {              has_equal |= (pooled == bottom_data[this->blob_bottom_->                  offset(n, c, h, w)]);            }          }          EXPECT_TRUE(has_equal);        }      }    }  }  // When we are doing stochastic pooling, the average we get should be higher  // than the simple data average since we are weighting more on higher-valued  // ones.  EXPECT_GE(total / this->blob_top_->count(), 0.55);}

void doResize(T& target, std::vector<bool>& valid, std::size_t newSize) {  auto oldSize = target.size();  auto before = validData(target, valid);  target.resize(newSize);  valid.resize(newSize);  for (auto i = oldSize; i < newSize; ++i) {    valid[i] = true;  }  auto after = validData(target, valid);  if (oldSize == newSize) {    EXPECT_EQ(before, after);  } else if (oldSize < newSize) {    EXPECT_LT(before.size(), after.size());    EXPECT_TRUE(std::equal(before.begin(), before.end(), after.begin()));  } else {    EXPECT_GE(before.size(), after.size());    EXPECT_TRUE(std::equal(after.begin(), after.end(), before.begin()));  }}

TEST(ArrayBufferBuilderTest, Append){    const char data[] = "HelloWorld";    size_t dataSize = sizeof(data) - 1;    ArrayBufferBuilder builder(2 * dataSize);    EXPECT_EQ(dataSize, builder.append(data, dataSize));    EXPECT_EQ(dataSize, builder.byteLength());    EXPECT_EQ(dataSize * 2, builder.capacity());    EXPECT_EQ(dataSize, builder.append(data, dataSize));    EXPECT_EQ(dataSize * 2, builder.byteLength());    EXPECT_EQ(dataSize * 2, builder.capacity());    EXPECT_EQ(dataSize, builder.append(data, dataSize));    EXPECT_EQ(dataSize * 3, builder.byteLength());    EXPECT_GE(builder.capacity(), dataSize * 3);}

// Test queue without concurrency.TEST(ThreadSafePriorityQueue, Serial){   const U32 min = 0;   const U32 max = 9;   const U32 len = 11;   U32 indices[len]    = {  2,   7,   4,   6,   1,   5,   3,   8,   6,   9, 0};   F32 priorities[len] = {0.2, 0.7, 0.4, 0.6, 0.1, 0.5, 0.3, 0.8, 0.6, 0.9, 0};      ThreadSafePriorityQueue<U32, F32, true>  minQueue;   ThreadSafePriorityQueue<U32, F32, false> maxQueue;   for(U32 i = 0; i < len; i++)   {      minQueue.insert(priorities[i], indices[i]);      maxQueue.insert(priorities[i], indices[i]);   }   EXPECT_FALSE(minQueue.isEmpty());   EXPECT_FALSE(maxQueue.isEmpty());      U32 index = min;   for(U32 i = 0; i < len; i++)   {      U32 popped;      EXPECT_TRUE(minQueue.takeNext(popped))         << "Failed to pop element from minQueue";      EXPECT_LE(index, popped)         << "Element from minQueue was not in sort order";      index = popped;   }      index = max;   for(U32 i = 0; i < len; i++)   {      U32 popped;      EXPECT_TRUE(maxQueue.takeNext(popped))         << "Failed to pop element from maxQueue";      EXPECT_GE(index, popped)         << "Element from maxQueue was not in sort order";      index = popped;   }}

unsignedhash(int h, bfpid_t const &pid){    if(debug) cout << "h=" << h << " pid=" << pid << endl;    EXPECT_GE(h, 0);    EXPECT_LT(h, (int) HASH_COUNT); // this cast is required to avoid "an unnamed type..." error in suncc    unsigned x = pid.vol();    if(debug) cout << " x= " << x << endl;    x ^= pid.page; // XOR doesn't do much, since                   // most of the time the volume is the same for all pages    if(debug) cout << " x= " << x << endl;    EXPECT_LT(h, (int) HASH_COUNT);    unsigned retval = w_hashing::uhash::hash64(_hash_seeds[h], x);    if(debug) cout << " retval= " << retval << endl;    retval %= unsigned(_size);    if(debug) cout << " retval= " << retval << endl;    return retval;}

TEST(EventManager, ResetTimer) {    bool callbackFired = false;    fp::InlineQueue queue;    fp::TimerEvent *timer = queue.registerEvent(std::chrono::seconds(1), [&](const fp::TimerEvent *event) {        callbackFired = true;    });    const auto startTime = std::chrono::steady_clock::now();    queue.dispatch(std::chrono::milliseconds(500)); //0.5 seconds    EXPECT_FALSE(callbackFired);    timer->reset();    queue.dispatch(std::chrono::seconds(2));    const auto endTime = std::chrono::steady_clock::now();    const auto actual = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);    EXPECT_TRUE(callbackFired);    EXPECT_LT(actual.count(), 1600);    EXPECT_GE(actual.count(), 1500);}

void randomgentest(int limit){   csString scriptstr;    if (limit<0)    {       scriptstr = "Roll = rnd();";       limit=1;    }    else        {       scriptstr.Format("Roll = rnd(%d);",limit);    }    MathScript *script = MathScript::Create("randomgen test", scriptstr.GetData());    MathEnvironment env;    ASSERT_NE(script, NULL) << scriptstr.GetData() << " did not create script";    bool above1=false, abovehalflimit=false;    for (int i=0; i<100; i++) //try 100 times, since this is random    {       script->Evaluate(&env);       MathVar *roll = env.Lookup("Roll");       EXPECT_GE(roll->GetValue(), 0);        EXPECT_LE(roll->GetValue(), limit);       if (roll->GetValue()>1)       {          above1 = true;       }       if (2*roll->GetValue()>limit)       {          abovehalflimit = true;       }    }    if (limit>1)    {       EXPECT_TRUE(above1) << scriptstr << "never exceeds 1";     }    if (limit>0)    {       EXPECT_TRUE(abovehalflimit) << scriptstr << "never exceeds half of limit";     }    delete script;}

TEST(umbrella, iovecSerialize) {  size_t nIovs = 3;  char value[] = "value";  iovec iovs[] = {{&value[0], 1}, {&value[1], 2}, {&value[3], 2}};  um_backing_msg_t bmsg;  um_backing_msg_init(&bmsg);  uint64_t reqId = 1;  mc_msg_t msg;  mc_msg_init_not_refcounted(&msg);  msg.op = mc_op_get;  msg.result = mc_res_found;  msg.flags = 0x4;  // Verify emitIov  std::string serializedVal = "";  EXPECT_EQ(      um_emit_iovs_extended(          &bmsg, reqId, &msg, iovs, nIovs, emitIov, (void *)&serializedVal),      0);  verifySerializedValue(serializedVal, reqId, &msg, value);  // Verify writeIov  um_backing_msg_cleanup(&bmsg);  um_backing_msg_init(&bmsg);  serializedVal = "";  reqId++;  iovec output[20];  ssize_t nOutIovs = um_write_iovs_extended(&bmsg, reqId, &msg,                                            iovs, nIovs, output, 20);  EXPECT_GE(nOutIovs, 1);  for (int i = 0; i < nOutIovs; i++) {    serializedVal.append((const char *)output[i].iov_base, output[i].iov_len);  }  verifySerializedValue(serializedVal, reqId, &msg, value);}

// Verify the sorting, [EGL 1.5] section 3.4.1.2 pg 30:// [configs are sorted] by larger total number of color bits (for an RGB// color buffer this is the sum of EGL_RED_SIZE, EGL_GREEN_SIZE, EGL_BLUE_SIZE,// and EGL_ALPHA_SIZE; for a luminance color buffer, the sum of EGL_LUMINANCE_SIZE// and EGL_ALPHA_SIZE).If the requested number of bits in attrib list for a// particular color component is 0 or EGL_DONT_CARE, then the number of bits// for that component is not considered.TEST(ConfigSetTest, Sorting_BitSizes){    egl::ConfigSet set;    size_t testConfigCount = 64;    for (size_t i = 0; i < testConfigCount; i++)    {        egl::Config config = GenerateGenericConfig();        // Give random-ish bit sizes to the config        config.redSize =   (i *  2) %  3;        config.greenSize = (i +  5) %  7;        config.blueSize =  (i +  7) % 11;        config.alphaSize = (i + 13) % 17;        set.add(config);    }    egl::AttributeMap greaterThan1BitFilter;    greaterThan1BitFilter.insert(EGL_RED_SIZE, 1);    greaterThan1BitFilter.insert(EGL_GREEN_SIZE, 1);    greaterThan1BitFilter.insert(EGL_BLUE_SIZE, 1);    greaterThan1BitFilter.insert(EGL_ALPHA_SIZE, 1);    std::vector<const egl::Config *> filteredConfigs = set.filter(greaterThan1BitFilter);    for (size_t i = 1; i < filteredConfigs.size(); i++)    {        const egl::Config &prevConfig = *filteredConfigs[i - 1];        size_t prevBitCount = prevConfig.redSize +                              prevConfig.greenSize +                              prevConfig.blueSize +                              prevConfig.alphaSize;        const egl::Config &curConfig = *filteredConfigs[i];        size_t curBitCount = curConfig.redSize +                             curConfig.greenSize +                             curConfig.blueSize +                             curConfig.alphaSize;        EXPECT_GE(prevBitCount, curBitCount);    }}

TYPED_TEST(InnerProductLayerTest, TestForwardNoBatch) {  typedef typename TypeParam::Dtype Dtype;  this->blob_bottom_vec_.push_back(this->blob_bottom_nobatch_);  LayerParameter layer_param;  InnerProductParameter* inner_product_param =      layer_param.mutable_inner_product_param();  inner_product_param->set_num_output(10);  inner_product_param->mutable_weight_filler()->set_type("uniform");  inner_product_param->mutable_bias_filler()->set_type("uniform");  inner_product_param->mutable_bias_filler()->set_min(1);  inner_product_param->mutable_bias_filler()->set_max(2);  shared_ptr<InnerProductLayer<Dtype> > layer(      new InnerProductLayer<Dtype>(layer_param));  layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_);  layer->Forward(this->blob_bottom_vec_, this->blob_top_vec_);  const Dtype* data = this->blob_top_->cpu_data();  const int_tp count = this->blob_top_->count();  for (int_tp i = 0; i < count; ++i) {    EXPECT_GE(data[i], 1.);  }}

TEST(RandomGenerateTest, CheckULLParams) {	std::vector<unsigned long long> arr;	std::ifstream in("generate_tests.txt");	int test_num;	in >> test_num;	SeqParams<unsigned long long> params, res_params;	for (int i = 0; i < test_num; ++i) {		in >> params;				generate(arr, params.len, params.min_val, params .max_val, params.repetitions_percent);		std::cerr << params.len << " " << params.min_val << " " << params .max_val << " " << params.repetitions_percent << std::endl;		res_params = calcRepetitionsPercent(arr);		EXPECT_LE(params.min_val, res_params.min_val);		EXPECT_GE(params.max_val, res_params.max_val);		EXPECT_LE(abs(params.repetitions_percent - res_params.repetitions_percent), 10);	}}

TYPED_TEST(ThresholdLayerTest, Test) {  typedef typename TypeParam::Dtype Dtype;  LayerParameter layer_param;  ThresholdLayer<Dtype> layer(layer_param);  layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);  layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_);  // Now, check values  const Dtype* bottom_data = this->blob_bottom_->cpu_data();  const Dtype* top_data = this->blob_top_->cpu_data();  const Dtype threshold_ = layer_param.threshold_param().threshold();  for (int i = 0; i < this->blob_bottom_->count(); ++i) {    EXPECT_GE(top_data[i], 0.);    EXPECT_LE(top_data[i], 1.);    if (top_data[i] == 0) {      EXPECT_LE(bottom_data[i], threshold_);    }    if (top_data[i] == 1) {      EXPECT_GT(bottom_data[i], threshold_);    }  }}

VOID TEST(SampleTest, FastSampleMacrosTest) {    EXPECT_TRUE(1);    EXPECT_FALSE(0);        EXPECT_EQ(1, 1); // ==    EXPECT_NE(1, 2); // !=    EXPECT_LE(1, 2); // <=    EXPECT_LT(1, 2); // <    EXPECT_GE(2, 1); // >=    EXPECT_GT(2, 1); // >    EXPECT_STREQ("winlin", "winlin");    EXPECT_STRNE("winlin", "srs");    EXPECT_STRCASEEQ("winlin", "Winlin");    EXPECT_STRCASENE("winlin", "srs");        EXPECT_FLOAT_EQ(1.0, 1.000000000000001);    EXPECT_DOUBLE_EQ(1.0, 1.0000000000000001);    EXPECT_NEAR(10, 15, 5);}

TEST_F(EventsDatabaseTests, test_optimize) {  auto sub = std::make_shared<DBFakeEventSubscriber>();  for (size_t i = 800; i < 800 + 10; ++i) {    sub->testAdd(i);  }  // Lie about the tool type to enable optimizations.  auto default_type = kToolType;  kToolType = ToolType::DAEMON;  FLAGS_events_optimize = true;  // Must also define an executing query.  setDatabaseValue(kPersistentSettings, kExecutingQuery, "events_db_test");  auto t = getUnixTime();  auto results = genRows(sub.get());  EXPECT_EQ(10U, results.size());  // Optimization will set the time NOW as the minimum event time.  // Thus it is not possible to set event in past.  EXPECT_GE(sub->optimize_time_ + 100, t);  EXPECT_LE(sub->optimize_time_ - 100, t);  // The last EID returned will also be stored for duplication checks.  EXPECT_EQ(10U, sub->optimize_eid_);  for (size_t i = t + 800; i < t + 800 + 10; ++i) {    sub->testAdd(i);  }  results = genRows(sub.get());  EXPECT_EQ(10U, results.size());  // The optimize time should have been written to the database.  // It should be the same as the current (relative) optimize time.  std::string content;  getDatabaseValue("events", "optimize.events_db_test", content);  EXPECT_EQ(std::to_string(sub->optimize_time_), content);  // Restore the tool type.  kToolType = default_type;}

TEST(HeapTest, SimpleHeapTest){    Heap<int> heap;    EXPECT_TRUE(heap.isEmpty());    heap.add(1);    heap.add(2);    heap.add(3);    EXPECT_EQ(heap.getNumNodes(), 3);    EXPECT_EQ(heap.getHeight(), 2);    for (int i = 4; i <= 15; i++)    {        heap.add(i);    }    ASSERT_EQ(heap.getNumNodes(), 15);    EXPECT_EQ(heap.getHeight(), 4);    int* testArray = new int[15];    for (int i = 0; i < 15; i++)    {        testArray[i] = heap.peekTop();        heap.remove();    }    for (int i = 0; i < 14; i++)    {        EXPECT_GE(testArray[i], testArray[i + 1]);    }    heap.clear();    EXPECT_TRUE(heap.isEmpty());    delete[] testArray;}

TYPED_TEST(MaxPoolingDropoutTest, TestBackward) {  typedef typename TypeParam::Dtype Dtype;  LayerParameter layer_param;  layer_param.set_phase(TRAIN);  PoolingParameter* pooling_param = layer_param.mutable_pooling_param();  pooling_param->clear_kernel_size();  pooling_param->add_kernel_size(3);  pooling_param->clear_stride();  pooling_param->add_stride(2);  PoolingLayer<Dtype> layer(layer_param);  layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);  layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_);  for (int i = 0; i < this->blob_top_->count(); ++i) {    this->blob_top_->mutable_cpu_diff()[i] = 1.;  }  vector<bool> propagate_down(this->blob_bottom_vec_.size(), true);  layer.Backward(this->blob_top_vec_, propagate_down,                 this->blob_bottom_vec_);  const Dtype* bottom_diff = this->blob_bottom_->cpu_diff();  Dtype sum = 0.;  for (int i = 0; i < this->blob_bottom_->count(); ++i) {    sum += bottom_diff[i];  }  EXPECT_EQ(sum, this->blob_top_->count());  // Dropout in-place  DropoutLayer<Dtype> dropout_layer(layer_param);  dropout_layer.SetUp(this->blob_top_vec_, this->blob_top_vec_);  dropout_layer.Forward(this->blob_top_vec_, this->blob_top_vec_);  dropout_layer.Backward(this->blob_top_vec_, propagate_down,                         this->blob_top_vec_);  layer.Backward(this->blob_top_vec_, propagate_down,                 this->blob_bottom_vec_);  Dtype sum_with_dropout = 0.;  bottom_diff = this->blob_bottom_->cpu_diff();  for (int i = 0; i < this->blob_bottom_->count(); ++i) {    sum_with_dropout += bottom_diff[i];  }  EXPECT_GE(sum_with_dropout, sum);}

TYPED_TEST(ArgMaxLayerTest, TestCPU) {  LayerParameter layer_param;  ArgMaxLayer<TypeParam> layer(layer_param);  layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);  layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_);  // Now, check values  const TypeParam* bottom_data = this->blob_bottom_->cpu_data();  const TypeParam* top_data = this->blob_top_->cpu_data();  int max_ind;  TypeParam max_val;  int num = this->blob_bottom_->num();  int dim = this->blob_bottom_->count() / num;  for (int i = 0; i < num; ++i) {    EXPECT_GE(top_data[i], 0);    EXPECT_LE(top_data[i], dim);    max_ind = top_data[i];    max_val = bottom_data[i * dim + max_ind];    for (int j = 0; j < dim; ++j) {      EXPECT_LE(bottom_data[i * dim + j], max_val);    }  }}

TYPED_TEST(CuDNNNeuronLayerTest, TestTanHCuDNN) {  Caffe::set_mode(Caffe::GPU);  LayerParameter layer_param;  CuDNNTanHLayer<TypeParam> layer(layer_param);  layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);  layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_);  // Test exact values  for (int i = 0; i < this->blob_bottom_->num(); ++i) {    for (int j = 0; j < this->blob_bottom_->channels(); ++j) {      for (int k = 0; k < this->blob_bottom_->height(); ++k) {        for (int l = 0; l < this->blob_bottom_->width(); ++l) {          EXPECT_GE(this->blob_top_->data_at(i, j, k, l) + 1e-4,             (exp(2*this->blob_bottom_->data_at(i, j, k, l)) - 1) /             (exp(2*this->blob_bottom_->data_at(i, j, k, l)) + 1));          EXPECT_LE(this->blob_top_->data_at(i, j, k, l) - 1e-4,             (exp(2*this->blob_bottom_->data_at(i, j, k, l)) - 1) /             (exp(2*this->blob_bottom_->data_at(i, j, k, l)) + 1));        }      }    }  }}

TEST(MapTests, TestOpenMap) {    char** options = nullptr;    options = ngsListAddNameValue(options, "DEBUG_MODE", "ON");    options = ngsListAddNameValue(options, "SETTINGS_DIR",                              ngsFormFileName(ngsGetCurrentDirectory(), "tmp",                                              nullptr));    EXPECT_EQ(ngsInit(options), COD_SUCCESS);    ngsListFree(options);    ngs::MapStore mapStore;    ngs::CatalogPtr catalog = ngs::Catalog::instance();    CPLString tmpDir = CPLFormFilename(CPLGetCurrentDir(), "tmp", nullptr);    ngs::ObjectPtr tmpDirObj = catalog->getObjectBySystemPath(tmpDir);    ASSERT_NE(tmpDirObj, nullptr);    ngs::ObjectContainer* tmpDirContainer =            ngsDynamicCast(ngs::ObjectContainer, tmpDirObj);    tmpDirContainer->loadChildren();    ASSERT_NE(tmpDirContainer->hasChildren(), 0);    ngs::ObjectPtr mapFileObj = tmpDirContainer->getChild("default.ngmd");    ngs::MapFile* mapFile = ngsDynamicCast(ngs::MapFile, mapFileObj);    char mapId = mapStore.openMap(mapFile);    EXPECT_GE(mapId, 0);    ngs::MapViewPtr defMap = mapStore.getMap(mapId);    ASSERT_NE(defMap, nullptr);    EXPECT_EQ(defMap->hasIconSet("simple"), true);    ngs::Catalog::setInstance(nullptr);    auto iconData = defMap->iconSet("simple");    ASSERT_NE(iconData.buffer, nullptr);    EXPECT_EQ(iconData.buffer[0], 0);    EXPECT_EQ(iconData.buffer[1], 0);    EXPECT_EQ(iconData.buffer[2], 0);    EXPECT_EQ(iconData.buffer[3], 0);    ngsUnInit();}