C++ CHECK_LE函數代碼示例

 inline int LegacyShape(int index) const {
   CHECK_LE(num_axes(), 4)
       << "Cannot use legacy accessors on Blobs with > 4 axes.";
   CHECK_LT(index, 4);
   CHECK_GE(index, -4);
   if (index >= num_axes() || index < -num_axes()) {
     // Axis is out of range, but still in [0, 3] (or [-4, -1] for reverse
     // indexing) -- this special case simulates the one-padding used to fill
     // extraneous axes of legacy blobs.
     return 1;
   }
   return shape(index);
 }

 inline int offset(const vector<int>& indices) const {
   CHECK_LE(indices.size(), num_axes());
   int offset = 0;
   for (int i = 0; i < num_axes(); ++i) {
     offset *= shape(i);
     if (indices.size() > i) {
       CHECK_GE(indices[i], 0);
       CHECK_LT(indices[i], shape(i));
       offset += indices[i];
     }
   }
   return offset;
 }

void ThriftServer::CumulativeFailureInjection::set(
    const FailureInjection& fi) {
  CHECK_GE(fi.errorFraction, 0);
  CHECK_GE(fi.dropFraction, 0);
  CHECK_GE(fi.disconnectFraction, 0);
  CHECK_LE(fi.errorFraction + fi.dropFraction + fi.disconnectFraction, 1);

  std::lock_guard<std::mutex> lock(mutex_);
  errorThreshold_ = fi.errorFraction;
  dropThreshold_ = errorThreshold_ + fi.dropFraction;
  disconnectThreshold_ = dropThreshold_ + fi.disconnectFraction;
  empty_.store((disconnectThreshold_ == 0), std::memory_order_relaxed);
}

 /**
  * Called by the parent Layer's SetUp to check that the number of bottom
  * and top Blobs provided as input match the expected numbers specified by
  * the {ExactNum,Min,Max}{Bottom,Top}Blobs() functions.
  */
 virtual void CheckBlobCounts(const vector<Blob<Dtype>*>& bottom,
                              const vector<Blob<Dtype>*>& top) {
   if (ExactNumBottomBlobs() >= 0) {
     CHECK_EQ(ExactNumBottomBlobs(), bottom.size())
         << type() << " Layer takes " << ExactNumBottomBlobs()
         << " bottom blob(s) as input.";
   }
   if (MinBottomBlobs() >= 0) {
     CHECK_LE(MinBottomBlobs(), bottom.size())
         << type() << " Layer takes at least " << MinBottomBlobs()
         << " bottom blob(s) as input.";
   }
   if (MaxBottomBlobs() >= 0) {
     CHECK_GE(MaxBottomBlobs(), bottom.size())
         << type() << " Layer takes at most " << MaxBottomBlobs()
         << " bottom blob(s) as input.";
   }
   if (ExactNumTopBlobs() >= 0) {
     CHECK_EQ(ExactNumTopBlobs(), top.size())
         << type() << " Layer produces " << ExactNumTopBlobs()
         << " top blob(s) as output.";
   }
   if (MinTopBlobs() >= 0) {
     CHECK_LE(MinTopBlobs(), top.size())
         << type() << " Layer produces at least " << MinTopBlobs()
         << " top blob(s) as output.";
   }
   if (MaxTopBlobs() >= 0) {
     CHECK_GE(MaxTopBlobs(), top.size())
         << type() << " Layer produces at most " << MaxTopBlobs()
         << " top blob(s) as output.";
   }
   if (EqualNumBottomTopBlobs()) {
     CHECK_EQ(bottom.size(), top.size())
         << type() << " Layer produces one top blob as output for each "
         << "bottom blob input.";
   }
 }

    TEST(Logging, CheckOpPass)
    {
        int i1 = 1;
        int i2 = 2;
        unsigned u1 = 3;
        unsigned u2 = 4;
        float f1 = 5.5f;
        float f2 = 6.6f;
        int* p1 = &i1;
        int* p2 = &i2;
        char const * message = "message";

        CHECK_EQ(i1, i1) << message;
        CHECK_EQ(u1, u1) << message;
        CHECK_EQ(f1, f1) << message;
        CHECK_EQ(p1, p1) << message;

        CHECK_NE(i1, i2) << message;
        CHECK_NE(u1, u2) << message;
        CHECK_NE(f1, f2) << message;
        CHECK_NE(p1, p2) << message;

        CHECK_LT(i1, i2) << message;
        CHECK_LT(u1, u2) << message;
        CHECK_LT(f1, f2) << message;

        CHECK_LE(i1, i1) << message;
        CHECK_LE(u1, u2) << message;
        CHECK_LE(f1, f1) << message;

        CHECK_GT(i2, i1) << message;
        CHECK_GT(u2, u1) << message;
        CHECK_GT(f2, f1) << message;

        CHECK_GE(i1, i1) << message;
        CHECK_GE(u2, u1) << message;
        CHECK_GE(f1, f1) << message;
    }

