Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-19 00:41:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

[wpinet] Rename constants to all caps (#8696)

Browse Source
This commit is contained in:
Peter Johnson
2026-03-20 23:02:21 -07:00
committed by GitHub
parent 0fc1f45324
commit 4e4ad9c498
23 changed files with 214 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
wpinet/src/main/native/cpp/DsClient.cpp
View File

@@ -16,7 +16,7 @@
using namespace wpi::net;
static constexpr uv::Timer::Time kReconnectTime{500};
static constexpr uv::Timer::Time RECONNECT_TIME{500};
DsClient::DsClient(wpi::net::uv::Loop& loop, wpi::util::Logger& logger,
const private_init&)
@@ -30,7 +30,7 @@ DsClient::DsClient(wpi::net::uv::Loop& loop, wpi::util::Logger& logger,
WPI_DEBUG4(m_logger, "DS connection closed");
clearIp();
// try to connect again
m_tcp->Reuse([this] { m_timer->Start(kReconnectTime); });
m_tcp->Reuse([this] { m_timer->Start(RECONNECT_TIME); });
});
m_tcp->data.connect([this](wpi::net::uv::Buffer buf, size_t len) {
HandleIncoming({buf.base, len});
@@ -58,7 +58,7 @@ void DsClient::Connect() {
connreq->error = [this](uv::Error err) {
WPI_DEBUG4(m_logger, "DS connect failure: {}", err.str());
// try to connect again
m_tcp->Reuse([this] { m_timer->Start(kReconnectTime); });
m_tcp->Reuse([this] { m_timer->Start(RECONNECT_TIME); });
};
WPI_DEBUG4(m_logger, "Starting DS connection attempt");

28
wpinet/src/main/native/cpp/HttpParser.cpp
View File

@@ -25,7 +25,7 @@ HttpParser::HttpParser(Type type) {
m_settings.on_message_begin = [](http_parser* p) -> int {
auto& self = *static_cast<HttpParser*>(p->data);
self.m_urlBuf.clear();
self.m_state = kStart;
self.m_state = State::START;
self.messageBegin();
return self.m_aborted;
};
@@ -38,7 +38,7 @@ HttpParser::HttpParser(Type type) {
return 1;
}
self.m_urlBuf += std::string_view{at, length};
self.m_state = kUrl;
self.m_state = State::URL;
return 0;
};
@@ -51,7 +51,7 @@ HttpParser::HttpParser(Type type) {
return 1;
}
self.m_valueBuf += std::string_view{at, length};
self.m_state = kStatus;
self.m_state = State::STATUS;
return 0;
};
@@ -61,7 +61,7 @@ HttpParser::HttpParser(Type type) {
auto& self = *static_cast<HttpParser*>(p->data);
// once we're in header, we know the URL is complete
if (self.m_state == kUrl) {
if (self.m_state == State::URL) {
self.url(self.m_urlBuf);
if (self.m_aborted) {
return 1;
@@ -69,7 +69,7 @@ HttpParser::HttpParser(Type type) {
}
// once we're in header, we know the status is complete
if (self.m_state == kStatus) {
if (self.m_state == State::STATUS) {
self.status(self.m_valueBuf);
if (self.m_aborted) {
return 1;
@@ -77,7 +77,7 @@ HttpParser::HttpParser(Type type) {
}
// if we previously were in value state, that means we finished a header
if (self.m_state == kValue) {
if (self.m_state == State::VALUE) {
self.header(self.m_fieldBuf, self.m_valueBuf);
if (self.m_aborted) {
return 1;
@@ -85,8 +85,8 @@ HttpParser::HttpParser(Type type) {
}
// clear field and value when we enter this state
if (self.m_state != kField) {
self.m_state = kField;
if (self.m_state != State::FIELD) {
self.m_state = State::FIELD;
self.m_fieldBuf.clear();
self.m_valueBuf.clear();
}
@@ -105,8 +105,8 @@ HttpParser::HttpParser(Type type) {
auto& self = *static_cast<HttpParser*>(p->data);
// if we weren't previously in value state, clear the buffer
if (self.m_state != kValue) {
self.m_state = kValue;
if (self.m_state != State::VALUE) {
self.m_state = State::VALUE;
self.m_valueBuf.clear();
}
@@ -123,7 +123,7 @@ HttpParser::HttpParser(Type type) {
auto& self = *static_cast<HttpParser*>(p->data);
// if we previously were in url state, that means we finished the url
if (self.m_state == kUrl) {
if (self.m_state == State::URL) {
self.url(self.m_urlBuf);
if (self.m_aborted) {
return 1;
@@ -131,7 +131,7 @@ HttpParser::HttpParser(Type type) {
}
// if we previously were in status state, that means we finished the status
if (self.m_state == kStatus) {
if (self.m_state == State::STATUS) {
self.status(self.m_valueBuf);
if (self.m_aborted) {
return 1;
@@ -139,7 +139,7 @@ HttpParser::HttpParser(Type type) {
}
// if we previously were in value state, that means we finished a header
if (self.m_state == kValue) {
if (self.m_state == State::VALUE) {
self.header(self.m_fieldBuf, self.m_valueBuf);
if (self.m_aborted) {
return 1;
@@ -185,7 +185,7 @@ void HttpParser::Reset(Type type) {
static_cast<http_parser_type>(static_cast<int>(type)));
m_parser.data = this;
m_maxLength = 1024;
m_state = kStart;
m_state = State::START;
m_urlBuf.clear();
m_fieldBuf.clear();
m_valueBuf.clear();

24
wpinet/src/main/native/cpp/HttpUtil.cpp
View File

@@ -433,19 +433,19 @@ void HttpMultipartScanner::SetBoundary(std::string_view boundary) {
m_boundaryWith += boundary;
m_boundaryWithout = "\n";
m_boundaryWithout += boundary;
m_dashes = kUnknown;
m_dashes = Dashes::UNKNOWN;
}
void HttpMultipartScanner::Reset(bool saveSkipped) {
m_saveSkipped = saveSkipped;
m_state = kBoundary;
m_state = State::BOUNDARY;
m_posWith = 0;
m_posWithout = 0;
m_buf.resize(0);
}
std::string_view HttpMultipartScanner::Execute(std::string_view in) {
if (m_state == kDone) {
if (m_state == State::DONE) {
Reset(m_saveSkipped);
}
if (m_saveSkipped) {
@@ -453,16 +453,16 @@ std::string_view HttpMultipartScanner::Execute(std::string_view in) {
}
size_t pos = 0;
if (m_state == kBoundary) {
if (m_state == State::BOUNDARY) {
for (char ch : in) {
++pos;
if (m_dashes != kWithout) {
if (m_dashes != Dashes::WITHOUT) {
if (ch == m_boundaryWith[m_posWith]) {
++m_posWith;
if (m_posWith == m_boundaryWith.size()) {
// Found the boundary; transition to padding
m_state = kPadding;
m_dashes = kWith; // no longer accept plain 'boundary'
m_state = State::PADDING;
m_dashes = Dashes::WITH; // no longer accept plain 'boundary'
break;
}
} else if (ch == m_boundaryWith[0]) {
@@ -472,13 +472,13 @@ std::string_view HttpMultipartScanner::Execute(std::string_view in) {
}
}
if (m_dashes != kWith) {
if (m_dashes != Dashes::WITH) {
if (ch == m_boundaryWithout[m_posWithout]) {
++m_posWithout;
if (m_posWithout == m_boundaryWithout.size()) {
// Found the boundary; transition to padding
m_state = kPadding;
m_dashes = kWithout; // no longer accept '--boundary'
m_state = State::PADDING;
m_dashes = Dashes::WITHOUT; // no longer accept '--boundary'
break;
}
} else if (ch == m_boundaryWithout[0]) {
@@ -490,12 +490,12 @@ std::string_view HttpMultipartScanner::Execute(std::string_view in) {
}
}
if (m_state == kPadding) {
if (m_state == State::PADDING) {
for (char ch : wpi::util::drop_front(in, pos)) {
++pos;
if (ch == '\n') {
// Found the LF; return remaining input buffer (following it)
m_state = kDone;
m_state = State::DONE;
if (m_saveSkipped) {
m_buf.resize(m_buf.size() - in.size() + pos);
}

88
wpinet/src/main/native/cpp/WebSocket.cpp
View File

@@ -107,9 +107,9 @@ class WebSocket::WriteReq : public uv::WriteReq,
std::shared_ptr<WriteReq> m_controlCont;
};
static constexpr uint8_t kFlagMasking = 0x80;
static constexpr uint8_t kLenMask = 0x7f;
static constexpr size_t kWriteAllocSize = 4096;
static constexpr uint8_t FLAG_MASKING = 0x80;
static constexpr uint8_t LEN_MASK = 0x7f;
static constexpr size_t WRITE_ALLOC_SIZE = 4096;
class WebSocket::ClientHandshakeData {
public:
@@ -134,7 +134,7 @@ class WebSocket::ClientHandshakeData {
wpi::util::SmallString<64> key; // the key sent to the server
wpi::util::SmallVector<std::string, 2> protocols; // valid protocols
HttpParser parser{HttpParser::kResponse}; // server response parser
HttpParser parser{HttpParser::Type::RESPONSE}; // server response parser
bool hasUpgrade = false;
bool hasConnection = false;
bool hasAccept = false;
@@ -192,13 +192,13 @@ std::shared_ptr<WebSocket> WebSocket::CreateServer(uv::Stream& stream,
void WebSocket::Close(uint16_t code, std::string_view reason) {
SendClose(code, reason);
if (m_state != FAILED && m_state != CLOSED) {
m_state = CLOSING;
if (m_state != State::FAILED && m_state != State::CLOSED) {
m_state = State::CLOSING;
}
}
void WebSocket::Fail(uint16_t code, std::string_view reason) {
if (m_state == FAILED || m_state == CLOSED) {
if (m_state == State::FAILED || m_state == State::CLOSED) {
return;
}
SendClose(code, reason);
@@ -207,7 +207,7 @@ void WebSocket::Fail(uint16_t code, std::string_view reason) {
}
void WebSocket::Terminate(uint16_t code, std::string_view reason) {
if (m_state == FAILED || m_state == CLOSED) {
if (m_state == State::FAILED || m_state == State::CLOSED) {
return;
}
SetClosed(code, reason);
@@ -222,7 +222,7 @@ void WebSocket::StartClient(std::string_view uri, std::string_view host,
// Build client request
wpi::util::SmallVector<uv::Buffer, 4> bufs;
raw_uv_ostream os{bufs, kWriteAllocSize};
raw_uv_ostream os{bufs, WRITE_ALLOC_SIZE};
os << "GET " << uri << " HTTP/1.1\r\n";
os << "Host: " << host << "\r\n";
@@ -319,8 +319,8 @@ void WebSocket::StartClient(std::string_view uri, std::string_view host,
!m_clientHandshake->protocols.empty())) {
return Terminate(1002, "invalid response");
}
if (m_state == CONNECTING) {
m_state = OPEN;
if (m_state == State::CONNECTING) {
m_state = State::OPEN;
open(m_protocol);
}
});
@@ -342,7 +342,7 @@ void WebSocket::StartServer(std::string_view key, std::string_view version,
// Build server response
wpi::util::SmallVector<uv::Buffer, 4> bufs;
raw_uv_ostream os{bufs, kWriteAllocSize};
raw_uv_ostream os{bufs, WRITE_ALLOC_SIZE};
// Handle unsupported version
if (version != "13") {
@@ -380,8 +380,8 @@ void WebSocket::StartServer(std::string_view key, std::string_view version,
for (auto& buf : bufs) {
buf.Deallocate();
}
if (m_state == CONNECTING) {
m_state = OPEN;
if (m_state == State::CONNECTING) {
m_state = State::OPEN;
open(m_protocol);
}
});
@@ -390,13 +390,13 @@ void WebSocket::StartServer(std::string_view key, std::string_view version,
void WebSocket::SendClose(uint16_t code, std::string_view reason) {
wpi::util::SmallVector<uv::Buffer, 4> bufs;
if (code != 1005) {
raw_uv_ostream os{bufs, kWriteAllocSize};
raw_uv_ostream os{bufs, WRITE_ALLOC_SIZE};
const uint8_t codeMsb[] = {static_cast<uint8_t>((code >> 8) & 0xff),
static_cast<uint8_t>(code & 0xff)};
os << std::span{codeMsb};
os << reason;
}
SendControl(kFlagFin | kOpClose, bufs, [](auto bufs, uv::Error) {
SendControl(FLAG_FIN | OP_CLOSE, bufs, [](auto bufs, uv::Error) {
for (auto&& buf : bufs) {
buf.Deallocate();
}
@@ -404,10 +404,10 @@ void WebSocket::SendClose(uint16_t code, std::string_view reason) {
}
void WebSocket::SetClosed(uint16_t code, std::string_view reason, bool failed) {
if (m_state == FAILED || m_state == CLOSED) {
if (m_state == State::FAILED || m_state == State::CLOSED) {
return;
}
m_state = failed ? FAILED : CLOSED;
m_state = failed ? State::FAILED : State::CLOSED;
closed(code, reason);
}
@@ -430,21 +430,21 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
m_lastReceivedTime = m_stream.GetLoopRef().Now().count();
// ignore incoming data if we're failed or closed
if (m_state == FAILED || m_state == CLOSED) {
if (m_state == State::FAILED || m_state == State::CLOSED) {
return;
}
std::string_view data{buf.base, size};
// Handle connecting state (mainly on client)
if (m_state == CONNECTING) {
if (m_state == State::CONNECTING) {
if (m_clientHandshake) {
data = m_clientHandshake->parser.Execute(data);
// check for parser failure
if (m_clientHandshake->parser.HasError()) {
return Terminate(1003, "invalid response");
}
if (m_state != OPEN) {
if (m_state != State::OPEN) {
return; // not done with handshake yet
}
@@ -478,13 +478,13 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
// Once we have first two bytes, we can calculate the header size
if (m_headerSize == 0) {
m_headerSize = 2;
uint8_t len = m_header[1] & kLenMask;
uint8_t len = m_header[1] & LEN_MASK;
if (len == 126) {
m_headerSize += 2;
} else if (len == 127) {
m_headerSize += 8;
}
bool masking = (m_header[1] & kFlagMasking) != 0;
bool masking = (m_header[1] & FLAG_MASKING) != 0;
if (masking) {
m_headerSize += 4; // masking key
}
@@ -510,7 +510,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
if (m_header.size() >= m_headerSize) {
// get payload length
uint8_t len = m_header[1] & kLenMask;
uint8_t len = m_header[1] & LEN_MASK;
if (len == 126) {
m_frameSize = (static_cast<uint16_t>(m_header[2]) << 8) |
static_cast<uint16_t>(m_header[3]);
@@ -528,7 +528,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
}
// limit maximum size
bool control = (m_header[0] & kFlagControl) != 0;
bool control = (m_header[0] & FLAG_CONTROL) != 0;
if (((control ? m_controlPayload.size() : m_payload.size()) +
m_frameSize) > m_maxMessageSize) {
return Fail(1009, "message too large");
@@ -537,7 +537,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
}
if (m_frameSize != UINT64_MAX) {
bool control = (m_header[0] & kFlagControl) != 0;
bool control = (m_header[0] & FLAG_CONTROL) != 0;
size_t need;
if (control) {
need = m_frameSize - m_controlPayload.size();
@@ -555,21 +555,21 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
if (need == 0) {
// We have a complete frame
// If the message had masking, unmask it
if ((m_header[1] & kFlagMasking) != 0) {
if ((m_header[1] & FLAG_MASKING) != 0) {
Unmask(control ? std::span{m_controlPayload}
: std::span{m_payload}.subspan(m_frameStart),
std::span<const uint8_t, 4>{&m_header[m_headerSize - 4], 4});
}
// Handle message
bool fin = (m_header[0] & kFlagFin) != 0;
uint8_t opcode = m_header[0] & kOpMask;
bool fin = (m_header[0] & FLAG_FIN) != 0;
uint8_t opcode = m_header[0] & OP_MASK;
switch (opcode) {
case kOpCont:
case OP_CONT:
WS_DEBUG(m_stream, "WS Fragment {} [{}]", m_payload.size(),
DebugBinary(m_payload));
switch (m_fragmentOpcode) {
case kOpText:
case OP_TEXT:
if (!m_combineFragments || fin) {
std::string_view content{
reinterpret_cast<char*>(m_payload.data()),
@@ -579,7 +579,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
text(content, fin);
}
break;
case kOpBinary:
case OP_BINARY:
if (!m_combineFragments || fin) {
WS_DEBUG(m_stream, "WS RecvBinary(Defrag) {} ({})",
m_payload.size(), DebugBinary(m_payload));
@@ -594,7 +594,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
m_fragmentOpcode = 0;
}
break;
case kOpText: {
case OP_TEXT: {
std::string_view content{reinterpret_cast<char*>(m_payload.data()),
m_payload.size()};
if (m_fragmentOpcode != 0) {
@@ -613,7 +613,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
}
break;
}
case kOpBinary:
case OP_BINARY:
if (m_fragmentOpcode != 0) {
WS_DEBUG(m_stream, "WS RecvBinary {} ({}) -> INCOMPLETE FRAGMENT",
m_payload.size(), DebugBinary(m_payload));
@@ -630,7 +630,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
m_fragmentOpcode = opcode;
}
break;
case kOpClose: {
case OP_CLOSE: {
uint16_t code;
std::string_view reason;
if (!fin) {
@@ -647,7 +647,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
2);
}
// Echo the close if we didn't previously send it
if (m_state != CLOSING) {
if (m_state != State::CLOSING) {
SendClose(code, reason);
}
SetClosed(code, fmt::format("remote close: {}", reason));
@@ -657,15 +657,15 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
}
break;
}
case kOpPing:
case OP_PING:
if (!fin) {
return Fail(1002, "cannot fragment control frames");
}
// If the connection is open, send a Pong in response
if (m_state == OPEN) {
if (m_state == State::OPEN) {
wpi::util::SmallVector<uv::Buffer, 4> bufs;
{
raw_uv_ostream os{bufs, kWriteAllocSize};
raw_uv_ostream os{bufs, WRITE_ALLOC_SIZE};
os << m_controlPayload;
}
SendPong(bufs, [](auto bufs, uv::Error) {
@@ -678,7 +678,7 @@ void WebSocket::HandleIncoming(uv::Buffer& buf, size_t size) {
DebugBinary(m_controlPayload));
ping(m_controlPayload);
break;
case kOpPong:
case OP_PONG:
if (!fin) {
return Fail(1002, "cannot fragment control frames");
}
@@ -749,7 +749,7 @@ void WebSocket::SendFrames(
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
// If we're not open, emit an error and don't send the data
WS_DEBUG(m_stream, "SendFrames({})", frames.size());
if (m_state != OPEN) {
if (m_state != State::OPEN) {
SendError(frames, callback);
return;
}
@@ -787,7 +787,7 @@ std::span<const WebSocket::Frame> WebSocket::TrySendFrames(
std::span<const Frame> frames,
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
// If we're not open, emit an error and don't send the data
if (m_state != WebSocket::OPEN) {
if (m_state != WebSocket::State::OPEN) {
SendError(frames, callback);
return {};
}
@@ -814,7 +814,7 @@ void WebSocket::SendControl(
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
Frame frame{opcode, data};
// If we're not open, emit an error and don't send the data
if (m_state != WebSocket::OPEN) {
if (m_state != WebSocket::State::OPEN) {
SendError({{frame}}, callback);
return;
}
@@ -851,7 +851,7 @@ void WebSocket::SendError(
std::span<const Frame> frames,
const std::function<void(std::span<uv::Buffer>, uv::Error)>& callback) {
int err;
if (m_state == WebSocket::CONNECTING) {
if (m_state == WebSocket::State::CONNECTING) {
err = UV_EAGAIN;
} else {
err = UV_ESHUTDOWN;

14
wpinet/src/main/native/cpp/WebSocketSerializer.cpp
View File

@@ -8,8 +8,8 @@
using namespace wpi::net::detail;
static constexpr uint8_t kFlagMasking = 0x80;
static constexpr size_t kWriteAllocSize = 4096;
static constexpr uint8_t FLAG_MASKING = 0x80;
static constexpr size_t WRITE_ALLOC_SIZE = 4096;
static std::span<uint8_t> BuildHeader(std::span<uint8_t, 10> header,
bool server,
@@ -25,13 +25,13 @@ static std::span<uint8_t> BuildHeader(std::span<uint8_t, 10> header,
size += buf.len;
}
if (size < 126) {
*pHeader++ = (server ? 0x00 : kFlagMasking) | size;
*pHeader++ = (server ? 0x00 : FLAG_MASKING) | size;
} else if (size <= 0xffff) {
*pHeader++ = (server ? 0x00 : kFlagMasking) | 126;
*pHeader++ = (server ? 0x00 : FLAG_MASKING) | 126;
*pHeader++ = (size >> 8) & 0xff;
*pHeader++ = size & 0xff;
} else {
*pHeader++ = (server ? 0x00 : kFlagMasking) | 127;
*pHeader++ = (server ? 0x00 : FLAG_MASKING) | 127;
*pHeader++ = (size >> 56) & 0xff;
*pHeader++ = (size >> 48) & 0xff;
*pHeader++ = (size >> 40) & 0xff;
@@ -90,8 +90,8 @@ size_t SerializedFrames::AddServerFrame(const WebSocket::Frame& frame) {
// manage allocBufs to efficiently store header
if (m_allocBufs.empty() ||
(m_allocBufPos + header.size()) > kWriteAllocSize) {
m_allocBufs.emplace_back(uv::Buffer::Allocate(kWriteAllocSize));
(m_allocBufPos + header.size()) > WRITE_ALLOC_SIZE) {
m_allocBufs.emplace_back(uv::Buffer::Allocate(WRITE_ALLOC_SIZE));
m_allocBufPos = 0;
}
char* internalBuf = m_allocBufs.back().data().data() + m_allocBufPos;

4
wpinet/src/main/native/cpp/WebSocketSerializer.hpp
View File

@@ -204,7 +204,7 @@ std::span<const WebSocket::Frame> TrySendFrames(
++frameStart;
}
bool isFin = (frameStart->opcode & WebSocket::kFlagFin) != 0;
bool isFin = (frameStart->opcode & WebSocket::FLAG_FIN) != 0;
if (offIt != offEnd && *offIt == sentBytes && isFin) {
// we finished at a normal FIN frame boundary; no need for a Write()
++frameStart;
@@ -271,7 +271,7 @@ std::span<const WebSocket::Frame> TrySendFrames(
continuePos += req->m_frames.AddFrame(*frameStart, server);
}
req->m_continueFrameOffs.emplace_back(continuePos);
isFin = (frameStart->opcode & WebSocket::kFlagFin) != 0;
isFin = (frameStart->opcode & WebSocket::FLAG_FIN) != 0;
++frameStart;
}

22
wpinet/src/main/native/cpp/uv/Process.cpp
View File

@@ -45,30 +45,30 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, std::string_view file,
for (auto&& o : options) {
switch (o.m_type) {
case Option::kArg:
case Option::Type::ARG:
argsBuf.push_back(const_cast<char*>(o.m_data.str));
break;
case Option::kEnv:
case Option::Type::ENV:
envBuf.push_back(const_cast<char*>(o.m_data.str));
break;
case Option::kCwd:
case Option::Type::WORKING_DIRECTORY:
coptions.cwd = o.m_data.str[0] == '\0' ? nullptr : o.m_data.str;
break;
case Option::kUid:
case Option::Type::USER_ID:
coptions.uid = o.m_data.uid;
coptions.flags |= UV_PROCESS_SETUID;
break;
case Option::kGid:
case Option::Type::GROUP_ID:
coptions.gid = o.m_data.gid;
coptions.flags |= UV_PROCESS_SETGID;
break;
case Option::kSetFlags:
case Option::Type::SET_FLAGS:
coptions.flags |= o.m_data.flags;
break;
case Option::kClearFlags:
case Option::Type::CLEAR_FLAGS:
coptions.flags &= ~o.m_data.flags;
break;
case Option::kStdioIgnore: {
case Option::Type::STDIO_IGNORE: {
size_t index = o.m_data.stdio.index;
if (index >= stdioBuf.size()) {
stdioBuf.resize(index + 1);
@@ -77,7 +77,7 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, std::string_view file,
stdioBuf[index].data.fd = 0;
break;
}
case Option::kStdioInheritFd: {
case Option::Type::STDIO_INHERIT_FD: {
size_t index = o.m_data.stdio.index;
if (index >= stdioBuf.size()) {
stdioBuf.resize(index + 1);
@@ -86,7 +86,7 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, std::string_view file,
stdioBuf[index].data.fd = o.m_data.stdio.fd;
break;
}
case Option::kStdioInheritPipe: {
case Option::Type::STDIO_INHERIT_PIPE: {
size_t index = o.m_data.stdio.index;
if (index >= stdioBuf.size()) {
stdioBuf.resize(index + 1);
@@ -95,7 +95,7 @@ std::shared_ptr<Process> Process::SpawnArray(Loop& loop, std::string_view file,
stdioBuf[index].data.stream = o.m_data.stdio.pipe->GetRawStream();
break;
}
case Option::kStdioCreatePipe: {
case Option::Type::STDIO_CREATE_PIPE: {
size_t index = o.m_data.stdio.index;
if (index >= stdioBuf.size()) {
stdioBuf.resize(index + 1);

11
wpinet/src/main/native/include/wpi/net/HttpParser.hpp
View File

@@ -21,10 +21,10 @@ namespace wpi::net {
*/
class HttpParser {
public:
enum Type {
kRequest = HTTP_REQUEST,
kResponse = HTTP_RESPONSE,
kBoth = HTTP_BOTH
enum class Type {
REQUEST = HTTP_REQUEST,
RESPONSE = HTTP_RESPONSE,
BOTH = HTTP_BOTH
};
/**
@@ -213,7 +213,8 @@ class HttpParser {
http_parser_settings m_settings;
size_t m_maxLength = 1024;
enum { kStart, kUrl, kStatus, kField, kValue } m_state = kStart;
enum class State { START, URL, STATUS, FIELD, VALUE };
State m_state = State::START;
wpi::util::SmallString<128> m_urlBuf;
wpi::util::SmallString<32> m_fieldBuf;
wpi::util::SmallString<128> m_valueBuf;

2
wpinet/src/main/native/include/wpi/net/HttpServerConnection.hpp
View File

@@ -128,7 +128,7 @@ class HttpServerConnection {
virtual void SendError(int code, std::string_view message = {});
/** The HTTP request. */
HttpParser m_request{HttpParser::kRequest};
HttpParser m_request{HttpParser::Type::REQUEST};
/** Whether the connection should be kept alive. */
bool m_keepAlive = false;

6
wpinet/src/main/native/include/wpi/net/HttpUtil.hpp
View File

@@ -432,7 +432,7 @@ class HttpMultipartScanner {
std::string_view Execute(std::string_view in);
// Returns true when the boundary has been found.
bool IsDone() const { return m_state == kDone; }
bool IsDone() const { return m_state == State::DONE; }
// Get the skipped data. Will be empty if saveSkipped was false.
std::string_view GetSkipped() const {
@@ -443,10 +443,10 @@ class HttpMultipartScanner {
wpi::util::SmallString<64> m_boundaryWith, m_boundaryWithout;
// Internal state
enum State { kBoundary, kPadding, kDone };
enum class State { BOUNDARY, PADDING, DONE };
State m_state;
size_t m_posWith, m_posWithout;
enum Dashes { kUnknown, kWith, kWithout };
enum class Dashes { UNKNOWN, WITH, WITHOUT };
Dashes m_dashes;
// Buffer

10
wpinet/src/main/native/include/wpi/net/NetworkStream.hpp
View File

@@ -14,11 +14,11 @@ class NetworkStream {
NetworkStream() = default;
virtual ~NetworkStream() = default;
enum Error {
kConnectionClosed = 0,
kConnectionReset = -1,
kConnectionTimedOut = -2,
kWouldBlock = -3
enum class Error {
CONNECTION_CLOSED = 0,
CONNECTION_RESET = -1,
CONNECTION_TIMED_OUT = -2,
WOULD_BLOCK = -3
};
virtual size_t send(const char* buffer, size_t len, Error* err) = 0;

54
wpinet/src/main/native/include/wpi/net/WebSocket.hpp
View File

@@ -33,15 +33,15 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
struct private_init {};
public:
static constexpr uint8_t kOpCont = 0x00;
static constexpr uint8_t kOpText = 0x01;
static constexpr uint8_t kOpBinary = 0x02;
static constexpr uint8_t kOpClose = 0x08;
static constexpr uint8_t kOpPing = 0x09;
static constexpr uint8_t kOpPong = 0x0A;
static constexpr uint8_t kOpMask = 0x0F;
static constexpr uint8_t kFlagFin = 0x80;
static constexpr uint8_t kFlagControl = 0x08;
static constexpr uint8_t OP_CONT = 0x00;
static constexpr uint8_t OP_TEXT = 0x01;
static constexpr uint8_t OP_BINARY = 0x02;
static constexpr uint8_t OP_CLOSE = 0x08;
static constexpr uint8_t OP_PING = 0x09;
static constexpr uint8_t OP_PONG = 0x0A;
static constexpr uint8_t OP_MASK = 0x0F;
static constexpr uint8_t FLAG_FIN = 0x80;
static constexpr uint8_t FLAG_CONTROL = 0x08;
WebSocket(uv::Stream& stream, bool server, const private_init&);
WebSocket(const WebSocket&) = delete;
@@ -53,7 +53,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
/**
* Connection states.
*/
enum State {
enum class State {
/** The connection is not yet open. */
CONNECTING = 0,
/** The connection is open and ready to communicate. */
@@ -83,14 +83,14 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
* Frame. Used by SendFrames().
*/
struct Frame {
static constexpr uint8_t kText = kFlagFin | kOpText;
static constexpr uint8_t kBinary = kFlagFin | kOpBinary;
static constexpr uint8_t kTextFragment = kOpText;
static constexpr uint8_t kBinaryFragment = kOpBinary;
static constexpr uint8_t kFragment = kOpCont;
static constexpr uint8_t kFinalFragment = kFlagFin | kOpCont;
static constexpr uint8_t kPing = kFlagFin | kOpPing;
static constexpr uint8_t kPong = kFlagFin | kOpPong;
static constexpr uint8_t TEXT = FLAG_FIN | OP_TEXT;
static constexpr uint8_t BINARY = FLAG_FIN | OP_BINARY;
static constexpr uint8_t TEXT_FRAGMENT = OP_TEXT;
static constexpr uint8_t BINARY_FRAGMENT = OP_BINARY;
static constexpr uint8_t FRAGMENT = OP_CONT;
static constexpr uint8_t FINAL_FRAGMENT = FLAG_FIN | OP_CONT;
static constexpr uint8_t PING = FLAG_FIN | OP_PING;
static constexpr uint8_t PONG = FLAG_FIN | OP_PONG;
constexpr Frame(uint8_t opcode, std::span<const uv::Buffer> data)
: opcode{opcode}, data{data} {}
@@ -158,7 +158,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
* Return if the connection is open. Messages can only be sent on open
* connections.
*/
bool IsOpen() const { return m_state == OPEN; }
bool IsOpen() const { return m_state == State::OPEN; }
/**
* Get the underlying stream.
@@ -202,7 +202,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
void SendText(
std::span<const uv::Buffer> data,
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
Send(kFlagFin | kOpText, data, std::move(callback));
Send(FLAG_FIN | OP_TEXT, data, std::move(callback));
}
/**
@@ -224,7 +224,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
void SendBinary(
std::span<const uv::Buffer> data,
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
Send(kFlagFin | kOpBinary, data, std::move(callback));
Send(FLAG_FIN | OP_BINARY, data, std::move(callback));
}
/**
@@ -248,7 +248,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
void SendTextFragment(
std::span<const uv::Buffer> data,
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
Send(kOpText, data, std::move(callback));
Send(OP_TEXT, data, std::move(callback));
}
/**
@@ -274,7 +274,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
void SendBinaryFragment(
std::span<const uv::Buffer> data,
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
Send(kOpBinary, data, std::move(callback));
Send(OP_BINARY, data, std::move(callback));
}
/**
@@ -300,7 +300,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
void SendFragment(
std::span<const uv::Buffer> data, bool fin,
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
Send(kOpCont | (fin ? kFlagFin : 0), data, std::move(callback));
Send(OP_CONT | (fin ? FLAG_FIN : 0), data, std::move(callback));
}
/**
@@ -338,7 +338,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
void SendPing(
std::span<const uv::Buffer> data,
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
SendControl(kFlagFin | kOpPing, data, std::move(callback));
SendControl(FLAG_FIN | OP_PING, data, std::move(callback));
}
/**
@@ -375,7 +375,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
void SendPong(
std::span<const uv::Buffer> data,
std::function<void(std::span<uv::Buffer>, uv::Error)> callback) {
SendControl(kFlagFin | kOpPong, data, std::move(callback));
SendControl(FLAG_FIN | OP_PONG, data, std::move(callback));
}
/**
@@ -522,7 +522,7 @@ class WebSocket : public std::enable_shared_from_this<WebSocket> {
std::weak_ptr<WriteReq> m_lastWriteReq;
// operating state
State m_state = CONNECTING;
State m_state = State::CONNECTING;
// incoming message buffers/state
uint64_t m_lastReceivedTime = 0;

2
wpinet/src/main/native/include/wpi/net/WebSocketServer.hpp
View File

@@ -172,7 +172,7 @@ class WebSocketServer : public std::enable_shared_from_this<WebSocketServer> {
private:
uv::Stream& m_stream;
HttpParser m_req{HttpParser::kRequest};
HttpParser m_req{HttpParser::Type::REQUEST};
WebSocketServerHelper m_helper;
wpi::util::SmallVector<std::string, 2> m_protocols;
ServerOptions m_options;

19
wpinet/src/main/native/include/wpi/net/uv/Loop.hpp
View File

@@ -6,7 +6,6 @@
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <thread>
#include <utility>
@@ -38,10 +37,10 @@ class Loop final : public std::enable_shared_from_this<Loop> {
public:
using Time = std::chrono::duration<uint64_t, std::milli>;
enum Mode {
kDefault = UV_RUN_DEFAULT,
kOnce = UV_RUN_ONCE,
kNoWait = UV_RUN_NOWAIT
enum class Mode {
DEFAULT = UV_RUN_DEFAULT,
ONCE = UV_RUN_ONCE,
NO_WAIT = UV_RUN_NOWAIT
};
explicit Loop(const private_init&) noexcept;
@@ -97,16 +96,16 @@ class Loop final : public std::enable_shared_from_this<Loop> {
*
* Available modes are:
*
* * `Loop::kDefault`: Run the event loop until there are no
* * `Mode::DEFAULT`: Run the event loop until there are no
* active and referenced handles or requests.
* * `Loop::kOnce`: Run a single event loop iteration. Note that this
* * `Mode::ONCE`: Run a single event loop iteration. Note that this
* function blocks if there are no pending callbacks.
* * `Loop::kNoWait`: Run a single event loop iteration, but don't block
* * `Mode::NO_WAIT`: Run a single event loop iteration, but don't block
* if there are no pending callbacks.
*
* @return True when done, false in all other cases.
*/
bool Run(Mode mode = kDefault) {
bool Run(Mode mode = Mode::DEFAULT) {
m_tid = std::this_thread::get_id();
int rv = uv_run(m_loop, static_cast<uv_run_mode>(static_cast<int>(mode)));
m_tid = std::thread::id{};
@@ -134,7 +133,7 @@ class Loop final : public std::enable_shared_from_this<Loop> {
* Get backend file descriptor.
*
* Only kqueue, epoll and event ports are supported.
* This can be used in conjunction with `run(Loop::kNoWait)` to poll
* This can be used in conjunction with `run(Loop::NO_WAIT)` to poll
* in one thread and run the event loop’s callbacks in another.
*
* @return The backend file descriptor.

50
wpinet/src/main/native/include/wpi/net/uv/Process.hpp
View File

@@ -39,22 +39,22 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* what it points to.
*/
struct Option {
enum Type {
kNone,
kArg,
kEnv,
kCwd,
kUid,
kGid,
kSetFlags,
kClearFlags,
kStdioIgnore,
kStdioInheritFd,
kStdioInheritPipe,
kStdioCreatePipe
enum class Type {
NONE,
ARG,
ENV,
WORKING_DIRECTORY,
USER_ID,
GROUP_ID,
SET_FLAGS,
CLEAR_FLAGS,
STDIO_IGNORE,
STDIO_INHERIT_FD,
STDIO_INHERIT_PIPE,
STDIO_CREATE_PIPE
};
Option() : m_type(kNone) {}
Option() : m_type(Type::NONE) {}
/*implicit*/ Option(const char* arg) { // NOLINT
m_data.str = arg;
@@ -76,7 +76,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
explicit Option(Type type) : m_type(type) {}
Type m_type = kArg;
Type m_type = Type::ARG;
std::string m_strData;
union {
const char* str;
@@ -100,7 +100,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* @param env environment variable
*/
static Option Env(std::string_view env) {
Option o(Option::kEnv);
Option o(Option::Type::ENV);
o.m_strData = env;
o.m_data.str = o.m_strData.c_str();
return o;
@@ -111,7 +111,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* @param cwd current working directory
*/
static Option Cwd(std::string_view cwd) {
Option o(Option::kCwd);
Option o(Option::Type::WORKING_DIRECTORY);
o.m_strData = cwd;
o.m_data.str = o.m_strData.c_str();
return o;
@@ -122,7 +122,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* @param uid user id
*/
static Option Uid(uv_uid_t uid) {
Option o(Option::kUid);
Option o(Option::Type::USER_ID);
o.m_data.uid = uid;
return o;
}
@@ -132,7 +132,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* @param gid group id
*/
static Option Gid(uv_gid_t gid) {
Option o(Option::kGid);
Option o(Option::Type::GROUP_ID);
o.m_data.gid = gid;
return o;
}
@@ -142,7 +142,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* @param flags Bitmask values from uv_process_flags.
*/
static Option SetFlags(unsigned int flags) {
Option o(Option::kSetFlags);
Option o(Option::Type::SET_FLAGS);
o.m_data.flags = flags;
return o;
}
@@ -152,7 +152,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* @param flags Bitmask values from uv_process_flags.
*/
static Option ClearFlags(unsigned int flags) {
Option o(Option::kClearFlags);
Option o(Option::Type::CLEAR_FLAGS);
o.m_data.flags = flags;
return o;
}
@@ -162,7 +162,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* @param index stdio index
*/
static Option StdioIgnore(size_t index) {
Option o(Option::kStdioIgnore);
Option o(Option::Type::STDIO_IGNORE);
o.m_data.stdio.index = index;
return o;
}
@@ -173,7 +173,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* @param fd parent file descriptor
*/
static Option StdioInherit(size_t index, int fd) {
Option o(Option::kStdioInheritFd);
Option o(Option::Type::STDIO_INHERIT_FD);
o.m_data.stdio.index = index;
o.m_data.stdio.fd = fd;
return o;
@@ -185,7 +185,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* @param pipe pipe
*/
static Option StdioInherit(size_t index, Pipe& pipe) {
Option o(Option::kStdioInheritPipe);
Option o(Option::Type::STDIO_INHERIT_PIPE);
o.m_data.stdio.index = index;
o.m_data.stdio.pipe = &pipe;
return o;
@@ -199,7 +199,7 @@ class Process final : public HandleImpl<Process, uv_process_t> {
* UV_OVERLAPPED_PIPE (Windows only, ignored on Unix).
*/
static Option StdioCreatePipe(size_t index, Pipe& pipe, unsigned int flags) {
Option o(Option::kStdioCreatePipe);
Option o(Option::Type::STDIO_CREATE_PIPE);
o.m_data.stdio.index = index;
o.m_data.stdio.pipe = &pipe;
o.m_data.stdio.flags = flags;

18
wpinet/src/main/native/thirdparty/tcpsockets/cpp/TCPStream.cpp vendored
View File

@@ -65,7 +65,7 @@ TCPStream::~TCPStream() {
size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
if (m_sd < 0) {
*err = kConnectionClosed;
*err = Error::CONNECTION_CLOSED;
return 0;
}
#ifdef _WIN32
@@ -80,7 +80,7 @@ size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
break;
}
if (!m_blocking) {
*err = kWouldBlock;
*err = Error::WOULD_BLOCK;
return 0;
}
Sleep(1);
@@ -91,7 +91,7 @@ size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
"Send() failed: WSA error={}\n", WSAGetLastError());
OutputDebugStringA(Buffer);
*err = kConnectionReset;
*err = Error::CONNECTION_RESET;
return 0;
}
#else
@@ -103,9 +103,9 @@ size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
#endif
if (rv < 0) {
if (!m_blocking && (errno == EAGAIN || errno == EWOULDBLOCK)) {
*err = kWouldBlock;
*err = Error::WOULD_BLOCK;
} else {
*err = kConnectionReset;
*err = Error::CONNECTION_RESET;
}
return 0;
}
@@ -115,7 +115,7 @@ size_t TCPStream::send(const char* buffer, size_t len, Error* err) {
size_t TCPStream::receive(char* buffer, size_t len, Error* err, int timeout) {
if (m_sd < 0) {
*err = kConnectionClosed;
*err = Error::CONNECTION_CLOSED;
return 0;
}
#ifdef _WIN32
@@ -136,7 +136,7 @@ size_t TCPStream::receive(char* buffer, size_t len, Error* err, int timeout) {
rv = read(m_sd, buffer, len);
#endif
} else {
*err = kConnectionTimedOut;
*err = Error::CONNECTION_TIMED_OUT;
return 0;
}
if (rv < 0) {
@@ -145,9 +145,9 @@ size_t TCPStream::receive(char* buffer, size_t len, Error* err, int timeout) {
#else
if (!m_blocking && (errno == EAGAIN || errno == EWOULDBLOCK)) {
#endif
*err = kWouldBlock;
*err = Error::WOULD_BLOCK;
} else {
*err = kConnectionReset;
*err = Error::CONNECTION_RESET;
}
return 0;
}

24
wpinet/src/test/native/cpp/HttpParserTest.cpp
View File

@@ -9,7 +9,7 @@
namespace wpi::net {
TEST(HttpParserTest, UrlMethodHeadersComplete) {
HttpParser p{HttpParser::kRequest};
HttpParser p{HttpParser::Type::REQUEST};
int callbacks = 0;
p.url.connect([&](std::string_view path) {
ASSERT_EQ(path, "/foo/bar");
@@ -27,7 +27,7 @@ TEST(HttpParserTest, UrlMethodHeadersComplete) {
}
TEST(HttpParserTest, UrlMethodHeader) {
HttpParser p{HttpParser::kRequest};
HttpParser p{HttpParser::Type::REQUEST};
int callbacks = 0;
p.url.connect([&](std::string_view path) {
ASSERT_EQ(path, "/foo/bar");
@@ -47,7 +47,7 @@ TEST(HttpParserTest, UrlMethodHeader) {
}
TEST(HttpParserTest, StatusHeadersComplete) {
HttpParser p{HttpParser::kResponse};
HttpParser p{HttpParser::Type::RESPONSE};
int callbacks = 0;
p.status.connect([&](std::string_view status) {
ASSERT_EQ(status, "OK");
@@ -64,7 +64,7 @@ TEST(HttpParserTest, StatusHeadersComplete) {
}
TEST(HttpParserTest, StatusHeader) {
HttpParser p{HttpParser::kResponse};
HttpParser p{HttpParser::Type::RESPONSE};
int callbacks = 0;
p.status.connect([&](std::string_view status) {
ASSERT_EQ(status, "OK");
@@ -81,7 +81,7 @@ TEST(HttpParserTest, StatusHeader) {
}
TEST(HttpParserTest, HeaderFieldComplete) {
HttpParser p{HttpParser::kRequest};
HttpParser p{HttpParser::Type::REQUEST};
int callbacks = 0;
p.header.connect([&](std::string_view name, std::string_view value) {
ASSERT_EQ(name, "Foo");
@@ -104,7 +104,7 @@ TEST(HttpParserTest, HeaderFieldComplete) {
}
TEST(HttpParserTest, HeaderFieldNext) {
HttpParser p{HttpParser::kRequest};
HttpParser p{HttpParser::Type::REQUEST};
int callbacks = 0;
p.header.connect([&](std::string_view name, std::string_view value) {
ASSERT_EQ(name, "Foo");
@@ -127,7 +127,7 @@ TEST(HttpParserTest, HeaderFieldNext) {
}
TEST(HttpParserTest, HeadersComplete) {
HttpParser p{HttpParser::kRequest};
HttpParser p{HttpParser::Type::REQUEST};
int callbacks = 0;
p.headersComplete.connect([&](bool keepAlive) {
ASSERT_EQ(keepAlive, false);
@@ -141,7 +141,7 @@ TEST(HttpParserTest, HeadersComplete) {
}
TEST(HttpParserTest, HeadersCompleteHTTP11) {
HttpParser p{HttpParser::kRequest};
HttpParser p{HttpParser::Type::REQUEST};
int callbacks = 0;
p.headersComplete.connect([&](bool keepAlive) {
ASSERT_EQ(keepAlive, true);
@@ -155,7 +155,7 @@ TEST(HttpParserTest, HeadersCompleteHTTP11) {
}
TEST(HttpParserTest, HeadersCompleteKeepAlive) {
HttpParser p{HttpParser::kRequest};
HttpParser p{HttpParser::Type::REQUEST};
int callbacks = 0;
p.headersComplete.connect([&](bool keepAlive) {
ASSERT_EQ(keepAlive, true);
@@ -171,7 +171,7 @@ TEST(HttpParserTest, HeadersCompleteKeepAlive) {
}
TEST(HttpParserTest, HeadersCompleteUpgrade) {
HttpParser p{HttpParser::kRequest};
HttpParser p{HttpParser::Type::REQUEST};
int callbacks = 0;
p.headersComplete.connect([&](bool) {
ASSERT_TRUE(p.IsUpgrade());
@@ -188,14 +188,14 @@ TEST(HttpParserTest, HeadersCompleteUpgrade) {
}
TEST(HttpParserTest, Reset) {
HttpParser p{HttpParser::kRequest};
HttpParser p{HttpParser::Type::REQUEST};
int callbacks = 0;
p.headersComplete.connect([&](bool) { ++callbacks; });
p.Execute("GET / HTTP/1.1\r\n");
ASSERT_EQ(callbacks, 0);
p.Execute("\r\n");
ASSERT_EQ(callbacks, 1);
p.Reset(HttpParser::kRequest);
p.Reset(HttpParser::Type::REQUEST);
p.Execute("GET / HTTP/1.1\r\n");
ASSERT_EQ(callbacks, 1);
p.Execute("\r\n");

2
wpinet/src/test/native/cpp/WebSocketClientTest.cpp
View File

@@ -94,7 +94,7 @@ class WebSocketClientTest : public WebSocketTest {
bool mockBadAccept = false;
std::vector<uint8_t> wireData;
std::shared_ptr<uv::Pipe> conn;
HttpParser req{HttpParser::kRequest};
HttpParser req{HttpParser::Type::REQUEST};
wpi::util::SmallString<64> clientKey;
std::string mockProtocol;
bool serverHeadersDone = false;

8
wpinet/src/test/native/cpp/WebSocketSerializerTest.cpp
View File

@@ -217,9 +217,9 @@ const std::array<uv::Buffer, 2> WebSocketTrySendTest::m_frame0bufs{m_bufs[0],
const std::array<uv::Buffer, 1> WebSocketTrySendTest::m_frame1bufs{m_bufs[2]};
const std::array<uv::Buffer, 1> WebSocketTrySendTest::m_frame2bufs{m_bufs[3]};
const std::array<WebSocket::Frame, 3> WebSocketTrySendTest::m_frames{
WebSocket::Frame{WebSocket::Frame::kBinaryFragment, m_frame0bufs},
WebSocket::Frame{WebSocket::Frame::kBinary, m_frame1bufs},
WebSocket::Frame{WebSocket::Frame::kText, m_frame2bufs},
WebSocket::Frame{WebSocket::Frame::BINARY_FRAGMENT, m_frame0bufs},
WebSocket::Frame{WebSocket::Frame::BINARY, m_frame1bufs},
WebSocket::Frame{WebSocket::Frame::TEXT, m_frame2bufs},
};
const std::array<std::vector<uint8_t>, 3> WebSocketTrySendTest::m_serialized{
WebSocketTest::BuildMessage(m_frames[0].opcode, false, false, m_frame0data),
@@ -395,7 +395,7 @@ TEST_F(WebSocketTrySendTest, Big) {
bufs.emplace_back(
uv::Buffer::Allocate(i < 100000 ? 1430 : (100000 - (i - 1430))));
}
WebSocket::Frame frame{WebSocket::kOpBinary | WebSocket::kFlagFin, bufs};
WebSocket::Frame frame{WebSocket::OP_BINARY | WebSocket::FLAG_FIN, bufs};
EXPECT_CALL(stream, TryWrite(_)).WillOnce(Return(7681));
// Write called for remainder of buffers

2
wpinet/src/test/native/cpp/WebSocketServerTest.cpp
View File

@@ -58,7 +58,7 @@ class WebSocketServerTest : public WebSocketTest {
std::function<void(std::string_view)> handleData;
std::vector<uint8_t> wireData;
std::shared_ptr<WebSocket> ws;
HttpParser resp{HttpParser::kResponse};
HttpParser resp{HttpParser::Type::RESPONSE};
bool headersDone = false;
};

10
wpinet/src/test/native/cpp/WebSocketTest.cpp
View File

@@ -107,7 +107,7 @@ TEST_F(WebSocketTest, CreateClientBasic) {
int gotKey = 0;
int gotVersion = 0;
HttpParser req{HttpParser::kRequest};
HttpParser req{HttpParser::Type::REQUEST};
req.url.connect([](std::string_view url) { ASSERT_EQ(url, "/test"); });
req.header.connect([&](std::string_view name, std::string_view value) {
if (wpi::util::equals_lower(name, "host")) {
@@ -160,7 +160,7 @@ TEST_F(WebSocketTest, CreateClientBasic) {
TEST_F(WebSocketTest, CreateClientExtraHeaders) {
int gotExtra1 = 0;
int gotExtra2 = 0;
HttpParser req{HttpParser::kRequest};
HttpParser req{HttpParser::Type::REQUEST};
req.header.connect([&](std::string_view name, std::string_view value) {
if (wpi::util::equals(name, "Extra1")) {
ASSERT_EQ(value, "Data1");
@@ -233,7 +233,7 @@ TEST_F(WebSocketTest, CreateServerBasic) {
int gotAccept = 0;
int gotOpen = 0;
HttpParser resp{HttpParser::kResponse};
HttpParser resp{HttpParser::Type::RESPONSE};
resp.status.connect([&](std::string_view status) {
++gotStatus;
ASSERT_EQ(resp.GetStatusCode(), 101u) << "status: " << status;
@@ -289,7 +289,7 @@ TEST_F(WebSocketTest, CreateServerProtocol) {
int gotProtocol = 0;
int gotOpen = 0;
HttpParser resp{HttpParser::kResponse};
HttpParser resp{HttpParser::Type::RESPONSE};
resp.header.connect([&](std::string_view name, std::string_view value) {
if (wpi::util::equals_lower(name, "sec-websocket-protocol")) {
++gotProtocol;
@@ -331,7 +331,7 @@ TEST_F(WebSocketTest, CreateServerBadVersion) {
int gotVersion = 0;
int gotUpgrade = 0;
HttpParser resp{HttpParser::kResponse};
HttpParser resp{HttpParser::Type::RESPONSE};
resp.status.connect([&](std::string_view status) {
++gotStatus;
ASSERT_EQ(resp.GetStatusCode(), 426u) << "status: " << status;