mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity

fix: sonarcloud (#2865) 

* refactor: implement FileTreeItem::children_ with a std::vector

* fix: std::move should not be called on forwarding reference

* fix: uninitialized scalar variable

* fix: unchecked return value from library

* fix: dereference before null check

* fix: unchecked return value from library

* fix: unchecked return value from library

* fixup! refactor: implement FileTreeItem::children_ with a std::vector

* fix: signed-unsigned comparison in libtransmission tests

* fix: avoid unnecessary copy by using const reference

* fix: function should be declared const

* refactor: use fmt::format to build log timestamps

* fix: use init-statement to reduce variable scope

* fixup! refactor: use fmt::format to build log timestamps

* fix: remove tau_tracker destructor for rule-of-zero

* fix: remove tr_peerIo destructor for rule-of-zero

* Revert "fix: dereference before null check"

This reverts commit cd78967815.

* fix: signed-unsigned comparison in libtransmission tests

* fix: use init-statement to reduce variable scope

* fix: extract nested code block into separate method

* fix: extract nested code block into separate method

* fix: extract nested code block into separate method

* fix: use init-statement to reduce variable scope

* fix: extract nested code block into separate method

* fix: signed-unsigned comparison in libtransmission tests

* fixup! fix: extract nested code block into separate method

* fix: mark possibly-unused as [[maybe_unused]]

* fix: invalid stack memory reference in tr_found_file_t

* fix: signed-unsigned comparison in libtransmission tests
This commit is contained in:
Charles Kerr 2022-04-02 09:06:02 -05:00 committed by GitHub
parent 46cc95f72e
commit 1cc9da26ba
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
42 changed files with 520 additions and 494 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gtk/Application.cc
View File

@ -542,12 +542,12 @@ void Application::Impl::on_startup()
/* ensure the directories are created */
if (auto const str = gtr_pref_string_get(TR_KEY_download_dir); !str.empty())
{
g_mkdir_with_parents(str.c_str(), 0777);
(void)g_mkdir_with_parents(str.c_str(), 0777);
}
if (auto const str = gtr_pref_string_get(TR_KEY_incomplete_dir); !str.empty())
{
g_mkdir_with_parents(str.c_str(), 0777);
(void)g_mkdir_with_parents(str.c_str(), 0777);
}
/* initialize the libtransmission session */

2
gtk/FaviconCache.cc
View File

@ -42,7 +42,7 @@ std::string favicon_get_cache_dir()
if (dir.empty())
{
dir = Glib::build_filename(Glib::get_user_cache_dir(), "transmission", "favicons");
g_mkdir_with_parents(dir.c_str(), 0777);
(void)g_mkdir_with_parents(dir.c_str(), 0777);
}
return dir;

25
libtransmission/announcer-udp.cc
View File

@ -7,6 +7,7 @@
#include <cstring> /* memset() */
#include <ctime>
#include <list>
#include <memory>
#include <string_view>
#include <vector>
@ -402,14 +403,6 @@ struct tau_tracker
return std::empty(announces) && std::empty(scrapes) && dns_request == nullptr;
}
~tau_tracker()
{
if (this->addr != nullptr)
{
evutil_freeaddrinfo(this->addr);
}
}
void failAll(bool did_connect, bool did_timeout, std::string_view errmsg)
{
for (auto& req : this->scrapes)
@ -433,7 +426,7 @@ struct tau_tracker
int const port;
evdns_getaddrinfo_request* dns_request = nullptr;
evutil_addrinfo* addr = nullptr;
std::shared_ptr<evutil_addrinfo> addr;
time_t addr_expiration_time = 0;
time_t connecting_at = 0;
@ -477,7 +470,7 @@ static void tau_tracker_on_dns(int errcode, struct evutil_addrinfo* addr, void*
else
{
logdbg(tracker->key, "DNS lookup succeeded");
tracker->addr = addr;
tracker->addr.reset(addr, evutil_freeaddrinfo);
tau_tracker_upkeep(tracker);
}
}
@ -488,7 +481,7 @@ static void tau_tracker_send_request(struct tau_tracker* tracker, void const* pa
logdbg(tracker->key, fmt::format("sending request w/connection id {}", tracker->connection_id));
evbuffer_add_hton_64(buf, tracker->connection_id);
evbuffer_add_reference(buf, payload, payload_len, nullptr, nullptr);
(void)tau_sendto(tracker->session, tracker->addr, tracker->port, evbuffer_pullup(buf, -1), evbuffer_get_length(buf));
(void)tau_sendto(tracker->session, tracker->addr.get(), tracker->port, evbuffer_pullup(buf, -1), evbuffer_get_length(buf));
evbuffer_free(buf);
}
@ -617,8 +610,7 @@ static void tau_tracker_upkeep_ex(struct tau_tracker* tracker, bool timeout_reqs
if (tracker->addr != nullptr && (closing || tracker->addr_expiration_time <= now))
{
logtrace(tracker->host, "Expiring old DNS result");
evutil_freeaddrinfo(tracker->addr);
tracker->addr = nullptr;
tracker->addr.reset();
tracker->addr_expiration_time = 0;
}
@ -673,7 +665,12 @@ static void tau_tracker_upkeep_ex(struct tau_tracker* tracker, bool timeout_reqs
evbuffer_add_hton_64(buf, 0x41727101980LL);
evbuffer_add_hton_32(buf, TAU_ACTION_CONNECT);
evbuffer_add_hton_32(buf, tracker->connection_transaction_id);
(void)tau_sendto(tracker->session, tracker->addr, tracker->port, evbuffer_pullup(buf, -1), evbuffer_get_length(buf));
(void)tau_sendto(
tracker->session,
tracker->addr.get(),
tracker->port,
evbuffer_pullup(buf, -1),
evbuffer_get_length(buf));
evbuffer_free(buf);
return;
}

14
libtransmission/blocklist.cc
View File

@ -443,16 +443,14 @@ int tr_blocklistFileSetContent(tr_blocklistFile* b, char const* filename)
#ifdef TR_ENABLE_ASSERTS
/* sanity checks: make sure the rules are sorted in ascending order and don't overlap */
for (size_t i = 0; i < ranges_count; ++i)
{
for (size_t i = 0; i < ranges_count; ++i)
{
TR_ASSERT(ranges[i].begin <= ranges[i].end);
}
TR_ASSERT(ranges[i].begin <= ranges[i].end);
}
for (size_t i = 1; i < ranges_count; ++i)
{
TR_ASSERT(ranges[i - 1].end < ranges[i].begin);
}
for (size_t i = 1; i < ranges_count; ++i)
{
TR_ASSERT(ranges[i - 1].end < ranges[i].begin);
}
#endif

2
libtransmission/handshake.cc
View File

@ -992,7 +992,7 @@ static ReadState canRead(tr_peerIo* io, void* vhandshake, size_t* piece)
auto* handshake = static_cast<tr_handshake*>(vhandshake);
struct evbuffer* inbuf = tr_peerIoGetReadBuffer(io);
evbuffer* const inbuf = io->getReadBuffer();
bool readyForMore = true;
/* no piece data in handshake */

26
libtransmission/log.cc
View File

@ -13,7 +13,7 @@
#include <event2/buffer.h>
#include <fmt/core.h>
#include <fmt/chrono.h>
#include <fmt/format.h>
#include "transmission.h"
@ -88,7 +88,7 @@ tr_sys_file_t tr_logGetFile()
void logAddImpl(
[[maybe_unused]] char const* file,
[[maybe_unused]] int line,
tr_log_level level,
[[maybe_unused]] tr_log_level level,
std::string_view msg,
[[maybe_unused]] std::string_view name)
{
@ -238,18 +238,14 @@ void tr_logFreeQueue(tr_log_message* list)
char* tr_logGetTimeStr(char* buf, size_t buflen)
{
auto const tv = tr_gettimeofday();
time_t const seconds = tv.tv_sec;
auto const milliseconds = int(tv.tv_usec / 1000);
char msec_str[8];
tr_snprintf(msec_str, sizeof msec_str, "%03d", milliseconds);
struct tm now_tm;
tr_localtime_r(&seconds, &now_tm);
char date_str[32];
strftime(date_str, sizeof(date_str), "%Y-%m-%d %H:%M:%S", &now_tm);
tr_snprintf(buf, buflen, "%s.%s", date_str, msec_str);
auto const a = std::chrono::system_clock::now();
auto const [out, len] = fmt::format_to_n(
buf,
buflen - 1,
"{0:%F %H:%M:}{1:%S}\n",
a,
std::chrono::duration_cast<std::chrono::milliseconds>(a.time_since_epoch()));
*out = '\0';
return buf;
}
@ -322,7 +318,7 @@ bool constexpr keysAreOrdered()
{
for (size_t i = 0, n = std::size(LogKeys); i < n; ++i)
{
if (LogKeys[i].second != i)
if (LogKeys[i].second != static_cast<tr_log_level>(i))
{
return false;
}

2
libtransmission/magnet-metainfo.h
View File

@ -67,7 +67,7 @@ public:
protected:
tr_announce_list announce_list_;
std::vector<std::string> webseed_urls_;
tr_sha1_digest_t info_hash_;
tr_sha1_digest_t info_hash_ = {};
std::string info_hash_str_;
std::string name_;
};

42
libtransmission/peer-io.cc
View File

@ -198,9 +198,9 @@ static void canReadWrapper(tr_peerIo* io)
while (!done && !err)
{
size_t piece = 0;
size_t const oldLen = evbuffer_get_length(io->inbuf);
size_t const oldLen = evbuffer_get_length(io->inbuf.get());
int const ret = io->canRead(io, io->userData, &piece);
size_t const used = oldLen - evbuffer_get_length(io->inbuf);
size_t const used = oldLen - evbuffer_get_length(io->inbuf.get());
unsigned int const overhead = guessPacketOverhead(used);
if (piece != 0 || piece != used)
@ -224,7 +224,7 @@ static void canReadWrapper(tr_peerIo* io)
switch (ret)
{
case READ_NOW:
if (evbuffer_get_length(io->inbuf) != 0)
if (evbuffer_get_length(io->inbuf.get()) != 0)
{
continue;
}
@ -261,7 +261,7 @@ static void event_read_cb(evutil_socket_t fd, short /*event*/, void* vio)
io->pendingEvents &= ~EV_READ;
unsigned int const curlen = evbuffer_get_length(io->inbuf);
unsigned int const curlen = evbuffer_get_length(io->inbuf.get());
unsigned int howmuch = curlen >= max ? 0 : max - curlen;
howmuch = io->bandwidth->clamp(TR_DOWN, howmuch);
@ -275,7 +275,7 @@ static void event_read_cb(evutil_socket_t fd, short /*event*/, void* vio)
}
EVUTIL_SET_SOCKET_ERROR(0);
auto const res = evbuffer_read(io->inbuf, fd, (int)howmuch);
auto const res = evbuffer_read(io->inbuf.get(), fd, (int)howmuch);
int const e = EVUTIL_SOCKET_ERROR();
if (res > 0)
@ -318,7 +318,7 @@ static void event_read_cb(evutil_socket_t fd, short /*event*/, void* vio)
static int tr_evbuffer_write(tr_peerIo* io, int fd, size_t howmuch)
{
EVUTIL_SET_SOCKET_ERROR(0);
int const n = evbuffer_write_atmost(io->outbuf, fd, howmuch);
int const n = evbuffer_write_atmost(io->outbuf.get(), fd, howmuch);
int const e = EVUTIL_SOCKET_ERROR();
tr_logAddTraceIo(io, fmt::format("wrote {} to peer ({})", n, (n == -1 ? tr_net_strerror(e).c_str() : "")));
@ -342,7 +342,7 @@ static void event_write_cb(evutil_socket_t fd, short /*event*/, void* vio)
/* Write as much as possible, since the socket is non-blocking, write() will
* return if it can't write any more data without blocking */
size_t const howmuch = io->bandwidth->clamp(dir, evbuffer_get_length(io->outbuf));
size_t const howmuch = io->bandwidth->clamp(dir, evbuffer_get_length(io->outbuf.get()));
/* if we don't have any bandwidth left, stop writing */
if (howmuch < 1)
@ -376,7 +376,7 @@ static void event_write_cb(evutil_socket_t fd, short /*event*/, void* vio)
goto FAIL;
}
if (evbuffer_get_length(io->outbuf) != 0)
if (evbuffer_get_length(io->outbuf.get()) != 0)
{
tr_peerIoSetEnabled(io, dir, true);
}
@ -385,7 +385,7 @@ static void event_write_cb(evutil_socket_t fd, short /*event*/, void* vio)
return;
RESCHEDULE:
if (evbuffer_get_length(io->outbuf) != 0)
if (evbuffer_get_length(io->outbuf.get()) != 0)
{
tr_peerIoSetEnabled(io, dir, true);
}
@ -423,7 +423,7 @@ static void utp_on_read(void* vio, unsigned char const* buf, size_t buflen)
TR_ASSERT(tr_isPeerIo(io));
if (auto const rc = evbuffer_add(io->inbuf, buf, buflen); rc < 0)
if (auto const rc = evbuffer_add(io->inbuf.get(), buf, buflen); rc < 0)
{
tr_logAddWarn(_("Couldn't write to peer"));
return;
@ -440,7 +440,7 @@ static void utp_on_write(void* vio, unsigned char* buf, size_t buflen)
TR_ASSERT(tr_isPeerIo(io));
int rc = evbuffer_remove(io->outbuf, buf, buflen);
int rc = evbuffer_remove(io->outbuf.get(), buf, buflen);
tr_logAddTraceIo(io, fmt::format("utp_on_write sending {} bytes... evbuffer_remove returned {}", buflen, rc));
TR_ASSERT(rc == (int)buflen); /* if this fails, we've corrupted our bookkeeping somewhere */
@ -475,7 +475,7 @@ static void utp_on_writable(tr_peerIo* io)
tr_logAddTraceIo(io, "libutp says this peer is ready to write");
int const n = tr_peerIoTryWrite(io, SIZE_MAX);
tr_peerIoSetEnabled(io, TR_UP, n != 0 && evbuffer_get_length(io->outbuf) != 0);
tr_peerIoSetEnabled(io, TR_UP, n != 0 && evbuffer_get_length(io->outbuf.get()) != 0);
}
static void utp_on_state_change(void* vio, int state)
@ -1017,7 +1017,7 @@ static unsigned int getDesiredOutputBufferSize(tr_peerIo const* io, uint64_t now
size_t tr_peerIoGetWriteBufferSpace(tr_peerIo const* io, uint64_t now)
{
size_t const desiredLen = getDesiredOutputBufferSize(io, now);
size_t const currentLen = evbuffer_get_length(io->outbuf);
size_t const currentLen = evbuffer_get_length(io->outbuf.get());
size_t freeSpace = 0;
if (desiredLen > currentLen)
@ -1092,14 +1092,14 @@ void tr_peerIoWriteBuf(tr_peerIo* io, struct evbuffer* buf, bool isPieceData)
{
size_t const byteCount = evbuffer_get_length(buf);
maybeEncryptBuffer(io, buf, 0, byteCount);
evbuffer_add_buffer(io->outbuf, buf);
evbuffer_add_buffer(io->outbuf.get(), buf);
addDatatype(io, byteCount, isPieceData);
}
void tr_peerIoWriteBytes(tr_peerIo* io, void const* bytes, size_t byteCount, bool isPieceData)
{
struct evbuffer_iovec iovec;
evbuffer_reserve_space(io->outbuf, byteCount, &iovec, 1);
evbuffer_reserve_space(io->outbuf.get(), byteCount, &iovec, 1);
iovec.iov_len = byteCount;
@ -1112,7 +1112,7 @@ void tr_peerIoWriteBytes(tr_peerIo* io, void const* bytes, size_t byteCount, boo
memcpy(iovec.iov_base, bytes, iovec.iov_len);
}
evbuffer_commit_space(io->outbuf, &iovec, 1);
evbuffer_commit_space(io->outbuf.get(), &iovec, 1);
addDatatype(io, byteCount, isPieceData);
}
@ -1239,7 +1239,7 @@ static int tr_peerIoTryRead(tr_peerIo* io, size_t howmuch)
/* UTP_RBDrained notifies libutp that your read buffer is emtpy.
* It opens up the congestion window by sending an ACK (soonish)
* if one was not going to be sent. */
if (evbuffer_get_length(io->inbuf) == 0)
if (evbuffer_get_length(io->inbuf.get()) == 0)
{
UTP_RBDrained(io->socket.handle.utp);
}
@ -1249,12 +1249,12 @@ static int tr_peerIoTryRead(tr_peerIo* io, size_t howmuch)
case TR_PEER_SOCKET_TYPE_TCP:
{
EVUTIL_SET_SOCKET_ERROR(0);
res = evbuffer_read(io->inbuf, io->socket.handle.tcp, (int)howmuch);
res = evbuffer_read(io->inbuf.get(), io->socket.handle.tcp, (int)howmuch);
int const e = EVUTIL_SOCKET_ERROR();
tr_logAddTraceIo(io, fmt::format("read {} from peer ({})", res, res == -1 ? tr_net_strerror(e).c_str() : ""));
if (evbuffer_get_length(io->inbuf) != 0)
if (evbuffer_get_length(io->inbuf.get()) != 0)
{
canReadWrapper(io);
}
@ -1287,7 +1287,7 @@ static int tr_peerIoTryRead(tr_peerIo* io, size_t howmuch)
static int tr_peerIoTryWrite(tr_peerIo* io, size_t howmuch)
{
auto const old_len = size_t{ evbuffer_get_length(io->outbuf) };
auto const old_len = size_t{ evbuffer_get_length(io->outbuf.get()) };
tr_logAddTraceIo(io, fmt::format("in tr_peerIoTryWrite {}", howmuch));
howmuch = std::min(howmuch, old_len);
@ -1302,7 +1302,7 @@ static int tr_peerIoTryWrite(tr_peerIo* io, size_t howmuch)
{
case TR_PEER_SOCKET_TYPE_UTP:
UTP_Write(io->socket.handle.utp, howmuch);
n = old_len - evbuffer_get_length(io->outbuf);
n = old_len - evbuffer_get_length(io->outbuf.get());
break;
case TR_PEER_SOCKET_TYPE_TCP:

38
libtransmission/peer-io.h
View File

@ -16,6 +16,7 @@
#include <cstddef> // size_t
#include <cstdint> // uintX_t
#include <ctime>
#include <memory>
#include <optional>
#include <event2/buffer.h>
@ -60,6 +61,16 @@ using tr_net_error_cb = void (*)(tr_peerIo* io, short what, void* userData);
auto inline constexpr PEER_IO_MAGIC_NUMBER = 206745;
struct evbuffer_deleter
{
void operator()(struct evbuffer* buf) const noexcept
{
evbuffer_free(buf);
}
};
using tr_evbuffer_ptr = std::unique_ptr<evbuffer, evbuffer_deleter>;
class tr_peerIo
{
public:
@ -75,21 +86,18 @@ public:
, addr{ addr_in }
, session{ session_in }
, time_created{ current_time }
, inbuf{ evbuffer_new() }
, outbuf{ evbuffer_new() }
, port{ port_in }
, is_seed{ is_seed_in }
{
}
~tr_peerIo()
{
evbuffer_free(outbuf);
evbuffer_free(inbuf);
}
std::string addrStr() const;
[[nodiscard]] auto getReadBuffer() noexcept
{
return inbuf.get();
}
tr_crypto crypto;
tr_address const addr;
@ -115,8 +123,9 @@ public:
// TODO: change tr_bandwidth* to owning pointer to the bandwidth, or remove * and own the value
Bandwidth* bandwidth = nullptr;
evbuffer* const inbuf;
evbuffer* const outbuf;
tr_evbuffer_ptr const inbuf = tr_evbuffer_ptr{ evbuffer_new() };
tr_evbuffer_ptr const outbuf = tr_evbuffer_ptr{ evbuffer_new() };
struct tr_datatype* outbuf_datatypes = nullptr;
struct event* event_read = nullptr;
@ -345,13 +354,4 @@ int tr_peerIoFlush(tr_peerIo* io, tr_direction dir, size_t byteLimit);
int tr_peerIoFlushOutgoingProtocolMsgs(tr_peerIo* io);
/**
***
**/
constexpr struct evbuffer* tr_peerIoGetReadBuffer(tr_peerIo* io)
{
return io->inbuf;
}
/* @} */

2
libtransmission/peer-msgs.cc
View File

@ -1931,7 +1931,7 @@ static void didWrite(tr_peerIo* io, size_t bytesWritten, bool wasPieceData, void
static ReadState canRead(tr_peerIo* io, void* vmsgs, size_t* piece)
{
auto* msgs = static_cast<tr_peerMsgsImpl*>(vmsgs);
struct evbuffer* in = tr_peerIoGetReadBuffer(io);
evbuffer* const in = io->getReadBuffer();
size_t const inlen = evbuffer_get_length(in);
logtrace(msgs, "canRead: inlen is %zu, msgs->state is %d", inlen, int(msgs->state));

7
libtransmission/rpcimpl.cc
View File

@ -1444,8 +1444,7 @@ static void onBlocklistFetched(tr_web::FetchResponse const& web_response)
// tr_blocklistSetContent needs a source file,
// so save content into a tmpfile
auto const filename = tr_pathbuf{ session->config_dir, "/blocklist.tmp"sv };
tr_error* error = nullptr;
if (!tr_saveFile(filename, content, &error))
if (tr_error* error = nullptr; !tr_saveFile(filename, content, &error))
{
fmt::format_to_n(
result,
@ -1460,9 +1459,9 @@ static void onBlocklistFetched(tr_web::FetchResponse const& web_response)
}
// feed it to the session and give the client a response
int const rule_count = tr_blocklistSetContent(session, filename.c_str());
int const rule_count = tr_blocklistSetContent(session, filename);
tr_variantDictAddInt(data->args_out, TR_KEY_blocklist_size, rule_count);
tr_sys_path_remove(filename.c_str());
tr_sys_path_remove(filename);
tr_idle_function_done(data, "success");
}

10
libtransmission/session.cc
View File

@ -521,14 +521,10 @@ void tr_sessionSaveSettings(tr_session* session, char const* config_dir, tr_vari
tr_variantInitDict(&settings, 0);
/* the existing file settings are the fallback values */
if (auto file_settings = tr_variant{}; tr_variantFromFile(&file_settings, TR_VARIANT_PARSE_JSON, filename))
{
tr_variant fileSettings;
if (tr_variantFromFile(&fileSettings, TR_VARIANT_PARSE_JSON, filename, nullptr))
{
tr_variantMergeDicts(&settings, &fileSettings);
tr_variantFree(&fileSettings);
}
tr_variantMergeDicts(&settings, &file_settings);
tr_variantFree(&file_settings);
}
/* the client's settings override the file settings */

10
libtransmission/torrent.cc
View File

@ -2416,7 +2416,7 @@ static void setLocationImpl(struct LocationData* const data)
if (auto found = tor->findFile(i); found)
{
auto const& oldpath = found->filename;
auto const newpath = tr_pathbuf{ location, "/"sv, found->subpath };
auto const newpath = tr_pathbuf{ location, '/', found->subpath() };
tr_logAddTraceTor(tor, fmt::format("Found file #{}: '{}'", i, oldpath));
@ -2563,10 +2563,10 @@ static void tr_torrentFileCompleted(tr_torrent* tor, tr_file_index_t i)
* it until now -- then rename it to match the one in the metadata */
if (auto found = tor->findFile(i); found)
{
if (auto const& file_subpath = tor->fileSubpath(i); file_subpath != found->subpath)
if (auto const& file_subpath = tor->fileSubpath(i); file_subpath != found->subpath())
{
auto const oldpath = tr_pathbuf{ found->base, "/"sv, found->subpath };
auto const newpath = tr_pathbuf{ found->base, "/"sv, file_subpath };
auto const& oldpath = found->filename;
auto const newpath = tr_pathbuf{ found->base(), '/', file_subpath };
tr_error* error = nullptr;
if (!tr_sys_path_rename(oldpath, newpath, &error))
@ -2708,7 +2708,7 @@ static void refreshCurrentDir(tr_torrent* tor)
else
{
auto const found = tor->findFile(0);
dir = found ? tr_interned_string{ found->base } : tor->incompleteDir();
dir = found ? tr_interned_string{ found->base() } : tor->incompleteDir();
}
TR_ASSERT(!std::empty(dir));

23
libtransmission/torrent.h
View File

@ -370,17 +370,28 @@ public:
struct tr_found_file_t : public tr_sys_path_info
{
tr_pathbuf filename; // /home/foo/Downloads/torrent/01-file-one.txt
std::string_view base; // /home/foo/Downloads
std::string_view subpath; // /torrent/01-file-one.txt
// /home/foo/Downloads/torrent/01-file-one.txt
tr_pathbuf filename;
size_t base_len;
tr_found_file_t(tr_sys_path_info info, tr_pathbuf&& filename_in, size_t base_len)
tr_found_file_t(tr_sys_path_info info, tr_pathbuf&& filename_in, size_t base_len_in)
: tr_sys_path_info{ info }
, filename{ std::move(filename_in) }
, base{ filename.sv().substr(0, base_len) }
, subpath{ filename.sv().substr(base_len + 1) }
, base_len{ base_len_in }
{
}
[[nodiscard]] constexpr auto base() const
{
// /home/foo/Downloads
return filename.sv().substr(0, base_len);
}
[[nodiscard]] constexpr auto subpath() const
{
// torrent/01-file-one.txt
return filename.sv().substr(base_len + 1);
}
};
std::optional<tr_found_file_t> findFile(tr_file_index_t i) const;

2
libtransmission/trevent.h
View File

@ -30,7 +30,7 @@ void tr_runInEventThread(tr_session* session, Func&& func, Args&&... args)
{
tr_runInEventThread(
session,
std::function<void(void)>{ [func = std::move(func), args = std::make_tuple(std::forward<Args>(args)...)]()
std::function<void(void)>{ [func = std::forward<Func&&>(func), args = std::make_tuple(std::forward<Args>(args)...)]()
{
std::apply(std::move(func), std::move(args));
} });

33
qt/FileTreeItem.cc
View File

@ -33,23 +33,34 @@ QHash<QString, int> const& FileTreeItem::getMyChildRows()
FileTreeItem::~FileTreeItem()
{
assert(children_.isEmpty());
assert(std::empty(children_));
if (parent_ != nullptr)
if (parent_ == nullptr)
{
int const pos = row();
assert(pos >= 0 && "couldn't find child in parent's lookup");
parent_->children_.removeAt(pos);
parent_->child_rows_.remove(name());
parent_->first_unhashed_row_ = pos;
return;
}
// find the parent's reference to this child
auto& siblings = parent_->children_;
auto it = std::find(std::begin(siblings), std::end(siblings), this);
if (it == std::end(siblings))
{
return;
}
// remove this child from the parent
parent_->child_rows_.remove(name());
it = siblings.erase(it);
// invalidate the row numbers of the siblings that came after this child
parent_->first_unhashed_row_ = std::distance(std::begin(siblings), it);
}
void FileTreeItem::appendChild(FileTreeItem* child)
{
int const n = childCount();
child->parent_ = this;
children_.append(child);
children_.push_back(child);
first_unhashed_row_ = n;
}
@ -214,7 +225,7 @@ QString FileTreeItem::sizeString() const
uint64_t FileTreeItem::size() const
{
if (children_.isEmpty())
if (std::empty(children_))
{
return total_size_;
}
@ -299,7 +310,7 @@ int FileTreeItem::priority() const
{
int i(0);
if (children_.isEmpty())
if (std::empty(children_))
{
switch (priority_)
{
@ -345,7 +356,7 @@ void FileTreeItem::setSubtreePriority(int i, QSet<int>& ids)
int FileTreeItem::isSubtreeWanted() const
{
if (children_.isEmpty())
if (std::empty(children_))
{
return is_wanted_ ? Qt::Checked : Qt::Unchecked;
}

4
qt/FileTreeItem.h
View File

@ -6,10 +6,10 @@
#pragma once
#include <cstdint>
#include <vector>
#include <QCoreApplication>
#include <QHash>
#include <QList>
#include <QSet>
#include <QString>
#include <QVariant>
@ -95,7 +95,7 @@ private:
FileTreeItem* parent_ = {};
QHash<QString, int> child_rows_;
QList<FileTreeItem*> children_;
std::vector<FileTreeItem*> children_;
QString name_;
uint64_t const total_size_ = {};
uint64_t have_size_ = {};

52
qt/InteropHelper.cc
View File

@ -9,52 +9,44 @@
bool InteropHelper::isConnected() const
{
bool is_connected = false;
#if defined(ENABLE_DBUS_INTEROP) && defined(ENABLE_COM_INTEROP)
#ifdef ENABLE_DBUS_INTEROP
return dbus_client_.isConnected() || com_client_.isConnected();
is_connected |= dbus_client_.isConnected();
#elif defined(ENABLE_DBUS_INTEROP)
return dbus_client_.isConnected();
#elif defined(ENABLE_COM_INTEROP)
return com_client_.isConnected();
#else
return false;
#endif
#ifdef ENABLE_COM_INTEROP
is_connected |= com_client_.isConnected();
#endif
return is_connected;
}
bool InteropHelper::addMetainfo(QString const& metainfo) const
{
#ifdef ENABLE_DBUS_INTEROP
#if defined(ENABLE_DBUS_INTEROP) && defined(ENABLE_COM_INTEROP)
{
QVariant const response = dbus_client_.addMetainfo(metainfo);
return dbus_client_.addMetainfo(metainfo).toBool() || com_client_.addMetainfo(metainfo).toBool();
if (response.isValid() && response.toBool())
{
return true;
}
}
#elif defined(ENABLE_DBUS_INTEROP)
#endif
return dbus_client_.addMetainfo(metainfo).toBool();
#ifdef ENABLE_COM_INTEROP
#elif defined(ENABLE_COM_INTEROP)
{
QVariant const response = com_client_.addMetainfo(metainfo);
return com_client_.addMetainfo(metainfo).toBool();
if (response.isValid() && response.toBool())
{
return true;
}
}
#endif
#else
return false;
#endif
}
void InteropHelper::initialize()

82
qt/Prefs.cc
View File

@ -237,100 +237,76 @@ Prefs::Prefs(QString config_dir)
switch (Items[i].type)
{
case QVariant::Int:
if (auto const value = getValue<int64_t>(b); value)
{
auto const value = getValue<int64_t>(b);
if (value)
{
values_[i].setValue(*value);
}
values_[i].setValue(*value);
}
break;
case CustomVariantType::SortModeType:
if (auto const value = getValue<std::string_view>(b); value)
{
auto const value = getValue<std::string_view>(b);
if (value)
auto const test = [&value](auto const& item)
{
auto const test = [&value](auto const& item)
{
return item.second == *value;
};
// NOLINTNEXTLINE(readability-qualified-auto)
auto const it = std::find_if(std::cbegin(SortModes), std::cend(SortModes), test);
auto const& pair = it == std::end(SortModes) ? SortModes.front() : *it;
values_[i] = QVariant::fromValue(SortMode(pair.first));
}
return item.second == *value;
};
// NOLINTNEXTLINE(readability-qualified-auto)
auto const it = std::find_if(std::cbegin(SortModes), std::cend(SortModes), test);
auto const& pair = it == std::end(SortModes) ? SortModes.front() : *it;
values_[i] = QVariant::fromValue(SortMode(pair.first));
}
break;
case CustomVariantType::FilterModeType:
if (auto const value = getValue<std::string_view>(b); value)
{
auto const value = getValue<std::string_view>(b);
if (value)
auto const test = [&value](auto const& item)
{
auto const test = [&value](auto const& item)
{
return item.second == *value;
};
// NOLINTNEXTLINE(readability-qualified-auto)
auto const it = std::find_if(std::cbegin(FilterModes), std::cend(FilterModes), test);
auto const& pair = it == std::end(FilterModes) ? FilterModes.front() : *it;
values_[i] = QVariant::fromValue(FilterMode(pair.first));
}
return item.second == *value;
};
// NOLINTNEXTLINE(readability-qualified-auto)
auto const it = std::find_if(std::cbegin(FilterModes), std::cend(FilterModes), test);
auto const& pair = it == std::end(FilterModes) ? FilterModes.front() : *it;
values_[i] = QVariant::fromValue(FilterMode(pair.first));
}
break;
case QVariant::String:
if (auto const value = getValue<QString>(b); value)
{
auto const value = getValue<QString>(b);
if (value)
{
values_[i].setValue(*value);
}
values_[i].setValue(*value);
}
break;
case QVariant::StringList:
if (auto const value = getValue<QStringList>(b); value)
{
auto const value = getValue<QStringList>(b);
if (value)
{
values_[i].setValue(*value);
}
values_[i].setValue(*value);
}
break;
case QVariant::Bool:
if (auto const value = getValue<bool>(b); value)
{
auto const value = getValue<bool>(b);
if (value)
{
values_[i].setValue(*value);
}
values_[i].setValue(*value);
}
break;
case QVariant::Double:
if (auto const value = getValue<double>(b); value)
{
auto const value = getValue<double>(b);
if (value)
{
values_[i].setValue(*value);
}
values_[i].setValue(*value);
}
break;
case QVariant::DateTime:
if (auto const value = getValue<time_t>(b); value)
{
auto const value = getValue<time_t>(b);
if (value)
{
#if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0)
values_[i].setValue(QDateTime::fromSecsSinceEpoch(*value));
values_[i].setValue(QDateTime::fromSecsSinceEpoch(*value));
#else
values_[i].setValue(QDateTime::fromTime_t(*value));
values_[i].setValue(QDateTime::fromTime_t(*value));
#endif
}
}
break;

58
qt/Torrent.cc
View File

@ -259,19 +259,15 @@ Torrent::fields_t Torrent::update(tr_quark const* keys, tr_variant const* const*
{
case TR_KEY_file_count:
case TR_KEY_primary_mime_type:
{
icon_ = {};
break;
}
icon_ = {};
break;
case TR_KEY_files:
for (size_t i = 0; i < files_.size(); ++i)
{
for (size_t i = 0; i < files_.size(); ++i)
{
files_[i].index = i;
}
break;
files_[i].index = i;
}
break;
case TR_KEY_trackers:
{
@ -292,66 +288,50 @@ Torrent::fields_t Torrent::update(tr_quark const* keys, tr_variant const* const*
QString Torrent::activityString() const
{
QString str;
switch (getActivity())
{
case TR_STATUS_STOPPED:
str = isFinished() ? tr("Finished") : tr("Paused");
break;
return isFinished() ? tr("Finished") : tr("Paused");
case TR_STATUS_CHECK_WAIT:
str = tr("Queued for verification");
break;
return tr("Queued for verification");
case TR_STATUS_CHECK:
str = tr("Verifying local data");
break;
return tr("Verifying local data");
case TR_STATUS_DOWNLOAD_WAIT:
str = tr("Queued for download");
break;
return tr("Queued for download");
case TR_STATUS_DOWNLOAD:
str = tr("Downloading");
break;
return tr("Downloading");
case TR_STATUS_SEED_WAIT:
str = tr("Queued for seeding");
break;
return tr("Queued for seeding");
case TR_STATUS_SEED:
str = tr("Seeding");
break;
}
return tr("Seeding");
return str;
default:
return {};
}
}
QString Torrent::getError() const
{
auto s = error_string_;
switch (error_)
{
case TR_STAT_TRACKER_WARNING:
s = tr("Tracker gave a warning: %1").arg(s);
break;
return tr("Tracker gave a warning: %1").arg(error_string_);
case TR_STAT_TRACKER_ERROR:
s = tr("Tracker gave an error: %1").arg(s);
break;
return tr("Tracker gave an error: %1").arg(error_string_);
case TR_STAT_LOCAL_ERROR:
s = tr("Error: %1").arg(s);
break;
return tr("Error: %1").arg(error_string_);
default:
s.clear();
break;
return {};
}
return s;
}
QPixmap TrackerStat::getFavicon() const

116
tests/libtransmission/announce-list-test.cc
View File

@ -53,7 +53,7 @@ TEST_F(AnnounceListTest, groupsSiblingsIntoSameTier)
EXPECT_TRUE(announce_list.add(Announce2, Tier2));
EXPECT_TRUE(announce_list.add(Announce3, Tier3));
EXPECT_EQ(3, std::size(announce_list));
EXPECT_EQ(3U, std::size(announce_list));
EXPECT_EQ(Tier1, announce_list.at(0).tier);
EXPECT_EQ(Tier1, announce_list.at(1).tier);
EXPECT_EQ(Tier1, announce_list.at(2).tier);
@ -98,13 +98,13 @@ TEST_F(AnnounceListTest, canNotAddDuplicateAnnounce)
auto announce_list = tr_announce_list{};
EXPECT_TRUE(announce_list.add(Announce, Tier));
EXPECT_EQ(1, announce_list.size());
EXPECT_EQ(1U, announce_list.size());
EXPECT_FALSE(announce_list.add(Announce, Tier));
EXPECT_EQ(1, announce_list.size());
EXPECT_EQ(1U, announce_list.size());
auto constexpr Announce2 = "https://example.org:443/announce"sv;
EXPECT_FALSE(announce_list.add(Announce2, Tier));
EXPECT_EQ(1, announce_list.size());
EXPECT_EQ(1U, announce_list.size());
}
TEST_F(AnnounceListTest, canNotAddInvalidUrl)
@ -114,7 +114,7 @@ TEST_F(AnnounceListTest, canNotAddInvalidUrl)
auto announce_list = tr_announce_list{};
EXPECT_FALSE(announce_list.add(Announce, Tier));
EXPECT_EQ(0, announce_list.size());
EXPECT_EQ(0U, announce_list.size());
}
TEST_F(AnnounceListTest, canSet)
@ -127,8 +127,8 @@ TEST_F(AnnounceListTest, canSet)
auto constexpr Tiers = std::array<tr_tracker_tier_t, 3>{ 1, 2, 3 };
auto announce_list = tr_announce_list{};
EXPECT_EQ(3, announce_list.set(std::data(Urls), std::data(Tiers), 3));
EXPECT_EQ(3, announce_list.size());
EXPECT_EQ(3U, announce_list.set(std::data(Urls), std::data(Tiers), 3));
EXPECT_EQ(3U, announce_list.size());
EXPECT_EQ(Tiers[0], announce_list.at(0).tier);
EXPECT_EQ(Tiers[1], announce_list.at(1).tier);
EXPECT_EQ(Tiers[2], announce_list.at(2).tier);
@ -149,14 +149,14 @@ TEST_F(AnnounceListTest, canSetUnsortedWithBackupsInTiers)
auto constexpr Tiers = std::array<tr_tracker_tier_t, 6>{ 0, 1, 2, 0, 1, 2 };
auto announce_list = tr_announce_list{};
EXPECT_EQ(6, announce_list.set(std::data(Urls), std::data(Tiers), 6));
EXPECT_EQ(6, announce_list.size());
EXPECT_EQ(0, announce_list.at(0).tier);
EXPECT_EQ(0, announce_list.at(1).tier);
EXPECT_EQ(1, announce_list.at(2).tier);
EXPECT_EQ(1, announce_list.at(3).tier);
EXPECT_EQ(2, announce_list.at(4).tier);
EXPECT_EQ(2, announce_list.at(5).tier);
EXPECT_EQ(6U, announce_list.set(std::data(Urls), std::data(Tiers), 6));
EXPECT_EQ(6U, announce_list.size());
EXPECT_EQ(0U, announce_list.at(0).tier);
EXPECT_EQ(0U, announce_list.at(1).tier);
EXPECT_EQ(1U, announce_list.at(2).tier);
EXPECT_EQ(1U, announce_list.at(3).tier);
EXPECT_EQ(2U, announce_list.at(4).tier);
EXPECT_EQ(2U, announce_list.at(5).tier);
EXPECT_EQ(Urls[0], announce_list.at(0).announce.full);
EXPECT_EQ(Urls[3], announce_list.at(1).announce.full);
EXPECT_EQ(Urls[1], announce_list.at(2).announce.full);
@ -183,8 +183,8 @@ TEST_F(AnnounceListTest, canSetExceptDuplicate)
auto constexpr Tiers = std::array<tr_tracker_tier_t, 3>{ 3, 2, 1 };
auto announce_list = tr_announce_list{};
EXPECT_EQ(2, announce_list.set(std::data(Urls), std::data(Tiers), 3));
EXPECT_EQ(2, announce_list.size());
EXPECT_EQ(2U, announce_list.set(std::data(Urls), std::data(Tiers), 3));
EXPECT_EQ(2U, announce_list.size());
EXPECT_EQ(Tiers[0], announce_list.at(1).tier);
EXPECT_EQ(Tiers[1], announce_list.at(0).tier);
EXPECT_EQ(Urls[0], announce_list.at(1).announce.full);
@ -201,8 +201,8 @@ TEST_F(AnnounceListTest, canSetExceptInvalid)
auto constexpr Tiers = std::array<tr_tracker_tier_t, 3>{ 1, 2, 3 };
auto announce_list = tr_announce_list{};
EXPECT_EQ(2, announce_list.set(std::data(Urls), std::data(Tiers), 3));
EXPECT_EQ(2, announce_list.size());
EXPECT_EQ(2U, announce_list.set(std::data(Urls), std::data(Tiers), 3));
EXPECT_EQ(2U, announce_list.size());
EXPECT_EQ(Tiers[0], announce_list.at(0).tier);
EXPECT_EQ(Tiers[2], announce_list.at(1).tier);
EXPECT_EQ(Urls[0], announce_list.at(0).announce.full);
@ -216,11 +216,11 @@ TEST_F(AnnounceListTest, canRemoveById)
auto announce_list = tr_announce_list{};
announce_list.add(Announce, Tier);
EXPECT_EQ(1, std::size(announce_list));
EXPECT_EQ(1U, std::size(announce_list));
auto const id = announce_list.at(0).id;
EXPECT_TRUE(announce_list.remove(id));
EXPECT_EQ(0, std::size(announce_list));
EXPECT_EQ(0U, std::size(announce_list));
}
TEST_F(AnnounceListTest, canNotRemoveByInvalidId)
@ -230,11 +230,11 @@ TEST_F(AnnounceListTest, canNotRemoveByInvalidId)
auto announce_list = tr_announce_list{};
announce_list.add(Announce, Tier);
EXPECT_EQ(1, std::size(announce_list));
EXPECT_EQ(1U, std::size(announce_list));
auto const id = announce_list.at(0).id;
EXPECT_FALSE(announce_list.remove(id + 1));
EXPECT_EQ(1, std::size(announce_list));
EXPECT_EQ(1U, std::size(announce_list));
EXPECT_EQ(Announce, announce_list.at(0).announce.full);
}
@ -245,10 +245,10 @@ TEST_F(AnnounceListTest, canRemoveByAnnounce)
auto announce_list = tr_announce_list{};
announce_list.add(Announce, Tier);
EXPECT_EQ(1, std::size(announce_list));
EXPECT_EQ(1U, std::size(announce_list));
EXPECT_TRUE(announce_list.remove(Announce));
EXPECT_EQ(0, std::size(announce_list));
EXPECT_EQ(0U, std::size(announce_list));
}
TEST_F(AnnounceListTest, canNotRemoveByInvalidAnnounce)
@ -258,10 +258,10 @@ TEST_F(AnnounceListTest, canNotRemoveByInvalidAnnounce)
auto announce_list = tr_announce_list{};
announce_list.add(Announce, Tier);
EXPECT_EQ(1, std::size(announce_list));
EXPECT_EQ(1U, std::size(announce_list));
EXPECT_FALSE(announce_list.remove("https://www.not-example.com/announce"sv));
EXPECT_EQ(1, std::size(announce_list));
EXPECT_EQ(1U, std::size(announce_list));
}
TEST_F(AnnounceListTest, canReplace)
@ -398,7 +398,7 @@ TEST_F(AnnounceListTest, SingleAnnounce)
auto constexpr Text = "https://www.example.com/a/announce";
EXPECT_TRUE(announce_list.parse(Text));
EXPECT_EQ(1, std::size(announce_list));
EXPECT_EQ(1U, std::size(announce_list));
EXPECT_EQ("https://www.example.com/a/announce", announce_list.at(0).announce.full);
}
@ -414,13 +414,13 @@ TEST_F(AnnounceListTest, parseThreeTier)
"https://www.example.com/c/announce"sv;
EXPECT_TRUE(announce_list.parse(Text));
EXPECT_EQ(3, std::size(announce_list));
EXPECT_EQ(3U, std::size(announce_list));
EXPECT_EQ("https://www.example.com/a/announce", announce_list.at(0).announce.full);
EXPECT_EQ(0, announce_list.at(0).tier);
EXPECT_EQ(0U, announce_list.at(0).tier);
EXPECT_EQ("https://www.example.com/b/announce", announce_list.at(1).announce.full);
EXPECT_EQ(1, announce_list.at(1).tier);
EXPECT_EQ(1U, announce_list.at(1).tier);
EXPECT_EQ("https://www.example.com/c/announce", announce_list.at(2).announce.full);
EXPECT_EQ(2, announce_list.at(2).tier);
EXPECT_EQ(2U, announce_list.at(2).tier);
EXPECT_EQ(tr_strvJoin(Text, "\n"sv), announce_list.toString());
}
@ -436,13 +436,13 @@ TEST_F(AnnounceListTest, parseThreeTierWithTrailingLf)
"https://www.example.com/c/announce\n"sv;
EXPECT_TRUE(announce_list.parse(Text));
EXPECT_EQ(3, std::size(announce_list));
EXPECT_EQ(3U, std::size(announce_list));
EXPECT_EQ("https://www.example.com/a/announce", announce_list.at(0).announce.full);
EXPECT_EQ(0, announce_list.at(0).tier);
EXPECT_EQ(0U, announce_list.at(0).tier);
EXPECT_EQ("https://www.example.com/b/announce", announce_list.at(1).announce.full);
EXPECT_EQ(1, announce_list.at(1).tier);
EXPECT_EQ(1U, announce_list.at(1).tier);
EXPECT_EQ("https://www.example.com/c/announce", announce_list.at(2).announce.full);
EXPECT_EQ(2, announce_list.at(2).tier);
EXPECT_EQ(2U, announce_list.at(2).tier);
EXPECT_EQ(Text, announce_list.toString());
}
@ -467,13 +467,13 @@ TEST_F(AnnounceListTest, parseThreeTierWithExcessLf)
"https://www.example.com/c/announce\n"sv;
EXPECT_TRUE(announce_list.parse(Text));
EXPECT_EQ(3, std::size(announce_list));
EXPECT_EQ(3U, std::size(announce_list));
EXPECT_EQ("https://www.example.com/a/announce", announce_list.at(0).announce.full);
EXPECT_EQ(0, announce_list.at(0).tier);
EXPECT_EQ(0U, announce_list.at(0).tier);
EXPECT_EQ("https://www.example.com/b/announce", announce_list.at(1).announce.full);
EXPECT_EQ(1, announce_list.at(1).tier);
EXPECT_EQ(1U, announce_list.at(1).tier);
EXPECT_EQ("https://www.example.com/c/announce", announce_list.at(2).announce.full);
EXPECT_EQ(2, announce_list.at(2).tier);
EXPECT_EQ(2U, announce_list.at(2).tier);
auto constexpr ExpectedText =
"https://www.example.com/a/announce\n"
@ -500,13 +500,13 @@ TEST_F(AnnounceListTest, parseThreeTierWithWhitespace)
" https://www.example.com/c/announce\n"sv;
EXPECT_TRUE(announce_list.parse(Text));
EXPECT_EQ(3, std::size(announce_list));
EXPECT_EQ(3U, std::size(announce_list));
EXPECT_EQ("https://www.example.com/a/announce", announce_list.at(0).announce.full);
EXPECT_EQ(0, announce_list.at(0).tier);
EXPECT_EQ(0U, announce_list.at(0).tier);
EXPECT_EQ("https://www.example.com/b/announce", announce_list.at(1).announce.full);
EXPECT_EQ(1, announce_list.at(1).tier);
EXPECT_EQ(1U, announce_list.at(1).tier);
EXPECT_EQ("https://www.example.com/c/announce", announce_list.at(2).announce.full);
EXPECT_EQ(2, announce_list.at(2).tier);
EXPECT_EQ(2U, announce_list.at(2).tier);
auto constexpr ExpectedText =
"https://www.example.com/a/announce\n"
@ -529,13 +529,13 @@ TEST_F(AnnounceListTest, parseThreeTierCrLf)
"https://www.example.com/c/announce\r\n"sv;
EXPECT_TRUE(announce_list.parse(Text));
EXPECT_EQ(3, std::size(announce_list));
EXPECT_EQ(3U, std::size(announce_list));
EXPECT_EQ("https://www.example.com/a/announce", announce_list.at(0).announce.full);
EXPECT_EQ(0, announce_list.at(0).tier);
EXPECT_EQ(0U, announce_list.at(0).tier);
EXPECT_EQ("https://www.example.com/b/announce", announce_list.at(1).announce.full);
EXPECT_EQ(1, announce_list.at(1).tier);
EXPECT_EQ(1U, announce_list.at(1).tier);
EXPECT_EQ("https://www.example.com/c/announce", announce_list.at(2).announce.full);
EXPECT_EQ(2, announce_list.at(2).tier);
EXPECT_EQ(2U, announce_list.at(2).tier);
auto constexpr ExpectedText =
"https://www.example.com/a/announce\n"
@ -564,28 +564,28 @@ TEST_F(AnnounceListTest, parseMultiTrackerInTier)
"https://www.example.com/i/announce\n"sv;
EXPECT_TRUE(announce_list.parse(Text));
EXPECT_EQ(9, std::size(announce_list));
EXPECT_EQ(9U, std::size(announce_list));
EXPECT_EQ("https://www.example.com/a/announce", announce_list.at(0).announce.full);
EXPECT_EQ(0, announce_list.at(0).tier);
EXPECT_EQ(0U, announce_list.at(0).tier);
EXPECT_EQ("https://www.example.com/b/announce", announce_list.at(1).announce.full);
EXPECT_EQ(0, announce_list.at(1).tier);
EXPECT_EQ(0U, announce_list.at(1).tier);
EXPECT_EQ("https://www.example.com/c/announce", announce_list.at(2).announce.full);
EXPECT_EQ(1, announce_list.at(2).tier);
EXPECT_EQ(1U, announce_list.at(2).tier);
EXPECT_EQ("https://www.example.com/d/announce", announce_list.at(3).announce.full);
EXPECT_EQ(1, announce_list.at(3).tier);
EXPECT_EQ(1U, announce_list.at(3).tier);
EXPECT_EQ("https://www.example.com/e/announce", announce_list.at(4).announce.full);
EXPECT_EQ(1, announce_list.at(4).tier);
EXPECT_EQ(1U, announce_list.at(4).tier);
EXPECT_EQ("https://www.example.com/f/announce", announce_list.at(5).announce.full);
EXPECT_EQ(1, announce_list.at(5).tier);
EXPECT_EQ(1U, announce_list.at(5).tier);
EXPECT_EQ("https://www.example.com/g/announce", announce_list.at(6).announce.full);
EXPECT_EQ(2, announce_list.at(6).tier);
EXPECT_EQ(2U, announce_list.at(6).tier);
EXPECT_EQ("https://www.example.com/h/announce", announce_list.at(7).announce.full);
EXPECT_EQ(2, announce_list.at(7).tier);
EXPECT_EQ(2U, announce_list.at(7).tier);
EXPECT_EQ("https://www.example.com/i/announce", announce_list.at(8).announce.full);
EXPECT_EQ(2, announce_list.at(8).tier);
EXPECT_EQ(2U, announce_list.at(8).tier);
EXPECT_EQ(Text, announce_list.toString());
}

16
tests/libtransmission/announcer-test.cc
View File

@ -46,8 +46,8 @@ TEST_F(AnnouncerTest, parseHttpAnnounceResponseNoPeers)
EXPECT_EQ(0, response.leechers);
EXPECT_EQ(2, response.downloads);
EXPECT_EQ(*tr_address::from_string("1.2.3.4"), response.external_ip);
EXPECT_EQ(0, std::size(response.pex));
EXPECT_EQ(0, std::size(response.pex6));
EXPECT_EQ(0U, std::size(response.pex));
EXPECT_EQ(0U, std::size(response.pex6));
EXPECT_EQ(""sv, response.errmsg);
EXPECT_EQ(""sv, response.warning);
}
@ -76,8 +76,8 @@ TEST_F(AnnouncerTest, parseHttpAnnounceResponsePexCompact)
EXPECT_EQ(2, response.downloads);
EXPECT_EQ(""sv, response.errmsg);
EXPECT_EQ(""sv, response.warning);
EXPECT_EQ(1, std::size(response.pex));
EXPECT_EQ(0, std::size(response.pex6));
EXPECT_EQ(1U, std::size(response.pex));
EXPECT_EQ(0U, std::size(response.pex6));
if (std::size(response.pex) == 1)
{
@ -115,8 +115,8 @@ TEST_F(AnnouncerTest, parseHttpAnnounceResponsePexList)
EXPECT_EQ(2, response.downloads);
EXPECT_EQ(""sv, response.errmsg);
EXPECT_EQ(""sv, response.warning);
EXPECT_EQ(1, std::size(response.pex));
EXPECT_EQ(0, std::size(response.pex6));
EXPECT_EQ(1U, std::size(response.pex));
EXPECT_EQ(0U, std::size(response.pex6));
if (std::size(response.pex) == 1)
{
@ -146,8 +146,8 @@ TEST_F(AnnouncerTest, parseHttpAnnounceResponseFailureReason)
EXPECT_EQ(3, response.seeders);
EXPECT_EQ(0, response.leechers);
EXPECT_EQ(2, response.downloads);
EXPECT_EQ(0, std::size(response.pex));
EXPECT_EQ(0, std::size(response.pex6));
EXPECT_EQ(0U, std::size(response.pex));
EXPECT_EQ(0U, std::size(response.pex6));
EXPECT_EQ("foobar"sv, response.errmsg);
EXPECT_EQ(""sv, response.warning);
}

74
tests/libtransmission/assets/alice_in_wonderland_librivox_archive.torrent Normal file
View File

File diff suppressed because one or more lines are too long

0
tests/libtransmission/assets/debian-11.2.0-amd64-DVD-1.iso.torrent.added Normal file
View File

22
tests/libtransmission/bitfield-test.cc
View File

@ -61,16 +61,16 @@ TEST(Bitfield, count)
}
auto bf = tr_bitfield{ 0 };
EXPECT_EQ(0, bf.count(0, 0));
EXPECT_EQ(0, bf.count(0, 1));
EXPECT_EQ(0U, bf.count(0, 0));
EXPECT_EQ(0U, bf.count(0, 1));
bf = tr_bitfield{ 100 };
EXPECT_EQ(0, bf.count(0, 0));
EXPECT_EQ(0, bf.count(0, 100));
EXPECT_EQ(0U, bf.count(0, 0));
EXPECT_EQ(0U, bf.count(0, 100));
bf.setHasAll();
EXPECT_EQ(0, bf.count(0, 0));
EXPECT_EQ(1, bf.count(0, 1));
EXPECT_EQ(100, bf.count(0, 100));
EXPECT_EQ(0U, bf.count(0, 0));
EXPECT_EQ(1U, bf.count(0, 1));
EXPECT_EQ(100U, bf.count(0, 100));
}
TEST(Bitfield, ctorFromFlagArray)
@ -137,13 +137,13 @@ TEST(Bitfield, setRaw)
// check that the spare bits t the end are zero
bf = tr_bitfield{ 1 };
uint8_t by = ~uint8_t{};
uint8_t by = std::numeric_limits<uint8_t>::max();
bf.setRaw(&by, 1);
EXPECT_TRUE(bf.hasAll());
EXPECT_FALSE(bf.hasNone());
EXPECT_EQ(1, bf.count());
EXPECT_EQ(1U, bf.count());
raw = bf.raw();
EXPECT_EQ(1, std::size(raw));
EXPECT_EQ(1U, std::size(raw));
EXPECT_EQ(1 << 7, raw[0]);
}
@ -254,7 +254,7 @@ TEST(Bitfield, bitfields)
field.unsetSpan(0, 100);
EXPECT_TRUE(field.hasNone());
EXPECT_FALSE(field.hasAll());
EXPECT_EQ(0, field.count());
EXPECT_EQ(0U, field.count());
/* test tr_bitfield::setSpan when it changes nothing */
field.setHasAll();

110
tests/libtransmission/block-info-test.cc
View File

@ -31,11 +31,11 @@ TEST_F(BlockInfoTest, fieldsAreSet)
EXPECT_EQ(TotalSize, info.total_size);
info.initSizes(0, 0);
EXPECT_EQ(0, info.final_block_size);
EXPECT_EQ(0, info.n_pieces);
EXPECT_EQ(0, info.final_piece_size);
EXPECT_EQ(0, info.piece_size);
EXPECT_EQ(0, info.total_size);
EXPECT_EQ(0U, info.final_block_size);
EXPECT_EQ(0U, info.n_pieces);
EXPECT_EQ(0U, info.final_piece_size);
EXPECT_EQ(0U, info.piece_size);
EXPECT_EQ(0U, info.total_size);
}
TEST_F(BlockInfoTest, handlesOddSize)
@ -49,8 +49,8 @@ TEST_F(BlockInfoTest, handlesOddSize)
uint64_t constexpr TotalSize = PieceSize * (PieceCount - 1) + 1;
info.initSizes(TotalSize, PieceSize);
EXPECT_EQ(1, info.final_block_size);
EXPECT_EQ(1, info.final_piece_size);
EXPECT_EQ(1U, info.final_block_size);
EXPECT_EQ(1U, info.final_piece_size);
EXPECT_EQ(PieceCount, info.n_pieces);
EXPECT_EQ(PieceSize, info.piece_size);
EXPECT_EQ(TotalSize, info.total_size);
@ -68,7 +68,7 @@ TEST_F(BlockInfoTest, pieceSize)
info.initSizes(TotalSize, PieceSize);
EXPECT_EQ(PieceSize, info.pieceSize(info.n_pieces - 2));
EXPECT_EQ(1, info.pieceSize(info.n_pieces - 1));
EXPECT_EQ(1U, info.pieceSize(info.n_pieces - 1));
}
TEST_F(BlockInfoTest, blockSize)
@ -83,7 +83,7 @@ TEST_F(BlockInfoTest, blockSize)
info.initSizes(TotalSize, PieceSize);
EXPECT_EQ(ExpectedBlockSize, info.blockSize(info.n_blocks - 2));
EXPECT_EQ(1, info.blockSize(info.n_blocks - 1));
EXPECT_EQ(1U, info.blockSize(info.n_blocks - 1));
}
TEST_F(BlockInfoTest, blockSpanForPiece)
@ -97,17 +97,17 @@ TEST_F(BlockInfoTest, blockSpanForPiece)
uint64_t constexpr TotalSize = PieceSize * (PieceCount - 1) + 1;
info.initSizes(TotalSize, PieceSize);
EXPECT_EQ(0, info.blockSpanForPiece(0).begin);
EXPECT_EQ(4, info.blockSpanForPiece(0).end);
EXPECT_EQ(12, info.blockSpanForPiece(3).begin);
EXPECT_EQ(16, info.blockSpanForPiece(3).end);
EXPECT_EQ(16, info.blockSpanForPiece(4).begin);
EXPECT_EQ(17, info.blockSpanForPiece(4).end);
EXPECT_EQ(0U, info.blockSpanForPiece(0).begin);
EXPECT_EQ(4U, info.blockSpanForPiece(0).end);
EXPECT_EQ(12U, info.blockSpanForPiece(3).begin);
EXPECT_EQ(16U, info.blockSpanForPiece(3).end);
EXPECT_EQ(16U, info.blockSpanForPiece(4).begin);
EXPECT_EQ(17U, info.blockSpanForPiece(4).end);
// test that uninitialized block_info returns an invalid span
info = tr_block_info{};
EXPECT_EQ(0, info.blockSpanForPiece(0).begin);
EXPECT_EQ(0, info.blockSpanForPiece(0).end);
EXPECT_EQ(0U, info.blockSpanForPiece(0).begin);
EXPECT_EQ(0U, info.blockSpanForPiece(0).end);
}
TEST_F(BlockInfoTest, blockLoc)
@ -127,19 +127,19 @@ TEST_F(BlockInfoTest, blockLoc)
// third block is halfway through the first piece
loc = info.blockLoc(2);
EXPECT_EQ(ExpectedBlockSize * 2, loc.byte);
EXPECT_EQ(2, loc.block);
EXPECT_EQ(0, loc.block_offset);
EXPECT_EQ(0, loc.piece);
EXPECT_EQ(ExpectedBlockSize * 2, loc.piece_offset);
EXPECT_EQ(ExpectedBlockSize * 2U, loc.byte);
EXPECT_EQ(2U, loc.block);
EXPECT_EQ(0U, loc.block_offset);
EXPECT_EQ(0U, loc.piece);
EXPECT_EQ(ExpectedBlockSize * 2U, loc.piece_offset);
// second piece aligns with fifth block
loc = info.blockLoc(4);
EXPECT_EQ(PieceSize, loc.byte);
EXPECT_EQ(4, loc.block);
EXPECT_EQ(0, loc.block_offset);
EXPECT_EQ(1, loc.piece);
EXPECT_EQ(0, loc.piece_offset);
EXPECT_EQ(4U, loc.block);
EXPECT_EQ(0U, loc.block_offset);
EXPECT_EQ(1U, loc.piece);
EXPECT_EQ(0U, loc.piece_offset);
}
TEST_F(BlockInfoTest, blockLastLoc)
@ -155,9 +155,9 @@ TEST_F(BlockInfoTest, blockLastLoc)
auto loc = info.blockLastLoc(0);
EXPECT_EQ(ExpectedBlockSize - 1, loc.byte);
EXPECT_EQ(0, loc.block);
EXPECT_EQ(0U, loc.block);
EXPECT_EQ(ExpectedBlockSize - 1, loc.block_offset);
EXPECT_EQ(0, loc.piece);
EXPECT_EQ(0U, loc.piece);
EXPECT_EQ(ExpectedBlockSize - 1, loc.piece_offset);
loc = info.blockLastLoc(info.blockCount() - 1);
@ -189,31 +189,31 @@ TEST_F(BlockInfoTest, pieceLoc)
EXPECT_EQ(info.blockLoc(i * ExpectedBlocksPerPiece), loc);
EXPECT_EQ(PieceSize * i, loc.byte);
EXPECT_EQ(ExpectedBlocksPerPiece * i, loc.block);
EXPECT_EQ(0, loc.block_offset);
EXPECT_EQ(0U, loc.block_offset);
EXPECT_EQ(i, loc.piece);
EXPECT_EQ(0, loc.piece_offset);
EXPECT_EQ(0U, loc.piece_offset);
}
loc = info.pieceLoc(0, PieceSize - 1);
EXPECT_EQ(PieceSize - 1, loc.byte);
EXPECT_EQ(ExpectedBlocksPerPiece - 1, loc.block);
EXPECT_EQ(ExpectedBlockSize - 1, loc.block_offset);
EXPECT_EQ(0, loc.piece);
EXPECT_EQ(0U, loc.piece);
EXPECT_EQ(PieceSize - 1, loc.piece_offset);
loc = info.pieceLoc(0, PieceSize);
EXPECT_EQ(PieceSize, loc.byte);
EXPECT_EQ(ExpectedBlocksPerPiece, loc.block);
EXPECT_EQ(0, loc.block_offset);
EXPECT_EQ(1, loc.piece);
EXPECT_EQ(0, loc.piece_offset);
EXPECT_EQ(0U, loc.block_offset);
EXPECT_EQ(1U, loc.piece);
EXPECT_EQ(0U, loc.piece_offset);
loc = info.pieceLoc(0, PieceSize + 1);
EXPECT_EQ(PieceSize + 1, loc.byte);
EXPECT_EQ(ExpectedBlocksPerPiece, loc.block);
EXPECT_EQ(1, loc.block_offset);
EXPECT_EQ(1, loc.piece);
EXPECT_EQ(1, loc.piece_offset);
EXPECT_EQ(1U, loc.block_offset);
EXPECT_EQ(1U, loc.piece);
EXPECT_EQ(1U, loc.piece_offset);
}
TEST_F(BlockInfoTest, pieceLastLoc)
@ -231,7 +231,7 @@ TEST_F(BlockInfoTest, pieceLastLoc)
EXPECT_EQ(PieceSize - 1, loc.byte);
EXPECT_EQ(ExpectedBlocksPerPiece - 1, loc.block);
EXPECT_EQ(ExpectedBlockSize - 1, loc.block_offset);
EXPECT_EQ(0, loc.piece);
EXPECT_EQ(0U, loc.piece);
EXPECT_EQ(PieceSize - 1, loc.piece_offset);
loc = info.pieceLastLoc(info.pieceCount() - 1);
@ -257,34 +257,34 @@ TEST_F(BlockInfoTest, byteLoc)
EXPECT_EQ(tr_block_info::Location{}, loc);
loc = info.byteLoc(1);
EXPECT_EQ(1, loc.byte);
EXPECT_EQ(0, loc.block);
EXPECT_EQ(1, loc.block_offset);
EXPECT_EQ(0, loc.piece);
EXPECT_EQ(1, loc.piece_offset);
EXPECT_EQ(1U, loc.byte);
EXPECT_EQ(0U, loc.block);
EXPECT_EQ(1U, loc.block_offset);
EXPECT_EQ(0U, loc.piece);
EXPECT_EQ(1U, loc.piece_offset);
auto n = ExpectedBlockSize - 1;
loc = info.byteLoc(n);
EXPECT_EQ(n, loc.byte);
EXPECT_EQ(0, loc.block);
EXPECT_EQ(0U, loc.block);
EXPECT_EQ(n, loc.block_offset);
EXPECT_EQ(0, loc.piece);
EXPECT_EQ(0U, loc.piece);
EXPECT_EQ(n, loc.piece_offset);
n = ExpectedBlockSize;
loc = info.byteLoc(n);
EXPECT_EQ(n, loc.byte);
EXPECT_EQ(1, loc.block);
EXPECT_EQ(0, loc.block_offset);
EXPECT_EQ(0, loc.piece);
EXPECT_EQ(1U, loc.block);
EXPECT_EQ(0U, loc.block_offset);
EXPECT_EQ(0U, loc.piece);
EXPECT_EQ(n, loc.piece_offset);
n = ExpectedBlockSize + 1;
loc = info.byteLoc(n);
EXPECT_EQ(n, loc.byte);
EXPECT_EQ(1, loc.block);
EXPECT_EQ(1, loc.block_offset);
EXPECT_EQ(0, loc.piece);
EXPECT_EQ(1U, loc.block);
EXPECT_EQ(1U, loc.block_offset);
EXPECT_EQ(0U, loc.piece);
EXPECT_EQ(n, loc.piece_offset);
n = PieceSize - 1;
@ -292,14 +292,14 @@ TEST_F(BlockInfoTest, byteLoc)
EXPECT_EQ(n, loc.byte);
EXPECT_EQ(ExpectedBlocksPerPiece - 1, loc.block);
EXPECT_EQ(ExpectedBlockSize - 1, loc.block_offset);
EXPECT_EQ(0, loc.piece);
EXPECT_EQ(0U, loc.piece);
EXPECT_EQ(n, loc.piece_offset);
n = PieceSize;
loc = info.byteLoc(n);
EXPECT_EQ(n, loc.byte);
EXPECT_EQ(ExpectedBlocksPerPiece, loc.block);
EXPECT_EQ(0, loc.block_offset);
EXPECT_EQ(1, loc.piece);
EXPECT_EQ(0, loc.piece_offset);
EXPECT_EQ(0U, loc.block_offset);
EXPECT_EQ(1U, loc.piece);
EXPECT_EQ(0U, loc.piece_offset);
}

8
tests/libtransmission/completion-test.cc
View File

@ -370,16 +370,16 @@ TEST_F(CompletionTest, countMissingBytesInPiece)
completion.addBlock(0);
EXPECT_EQ(block_info.pieceSize(0) - tr_block_info::BlockSize, completion.countMissingBytesInPiece(0));
completion.addPiece(0);
EXPECT_EQ(0, completion.countMissingBytesInPiece(0));
EXPECT_EQ(0U, completion.countMissingBytesInPiece(0));
auto const final_piece = block_info.n_pieces - 1;
auto const final_block = block_info.n_blocks - 1;
EXPECT_EQ(block_info.pieceSize(final_piece), completion.countMissingBytesInPiece(final_piece));
completion.addBlock(final_block);
EXPECT_EQ(1, block_info.final_piece_size);
EXPECT_EQ(1, block_info.final_block_size);
EXPECT_EQ(1U, block_info.final_piece_size);
EXPECT_EQ(1U, block_info.final_block_size);
EXPECT_TRUE(completion.hasPiece(final_piece));
EXPECT_EQ(0, completion.countMissingBytesInPiece(final_piece));
EXPECT_EQ(0U, completion.countMissingBytesInPiece(final_piece));
}
TEST_F(CompletionTest, amountDone)

12
tests/libtransmission/file-piece-map-test.cc
View File

@ -63,26 +63,26 @@ TEST_F(FilePieceMapTest, fileOffset)
// first byte of the first file
auto file_offset = fpm.fileOffset(0);
EXPECT_EQ(0, file_offset.index);
EXPECT_EQ(0, file_offset.offset);
EXPECT_EQ(0U, file_offset.index);
EXPECT_EQ(0U, file_offset.offset);
// final byte of the first file
file_offset = fpm.fileOffset(FileSizes[0] - 1);
EXPECT_EQ(0, file_offset.index);
EXPECT_EQ(0U, file_offset.index);
EXPECT_EQ(FileSizes[0] - 1, file_offset.offset);
// first byte of the second file
// NB: this is an edge case, second file is 0 bytes.
// The second nonzero file is file #5
file_offset = fpm.fileOffset(FileSizes[0]);
EXPECT_EQ(5, file_offset.index);
EXPECT_EQ(0, file_offset.offset);
EXPECT_EQ(5U, file_offset.index);
EXPECT_EQ(0U, file_offset.offset);
// the last byte of in the torrent.
// NB: reverse of previous edge case, since
// the final 4 files in the torrent are all 0 bytes
file_offset = fpm.fileOffset(TotalSize - 1);
EXPECT_EQ(12, file_offset.index);
EXPECT_EQ(12U, file_offset.index);
EXPECT_EQ(FileSizes[12] - 1, file_offset.offset);
}

14
tests/libtransmission/history-test.cc
View File

@ -13,12 +13,12 @@ TEST(History, recentHistory)
auto h = tr_recentHistory{};
h.add(10000, 1);
EXPECT_EQ(0, h.count(12000, 1000));
EXPECT_EQ(1, h.count(12000, 3000));
EXPECT_EQ(1, h.count(12000, 5000));
EXPECT_EQ(0U, h.count(12000, 1000));
EXPECT_EQ(1U, h.count(12000, 3000));
EXPECT_EQ(1U, h.count(12000, 5000));
h.add(20000, 1);
EXPECT_EQ(0, h.count(22000, 1000));
EXPECT_EQ(1, h.count(22000, 3000));
EXPECT_EQ(2, h.count(22000, 15000));
EXPECT_EQ(2, h.count(22000, 20000));
EXPECT_EQ(0U, h.count(22000, 1000));
EXPECT_EQ(1U, h.count(22000, 3000));
EXPECT_EQ(2U, h.count(22000, 15000));
EXPECT_EQ(2U, h.count(22000, 20000));
}

2
tests/libtransmission/json-test.cc
View File

@ -163,7 +163,7 @@ TEST_P(JSONTest, test1)
auto* ids = tr_variantDictFind(args, TR_KEY_ids);
EXPECT_NE(nullptr, ids);
EXPECT_TRUE(tr_variantIsList(ids));
EXPECT_EQ(2, tr_variantListSize(ids));
EXPECT_EQ(2U, tr_variantListSize(ids));
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(ids, 0), &i));
EXPECT_EQ(7, i);
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(ids, 1), &i));