void EltwiseAccuracyLayer<Dtype>::Reshape(
  const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  CHECK_EQ(bottom[0]->num(), bottom[1]->num())
      << "The data and label should have the same number.";
  CHECK_LE(top_k_, bottom[0]->count() / bottom[0]->num())
      << "top_k must be less than or equal to the number of classes.";
  CHECK_EQ(bottom[1]->channels(), 1)
      << "Label data should have channel 1.";
  CHECK_EQ(bottom[0]->height(), bottom[1]->height())
      << "The data and label should have the same height.";
  CHECK_EQ(bottom[0]->width(), bottom[1]->width())
      << "the data and label should have the same width.";
  top[0]->Reshape(1, 1, 1, 1);
}

bool CoverageSet::covers(size_t begin, size_t end) const noexcept {
  CHECK_LE(begin, end)
      << "End of interval must be greater than or equal to begin";
  if (begin == end) {
    return true;
  }

  auto right = set_.upper_bound(Interval{begin, end});
  if (right == set_.begin()) {
    return false;
  }
  auto left = std::prev(right);
  return left->begin <= begin && end <= left->end;
}

void Blob<Dtype>::Reshape(const vector<int>& shape) {
  CHECK_LE(shape.size(), kMaxBlobAxes);
  count_ = 1;
  shape_.resize(shape.size());
  if (!shape_data_ || shape_data_->size() < shape.size() * sizeof(int)) {
    shape_data_.reset(new SyncedMemory(shape.size() * sizeof(int)));
  }
  int* shape_data = static_cast<int*>(shape_data_->mutable_cpu_data());
  for (int i = 0; i < shape.size(); ++i) {
    CHECK_GE(shape[i], 0);
    if (count_ != 0) {
      CHECK_LE(shape[i], INT_MAX / count_) << "blob size exceeds INT_MAX";
    }
    count_ *= shape[i];
    shape_[i] = shape[i];
    shape_data[i] = shape[i];
  }
  if (count_ > capacity_) {
    capacity_ = count_;
    data_.reset(new SyncedMemory(capacity_ * sizeof(Dtype)));
    diff_.reset(new SyncedMemory(capacity_ * sizeof(Dtype)));
  }
}

std::unique_ptr<IOBuf> SnappyCodec::doCompress(const IOBuf* data) {
  IOBufSnappySource source(data);
  auto out =
    IOBuf::create(snappy::MaxCompressedLength(source.Available()));

  snappy::UncheckedByteArraySink sink(reinterpret_cast<char*>(
      out->writableTail()));

  size_t n = snappy::Compress(&source, &sink);

  CHECK_LE(n, out->capacity());
  out->append(n);
  return out;
}

// Asynchronous read on a overlapped int_fd. Returns `Error` on fatal errors,
// `None()` on a successful pending IO operation or number of bytes read on a
// successful IO operation that finished immediately.
inline Result<size_t> read_async(
    const int_fd& fd,
    void* data,
    size_t size,
    OVERLAPPED* overlapped)
{
  CHECK_LE(size, UINT_MAX);

  switch (fd.type()) {
    case WindowsFD::Type::HANDLE: {
      DWORD bytes;
      const bool success =
        ::ReadFile(fd, data, static_cast<DWORD>(size), &bytes, overlapped);

      // On failure, there are two EOF cases for reads:
      //   1) ERROR_BROKEN_PIPE: The write end is closed and there is no data.
      //   2) ERROR_HANDLE_EOF: We hit the EOF for an asynchronous file handle.
      const DWORD errorCode = ::GetLastError();
      if (success == FALSE &&
          (errorCode == ERROR_BROKEN_PIPE || errorCode == ERROR_HANDLE_EOF)) {
        return 0;
      }

      return ::internal::windows::process_async_io_result(success, bytes);
    }
    case WindowsFD::Type::SOCKET: {
      static_assert(
          std::is_same<OVERLAPPED, WSAOVERLAPPED>::value,
          "Expected `WSAOVERLAPPED` to be of type `OVERLAPPED`.");

      // Note that it's okay to allocate this on the stack, since the WinSock
      // providers must copy the WSABUF to their internal buffers. See
      // https://msdn.microsoft.com/en-us/library/windows/desktop/ms741688(v=vs.85).aspx // NOLINT(whitespace/line_length)
      WSABUF buf = {
        static_cast<u_long>(size),
        static_cast<char*>(data)
      };

      DWORD bytes;
      DWORD flags = 0;
      const int result =
        ::WSARecv(fd, &buf, 1, &bytes, &flags, overlapped, nullptr);

      return ::internal::windows::process_async_io_result(result == 0, bytes);
    }
  }

  UNREACHABLE();
}

void ArgMaxLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      vector<Blob<Dtype>*>* top) {
  out_max_val_ = this->layer_param_.argmax_param().out_max_val();
  top_k_ = this->layer_param_.argmax_param().top_k();
  CHECK_GE(top_k_, 1) << " top k must not be less than 1.";
  CHECK_LE(top_k_, bottom[0]->count() / bottom[0]->num())
      << "top_k must be less than or equal to the number of classes.";
  if (out_max_val_) {
    // Produces max_ind and max_val
    (*top)[0]->Reshape(bottom[0]->num(), 2, top_k_, 1);
  } else {
    // Produces only max_ind
    (*top)[0]->Reshape(bottom[0]->num(), 1, top_k_, 1);
  }
}

Vector ЧебышёвSeries<Vector>::Evaluate(Instant const& t) const {
    // This formula ensures continuity at the edges by producing -1 or +1 within
    // 2 ulps for |t_min_| and |t_max_|.
    double const scaled_t = ((t - t_max_) + (t - t_min_)) * one_over_duration_;
    // We have to allow |scaled_t| to go slightly out of [-1, 1] because of
    // computation errors.  But if it goes too far, something is broken.
    // TODO(phl): This should use DCHECK but these macros don't work because the
    // Principia projects don't define NDEBUG.
#ifdef _DEBUG
    CHECK_LE(scaled_t, 1.1);
    CHECK_GE(scaled_t, -1.1);
#endif

    return helper_.EvaluateImplementation(scaled_t);
}

void Blob<Dtype>::Reshape(const vector<int>& shape) {
  CHECK_LE(shape.size(), kMaxBlobAxes);
  count_ = 1;
  shape_.resize(shape.size());
  for (int i = 0; i < shape.size(); ++i) {
    CHECK_GE(shape[i], 0);
    count_ *= shape[i];
    shape_[i] = shape[i];
  }
  if (count_ > capacity_) {
    capacity_ = count_;
    data_.reset(new SyncedMemory(capacity_ * sizeof(Dtype)));
    diff_.reset(new SyncedMemory(capacity_ * sizeof(Dtype)));
  }
}

void SegAccuracyLayer<Dtype>::Reshape(
  const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  CHECK_LE(1, bottom[0]->channels())
      << "top_k must be less than or equal to the number of channels (classes).";
  CHECK_EQ(bottom[0]->num(), bottom[1]->num())
    << "The data and label should have the same number.";
  CHECK_EQ(bottom[1]->channels(), 1)
    << "The label should have one channel.";
  CHECK_EQ(bottom[0]->height(), bottom[1]->height())
    << "The data should have the same height as label.";
  CHECK_EQ(bottom[0]->width(), bottom[1]->width())
    << "The data should have the same width as label.";
 
  top[0]->Reshape(1, 1, 1, 5);
}

ReturnValue BleApiTest_TestEncodingLongDataExactLength(pBleDevice dev)
{
	ReturnValue retval;

	U2F_AUTHENTICATE_REQ authReq;
	unsigned char reply[2048];
	unsigned int replyLength = sizeof(reply);
	unsigned char request[256];
	unsigned int requestlen;
	unsigned char replyCmd;

	// pick random challenge and use registered appId.
	for (size_t i = 0; i < sizeof(authReq.nonce); ++i)
		authReq.nonce[i] = rand();
	memcpy(authReq.appId, regReq.appId, sizeof(authReq.appId));
	authReq.keyHandleLen = regRsp.keyHandleLen;
	memcpy(authReq.keyHandle, regRsp.keyHandleCertSig,
	       authReq.keyHandleLen);

	uint64_t t = dev->TimeMs();

	/* prepare register request */
	request[0] = 0x00;
	request[1] = U2F_INS_AUTHENTICATE;
	request[2] = U2F_AUTH_ENFORCE;
	request[3] = 0x00;
	request[4] = 0x00;
	request[5] = 0x00;
	request[6] = U2F_NONCE_SIZE + U2F_APPID_SIZE + 1 + authReq.keyHandleLen;
	memcpy(request + 7, reinterpret_cast < char *>(&authReq), request[6]);
	requestlen = 7 + request[6];
	request[requestlen++] = 0x00;
	/* 1 byte user presence + 4 bytes counter + upto (6 + 33 + 33) bytes signature */
	request[requestlen++] = 0x01 + 0x04 + 0x48;

	/* write command */
	retval =
	    dev->CommandWrite(FIDO_BLE_CMD_MSG, request, requestlen, &replyCmd,
			      reply, &replyLength);
	CHECK_EQ(retval, ReturnValue::BLEAPI_ERROR_SUCCESS);

  CHECK_EQ(replyCmd, FIDO_BLE_CMD_MSG, "Reply is not a FIDO_BLE_CMD_MSG (0x83)");
	CHECK_EQ(FIDO_RESP_SUCCESS, bytes2short(reply, replyLength - 2), "expects FIDO_RESP_SUCCESS (0x9000)");
	CHECK_NE(replyLength, 2);
  CHECK_LE(replyLength - 2, sizeof(U2F_AUTHENTICATE_RESP), "Returned authentication response does not match expected length.");

	return ReturnValue::BLEAPI_ERROR_SUCCESS;
}