, exception(AsyncSocketException::UNKNOWN, "none")
, mcb_(mcb) {}
- ~WriteCallbackBase() {
+ ~WriteCallbackBase() override {
EXPECT_EQ(STATE_SUCCEEDED, state);
}
}
}
- virtual void writeSuccess() noexcept override {
+ void writeSuccess() noexcept override {
std::cerr << "writeSuccess" << std::endl;
state = STATE_SUCCEEDED;
}
explicit ExpectWriteErrorCallback(SendMsgParamsCallbackBase* mcb = nullptr)
: WriteCallbackBase(mcb) {}
- ~ExpectWriteErrorCallback() {
+ ~ExpectWriteErrorCallback() override {
EXPECT_EQ(STATE_FAILED, state);
EXPECT_EQ(exception.type_,
AsyncSocketException::AsyncSocketExceptionType::NETWORK_ERROR);
explicit WriteCheckTimestampCallback(SendMsgParamsCallbackBase* mcb = nullptr)
: WriteCallbackBase(mcb) {}
- ~WriteCheckTimestampCallback() {
+ ~WriteCheckTimestampCallback() override {
EXPECT_EQ(STATE_SUCCEEDED, state);
EXPECT_TRUE(gotTimestamp_);
EXPECT_TRUE(gotByteSeq_);
explicit ReadCallbackBase(WriteCallbackBase* wcb)
: wcb_(wcb), state(STATE_WAITING) {}
- ~ReadCallbackBase() {
+ ~ReadCallbackBase() override {
EXPECT_EQ(STATE_SUCCEEDED, state);
}
: ReadCallbackBase(wcb)
, buffers() {}
- ~ReadCallback() {
+ ~ReadCallback() override {
for (std::vector<Buffer>::iterator it = buffers.begin();
it != buffers.end();
++it) {
cv_.wait(lock, [this] { return state != STATE_WAITING; });
}
- ~HandshakeCallback() {
+ ~HandshakeCallback() override {
EXPECT_EQ(STATE_SUCCEEDED, state);
}
SSLServerAcceptCallbackBase(hcb),
timeout_(timeout) {}
- virtual ~SSLServerAcceptCallback() {
+ ~SSLServerAcceptCallback() override {
if (timeout_ > 0) {
// if we set a timeout, we expect failure
EXPECT_EQ(hcb_->state, STATE_FAILED);
socket_->sslAccept(this);
}
- ~RenegotiatingServer() {
+ ~RenegotiatingServer() override {
socket_->setReadCB(nullptr);
}
memset(buf_, 'a', sizeof(buf_));
}
- ~SSLClient() {
+ ~SSLClient() override {
if (session_) {
SSL_SESSION_free(session_);
}