12
tests/libtransmission/magnet-metainfo-test.cc
View File

@ -64,16 +64,16 @@ TEST(MagnetMetainfo, magnetParse)
auto mm = tr_magnet_metainfo{};
EXPECT_TRUE(mm.parseMagnet(uri));
EXPECT_EQ(2, std::size(mm.announceList()));
EXPECT_EQ(2U, std::size(mm.announceList()));
auto it = std::begin(mm.announceList());
EXPECT_EQ(0, it->tier);
EXPECT_EQ(0U, it->tier);
EXPECT_EQ("http://tracker.openbittorrent.com/announce"sv, it->announce.full);
EXPECT_EQ("http://tracker.openbittorrent.com/scrape"sv, it->scrape.full);
++it;
EXPECT_EQ(1, it->tier);
EXPECT_EQ(1U, it->tier);
EXPECT_EQ("http://tracker.opentracker.org/announce", it->announce.full);
EXPECT_EQ("http://tracker.opentracker.org/scrape", it->scrape.full);
EXPECT_EQ(1, mm.webseedCount());
EXPECT_EQ(1U, mm.webseedCount());
EXPECT_EQ("http://server.webseed.org/path/to/file"sv, mm.webseed(0));
EXPECT_EQ("Display Name"sv, mm.name());
EXPECT_EQ(ExpectedHash, mm.infoHash());
@ -84,8 +84,8 @@ TEST(MagnetMetainfo, magnetParse)
auto mm = tr_magnet_metainfo{};
EXPECT_TRUE(mm.parseMagnet(uri));
EXPECT_EQ(0, std::size(mm.announceList()));
EXPECT_EQ(0, mm.webseedCount());
EXPECT_EQ(0U, std::size(mm.announceList()));
EXPECT_EQ(0U, mm.webseedCount());
EXPECT_EQ(ExpectedHash, mm.infoHash());
}
}

