mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity
transmission/tests/libtransmission/completion-test.cc

508 lines
19 KiB
C++
Raw Blame History

// This file Copyright (C) 2021-2022 Mnemosyne LLC.
// It may be used under GPLv2 (SPDX: GPL-2.0-only), GPLv3 (SPDX: GPL-3.0-only),
// or any future license endorsed by Mnemosyne LLC.
// License text can be found in the licenses/ folder.
#include <algorithm>
#include <array>
#include <cstdint>
#include <set>
#include "transmission.h"
#include "block-info.h"
#include "crypto-utils.h" // tr_rand_buffer()
#include "completion.h"
#include "gtest/gtest.h"
using CompletionTest = ::testing::Test;
namespace
{
struct TestTorrent : public tr_completion::torrent_view
{
std::set<tr_piece_index_t> dnd_pieces;
[[nodiscard]] bool pieceIsWanted(tr_piece_index_t piece) const final
{
return dnd_pieces.count(piece) == 0;
}
};
auto constexpr BlockSize = uint64_t{ 16 } * 1024U;
} // namespace
TEST_F(CompletionTest, MagnetLink)
{
auto torrent = TestTorrent{};
auto block_info = tr_block_info{};
auto completion = tr_completion(&torrent, &block_info);
EXPECT_FALSE(completion.hasAll());
EXPECT_TRUE(completion.hasNone());
EXPECT_FALSE(completion.hasBlocks({ 0, 1 }));
EXPECT_FALSE(completion.hasBlocks({ 0, 1000 }));
EXPECT_FALSE(completion.hasPiece(0));
EXPECT_DOUBLE_EQ(0.0, completion.percentDone());
EXPECT_DOUBLE_EQ(0.0, completion.percentComplete());
EXPECT_EQ(TR_LEECH, completion.status());
EXPECT_EQ(0, completion.hasTotal());
EXPECT_EQ(0, completion.hasValid());
EXPECT_EQ(0, completion.leftUntilDone());
EXPECT_EQ(0, completion.sizeWhenDone());
}
TEST_F(CompletionTest, setBlocks)
{
auto constexpr TotalSize = uint64_t{ BlockSize * 64 * 50000 }; // 50GB
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto torrent = TestTorrent{};
auto const block_info = tr_block_info{ TotalSize, PieceSize };
auto completion = tr_completion(&torrent, &block_info);
EXPECT_FALSE(completion.blocks().hasAll());
EXPECT_FALSE(completion.hasAll());
EXPECT_EQ(0, completion.hasTotal());
auto bitfield = tr_bitfield{ block_info.blockCount() };
bitfield.setHasAll();
// test that the bitfield did get replaced
completion.setBlocks(bitfield);
EXPECT_TRUE(completion.blocks().hasAll());
EXPECT_TRUE(completion.hasAll());
EXPECT_EQ(block_info.totalSize(), completion.hasTotal());
}
TEST_F(CompletionTest, hasBlock)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 };
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
auto completion = tr_completion(&torrent, &block_info);
EXPECT_FALSE(completion.hasBlock(0));
EXPECT_FALSE(completion.hasBlock(1));
completion.addBlock(0);
EXPECT_TRUE(completion.hasBlock(0));
EXPECT_FALSE(completion.hasBlock(1));
completion.addPiece(0);
EXPECT_TRUE(completion.hasBlock(0));
EXPECT_TRUE(completion.hasBlock(1));
}
TEST_F(CompletionTest, hasBlocks)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 };
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
auto completion = tr_completion(&torrent, &block_info);
EXPECT_FALSE(completion.hasBlocks({ 0, 1 }));
EXPECT_FALSE(completion.hasBlocks({ 0, 2 }));
completion.addBlock(0);
EXPECT_TRUE(completion.hasBlocks({ 0, 1 }));
EXPECT_FALSE(completion.hasBlocks({ 0, 2 }));
}
TEST_F(CompletionTest, hasNone)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 };
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
auto completion = tr_completion(&torrent, &block_info);
EXPECT_TRUE(completion.hasNone());
completion.addBlock(0);
EXPECT_FALSE(completion.hasNone());
}
TEST_F(CompletionTest, hasPiece)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 };
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
// check that the initial state does not have it
auto completion = tr_completion(&torrent, &block_info);
EXPECT_FALSE(completion.hasPiece(0));
EXPECT_FALSE(completion.hasPiece(1));
EXPECT_EQ(0, completion.hasValid());
// check that adding a piece means we have it
completion.addPiece(0);
EXPECT_TRUE(completion.hasPiece(0));
EXPECT_FALSE(completion.hasPiece(1));
EXPECT_EQ(PieceSize, completion.hasValid());
// check that removing a piece means we don't have it
completion.removePiece(0);
EXPECT_FALSE(completion.hasPiece(0));
EXPECT_FALSE(completion.hasPiece(1));
EXPECT_EQ(0, completion.hasValid());
// check that adding all the blocks in a piece means we have it
for (tr_block_index_t i = 1, n = block_info.pieceLoc(1).block; i < n; ++i)
{
completion.addBlock(i);
}
EXPECT_FALSE(completion.hasPiece(0));
EXPECT_EQ(0, completion.hasValid());
completion.addBlock(0);
EXPECT_TRUE(completion.hasPiece(0));
EXPECT_EQ(PieceSize, completion.hasValid());
}
TEST_F(CompletionTest, percentCompleteAndDone)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 };
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
// check that in blank-slate initial state, isDone() is false
auto completion = tr_completion(&torrent, &block_info);
EXPECT_DOUBLE_EQ(0.0, completion.percentComplete());
EXPECT_DOUBLE_EQ(0.0, completion.percentDone());
// add half the pieces
for (size_t i = 0; i < 32; ++i)
{
completion.addPiece(i);
}
EXPECT_DOUBLE_EQ(0.5, completion.percentComplete());
EXPECT_DOUBLE_EQ(0.5, completion.percentDone());
// but marking some of the pieces we have as unwanted
// should not change percentDone
for (size_t i = 0; i < 16; ++i)
{
torrent.dnd_pieces.insert(i);
}
completion.invalidateSizeWhenDone();
EXPECT_DOUBLE_EQ(0.5, completion.percentComplete());
EXPECT_DOUBLE_EQ(0.5, completion.percentDone());
// but marking some of the pieces we DON'T have as unwanted
// SHOULD change percentDone
for (size_t i = 32; i < 48; ++i)
{
torrent.dnd_pieces.insert(i);
}
completion.invalidateSizeWhenDone();
EXPECT_DOUBLE_EQ(0.5, completion.percentComplete());
EXPECT_DOUBLE_EQ(2.0 / 3.0, completion.percentDone());
}
TEST_F(CompletionTest, hasTotalAndValid)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 } + 1;
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
// check that the initial blank-slate state has nothing
auto completion = tr_completion(&torrent, &block_info);
EXPECT_EQ(0, completion.hasTotal());
EXPECT_EQ(completion.hasValid(), completion.hasTotal());
// check that adding the final piece adjusts by block_info.final_piece_size
completion.setHasPiece(block_info.pieceCount() - 1, true);
EXPECT_EQ(block_info.pieceSize(block_info.pieceCount() - 1), completion.hasTotal());
EXPECT_EQ(completion.hasValid(), completion.hasTotal());
// check that adding a non-final piece adjusts by block_info.pieceSize()
completion.setHasPiece(0, true);
EXPECT_EQ(block_info.pieceSize(block_info.pieceCount() - 1) + block_info.pieceSize(), completion.hasTotal());
EXPECT_EQ(completion.hasValid(), completion.hasTotal());
// check that removing the final piece adjusts by block_info.final_piece_size
completion.setHasPiece(block_info.pieceCount() - 1, false);
EXPECT_EQ(block_info.pieceSize(), completion.hasValid());
EXPECT_EQ(completion.hasValid(), completion.hasTotal());
// check that removing a non-final piece adjusts by block_info.pieceSize()
completion.setHasPiece(0, false);
EXPECT_EQ(0, completion.hasValid());
EXPECT_EQ(completion.hasValid(), completion.hasTotal());
// check that adding an incomplete piece adjusts hasTotal but not hasValid
completion.addBlock(0);
EXPECT_EQ(0, completion.hasValid());
EXPECT_EQ(BlockSize, completion.hasTotal());
}
TEST_F(CompletionTest, leftUntilDone)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 } + 1;
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
// check that the initial blank-slate state has nothing
auto completion = tr_completion(&torrent, &block_info);
EXPECT_EQ(block_info.totalSize(), completion.leftUntilDone());
// check that adding the final piece adjusts by block_info.final_piece_size
completion.addPiece(block_info.pieceCount() - 1);
EXPECT_EQ(block_info.totalSize() - block_info.pieceSize(block_info.pieceCount() - 1), completion.leftUntilDone());
// check that adding a non-final piece adjusts by block_info.pieceSize()
completion.addPiece(0);
EXPECT_EQ(
block_info.totalSize() - block_info.pieceSize(block_info.pieceCount() - 1) - block_info.pieceSize(),
completion.leftUntilDone());
// check that removing the final piece adjusts by block_info.final_piece_size
completion.removePiece(block_info.pieceCount() - 1);
EXPECT_EQ(block_info.totalSize() - block_info.pieceSize(), completion.leftUntilDone());
// check that dnd-flagging a piece we already have affects nothing
torrent.dnd_pieces.insert(0);
completion.invalidateSizeWhenDone();
EXPECT_EQ(block_info.totalSize() - block_info.pieceSize(), completion.leftUntilDone());
torrent.dnd_pieces.clear();
completion.invalidateSizeWhenDone();
// check that dnd-flagging a piece we DON'T already have adjusts by block_info.pieceSize()
torrent.dnd_pieces.insert(1);
completion.invalidateSizeWhenDone();
EXPECT_EQ(block_info.totalSize() - block_info.pieceSize() * uint64_t{ 2U }, completion.leftUntilDone());
torrent.dnd_pieces.clear();
completion.invalidateSizeWhenDone();
// check that removing a non-final piece adjusts by block_info.pieceSize()
completion.removePiece(0);
EXPECT_EQ(block_info.totalSize(), completion.leftUntilDone());
// check that adding a block adjusts by block_info.block_size
completion.addBlock(0);
EXPECT_EQ(block_info.totalSize() - tr_block_info::BlockSize, completion.leftUntilDone());
}
TEST_F(CompletionTest, sizeWhenDone)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 64 * 50000 }; // 50GB
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
// check that adding or removing blocks or pieces does not affect sizeWhenDone
auto completion = tr_completion(&torrent, &block_info);
EXPECT_EQ(block_info.totalSize(), completion.sizeWhenDone());
completion.addBlock(0);
EXPECT_EQ(block_info.totalSize(), completion.sizeWhenDone());
completion.addPiece(0);
EXPECT_EQ(block_info.totalSize(), completion.sizeWhenDone());
completion.removePiece(0);
EXPECT_EQ(block_info.totalSize(), completion.sizeWhenDone());
// check that flagging complete pieces as dnd does not affect sizeWhenDone
for (size_t i = 0; i < 32; ++i)
{
completion.addPiece(i);
torrent.dnd_pieces.insert(i);
}
completion.invalidateSizeWhenDone();
EXPECT_EQ(block_info.totalSize(), completion.sizeWhenDone());
// check that flagging missing pieces as dnd does not affect sizeWhenDone
for (size_t i = 32; i < 48; ++i)
{
torrent.dnd_pieces.insert(i);
}
completion.invalidateSizeWhenDone();
EXPECT_EQ(block_info.totalSize() - uint64_t{ 16U } * block_info.pieceSize(), completion.sizeWhenDone());
}
TEST_F(CompletionTest, createPieceBitfield)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 } + 1;
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
// make a completion object that has a random assortment of pieces
auto completion = tr_completion(&torrent, &block_info);
auto buf = std::array<char, 65>{};
ASSERT_EQ(std::size(buf), block_info.pieceCount());
EXPECT_TRUE(tr_rand_buffer(std::data(buf), std::size(buf)));
for (uint64_t i = 0; i < block_info.pieceCount(); ++i)
{
if ((buf[i] % 2) != 0)
{
completion.addPiece(i);
}
}
// serialize it to a raw bitfield, read it back into a bitfield,
// and test that the new bitfield matches
auto const pieces_raw_bitfield = completion.createPieceBitfield();
tr_bitfield pieces{ size_t{ block_info.pieceCount() } };
pieces.setRaw(std::data(pieces_raw_bitfield), std::size(pieces_raw_bitfield));
for (uint64_t i = 0; i < block_info.pieceCount(); ++i)
{
EXPECT_EQ(completion.hasPiece(i), pieces.test(i));
}
}
TEST_F(CompletionTest, setHasPiece)
{
}
TEST_F(CompletionTest, countMissingBytesInPiece)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 } + 1;
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
auto completion = tr_completion(&torrent, &block_info);
EXPECT_EQ(block_info.pieceSize(0), completion.countMissingBytesInPiece(0));
completion.addBlock(0);
EXPECT_EQ(block_info.pieceSize(0) - tr_block_info::BlockSize, completion.countMissingBytesInPiece(0));
completion.addPiece(0);
EXPECT_EQ(0U, completion.countMissingBytesInPiece(0));
auto const final_piece = block_info.pieceCount() - 1;
auto const final_block = block_info.blockCount() - 1;
EXPECT_EQ(block_info.pieceSize(final_piece), completion.countMissingBytesInPiece(final_piece));
completion.addBlock(final_block);
EXPECT_EQ(1U, block_info.pieceSize(block_info.pieceCount() - 1));
EXPECT_TRUE(completion.hasPiece(final_piece));
EXPECT_EQ(0U, completion.countMissingBytesInPiece(final_piece));
}
TEST_F(CompletionTest, amountDone)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 } + 1;
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
auto completion = tr_completion(&torrent, &block_info);
// make bins s.t. each bin is a single piece
auto bins = std::array<float, TotalSize / PieceSize>{};
for (tr_piece_index_t piece = 0; piece < block_info.pieceCount(); ++piece)
{
completion.removePiece(piece);
}
completion.amountDone(std::data(bins), std::size(bins));
std::for_each(std::begin(bins), std::end(bins), [](float bin) { EXPECT_DOUBLE_EQ(0.0, bin); });
// one block
completion.addBlock(0);
completion.amountDone(std::data(bins), std::size(bins));
EXPECT_DOUBLE_EQ(0.0, bins[1]);
// one piece
completion.addPiece(0);
completion.amountDone(std::data(bins), std::size(bins));
EXPECT_DOUBLE_EQ(1.0, bins[0]);
EXPECT_DOUBLE_EQ(0.0, bins[1]);
// all pieces
for (tr_piece_index_t piece = 0; piece < block_info.pieceCount(); ++piece)
{
completion.addPiece(piece);
}
completion.amountDone(std::data(bins), std::size(bins));
std::for_each(std::begin(bins), std::end(bins), [](float bin) { EXPECT_DOUBLE_EQ(1.0, bin); });
// don't do anything if fed bad input
auto const backup = bins;
completion.amountDone(std::data(bins), 0);
EXPECT_EQ(backup, bins);
}
TEST_F(CompletionTest, countHasBytesInSpan)
{
// set up a fake torrent
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 } + 1;
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
auto completion = tr_completion(&torrent, &block_info);
// torrent is complete
auto blocks = tr_bitfield{ block_info.blockCount() };
blocks.setHasAll();
completion.setBlocks(blocks);
EXPECT_EQ(TotalSize, completion.countHasBytesInSpan({ 0, TotalSize }));
EXPECT_EQ(TotalSize, completion.countHasBytesInSpan({ 0, TotalSize + 1 }));
// test span that's entirely in a single block
EXPECT_EQ(1, completion.countHasBytesInSpan({ 16, 17 }));
EXPECT_EQ(16, completion.countHasBytesInSpan({ 16, 32 }));
// test edge cases on block boundary
EXPECT_EQ(1, completion.countHasBytesInSpan({ BlockSize - 1, BlockSize }));
EXPECT_EQ(1, completion.countHasBytesInSpan({ BlockSize, BlockSize + 1 }));
EXPECT_EQ(2, completion.countHasBytesInSpan({ BlockSize - 1, BlockSize + 1 }));
// test edge cases on piece boundary
EXPECT_EQ(1, completion.countHasBytesInSpan({ PieceSize - 1, PieceSize }));
EXPECT_EQ(1, completion.countHasBytesInSpan({ PieceSize, PieceSize + 1 }));
EXPECT_EQ(2, completion.countHasBytesInSpan({ PieceSize - 1, PieceSize + 1 }));
// test span that has a middle block
EXPECT_EQ(BlockSize * 3, completion.countHasBytesInSpan({ 0, BlockSize * 3 }));
EXPECT_EQ(BlockSize * 2, completion.countHasBytesInSpan({ BlockSize / 2, BlockSize * 2 + BlockSize / 2 }));
// test span where first block is missing
blocks.unset(0);
completion.setBlocks(blocks);
EXPECT_EQ(BlockSize * 2, completion.countHasBytesInSpan({ 0, BlockSize * 3 }));
EXPECT_EQ(BlockSize * 1.5, completion.countHasBytesInSpan({ BlockSize / 2, BlockSize * 2 + BlockSize / 2 }));
// test span where final block is missing
blocks.setHasAll();
blocks.unset(2);
completion.setBlocks(blocks);
EXPECT_EQ(BlockSize * 2, completion.countHasBytesInSpan({ 0, BlockSize * 3 }));
EXPECT_EQ(BlockSize * 1.5, completion.countHasBytesInSpan({ BlockSize / 2, BlockSize * 2 + BlockSize / 2 }));
}
TEST_F(CompletionTest, wantNone)
{
auto torrent = TestTorrent{};
auto constexpr TotalSize = uint64_t{ BlockSize * 4096 };
auto constexpr PieceSize = uint64_t{ BlockSize * 64 };
auto const block_info = tr_block_info{ TotalSize, PieceSize };
auto completion = tr_completion(&torrent, &block_info);
// we have some data
completion.addBlock(0);
// and want nothing
for (tr_piece_index_t i = 0, n = block_info.blockCount(); i < n; ++i)
{
torrent.dnd_pieces.insert(i);
}
completion.invalidateSizeWhenDone();
EXPECT_LE(completion.hasTotal(), completion.sizeWhenDone());
EXPECT_EQ(completion.hasTotal(), block_info.BlockSize);
EXPECT_EQ(completion.sizeWhenDone(), block_info.BlockSize);
EXPECT_LE(completion.leftUntilDone(), completion.sizeWhenDone());
EXPECT_EQ(completion.leftUntilDone(), 0);
// but we magically get a block anyway
completion.addBlock(1);
EXPECT_LE(completion.hasTotal(), completion.sizeWhenDone());
EXPECT_EQ(completion.hasTotal(), 2 * block_info.BlockSize);
EXPECT_EQ(completion.sizeWhenDone(), 2 * block_info.BlockSize);
EXPECT_LE(completion.leftUntilDone(), completion.sizeWhenDone());
EXPECT_EQ(completion.leftUntilDone(), 0);
}
Reference in New Issue View Git Blame Copy Permalink