72
tests/libtransmission/peer-mgr-active-requests-test.cc
View File

@ -65,19 +65,19 @@ TEST_F(PeerMgrActiveRequestsTest, requestsAreRemoved)
auto const when = time_t(0);
EXPECT_TRUE(requests.add(block, peer, when));
EXPECT_EQ(1, requests.count(block));
EXPECT_EQ(1, requests.count(peer));
EXPECT_EQ(1, requests.size());
EXPECT_EQ(1U, requests.count(block));
EXPECT_EQ(1U, requests.count(peer));
EXPECT_EQ(1U, requests.size());
EXPECT_TRUE(requests.remove(block, peer));
EXPECT_EQ(0, requests.count(block));
EXPECT_EQ(0, requests.count(peer));
EXPECT_EQ(0, requests.size());
EXPECT_EQ(0U, requests.count(block));
EXPECT_EQ(0U, requests.count(peer));
EXPECT_EQ(0U, requests.size());
EXPECT_FALSE(requests.remove(block, peer));
EXPECT_EQ(0, requests.count(block));
EXPECT_EQ(0, requests.count(peer));
EXPECT_EQ(0, requests.size());
EXPECT_EQ(0U, requests.count(block));
EXPECT_EQ(0U, requests.count(peer));
EXPECT_EQ(0U, requests.size());
}
TEST_F(PeerMgrActiveRequestsTest, peersAreRemoved)
@ -90,16 +90,16 @@ TEST_F(PeerMgrActiveRequestsTest, peersAreRemoved)
// setup: add a request
EXPECT_TRUE(requests.add(block, peer, when));
EXPECT_EQ(1, requests.count(block));
EXPECT_EQ(1, requests.count(peer));
EXPECT_EQ(1, requests.size());
EXPECT_EQ(1U, requests.count(block));
EXPECT_EQ(1U, requests.count(peer));
EXPECT_EQ(1U, requests.size());
// try removing requests for that block (should remove the 1 active request)
auto const removed = requests.remove(block);
EXPECT_EQ(std::vector<tr_peer*>{ peer }, removed);
EXPECT_EQ(0, requests.count(block));
EXPECT_EQ(0, requests.count(peer));
EXPECT_EQ(0, requests.size());
EXPECT_EQ(0U, requests.count(block));
EXPECT_EQ(0U, requests.count(peer));
EXPECT_EQ(0U, requests.size());
// try removing requests for that block agian (should remove nothing)
EXPECT_EQ(std::vector<tr_peer*>{}, requests.remove(block));
@ -119,9 +119,9 @@ TEST_F(PeerMgrActiveRequestsTest, multiplePeersAreRemoved)
auto const when_c = when_b;
EXPECT_TRUE(requests.add(block_c, peer_c_, when_c));
EXPECT_EQ(block_a, block_b);
EXPECT_EQ(2, requests.count(block_a));
EXPECT_EQ(1, requests.count(block_c));
EXPECT_EQ(3, requests.size());
EXPECT_EQ(2U, requests.count(block_a));
EXPECT_EQ(1U, requests.count(block_c));
EXPECT_EQ(3U, requests.size());
// now remove block_a, which was req'd by peer_a_ and peer_b_
auto expected = std::vector<tr_peer*>{ peer_a_, peer_b_ };
@ -141,11 +141,11 @@ TEST_F(PeerMgrActiveRequestsTest, multipleBlocksAreRemoved)
auto const block_a2 = tr_block_index_t{ 256 };
auto const when_a2 = 400;
EXPECT_TRUE(requests.add(block_a2, peer_a_, when_a2));
EXPECT_EQ(2, requests.size());
EXPECT_EQ(2, requests.count(peer_a_));
EXPECT_EQ(1, requests.count(block_a1));
EXPECT_EQ(0, requests.count(peer_b_));
EXPECT_EQ(0, requests.count(tr_block_index_t{ 512 }));
EXPECT_EQ(2U, requests.size());
EXPECT_EQ(2U, requests.count(peer_a_));
EXPECT_EQ(1U, requests.count(block_a1));
EXPECT_EQ(0U, requests.count(peer_b_));
EXPECT_EQ(0U, requests.count(tr_block_index_t{ 512 }));
// confirm that removing peer_a_ removes all of its requests
auto expected = std::vector<tr_block_index_t>{ block_a1, block_a2 };
@ -153,9 +153,9 @@ TEST_F(PeerMgrActiveRequestsTest, multipleBlocksAreRemoved)
auto removed = requests.remove(peer_a_);
std::sort(std::begin(removed), std::end(removed));
EXPECT_EQ(expected, removed);
EXPECT_EQ(0, requests.size());
EXPECT_EQ(0, requests.count(peer_a_));
EXPECT_EQ(0, requests.count(block_a1));
EXPECT_EQ(0U, requests.size());
EXPECT_EQ(0U, requests.count(peer_a_));
EXPECT_EQ(0U, requests.count(block_a1));
}
TEST_F(PeerMgrActiveRequestsTest, sentBefore)
@ -168,21 +168,21 @@ TEST_F(PeerMgrActiveRequestsTest, sentBefore)
auto const block_a2 = tr_block_index_t{ 256 };
auto const when_a2 = 400;
EXPECT_TRUE(requests.add(block_a2, peer_a_, when_a2));
EXPECT_EQ(2, requests.size());
EXPECT_EQ(2, requests.count(peer_a_));
EXPECT_EQ(1, requests.count(block_a1));
EXPECT_EQ(2U, requests.size());
EXPECT_EQ(2U, requests.count(peer_a_));
EXPECT_EQ(1U, requests.count(block_a1));
// test that the timestamps are counted correctly
EXPECT_EQ(0, std::size(requests.sentBefore(when_a1 - 1)));
EXPECT_EQ(0, std::size(requests.sentBefore(when_a1)));
EXPECT_EQ(1, std::size(requests.sentBefore(when_a1 + 1)));
EXPECT_EQ(1, std::size(requests.sentBefore(when_a2 - 1)));
EXPECT_EQ(1, std::size(requests.sentBefore(when_a2)));
EXPECT_EQ(2, std::size(requests.sentBefore(when_a2 + 1)));
EXPECT_EQ(0U, std::size(requests.sentBefore(when_a1 - 1)));
EXPECT_EQ(0U, std::size(requests.sentBefore(when_a1)));
EXPECT_EQ(1U, std::size(requests.sentBefore(when_a1 + 1)));
EXPECT_EQ(1U, std::size(requests.sentBefore(when_a2 - 1)));
EXPECT_EQ(1U, std::size(requests.sentBefore(when_a2)));
EXPECT_EQ(2U, std::size(requests.sentBefore(when_a2 + 1)));
// test that the returned block + peer pairs are correct
auto items = requests.sentBefore(when_a1 + 1);
ASSERT_EQ(1, std::size(items));
ASSERT_EQ(1U, std::size(items));
EXPECT_EQ(block_a1, items[0].first);
EXPECT_EQ(peer_a_, items[0].second);
}

38
tests/libtransmission/peer-mgr-wishlist-test.cc
View File

@ -92,7 +92,7 @@ TEST_F(PeerMgrWishlistTest, doesNotRequestPiecesThatCannotBeRequested)
// we should only get the first piece back
auto spans = Wishlist::next(mediator, 1000);
ASSERT_EQ(1, std::size(spans));
ASSERT_EQ(1U, std::size(spans));
EXPECT_EQ(mediator.block_span_[0].begin, spans[0].begin);
EXPECT_EQ(mediator.block_span_[0].end, spans[0].end);
}
@ -130,9 +130,9 @@ TEST_F(PeerMgrWishlistTest, doesNotRequestBlocksThatCannotBeRequested)
{
requested.setSpan(span.begin, span.end);
}
EXPECT_EQ(240, requested.count());
EXPECT_EQ(0, requested.count(0, 10));
EXPECT_EQ(240, requested.count(10, 250));
EXPECT_EQ(240U, requested.count());
EXPECT_EQ(0U, requested.count(0, 10));
EXPECT_EQ(240U, requested.count(10, 250));
}
TEST_F(PeerMgrWishlistTest, doesNotRequestTooManyBlocks)
@ -160,7 +160,7 @@ TEST_F(PeerMgrWishlistTest, doesNotRequestTooManyBlocks)
// but we only ask for 10 blocks,
// so that's how many we should get back
auto const n_wanted = 10;
auto const n_wanted = 10U;
auto const spans = Wishlist::next(mediator, n_wanted);
auto n_got = size_t{};
for (auto const& span : spans)
@ -204,7 +204,7 @@ TEST_F(PeerMgrWishlistTest, prefersHighPriorityPieces)
auto const num_runs = 1000;
for (int run = 0; run < num_runs; ++run)
{
auto const n_wanted = 10;
auto const n_wanted = 10U;
auto spans = Wishlist::next(mediator, n_wanted);
auto n_got = size_t{};
for (auto const& span : spans)
@ -257,9 +257,9 @@ TEST_F(PeerMgrWishlistTest, onlyRequestsDupesDuringEndgame)
{
requested.setSpan(span.begin, span.end);
}
EXPECT_EQ(150, requested.count());
EXPECT_EQ(0, requested.count(0, 150));
EXPECT_EQ(150, requested.count(150, 300));
EXPECT_EQ(150U, requested.count());
EXPECT_EQ(0U, requested.count(0, 150));
EXPECT_EQ(150U, requested.count(150, 300));
// BUT during endgame it's OK to request dupes,
// so then we _should_ see the first 150 in the list
@ -270,9 +270,9 @@ TEST_F(PeerMgrWishlistTest, onlyRequestsDupesDuringEndgame)
{
requested.setSpan(span.begin, span.end);
}
EXPECT_EQ(300, requested.count());
EXPECT_EQ(150, requested.count(0, 150));
EXPECT_EQ(150, requested.count(150, 300));
EXPECT_EQ(300U, requested.count());
EXPECT_EQ(150U, requested.count(0, 150));
EXPECT_EQ(150U, requested.count(150, 300));
}
TEST_F(PeerMgrWishlistTest, prefersNearlyCompletePieces)
@ -320,9 +320,9 @@ TEST_F(PeerMgrWishlistTest, prefersNearlyCompletePieces)
{
requested.setSpan(range.begin, range.end);
}
EXPECT_EQ(10, requested.count());
EXPECT_EQ(10, requested.count(0, 100));
EXPECT_EQ(0, requested.count(100, 300));
EXPECT_EQ(10U, requested.count());
EXPECT_EQ(10U, requested.count(0, 100));
EXPECT_EQ(0U, requested.count(100, 300));
}
// Same premise as previous test, but ask for more blocks.
@ -336,9 +336,9 @@ TEST_F(PeerMgrWishlistTest, prefersNearlyCompletePieces)
{
requested.setSpan(range.begin, range.end);
}
EXPECT_EQ(20, requested.count());
EXPECT_EQ(10, requested.count(0, 100));
EXPECT_EQ(10, requested.count(100, 200));
EXPECT_EQ(0, requested.count(200, 300));
EXPECT_EQ(20U, requested.count());
EXPECT_EQ(10U, requested.count(0, 100));
EXPECT_EQ(10U, requested.count(100, 200));
EXPECT_EQ(0U, requested.count(200, 300));
}
}

2
tests/libtransmission/rename-test.cc
View File

@ -71,7 +71,7 @@ protected:
{
// create the torrent ctor
auto const benc = tr_base64_decode(benc_base64);
EXPECT_LT(0, std::size(benc));
EXPECT_LT(0U, std::size(benc));
tr_error* error = nullptr;
EXPECT_TRUE(tr_ctorSetMetainfo(ctor, std::data(benc), std::size(benc), &error));
EXPECT_EQ(nullptr, error) << *error;

4
tests/libtransmission/rpc-test.cc
View File

@ -40,7 +40,7 @@ TEST_F(RpcTest, list)
tr_rpc_parse_list_str(&top, "6,7"sv);
EXPECT_TRUE(tr_variantIsList(&top));
EXPECT_EQ(2, tr_variantListSize(&top));
EXPECT_EQ(2U, tr_variantListSize(&top));
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(&top, 0), &i));
EXPECT_EQ(6, i);
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(&top, 1), &i));
@ -55,7 +55,7 @@ TEST_F(RpcTest, list)
tr_rpc_parse_list_str(&top, "1,3-5"sv);
EXPECT_TRUE(tr_variantIsList(&top));
EXPECT_EQ(4, tr_variantListSize(&top));
EXPECT_EQ(4U, tr_variantListSize(&top));
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(&top, 0), &i));
EXPECT_EQ(1, i);
EXPECT_TRUE(tr_variantGetInt(tr_variantListChild(&top, 1), &i));

8
tests/libtransmission/session-test.cc
View File

@ -229,7 +229,7 @@ TEST_F(SessionTest, sessionId)
auto const* session_id_str_1 = tr_session_id_get_current(session_id);
EXPECT_NE(nullptr, session_id_str_1);
EXPECT_EQ(48, strlen(session_id_str_1));
EXPECT_EQ(48U, strlen(session_id_str_1));
session_id_str_1 = tr_strdup(session_id_str_1);
EXPECT_TRUE(tr_session_id_is_local(session_id_str_1));
@ -240,7 +240,7 @@ TEST_F(SessionTest, sessionId)
auto const* session_id_str_2 = tr_session_id_get_current(session_id);
EXPECT_NE(nullptr, session_id_str_2);
EXPECT_EQ(48, strlen(session_id_str_2));
EXPECT_EQ(48U, strlen(session_id_str_2));
EXPECT_STREQ(session_id_str_1, session_id_str_2);
tr_timeUpdate(60 * 60);
@ -249,7 +249,7 @@ TEST_F(SessionTest, sessionId)
session_id_str_2 = tr_session_id_get_current(session_id);
EXPECT_NE(nullptr, session_id_str_2);
EXPECT_EQ(48, strlen(session_id_str_2));
EXPECT_EQ(48U, strlen(session_id_str_2));
EXPECT_STRNE(session_id_str_1, session_id_str_2);
session_id_str_2 = tr_strdup(session_id_str_2);
@ -263,7 +263,7 @@ TEST_F(SessionTest, sessionId)
auto const* session_id_str_3 = tr_session_id_get_current(session_id);
EXPECT_NE(nullptr, session_id_str_3);
EXPECT_EQ(48, strlen(session_id_str_3));
EXPECT_EQ(48U, strlen(session_id_str_3));
EXPECT_STRNE(session_id_str_2, session_id_str_3);
EXPECT_STRNE(session_id_str_1, session_id_str_3);
session_id_str_3 = tr_strdup(session_id_str_3);

6
tests/libtransmission/strbuf-test.cc
View File

@ -63,7 +63,7 @@ TEST_F(StrbufTest, clear)
TEST_F(StrbufTest, constructorDefault)
{
auto buf = tr_pathbuf{};
EXPECT_EQ(0, std::size(buf));
EXPECT_EQ(0U, std::size(buf));
EXPECT_TRUE(std::empty(buf));
}
@ -123,7 +123,7 @@ TEST_F(StrbufTest, iterators)
auto begin = std::begin(buf);
auto end = std::end(buf);
EXPECT_EQ(Value.front(), *begin);
EXPECT_EQ(std::size(Value), std::distance(begin, end));
EXPECT_EQ(std::size(Value), static_cast<size_t>(std::distance(begin, end)));
}
// const
@ -132,7 +132,7 @@ TEST_F(StrbufTest, iterators)
auto const begin = std::begin(buf);
auto const end = std::end(buf);
EXPECT_EQ(Value.front(), *begin);
EXPECT_EQ(std::size(Value), std::distance(begin, end));
EXPECT_EQ(std::size(Value), static_cast<size_t>(std::distance(begin, end)));
}
}

8
tests/libtransmission/test-fixtures.h
View File

@ -386,7 +386,7 @@ protected:
// create the torrent ctor
auto const benc = tr_base64_decode(benc_base64);
EXPECT_LT(0, std::size(benc));
EXPECT_LT(0U, std::size(benc));
auto* ctor = tr_ctorNew(session_);
tr_error* error = nullptr;
EXPECT_TRUE(tr_ctorSetMetainfo(ctor, std::data(benc), std::size(benc), &error));
@ -397,12 +397,12 @@ protected:
if (state != ZeroTorrentState::NoFiles)
{
auto const* const metainfo = tr_ctorGetMetainfo(ctor);
for (size_t i = 0, n = metainfo->fileCount(); i < n; ++i)
for (tr_file_index_t i = 0, n = metainfo->fileCount(); i < n; ++i)
{
auto const base = state == ZeroTorrentState::Partial && tr_sessionIsIncompleteDirEnabled(session_) ?
tr_sessionGetIncompleteDir(session_) :
tr_sessionGetDownloadDir(session_);
auto const subpath = metainfo->fileSubpath(i);
auto const& subpath = metainfo->fileSubpath(i);
auto const partial = state == ZeroTorrentState::Partial && i == 0;
auto const suffix = std::string_view{ partial ? ".part" : "" };
auto const filename = tr_pathbuf{ base, '/', subpath, suffix };
@ -446,7 +446,7 @@ protected:
4000));
}
void blockingTorrentVerify(tr_torrent* tor)
void blockingTorrentVerify(tr_torrent* tor) const
{
EXPECT_NE(nullptr, tor->session);
EXPECT_FALSE(tr_amInEventThread(tor->session));

4
tests/libtransmission/torrent-metainfo-test.cc
View File

@ -40,8 +40,8 @@ TEST_F(TorrentMetainfoTest, magnetLink)
auto metainfo = tr_torrent_metainfo{};
EXPECT_TRUE(metainfo.parseMagnet(MagnetLink));
EXPECT_EQ(0, metainfo.fileCount()); // because it's a magnet link
EXPECT_EQ(2, std::size(metainfo.announceList()));
EXPECT_EQ(0U, metainfo.fileCount()); // because it's a magnet link
EXPECT_EQ(2U, std::size(metainfo.announceList()));
EXPECT_EQ(MagnetLink, metainfo.magnet().sv());
}

2
tests/libtransmission/utils-test.cc
View File

@ -357,7 +357,7 @@ TEST_F(UtilsTest, trStrlcpy)
ASSERT_EQ(responce, length);
// Check what was copied
for (auto i = 0; i < 97; i++)
for (unsigned i = 0U; i < 97U; ++i)
{
if (i <= length)
{

34
utils/remote.cc
View File

@ -2943,22 +2943,20 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv)
}
case 'S': /* stop */
if (tadd != nullptr)
{
if (tadd != nullptr)
{
tr_variantDictAddBool(tr_variantDictFind(tadd, TR_KEY_arguments), TR_KEY_paused, true);
}
else
{
auto* top = tr_new0(tr_variant, 1);
tr_variantInitDict(top, 2);
tr_variantDictAddStrView(top, TR_KEY_method, "torrent-stop"sv);
addIdArg(tr_variantDictAddDict(top, Arguments, 1), id, nullptr);
status |= flush(rpcurl, &top);
}
break;
tr_variantDictAddBool(tr_variantDictFind(tadd, TR_KEY_arguments), TR_KEY_paused, true);
}
else
{
auto* top = tr_new0(tr_variant, 1);
tr_variantInitDict(top, 2);
tr_variantDictAddStrView(top, TR_KEY_method, "torrent-stop"sv);
addIdArg(tr_variantDictAddDict(top, Arguments, 1), id, nullptr);
status |= flush(rpcurl, &top);
}
break;
case 'w':
{
@ -3074,11 +3072,9 @@ static int processArgs(char const* rpcurl, int argc, char const* const* argv)
}
default:
{
fprintf(stderr, "got opt [%d]\n", c);
showUsage();
break;
}
fprintf(stderr, "got opt [%d]\n", c);
showUsage();
break;
}
}
}

12
utils/show.cc
View File

@ -313,12 +313,12 @@ size_t writeFunc(void* ptr, size_t size, size_t nmemb, void* vbuf)
CURL* tr_curl_easy_init(struct evbuffer* writebuf)
{
CURL* curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_USERAGENT, UserAgent);
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeFunc);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, writebuf);
curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
curl_easy_setopt(curl, CURLOPT_VERBOSE, tr_env_key_exists("TR_CURL_VERBOSE"));
curl_easy_setopt(curl, CURLOPT_ENCODING, "");
(void)curl_easy_setopt(curl, CURLOPT_USERAGENT, UserAgent);
(void)curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, writeFunc);
(void)curl_easy_setopt(curl, CURLOPT_WRITEDATA, writebuf);
(void)curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
(void)curl_easy_setopt(curl, CURLOPT_VERBOSE, tr_env_key_exists("TR_CURL_VERBOSE"));
(void)curl_easy_setopt(curl, CURLOPT_ENCODING, "");
return curl;
}