Mirrored_Repos/LookingGlass
1
0
Fork 0
mirror of https://github.com/gnif/LookingGlass.git synced 2026-08-22 07:01:30 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[client] cosmetics/naming cleanup

Browse Source
This commit is contained in:
Geoffrey McRae
2026-08-15 01:34:40 +10:00
parent c11842a43c
commit 97b249b49b
18 changed files with 630 additions and 633 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
client/tests/clipboard_files_stub.c
View File

@@ -20,97 +20,97 @@
#include "core/clipboard_files.h"
unsigned lgClipboardFilesStubRemoteOfferCount;
unsigned lgClipboardFilesStubRemoteClearCount;
uint64_t lgClipboardFilesStubRemoteDataset;
bool lgClipboardFilesStubRemoteReady;
bool lgClipboardFilesStubRemoteOfferResult = true;
unsigned clipboardFilesStubRemoteOfferCount;
unsigned clipboardFilesStubRemoteClearCount;
uint64_t clipboardFilesStubRemoteDataset;
bool clipboardFilesStubRemoteReady;
bool clipboardFilesStubRemoteOfferResult = true;
bool lgClipboardFiles_init(void) { return true; }
void lgClipboardFiles_free(void) {}
bool lgClipboardFiles_setLocal(const char * mime,
bool clipboardFiles_init(void) { return true; }
void clipboardFiles_free(void) {}
bool clipboardFiles_setLocal(const char * mime,
const void * data, size_t size)
{
(void)mime; (void)data; (void)size; return false;
}
void lgClipboardFiles_clearLocal(void) {}
bool lgClipboardFiles_getRemote(const char * mime, char ** data, size_t * size)
void clipboardFiles_clearLocal(void) {}
bool clipboardFiles_getRemote(const char * mime, char ** data, size_t * size)
{
(void)mime; (void)data; (void)size; return false;
}
uint64_t lgClipboardFiles_remotePresentationAcquire(void) { return 0; }
bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
uint64_t clipboardFiles_remotePresentationAcquire(void) { return 0; }
bool clipboardFiles_getRemotePresentation(uint64_t presentation,
const char * mime, char ** data, size_t * size)
{
(void)presentation; (void)mime; (void)data; (void)size; return false;
}
void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
void clipboardFiles_remotePresentationDelivered(uint64_t presentation)
{
(void)presentation;
}
void lgClipboardFiles_remotePresentationRelease(uint64_t presentation)
void clipboardFiles_remotePresentationRelease(uint64_t presentation)
{
(void)presentation;
}
bool lgClipboardFiles_remoteReady(uint64_t dataset)
bool clipboardFiles_remoteReady(uint64_t dataset)
{
return lgClipboardFilesStubRemoteReady &&
dataset == lgClipboardFilesStubRemoteDataset;
return clipboardFilesStubRemoteReady &&
dataset == clipboardFilesStubRemoteDataset;
}
bool lgClipboardFiles_remoteOffer(uint64_t dataset)
bool clipboardFiles_remoteOffer(uint64_t dataset)
{
++lgClipboardFilesStubRemoteOfferCount;
lgClipboardFilesStubRemoteDataset = dataset;
return lgClipboardFilesStubRemoteOfferResult;
++clipboardFilesStubRemoteOfferCount;
clipboardFilesStubRemoteDataset = dataset;
return clipboardFilesStubRemoteOfferResult;
}
void lgClipboardFiles_remoteClear(void)
void clipboardFiles_remoteClear(void)
{
++lgClipboardFilesStubRemoteClearCount;
lgClipboardFilesStubRemoteDataset = 0;
++clipboardFilesStubRemoteClearCount;
clipboardFilesStubRemoteDataset = 0;
}
void lgClipboardFiles_providerUnavailable(void) {}
void lgClipboardFiles_remoteAcquired(uint64_t dataset,
void clipboardFiles_providerUnavailable(void) {}
void clipboardFiles_remoteAcquired(uint64_t dataset,
uint64_t acquisition, LG_ClipboardFileError error)
{
(void)dataset; (void)acquisition; (void)error;
}
LG_ClipboardResult lgClipboardFiles_remoteDataBegin(
LG_ClipboardResult clipboardFiles_remoteDataBegin(
const LG_ClipboardFileRequest * request, uint64_t sizeHint)
{
(void)request; (void)sizeHint; return LG_CLIPBOARD_RESULT_FAILED;
}
LG_ClipboardResult lgClipboardFiles_remoteDataChunk(
LG_ClipboardResult clipboardFiles_remoteDataChunk(
const LG_ClipboardFileRequest * request, uint64_t offset,
const void * data, size_t size)
{
(void)request; (void)offset; (void)data; (void)size;
return LG_CLIPBOARD_RESULT_FAILED;
}
LG_ClipboardResult lgClipboardFiles_remoteDataEnd(
LG_ClipboardResult clipboardFiles_remoteDataEnd(
const LG_ClipboardFileRequest * request, uint64_t size)
{
(void)request; (void)size; return LG_CLIPBOARD_RESULT_FAILED;
}
void lgClipboardFiles_remoteCancel(uint64_t dataset,
void clipboardFiles_remoteCancel(uint64_t dataset,
uint64_t request, LG_ClipboardFileError reason)
{
(void)dataset; (void)request; (void)reason;
}
void lgClipboardFiles_localAcquire(uint64_t dataset, uint64_t acquisition)
void clipboardFiles_localAcquire(uint64_t dataset, uint64_t acquisition)
{
(void)dataset; (void)acquisition;
}
void lgClipboardFiles_localRelease(uint64_t dataset, uint64_t acquisition)
void clipboardFiles_localRelease(uint64_t dataset, uint64_t acquisition)
{
(void)dataset; (void)acquisition;
}
void lgClipboardFiles_localRequest(const LG_ClipboardFileRequest * request)
void clipboardFiles_localRequest(const LG_ClipboardFileRequest * request)
{
(void)request;
}
void lgClipboardFiles_localCancel(uint64_t dataset,
void clipboardFiles_localCancel(uint64_t dataset,
uint64_t request, LG_ClipboardFileError reason)
{
(void)dataset; (void)request; (void)reason;
}
void lgClipboardFiles_localReady(uint64_t request) { (void)request; }
void clipboardFiles_localReady(uint64_t request) { (void)request; }

236
client/tests/clipboard_files_test.c
View File

@@ -59,13 +59,13 @@ static uint64_t cancelledDataset;
static uint64_t cancelledRequest;
static LG_ClipboardFileError cancelledReason;
void lgClipboard_notifyFiles(uint64_t dataset)
void clipboard_notifyFiles(uint64_t dataset)
{
CHECK(notices < sizeof(datasets) / sizeof(datasets[0]));
datasets[notices++] = dataset;
}
bool lgClipboard_fileAcquire(uint64_t dataset, uint64_t acquisition)
bool clipboard_fileAcquire(uint64_t dataset, uint64_t acquisition)
{
++acquireCount;
acquiredDataset = dataset;
@@ -73,7 +73,7 @@ bool lgClipboard_fileAcquire(uint64_t dataset, uint64_t acquisition)
return true;
}
bool lgClipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
bool clipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
LG_ClipboardFileError error)
{
(void)dataset;
@@ -82,7 +82,7 @@ bool lgClipboard_fileAcquired(uint64_t dataset, uint64_t acquisition,
return false;
}
bool lgClipboard_fileRelease(uint64_t dataset, uint64_t acquisition)
bool clipboard_fileRelease(uint64_t dataset, uint64_t acquisition)
{
++releaseCount;
releasedDataset = dataset;
@@ -90,7 +90,7 @@ bool lgClipboard_fileRelease(uint64_t dataset, uint64_t acquisition)
return true;
}
bool lgClipboard_fileRequest(const LG_ClipboardFileRequest * request)
bool clipboard_fileRequest(const LG_ClipboardFileRequest * request)
{
CHECK(request);
++requestCount;
@@ -98,7 +98,7 @@ bool lgClipboard_fileRequest(const LG_ClipboardFileRequest * request)
return remoteRequestSucceeds;
}
LG_ClipboardResult lgClipboard_fileDataBegin(
LG_ClipboardResult clipboard_fileDataBegin(
const LG_ClipboardFileRequest * request, uint64_t sizeHint)
{
CHECK(request);
@@ -110,7 +110,7 @@ LG_ClipboardResult lgClipboard_fileDataBegin(
return LG_CLIPBOARD_RESULT_ACCEPTED;
}
LG_ClipboardResult lgClipboard_fileDataChunk(
LG_ClipboardResult clipboard_fileDataChunk(
const LG_ClipboardFileRequest * request, uint64_t responseOffset,
const void * data, size_t size, bool end)
{
@@ -135,7 +135,7 @@ LG_ClipboardResult lgClipboard_fileDataChunk(
return LG_CLIPBOARD_RESULT_ACCEPTED;
}
LG_ClipboardResult lgClipboard_fileDataEnd(
LG_ClipboardResult clipboard_fileDataEnd(
const LG_ClipboardFileRequest * request, uint64_t finalSize)
{
CHECK(request);
@@ -147,7 +147,7 @@ LG_ClipboardResult lgClipboard_fileDataEnd(
return LG_CLIPBOARD_RESULT_ACCEPTED;
}
bool lgClipboard_fileCancel(uint64_t dataset, uint64_t request,
bool clipboard_fileCancel(uint64_t dataset, uint64_t request,
LG_ClipboardFileError reason)
{
++cancelCount;
@@ -157,13 +157,13 @@ bool lgClipboard_fileCancel(uint64_t dataset, uint64_t request,
return true;
}
void lgClipboard_fileRemoteReady(uint64_t dataset)
void clipboard_fileRemoteReady(uint64_t dataset)
{
CHECK(dataset == acquiredDataset);
++remoteReadyCount;
}
void lgClipboard_fileRemoteFailed(uint64_t dataset)
void clipboard_fileRemoteFailed(uint64_t dataset)
{
CHECK(dataset);
++remoteFailedCount;
@@ -191,7 +191,7 @@ static bool runLocalRequest(uint64_t dataset, uint64_t node,
.length = length,
.operation = operation,
};
const bool result = lgClipboardFiles_testLocalRequest(&request);
const bool result = clipboardFiles_testLocalRequest(&request);
CHECK(!result || responseComplete);
CHECK(!result || !responseSize || responseWireEnded);
CHECK(result ? cancelCount == 0U : cancelCount == 1U);
@@ -251,40 +251,40 @@ static void testLocalLifecycle(void)
CHECK(write(fd, "clipboard", 9) == 9);
CHECK(close(fd) == 0);
CHECK(lgClipboardFiles_testInit(UINT64_C(0x1234000012340000)));
CHECK(clipboardFiles_testInit(UINT64_C(0x1234000012340000)));
char uri[320];
const int uriLength = snprintf(uri, sizeof(uri), "file://%s\r\n", path);
CHECK(uriLength > 0 && (size_t)uriLength < sizeof(uri));
CHECK(lgClipboardFiles_setLocal(
CHECK(clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)uriLength));
CHECK(notices == 1);
CHECK(datasets[0] != 0);
CHECK(kvmfrClipboardTransferFromClient(datasets[0]));
lgClipboardFiles_clearLocal();
clipboardFiles_clearLocal();
char gnome[336];
const int gnomeLength = snprintf(
gnome, sizeof(gnome), "copy\nfile://%s\n", path);
CHECK(gnomeLength > 0 && (size_t)gnomeLength < sizeof(gnome));
CHECK(lgClipboardFiles_setLocal("x-special/gnome-copied-files",
CHECK(clipboardFiles_setLocal("x-special/gnome-copied-files",
gnome, (size_t)gnomeLength));
CHECK(notices == 2);
CHECK(datasets[1] != datasets[0]);
static const char invalid[] = "file:///does/not/exist\n";
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", invalid, sizeof(invalid) - 1U));
lgClipboardFiles_clearLocal();
lgClipboardFiles_free();
lgClipboardFiles_free();
clipboardFiles_clearLocal();
clipboardFiles_free();
clipboardFiles_free();
CHECK(lgClipboardFiles_testInit(UINT64_C(0x5678000056780000)));
CHECK(lgClipboardFiles_setLocal(
CHECK(clipboardFiles_testInit(UINT64_C(0x5678000056780000)));
CHECK(clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)uriLength));
CHECK(notices == 3);
CHECK(datasets[2] != datasets[0]);
CHECK(datasets[2] != datasets[1]);
lgClipboardFiles_free();
clipboardFiles_free();
CHECK(unlink(path) == 0);
CHECK(rmdir(directory) == 0);
@@ -309,81 +309,81 @@ static void testLocalUriValidation(void)
CHECK(symlink("item.txt", link) == 0);
CHECK(symlink(".", alias) == 0);
CHECK(lgClipboardFiles_testInit(UINT64_C(0x684b2452684b2452)));
CHECK(clipboardFiles_testInit(UINT64_C(0x684b2452684b2452)));
const unsigned before = notices;
char uri[512];
int length = snprintf(uri, sizeof(uri),
"FILE://LOCALHOST%s/item%%20space.txt\r\n", directory);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(lgClipboardFiles_setLocal(
CHECK(clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
lgClipboardFiles_clearLocal();
clipboardFiles_clearLocal();
length = snprintf(uri, sizeof(uri), "file://%s%%\n", plain);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri), "file://%s%%0\n", plain);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri), "file://%s%%GG\n", plain);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri), "file://%s%%00suffix\n", plain);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri), "file://%s?query\n", plain);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri), "file://%s#fragment\n", plain);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri), "file://example.invalid%s\n", plain);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
static const char root[] = "file:///\n";
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", root, sizeof(root) - 1U));
length = snprintf(uri, sizeof(uri), "file://%s/\n", directory);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(lgClipboardFiles_setLocal(
CHECK(clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
lgClipboardFiles_clearLocal();
clipboardFiles_clearLocal();
length = snprintf(uri, sizeof(uri), "file://%s/./item.txt\n", directory);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri), "file://%s//item.txt\n", directory);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri), "file://%s\n", link);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri),
"file://%s/alias/item.txt\n", directory);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri), "file://%s\n", spaced);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)length));
length = snprintf(uri, sizeof(uri),
"cutx\nfile://%s\n", plain);
CHECK(length > 0 && (size_t)length < sizeof(uri));
CHECK(!lgClipboardFiles_setLocal(
CHECK(!clipboardFiles_setLocal(
"x-special/gnome-copied-files", uri, (size_t)length));
CHECK(notices == before + 2U);
lgClipboardFiles_free();
clipboardFiles_free();
CHECK(unlink(alias) == 0);
CHECK(unlink(link) == 0);
CHECK(unlink(spaced) == 0);
@@ -404,12 +404,12 @@ static void testLocalSnapshot(void)
createFile(stable, "stable");
createFile(changed, "before");
CHECK(lgClipboardFiles_testInit(UINT64_C(0x1a72021b1a72021b)));
CHECK(clipboardFiles_testInit(UINT64_C(0x1a72021b1a72021b)));
char uri[320];
const int uriLength = snprintf(
uri, sizeof(uri), "file://%s\r\n", directory);
CHECK(uriLength > 0 && (size_t)uriLength < sizeof(uri));
CHECK(lgClipboardFiles_setLocal(
CHECK(clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)uriLength));
const uint64_t dataset = datasets[notices - 1U];
@@ -441,7 +441,7 @@ static void testLocalSnapshot(void)
LG_CLIPBOARD_FILE_READ, 0, (uint32_t)stableEntry.size));
CHECK(responseSize == strlen("stable"));
CHECK(!memcmp(responseData, "stable", responseSize));
lgClipboardFiles_testForceLocalEof();
clipboardFiles_testForceLocalEof();
CHECK(!runLocalRequest(dataset, stableEntry.node,
LG_CLIPBOARD_FILE_READ, 0, (uint32_t)stableEntry.size));
CHECK(cancelledReason == LG_CLIPBOARD_FILE_ERROR_IO);
@@ -476,7 +476,7 @@ static void testLocalSnapshot(void)
LG_CLIPBOARD_FILE_READ, 0, (uint32_t)stableEntry.size));
CHECK(cancelledReason == LG_CLIPBOARD_FILE_ERROR_STALE);
lgClipboardFiles_free();
clipboardFiles_free();
CHECK(unlink(replacement) == 0);
CHECK(rmdir(directory) == 0);
CHECK(unlink(movedStable) == 0);
@@ -500,12 +500,12 @@ static void testLocalUnsupportedEntry(void)
CHECK(symlink("target.txt", link) == 0);
CHECK(mkfifo(fifo, 0600) == 0);
CHECK(lgClipboardFiles_testInit(UINT64_C(0x62d1147362d11473)));
CHECK(clipboardFiles_testInit(UINT64_C(0x62d1147362d11473)));
char uri[320];
const int uriLength = snprintf(
uri, sizeof(uri), "file://%s\r\n", directory);
CHECK(uriLength > 0 && (size_t)uriLength < sizeof(uri));
CHECK(lgClipboardFiles_setLocal(
CHECK(clipboardFiles_setLocal(
"text/uri-list", uri, (size_t)uriLength));
const uint64_t dataset = datasets[notices - 1U];
CHECK(runLocalRequest(dataset, KVMFR_CLIPBOARD_FILE_ROOT_NODE,
@@ -518,7 +518,7 @@ static void testLocalUnsupportedEntry(void)
LG_CLIPBOARD_FILE_LIST, 0, 0));
CHECK(cancelledReason == LG_CLIPBOARD_FILE_ERROR_NOT_SUPPORTED);
lgClipboardFiles_free();
clipboardFiles_free();
CHECK(unlink(fifo) == 0);
CHECK(unlink(link) == 0);
CHECK(unlink(target) == 0);
@@ -530,12 +530,12 @@ static uint64_t completeRemoteOffer(uint64_t dataset, const char * name)
const unsigned previousAcquires = acquireCount;
const unsigned previousRequests = requestCount;
const unsigned previousReady = remoteReadyCount;
CHECK(lgClipboardFiles_remoteOffer(dataset));
CHECK(clipboardFiles_remoteOffer(dataset));
CHECK(acquireCount == previousAcquires + 1U);
CHECK(acquiredDataset == dataset);
const uint64_t acquisition = acquiredRequest;
lgClipboardFiles_remoteAcquired(dataset, acquisition,
clipboardFiles_remoteAcquired(dataset, acquisition,
LG_CLIPBOARD_FILE_ERROR_NONE);
CHECK(requestCount == previousRequests + 1U);
CHECK(remoteRequest.dataset == dataset);
@@ -558,22 +558,22 @@ static uint64_t completeRemoteOffer(uint64_t dataset, const char * name)
};
memcpy(wire, &entry, sizeof(entry));
memcpy(wire + sizeof(entry), name, nameLength);
CHECK(lgClipboardFiles_remoteDataBegin(
CHECK(clipboardFiles_remoteDataBegin(
&remoteRequest, wireSize) == LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboardFiles_remoteDataChunk(&remoteRequest, 0,
CHECK(clipboardFiles_remoteDataChunk(&remoteRequest, 0,
wire, (size_t)wireSize) == LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboardFiles_remoteDataEnd(
CHECK(clipboardFiles_remoteDataEnd(
&remoteRequest, wireSize) == LG_CLIPBOARD_RESULT_ACCEPTED);
free(wire);
CHECK(remoteReadyCount == previousReady + 1U);
CHECK(lgClipboardFiles_remoteReady(dataset));
CHECK(clipboardFiles_remoteReady(dataset));
return acquisition;
}
static uint64_t beginRemoteOffer(uint64_t dataset)
{
const unsigned previousAcquires = acquireCount;
CHECK(lgClipboardFiles_remoteOffer(dataset));
CHECK(clipboardFiles_remoteOffer(dataset));
CHECK(acquireCount == previousAcquires + 1U);
CHECK(acquiredDataset == dataset);
return acquiredRequest;
@@ -584,7 +584,7 @@ static LG_ClipboardFileRequest beginRemoteList(uint64_t dataset,
{
const unsigned previousRequests = requestCount;
*acquisition = beginRemoteOffer(dataset);
lgClipboardFiles_remoteAcquired(dataset, *acquisition,
clipboardFiles_remoteAcquired(dataset, *acquisition,
LG_CLIPBOARD_FILE_ERROR_NONE);
CHECK(requestCount == previousRequests + 1U);
CHECK(remoteRequest.dataset == dataset);
@@ -601,12 +601,12 @@ static void checkRemoteFailure(uint64_t dataset,
CHECK(releaseCount == previousReleases + (acquired ? 1U : 0U));
if (acquired)
CHECK(releasedDataset == dataset);
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);
}
static void testRemoteFailures(void)
{
CHECK(lgClipboardFiles_testInit(UINT64_C(0x7315000073150000)));
CHECK(clipboardFiles_testInit(UINT64_C(0x7315000073150000)));
acquireCount = 0;
releaseCount = 0;
requestCount = 0;
@@ -619,7 +619,7 @@ static void testRemoteFailures(void)
uint64_t acquisition = beginRemoteOffer(dataset);
unsigned previousFailures = remoteFailedCount;
unsigned previousReleases = releaseCount;
lgClipboardFiles_remoteAcquired(dataset, acquisition,
clipboardFiles_remoteAcquired(dataset, acquisition,
LG_CLIPBOARD_FILE_ERROR_ACCESS);
checkRemoteFailure(dataset, previousFailures, previousReleases, false);
@@ -627,7 +627,7 @@ static void testRemoteFailures(void)
acquisition = beginRemoteOffer(dataset);
previousFailures = remoteFailedCount;
previousReleases = releaseCount;
lgClipboardFiles_remoteCancel(dataset, acquisition,
clipboardFiles_remoteCancel(dataset, acquisition,
LG_CLIPBOARD_FILE_ERROR_CANCELLED);
checkRemoteFailure(dataset, previousFailures, previousReleases, false);
@@ -635,7 +635,7 @@ static void testRemoteFailures(void)
LG_ClipboardFileRequest request = beginRemoteList(dataset, &acquisition);
previousFailures = remoteFailedCount;
previousReleases = releaseCount;
lgClipboardFiles_remoteCancel(dataset, request.request,
clipboardFiles_remoteCancel(dataset, request.request,
LG_CLIPBOARD_FILE_ERROR_CANCELLED);
checkRemoteFailure(dataset, previousFailures, previousReleases, true);
@@ -644,7 +644,7 @@ static void testRemoteFailures(void)
previousFailures = remoteFailedCount;
previousReleases = releaseCount;
remoteRequestSucceeds = false;
lgClipboardFiles_remoteAcquired(dataset, acquisition,
clipboardFiles_remoteAcquired(dataset, acquisition,
LG_CLIPBOARD_FILE_ERROR_NONE);
remoteRequestSucceeds = true;
checkRemoteFailure(dataset, previousFailures, previousReleases, true);
@@ -655,27 +655,27 @@ static void testRemoteFailures(void)
malformed.node += 1U;
previousFailures = remoteFailedCount;
previousReleases = releaseCount;
CHECK(lgClipboardFiles_remoteDataBegin(&malformed, 0) ==
CHECK(clipboardFiles_remoteDataBegin(&malformed, 0) ==
LG_CLIPBOARD_RESULT_FAILED);
checkRemoteFailure(dataset, previousFailures, previousReleases, true);
dataset += 1U;
request = beginRemoteList(dataset, &acquisition);
CHECK(lgClipboardFiles_remoteDataBegin(&request, 1) ==
CHECK(clipboardFiles_remoteDataBegin(&request, 1) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
previousFailures = remoteFailedCount;
previousReleases = releaseCount;
CHECK(lgClipboardFiles_remoteDataChunk(&request, 0, NULL, 1) ==
CHECK(clipboardFiles_remoteDataChunk(&request, 0, NULL, 1) ==
LG_CLIPBOARD_RESULT_FAILED);
checkRemoteFailure(dataset, previousFailures, previousReleases, true);
dataset += 1U;
request = beginRemoteList(dataset, &acquisition);
CHECK(lgClipboardFiles_remoteDataBegin(&request, 1) ==
CHECK(clipboardFiles_remoteDataBegin(&request, 1) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
previousFailures = remoteFailedCount;
previousReleases = releaseCount;
CHECK(lgClipboardFiles_remoteDataEnd(&request, 0) ==
CHECK(clipboardFiles_remoteDataEnd(&request, 0) ==
LG_CLIPBOARD_RESULT_FAILED);
checkRemoteFailure(dataset, previousFailures, previousReleases, true);
@@ -695,25 +695,25 @@ static void testRemoteFailures(void)
};
memcpy(wire, &entry, sizeof(entry));
memcpy(wire + sizeof(entry), invalidName, sizeof(invalidName) - 1U);
CHECK(lgClipboardFiles_remoteDataBegin(&request, wireSize) ==
CHECK(clipboardFiles_remoteDataBegin(&request, wireSize) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboardFiles_remoteDataChunk(&request, 0, wire, wireSize) ==
CHECK(clipboardFiles_remoteDataChunk(&request, 0, wire, wireSize) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
previousFailures = remoteFailedCount;
previousReleases = releaseCount;
CHECK(lgClipboardFiles_remoteDataEnd(&request, wireSize) ==
CHECK(clipboardFiles_remoteDataEnd(&request, wireSize) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
free(wire);
checkRemoteFailure(dataset, previousFailures, previousReleases, true);
lgClipboardFiles_free();
clipboardFiles_free();
}
static void checkRemoteUri(uint64_t presentation, const char * name)
{
char * uri = NULL;
size_t size = 0;
CHECK(lgClipboardFiles_getRemotePresentation(
CHECK(clipboardFiles_getRemotePresentation(
presentation, "text/uri-list", &uri, &size));
CHECK(uri);
CHECK(size == strlen(uri));
@@ -733,7 +733,7 @@ static void * releasePresentation(void * opaque)
ReleasePresentationTask * task = opaque;
const int result = pthread_barrier_wait(task->barrier);
CHECK(result == 0 || result == PTHREAD_BARRIER_SERIAL_THREAD);
lgClipboardFiles_remotePresentationRelease(task->presentation);
clipboardFiles_remotePresentationRelease(task->presentation);
return NULL;
}
@@ -759,9 +759,9 @@ static void releasePresentationConcurrently(uint64_t presentation)
static void testRemoteLifecycle(void)
{
CHECK(lgClipboardFiles_testFuseStopWake());
CHECK(lgClipboardFiles_testInit(UINT64_C(0x7311000073110000)));
CHECK(lgClipboardFiles_testUnsentRemoteOwnership());
CHECK(clipboardFiles_testFuseStopWake());
CHECK(clipboardFiles_testInit(UINT64_C(0x7311000073110000)));
CHECK(clipboardFiles_testUnsentRemoteOwnership());
acquireCount = 0;
releaseCount = 0;
requestCount = 0;
@@ -772,59 +772,59 @@ static void testRemoteLifecycle(void)
UINT64_C(0x73110001);
const uint64_t first = completeRemoteOffer(firstDataset, "first.txt");
CHECK(lgClipboardFiles_testRemoteRead(first, 2, 0, 9));
CHECK(clipboardFiles_testRemoteRead(first, 2, 0, 9));
LG_ClipboardFileRequest shortRead = remoteRequest;
CHECK(lgClipboardFiles_remoteDataBegin(&shortRead, 8) ==
CHECK(clipboardFiles_remoteDataBegin(&shortRead, 8) ==
LG_CLIPBOARD_RESULT_FAILED);
CHECK(lgClipboardFiles_testRemoteRead(first, 2, 0, 9));
CHECK(clipboardFiles_testRemoteRead(first, 2, 0, 9));
shortRead = remoteRequest;
CHECK(lgClipboardFiles_remoteDataBegin(&shortRead, 9) ==
CHECK(clipboardFiles_remoteDataBegin(&shortRead, 9) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
const uint8_t shortData[8] = { 0 };
CHECK(lgClipboardFiles_remoteDataChunk(&shortRead, 0,
CHECK(clipboardFiles_remoteDataChunk(&shortRead, 0,
shortData, sizeof(shortData)) == LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboardFiles_remoteDataEnd(&shortRead, sizeof(shortData)) ==
CHECK(clipboardFiles_remoteDataEnd(&shortRead, sizeof(shortData)) ==
LG_CLIPBOARD_RESULT_FAILED);
const uint64_t firstPresentation =
lgClipboardFiles_remotePresentationAcquire();
clipboardFiles_remotePresentationAcquire();
CHECK(firstPresentation == first);
checkRemoteUri(firstPresentation, "first.txt");
const uint64_t secondDataset = KVMFR_CLIPBOARD_TRANSFER_HELPER |
UINT64_C(0x73110002);
completeRemoteOffer(secondDataset, "second.txt");
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 2U);
CHECK(clipboardFiles_testRemoteDatasetCount() == 2U);
CHECK(releaseCount == 0U);
checkRemoteUri(firstPresentation, "first.txt");
lgClipboardFiles_remotePresentationRelease(firstPresentation);
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 1U);
clipboardFiles_remotePresentationRelease(firstPresentation);
CHECK(clipboardFiles_testRemoteDatasetCount() == 1U);
CHECK(releaseCount == 1U);
CHECK(releasedDataset == firstDataset);
CHECK(releasedAcquisition == first);
const uint64_t secondPresentation =
lgClipboardFiles_remotePresentationAcquire();
clipboardFiles_remotePresentationAcquire();
CHECK(secondPresentation != 0);
checkRemoteUri(secondPresentation, "second.txt");
lgClipboardFiles_remotePresentationDelivered(secondPresentation);
lgClipboardFiles_remotePresentationRelease(secondPresentation);
clipboardFiles_remotePresentationDelivered(secondPresentation);
clipboardFiles_remotePresentationRelease(secondPresentation);
const uint64_t thirdDataset = KVMFR_CLIPBOARD_TRANSFER_HELPER |
UINT64_C(0x73110003);
completeRemoteOffer(thirdDataset, "third.txt");
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 2U);
CHECK(clipboardFiles_testRemoteDatasetCount() == 2U);
CHECK(releaseCount == 1U);
CHECK(lgClipboardFiles_testBeginRemoteLookup(secondPresentation));
lgClipboardFiles_testExpireRemoteDeliveries();
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 2U);
CHECK(clipboardFiles_testBeginRemoteLookup(secondPresentation));
clipboardFiles_testExpireRemoteDeliveries();
CHECK(clipboardFiles_testRemoteDatasetCount() == 2U);
CHECK(releaseCount == 1U);
lgClipboardFiles_testEndRemoteLookup(secondPresentation);
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 1U);
clipboardFiles_testEndRemoteLookup(secondPresentation);
CHECK(clipboardFiles_testRemoteDatasetCount() == 1U);
CHECK(releaseCount == 2U);
CHECK(releasedDataset == secondDataset);
lgClipboardFiles_remoteClear();
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
clipboardFiles_remoteClear();
CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);
CHECK(releaseCount == 3U);
for (uint64_t i = 0; i < 10; ++i)
@@ -834,16 +834,16 @@ static void testRemoteLifecycle(void)
const uint64_t acquisition =
completeRemoteOffer(dataset, "grace.txt");
const uint64_t presentation =
lgClipboardFiles_remotePresentationAcquire();
clipboardFiles_remotePresentationAcquire();
CHECK(presentation == acquisition);
checkRemoteUri(presentation, "grace.txt");
lgClipboardFiles_remotePresentationDelivered(presentation);
lgClipboardFiles_remotePresentationRelease(presentation);
CHECK(lgClipboardFiles_testRemoteDatasetCount() <= 5U);
clipboardFiles_remotePresentationDelivered(presentation);
clipboardFiles_remotePresentationRelease(presentation);
CHECK(clipboardFiles_testRemoteDatasetCount() <= 5U);
}
lgClipboardFiles_remoteClear();
lgClipboardFiles_testExpireRemoteDeliveries();
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
clipboardFiles_remoteClear();
clipboardFiles_testExpireRemoteDeliveries();
CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);
for (uint64_t i = 0; i < 16; ++i)
{
@@ -852,7 +852,7 @@ static void testRemoteLifecycle(void)
const uint64_t oldAcquisition =
completeRemoteOffer(oldDataset, "old.txt");
const uint64_t presentation =
lgClipboardFiles_remotePresentationAcquire();
clipboardFiles_remotePresentationAcquire();
CHECK(presentation == oldAcquisition);
const uint64_t currentDataset = oldDataset + 1U;
completeRemoteOffer(currentDataset, "current.txt");
@@ -860,27 +860,27 @@ static void testRemoteLifecycle(void)
releasePresentationConcurrently(presentation);
CHECK(releaseCount == previousReleases + 1U);
CHECK(releasedDataset == oldDataset);
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 1U);
lgClipboardFiles_remoteClear();
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
CHECK(clipboardFiles_testRemoteDatasetCount() == 1U);
clipboardFiles_remoteClear();
CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);
}
const uint64_t pendingDataset = KVMFR_CLIPBOARD_TRANSFER_HELPER |
UINT64_C(0x73140001);
CHECK(lgClipboardFiles_remoteOffer(pendingDataset));
CHECK(clipboardFiles_remoteOffer(pendingDataset));
CHECK(acquiredDataset == pendingDataset);
const uint64_t pendingAcquisition = acquiredRequest;
const uint64_t replacementDataset = pendingDataset + 1U;
const unsigned previousCancels = cancelCount;
CHECK(lgClipboardFiles_remoteOffer(replacementDataset));
CHECK(clipboardFiles_remoteOffer(replacementDataset));
CHECK(cancelCount == previousCancels + 1U);
CHECK(cancelledDataset == pendingDataset);
CHECK(cancelledRequest == pendingAcquisition);
CHECK(cancelledReason == LG_CLIPBOARD_FILE_ERROR_CANCELLED);
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 1U);
lgClipboardFiles_remoteClear();
CHECK(lgClipboardFiles_testRemoteDatasetCount() == 0U);
lgClipboardFiles_free();
CHECK(clipboardFiles_testRemoteDatasetCount() == 1U);
clipboardFiles_remoteClear();
CHECK(clipboardFiles_testRemoteDatasetCount() == 0U);
clipboardFiles_free();
}
static int testMount(void)
@@ -889,8 +889,8 @@ static int testMount(void)
return 77;
if (!getenv("XDG_RUNTIME_DIR"))
CHECK(setenv("XDG_RUNTIME_DIR", "/tmp", 1) == 0);
CHECK(lgClipboardFiles_init());
lgClipboardFiles_free();
CHECK(clipboardFiles_init());
clipboardFiles_free();
return 0;
}

264
client/tests/clipboard_test.c
View File

@@ -144,11 +144,11 @@ static struct Provider q;
static struct Provider r;
static struct Display d;
extern unsigned lgClipboardFilesStubRemoteOfferCount;
extern unsigned lgClipboardFilesStubRemoteClearCount;
extern uint64_t lgClipboardFilesStubRemoteDataset;
extern bool lgClipboardFilesStubRemoteReady;
extern bool lgClipboardFilesStubRemoteOfferResult;
extern unsigned clipboardFilesStubRemoteOfferCount;
extern unsigned clipboardFilesStubRemoteClearCount;
extern uint64_t clipboardFilesStubRemoteDataset;
extern bool clipboardFilesStubRemoteReady;
extern bool clipboardFilesStubRemoteOfferResult;
struct AppState g_state;
struct AppParams g_params;
@@ -457,14 +457,14 @@ static void dsRequest(LG_ClipboardRequest id, LG_ClipboardData type)
d.reqId[no] = id;
d.reqType[no] = type;
if (d.autoData)
lgClipboard_data(id, d.autoType, d.autoBuf, d.autoSize);
clipboard_data(id, d.autoType, d.autoBuf, d.autoSize);
}
static void dsRequestReady(LG_ClipboardRequest id)
{
++d.ready;
if (d.autoBegin)
d.readyResult = lgClipboard_dataBegin(
d.readyResult = clipboard_dataBegin(
id, LG_CLIPBOARD_DATA_TEXT, LG_CLIPBOARD_SIZE_UNKNOWN);
}
@@ -512,21 +512,21 @@ static void init(void)
atomic_init(&d.blockCancel, false);
atomic_init(&d.cancelEntered, false);
atomic_init(&d.releaseCancel, false);
lgClipboardFilesStubRemoteOfferCount = 0;
lgClipboardFilesStubRemoteClearCount = 0;
lgClipboardFilesStubRemoteDataset = 0;
lgClipboardFilesStubRemoteReady = false;
lgClipboardFilesStubRemoteOfferResult = true;
clipboardFilesStubRemoteOfferCount = 0;
clipboardFilesStubRemoteClearCount = 0;
clipboardFilesStubRemoteDataset = 0;
clipboardFilesStubRemoteReady = false;
clipboardFilesStubRemoteOfferResult = true;
g_state.ds = &dsOps;
g_params.clipboardToVM = true;
g_params.clipboardToLocal = true;
CHECK(lgClipboard_init());
lgClipboard_setLocalAvailable(true);
CHECK(clipboard_init());
clipboard_setLocalAvailable(true);
}
static void bind(struct Provider * provider)
{
lgClipboard_setFallback(&plainOps, provider);
clipboard_setFallback(&plainOps, provider);
CHECK(provider->attach == 1);
}
@@ -574,7 +574,7 @@ static void onReply(void * opaque, LG_ClipboardData type,
CHECK(!buf);
if (type != LG_CLIPBOARD_DATA_NONE && reply->next)
reply->nested = lgClipboard_request(
reply->nested = clipboard_request(
LG_CLIPBOARD_DATA_TEXT, onReply, reply->next);
}
@@ -589,13 +589,13 @@ static void testPreference(void)
{
init();
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
lgClipboard_notifyTypes(types, 1);
clipboard_notifyTypes(types, 1);
lgClipboard_setFallback(&statOps, &p);
clipboard_setFallback(&statOps, &p);
CHECK(p.attach == 1);
CHECK(p.notice == 1);
lgClipboard_setTransport(&statOps, &q);
clipboard_setTransport(&statOps, &q);
CHECK(p.release == 1);
CHECK(p.detach == 1);
CHECK(q.attach == 1);
@@ -611,7 +611,7 @@ static void testPreference(void)
const LG_ClipboardStatusFn staleFn = q.statFn;
void * staleCtx = q.statCtx;
CHECK(staleFn);
lgClipboard_dropTransport();
clipboard_dropTransport();
CHECK(q.release == 0);
CHECK(q.detach == 0);
CHECK(p.attach == 2);
@@ -624,68 +624,68 @@ static void testPreference(void)
staleFn(staleCtx, &stale);
CHECK(p.attach == 2);
lgClipboard_setTransport(&statOps, &r);
clipboard_setTransport(&statOps, &r);
CHECK(p.release == 2);
CHECK(p.detach == 2);
CHECK(r.attach == 1);
lgClipboard_setTransport(NULL, NULL);
clipboard_setTransport(NULL, NULL);
CHECK(r.statClear == 1);
CHECK(r.release == 1);
CHECK(r.detach == 1);
CHECK(p.attach == 3);
lgClipboard_free();
clipboard_free();
}
static void testFilePublication(void)
{
init();
lgClipboard_setFallback(&fileOps, &p);
clipboard_setFallback(&fileOps, &p);
const uint64_t dataset = UINT64_C(0x123456789abcdef);
lgClipboard_notifyFiles(dataset);
clipboard_notifyFiles(dataset);
CHECK(p.fileOffer == 1);
CHECK(p.fileDataset[0] == dataset);
const LG_ClipboardData files[] = { LG_CLIPBOARD_DATA_FILES };
lgClipboard_notifyTypes(files, 1);
clipboard_notifyTypes(files, 1);
CHECK(p.notice == 0);
CHECK(p.fileOffer == 1);
lgClipboard_setTransport(&plainOps, &r);
clipboard_setTransport(&plainOps, &r);
CHECK(r.attach == 1);
CHECK(r.release == 1);
const uint64_t replacement = dataset + 1U;
lgClipboard_notifyFiles(replacement);
clipboard_notifyFiles(replacement);
CHECK(r.release == 2);
lgClipboard_dropTransport();
clipboard_dropTransport();
CHECK(p.attach == 2);
CHECK(p.fileOffer == 2);
CHECK(p.fileDataset[1] == replacement);
lgClipboard_setTransport(&fileOps, &q);
clipboard_setTransport(&fileOps, &q);
CHECK(q.attach == 1);
CHECK(q.fileOffer == 1);
CHECK(q.fileDataset[0] == replacement);
lgClipboard_dropTransport();
clipboard_dropTransport();
CHECK(p.attach == 3);
CHECK(p.fileOffer == 3);
CHECK(p.fileDataset[2] == replacement);
lgClipboard_free();
clipboard_free();
}
static void testFileReplacement(void)
{
init();
bind(&p);
lgClipboardFilesStubRemoteReady = true;
clipboardFilesStubRemoteReady = true;
const uint64_t first = UINT64_C(0x2000000000000001);
p.ev->fileOffer(p.evCtx, first);
CHECK(lgClipboardFilesStubRemoteOfferCount == 1);
CHECK(lgClipboardFilesStubRemoteDataset == first);
CHECK(clipboardFilesStubRemoteOfferCount == 1);
CHECK(clipboardFilesStubRemoteDataset == first);
const LG_ClipboardData files[] = { LG_CLIPBOARD_DATA_FILES };
p.ev->notice(p.evCtx, files, 1);
CHECK(d.notice == 1);
@@ -693,8 +693,8 @@ static void testFileReplacement(void)
const LG_ClipboardData text[] = { LG_CLIPBOARD_DATA_TEXT };
p.ev->notice(p.evCtx, text, 1);
CHECK(lgClipboardFilesStubRemoteClearCount == 1);
CHECK(lgClipboardFilesStubRemoteDataset == 0);
CHECK(clipboardFilesStubRemoteClearCount == 1);
CHECK(clipboardFilesStubRemoteDataset == 0);
CHECK(d.notice == 2);
CHECK(d.noticeType[1] == LG_CLIPBOARD_DATA_TEXT);
@@ -706,17 +706,17 @@ static void testFileReplacement(void)
LG_CLIPBOARD_DATA_FILES,
};
p.ev->notice(p.evCtx, mixed, 2);
CHECK(lgClipboardFilesStubRemoteClearCount == 1);
CHECK(lgClipboardFilesStubRemoteDataset == mixedDataset);
CHECK(clipboardFilesStubRemoteClearCount == 1);
CHECK(clipboardFilesStubRemoteDataset == mixedDataset);
CHECK(d.notice == 3);
CHECK(d.noticeType[2] == LG_CLIPBOARD_DATA_FILES);
p.ev->notice(p.evCtx, text, 1);
CHECK(lgClipboardFilesStubRemoteClearCount == 2);
CHECK(lgClipboardFilesStubRemoteDataset == 0);
CHECK(clipboardFilesStubRemoteClearCount == 2);
CHECK(clipboardFilesStubRemoteDataset == 0);
CHECK(d.notice == 4);
CHECK(d.noticeType[3] == LG_CLIPBOARD_DATA_TEXT);
lgClipboard_free();
clipboard_free();
}
static void testFileFailure(void)
@@ -742,37 +742,37 @@ static void testFileFailure(void)
CHECK(d.notice == 1);
CHECK(d.release == 0);
lgClipboard_fileRemoteFailed(first);
clipboard_fileRemoteFailed(first);
CHECK(d.release == 0);
CHECK(lgClipboardFilesStubRemoteDataset == second);
CHECK(clipboardFilesStubRemoteDataset == second);
lgClipboard_fileRemoteFailed(second);
clipboard_fileRemoteFailed(second);
CHECK(d.release == 1);
lgClipboard_fileRemoteFailed(second);
clipboard_fileRemoteFailed(second);
CHECK(d.release == 1);
p.ev->notice(p.evCtx, text, 1);
CHECK(d.notice == 2);
lgClipboardFilesStubRemoteOfferResult = false;
const unsigned previousClears = lgClipboardFilesStubRemoteClearCount;
clipboardFilesStubRemoteOfferResult = false;
const unsigned previousClears = clipboardFilesStubRemoteClearCount;
p.ev->fileOffer(p.evCtx, second + 1U);
CHECK(lgClipboardFilesStubRemoteClearCount == previousClears + 1U);
CHECK(clipboardFilesStubRemoteClearCount == previousClears + 1U);
p.ev->notice(p.evCtx, files, 1);
CHECK(d.notice == 2);
CHECK(d.release == 2);
p.ev->notice(p.evCtx, text, 1);
CHECK(d.notice == 3);
lgClipboardFilesStubRemoteOfferResult = true;
clipboardFilesStubRemoteOfferResult = true;
const uint64_t pending = second + 2U;
p.ev->fileOffer(p.evCtx, pending);
lgClipboard_fileRemoteFailed(pending);
clipboard_fileRemoteFailed(pending);
CHECK(d.release == 2);
p.ev->notice(p.evCtx, files, 1);
CHECK(d.notice == 3);
CHECK(d.release == 3);
lgClipboard_free();
clipboard_free();
}
struct CallbackSerializationTask
@@ -784,7 +784,7 @@ struct CallbackSerializationTask
static void * switchClipboardProvider(void * opaque)
{
struct CallbackSerializationTask * task = opaque;
lgClipboard_setTransport(&plainOps, &q);
clipboard_setTransport(&plainOps, &q);
atomic_store_explicit(&task->switched, true, memory_order_release);
return NULL;
}
@@ -792,7 +792,7 @@ static void * switchClipboardProvider(void * opaque)
static void * clearClipboardAvailability(void * opaque)
{
struct CallbackSerializationTask * task = opaque;
lgClipboard_setLocalAvailable(false);
clipboard_setLocalAvailable(false);
atomic_store_explicit(
&task->availabilityChanged, true, memory_order_release);
return NULL;
@@ -814,7 +814,7 @@ static void testCallbackSerialization(void)
init();
bind(&p);
const LG_ClipboardData text[] = { LG_CLIPBOARD_DATA_TEXT };
lgClipboard_notifyTypes(text, 1);
clipboard_notifyTypes(text, 1);
CHECK(p.ev->request(p.evCtx, 1, LG_CLIPBOARD_DATA_TEXT));
CHECK(d.request == 1);
@@ -842,7 +842,7 @@ static void testCallbackSerialization(void)
&task.availabilityChanged, memory_order_acquire));
CHECK(d.cancel == 1);
CHECK(d.cancelReason == LG_CLIPBOARD_CANCEL_UNAVAILABLE);
lgClipboard_free();
clipboard_free();
}
static void testRequest(void)
@@ -857,8 +857,8 @@ static void testRequest(void)
struct Reply a = { 0 };
struct Reply b = { 0 };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &a));
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &b));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &a));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &b));
CHECK(p.request == 2);
CHECK(p.reqId[0] != LG_CLIPBOARD_REQUEST_INVALID);
CHECK(p.reqId[0] != p.reqId[1]);
@@ -880,7 +880,7 @@ static void testRequest(void)
CHECK(b.size == sizeof(two));
CHECK(memcmp(b.data, two, sizeof(two)) == 0);
lgClipboard_free();
clipboard_free();
}
static void testRemoteKeepsLocalRequest(void)
@@ -889,7 +889,7 @@ static void testRemoteKeepsLocalRequest(void)
bind(&p);
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
lgClipboard_notifyTypes(types, 1);
clipboard_notifyTypes(types, 1);
CHECK(p.notice == 1);
g_params.clipboardToLocal = false;
@@ -898,7 +898,7 @@ static void testRemoteKeepsLocalRequest(void)
/* A notice which is not published locally must not discard the local
* clipboard advertised towards the guest. */
lgClipboard_setTransport(&plainOps, &q);
clipboard_setTransport(&plainOps, &q);
CHECK(q.attach == 1);
CHECK(q.notice == 1);
CHECK(q.release == 0);
@@ -914,7 +914,7 @@ static void testRemoteKeepsLocalRequest(void)
CHECK(d.request == 1);
CHECK(d.reqType[0] == LG_CLIPBOARD_DATA_TEXT);
lgClipboard_free();
clipboard_free();
}
static void testPendingRemoteKeepsLocalRequest(void)
@@ -923,14 +923,14 @@ static void testPendingRemoteKeepsLocalRequest(void)
bind(&p);
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
lgClipboard_notifyTypes(types, 1);
clipboard_notifyTypes(types, 1);
CHECK(p.notice == 1);
lgClipboard_setLocalAvailable(false);
clipboard_setLocalAvailable(false);
notice(&p, types, 1);
CHECK(d.notice == 0);
lgClipboard_setLocalAvailable(true);
clipboard_setLocalAvailable(true);
CHECK(d.notice == 1);
/* Publishing a notice which arrived while the local clipboard was
@@ -939,7 +939,7 @@ static void testPendingRemoteKeepsLocalRequest(void)
CHECK(d.request == 1);
CHECK(d.reqType[0] == LG_CLIPBOARD_DATA_TEXT);
lgClipboard_free();
clipboard_free();
}
static void testInvalid(void)
@@ -954,12 +954,12 @@ static void testInvalid(void)
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
notice(&p, types, 1);
CHECK(!lgClipboard_request(
CHECK(!clipboard_request(
LG_CLIPBOARD_DATA_NONE, onReply, &(struct Reply) { 0 }));
CHECK(!lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, NULL, NULL));
CHECK(!clipboard_request(LG_CLIPBOARD_DATA_TEXT, NULL, NULL));
struct Reply empty = { 0 };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &empty));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &empty));
remoteData(&p, LG_CLIPBOARD_REQUEST_INVALID,
LG_CLIPBOARD_DATA_TEXT, NULL, 0);
CHECK(empty.count == 0);
@@ -970,13 +970,13 @@ static void testInvalid(void)
CHECK(empty.size == 0);
struct Reply wrong = { 0 };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &wrong));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &wrong));
remoteData(&p, p.reqId[p.request - 1],
LG_CLIPBOARD_DATA_PNG, NULL, 0);
checkNone(&wrong);
struct Reply null = { 0 };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &null));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &null));
remoteData(&p, p.reqId[p.request - 1],
LG_CLIPBOARD_DATA_TEXT, NULL, 1);
checkNone(&null);
@@ -984,7 +984,7 @@ static void testInvalid(void)
#if SIZE_MAX > UINT32_MAX
struct Reply large = { 0 };
const uint8_t byte = 1;
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &large));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &large));
remoteData(&p, p.reqId[p.request - 1], LG_CLIPBOARD_DATA_TEXT,
&byte, (size_t)UINT32_MAX + 1);
checkNone(&large);
@@ -992,11 +992,11 @@ static void testInvalid(void)
p.reqOK = false;
struct Reply failed = { 0 };
CHECK(!lgClipboard_request(
CHECK(!clipboard_request(
LG_CLIPBOARD_DATA_TEXT, onReply, &failed));
CHECK(failed.count == 0);
lgClipboard_free();
clipboard_free();
}
static void testCancel(void)
@@ -1008,7 +1008,7 @@ static void testCancel(void)
notice(&p, text, 1);
struct Reply newer = { 0 };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &newer));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &newer));
const LG_ClipboardRequest newerId = p.reqId[p.request - 1];
notice(&p, png, 1);
checkNone(&newer);
@@ -1016,7 +1016,7 @@ static void testCancel(void)
CHECK(newer.count == 1);
struct Reply released = { 0 };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_PNG, onReply, &released));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_PNG, onReply, &released));
const LG_ClipboardRequest releaseId = p.reqId[p.request - 1];
p.ev->release(p.evCtx);
checkNone(&released);
@@ -1025,39 +1025,39 @@ static void testCancel(void)
notice(&p, text, 1);
struct Reply unavailable = { 0 };
CHECK(lgClipboard_request(
CHECK(clipboard_request(
LG_CLIPBOARD_DATA_TEXT, onReply, &unavailable));
const LG_ClipboardRequest unavailableId = p.reqId[p.request - 1];
lgClipboard_setLocalAvailable(false);
clipboard_setLocalAvailable(false);
checkNone(&unavailable);
remoteData(&p, unavailableId, LG_CLIPBOARD_DATA_TEXT, "x", 1);
CHECK(unavailable.count == 1);
lgClipboard_setLocalAvailable(true);
clipboard_setLocalAvailable(true);
notice(&p, text, 1);
struct Reply switched = { 0 };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &switched));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &switched));
const LG_ClipboardRequest switchedId = p.reqId[p.request - 1];
lgClipboard_setTransport(&plainOps, &q);
clipboard_setTransport(&plainOps, &q);
checkNone(&switched);
CHECK(p.oldEv);
p.oldEv->data(p.oldCtx, switchedId, LG_CLIPBOARD_DATA_TEXT, "x", 1);
CHECK(switched.count == 1);
CHECK(d.release == 3);
lgClipboard_free();
clipboard_free();
}
static void testGeneration(void)
{
init();
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
lgClipboard_notifyTypes(types, 1);
lgClipboard_setFallback(&statOps, &p);
clipboard_notifyTypes(types, 1);
clipboard_setFallback(&statOps, &p);
notice(&p, types, 1);
struct Reply old = { 0 };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &old));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &old));
const LG_ClipboardRequest oldId = p.reqId[p.request - 1];
setStatus(&p, true, 2);
checkNone(&old);
@@ -1069,7 +1069,7 @@ static void testGeneration(void)
CHECK(old.count == 1);
notice(&p, types, 1);
struct Reply next = { 0 };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &next));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &next));
remoteData(&p, p.reqId[p.request - 1],
LG_CLIPBOARD_DATA_TEXT, "new", 3);
CHECK(next.count == 1);
@@ -1077,7 +1077,7 @@ static void testGeneration(void)
CHECK(next.size == 3);
CHECK(memcmp(next.data, "new", 3) == 0);
lgClipboard_free();
clipboard_free();
}
static void testLocal(void)
@@ -1088,11 +1088,11 @@ static void testLocal(void)
const LG_ClipboardData many[LG_CLIPBOARD_DATA_NONE + 1] = { 0 };
const LG_ClipboardData types[] =
{ LG_CLIPBOARD_DATA_TEXT, LG_CLIPBOARD_DATA_PNG };
lgClipboard_notifyTypes(NULL, 1);
lgClipboard_notifyTypes(bad, 1);
lgClipboard_notifyTypes(many, LG_CLIPBOARD_DATA_NONE + 1);
clipboard_notifyTypes(NULL, 1);
clipboard_notifyTypes(bad, 1);
clipboard_notifyTypes(many, LG_CLIPBOARD_DATA_NONE + 1);
CHECK(p.notice == 0);
lgClipboard_notifyTypes(types, 2);
clipboard_notifyTypes(types, 2);
CHECK(p.notice == 1);
CHECK(!p.ev->request(
@@ -1103,9 +1103,9 @@ static void testLocal(void)
CHECK(!p.ev->request(p.evCtx, 41, LG_CLIPBOARD_DATA_PNG));
const LG_ClipboardRequest first = d.reqId[0];
lgClipboard_data(first + 100, LG_CLIPBOARD_DATA_TEXT, "x", 1);
clipboard_data(first + 100, LG_CLIPBOARD_DATA_TEXT, "x", 1);
CHECK(p.data == 0);
lgClipboard_data(first, LG_CLIPBOARD_DATA_PNG, "x", 1);
clipboard_data(first, LG_CLIPBOARD_DATA_PNG, "x", 1);
CHECK(p.data == 1);
CHECK(p.dataId[0] == 40);
CHECK(p.dataType[0] == LG_CLIPBOARD_DATA_NONE);
@@ -1113,9 +1113,9 @@ static void testLocal(void)
CHECK(p.ev->request(p.evCtx, 41, LG_CLIPBOARD_DATA_PNG));
const LG_ClipboardRequest second = d.reqId[1];
lgClipboard_abort(second + 100);
clipboard_abort(second + 100);
CHECK(p.data == 1);
lgClipboard_abort(second);
clipboard_abort(second);
CHECK(p.data == 2);
CHECK(p.dataId[1] == 41);
CHECK(p.dataType[1] == LG_CLIPBOARD_DATA_NONE);
@@ -1123,16 +1123,16 @@ static void testLocal(void)
CHECK(p.ev->request(p.evCtx, 42, LG_CLIPBOARD_DATA_TEXT));
const LG_ClipboardRequest third = d.reqId[2];
const uint8_t buf[] = { 5, 6, 7 };
lgClipboard_data(third, LG_CLIPBOARD_DATA_TEXT, buf, sizeof(buf));
clipboard_data(third, LG_CLIPBOARD_DATA_TEXT, buf, sizeof(buf));
CHECK(p.data == 3);
CHECK(p.dataId[2] == 42);
CHECK(p.dataType[2] == LG_CLIPBOARD_DATA_TEXT);
CHECK(p.dataSize[2] == sizeof(buf));
CHECK(memcmp(p.dataBuf[2], buf, sizeof(buf)) == 0);
lgClipboard_data(third, LG_CLIPBOARD_DATA_TEXT, buf, sizeof(buf));
clipboard_data(third, LG_CLIPBOARD_DATA_TEXT, buf, sizeof(buf));
CHECK(p.data == 3);
lgClipboard_free();
clipboard_free();
}
static void testReentrant(void)
@@ -1144,7 +1144,7 @@ static void testReentrant(void)
struct Reply second = { 0 };
struct Reply first = { .next = &second };
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &first));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, onReply, &first));
remoteData(&p, p.reqId[0], LG_CLIPBOARD_DATA_TEXT, "a", 1);
CHECK(first.count == 1);
CHECK(first.nested);
@@ -1152,7 +1152,7 @@ static void testReentrant(void)
remoteData(&p, p.reqId[1], LG_CLIPBOARD_DATA_TEXT, "b", 1);
CHECK(second.count == 1);
lgClipboard_notifyTypes(types, 1);
clipboard_notifyTypes(types, 1);
d.autoData = true;
d.autoType = LG_CLIPBOARD_DATA_TEXT;
d.autoBuf = "local";
@@ -1164,27 +1164,27 @@ static void testReentrant(void)
CHECK(p.dataSize[0] == 5);
CHECK(memcmp(p.dataBuf[0], "local", 5) == 0);
lgClipboard_free();
clipboard_free();
}
static void testStreamLocal(void)
{
init();
lgClipboard_setFallback(&streamOps, &p);
clipboard_setFallback(&streamOps, &p);
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
lgClipboard_notifyTypes(types, 1);
clipboard_notifyTypes(types, 1);
CHECK(p.ev->request(p.evCtx, 40, LG_CLIPBOARD_DATA_TEXT));
const LG_ClipboardRequest transfer = d.reqId[0];
CHECK(lgClipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
CHECK(clipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
LG_CLIPBOARD_SIZE_UNKNOWN) == LG_CLIPBOARD_RESULT_ACCEPTED);
const uint8_t first[] = { 1, 2 };
const uint8_t second[] = { 3, 4, 5 };
CHECK(lgClipboard_dataChunk(transfer, 0, first, sizeof(first)) ==
CHECK(clipboard_dataChunk(transfer, 0, first, sizeof(first)) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataChunk(transfer, sizeof(first),
CHECK(clipboard_dataChunk(transfer, sizeof(first),
second, sizeof(second)) == LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataEnd(transfer,
CHECK(clipboard_dataEnd(transfer,
sizeof(first) + sizeof(second)) == LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(p.begin == 1);
CHECK(p.streamId == 40);
@@ -1197,9 +1197,9 @@ static void testStreamLocal(void)
CHECK(p.ev->request(p.evCtx, 41, LG_CLIPBOARD_DATA_TEXT));
const LG_ClipboardRequest invalid = d.reqId[1];
CHECK(lgClipboard_dataBegin(invalid, LG_CLIPBOARD_DATA_TEXT, 1) ==
CHECK(clipboard_dataBegin(invalid, LG_CLIPBOARD_DATA_TEXT, 1) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataChunk(invalid, 1, first, 1) ==
CHECK(clipboard_dataChunk(invalid, 1, first, 1) ==
LG_CLIPBOARD_RESULT_FAILED);
CHECK(p.cancel == 1);
CHECK(p.streamId == 41);
@@ -1210,20 +1210,20 @@ static void testStreamLocal(void)
CHECK(d.cancel == 1);
CHECK(d.cancelReason == LG_CLIPBOARD_CANCEL_REPLACED);
lgClipboard_free();
clipboard_free();
}
static void testStreamBlocked(void)
{
init();
lgClipboard_setFallback(&streamOps, &p);
clipboard_setFallback(&streamOps, &p);
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
lgClipboard_notifyTypes(types, 1);
clipboard_notifyTypes(types, 1);
CHECK(p.ev->request(p.evCtx, 50, LG_CLIPBOARD_DATA_TEXT));
p.beginResult = LG_CLIPBOARD_RESULT_BLOCKED;
uint8_t data[] = { 7, 8, 9 };
lgClipboard_data(d.reqId[0], LG_CLIPBOARD_DATA_TEXT,
clipboard_data(d.reqId[0], LG_CLIPBOARD_DATA_TEXT,
data, sizeof(data));
CHECK(p.begin == 1);
CHECK(p.chunk == 0);
@@ -1244,30 +1244,30 @@ static void testStreamBlocked(void)
CHECK(p.ev->request(p.evCtx, 51, LG_CLIPBOARD_DATA_TEXT));
const LG_ClipboardRequest transfer = d.reqId[1];
p.beginResult = LG_CLIPBOARD_RESULT_BLOCKED;
CHECK(lgClipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
CHECK(clipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
LG_CLIPBOARD_SIZE_UNKNOWN) == LG_CLIPBOARD_RESULT_BLOCKED);
p.beginResult = LG_CLIPBOARD_RESULT_ACCEPTED;
d.autoBegin = true;
p.ev->dataReady(p.evCtx, 51);
CHECK(d.ready == 1);
CHECK(d.readyResult == LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataEnd(transfer, 0) ==
CHECK(clipboard_dataEnd(transfer, 0) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
lgClipboard_free();
clipboard_free();
}
static void testStreamRemote(void)
{
init();
lgClipboard_setFallback(&streamOps, &p);
clipboard_setFallback(&streamOps, &p);
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
notice(&p, types, 1);
struct StreamSink sink = { 0 };
initSink(&sink);
LG_ClipboardRequest id;
CHECK(lgClipboard_requestStream(
CHECK(clipboard_requestStream(
LG_CLIPBOARD_DATA_TEXT, &sinkOps, &sink, &id));
CHECK(id == p.reqId[0]);
CHECK(p.ev->dataBegin(p.evCtx, id, LG_CLIPBOARD_DATA_TEXT,
@@ -1281,7 +1281,7 @@ static void testStreamRemote(void)
LG_CLIPBOARD_RESULT_BLOCKED);
CHECK(sink.chunk == 1);
sink.chunkResult = LG_CLIPBOARD_RESULT_ACCEPTED;
CHECK(lgClipboard_requestReady(id));
CHECK(clipboard_requestReady(id));
CHECK(p.ready == 1);
CHECK(p.streamId == id);
CHECK(p.ev->dataChunk(p.evCtx, id, 0, data, sizeof(data)) ==
@@ -1295,19 +1295,19 @@ static void testStreamRemote(void)
struct StreamSink cancel = { 0 };
initSink(&cancel);
CHECK(lgClipboard_requestStream(
CHECK(clipboard_requestStream(
LG_CLIPBOARD_DATA_TEXT, &sinkOps, &cancel, &id));
p.ev->dataCancel(p.evCtx, id, LG_CLIPBOARD_CANCEL_ABORTED);
CHECK(cancel.cancel == 1);
CHECK(cancel.reason == LG_CLIPBOARD_CANCEL_ABORTED);
lgClipboard_free();
clipboard_free();
}
static void testRequestPublication(void)
{
init();
lgClipboard_setFallback(&streamOps, &p);
clipboard_setFallback(&streamOps, &p);
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
notice(&p, types, 1);
@@ -1315,7 +1315,7 @@ static void testRequestPublication(void)
initSink(&sink);
sink.requireRequest = true;
p.earlyBegin = true;
CHECK(lgClipboard_requestStream(LG_CLIPBOARD_DATA_TEXT,
CHECK(clipboard_requestStream(LG_CLIPBOARD_DATA_TEXT,
&sinkOps, &sink, &sink.request));
CHECK(sink.request == p.reqId[0]);
CHECK(p.earlyResult == LG_CLIPBOARD_RESULT_ACCEPTED);
@@ -1324,7 +1324,7 @@ static void testRequestPublication(void)
LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(sink.end == 1);
lgClipboard_free();
clipboard_free();
}
static void testStreamLegacy(void)
@@ -1332,19 +1332,19 @@ static void testStreamLegacy(void)
init();
bind(&p);
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
lgClipboard_notifyTypes(types, 1);
clipboard_notifyTypes(types, 1);
CHECK(p.ev->request(p.evCtx, 60, LG_CLIPBOARD_DATA_TEXT));
const LG_ClipboardRequest transfer = d.reqId[0];
const uint8_t first[] = { 2, 4 };
const uint8_t second[] = { 6, 8 };
CHECK(lgClipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
CHECK(clipboard_dataBegin(transfer, LG_CLIPBOARD_DATA_TEXT,
LG_CLIPBOARD_SIZE_UNKNOWN) == LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataChunk(transfer, 0, first, sizeof(first)) ==
CHECK(clipboard_dataChunk(transfer, 0, first, sizeof(first)) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataChunk(transfer, sizeof(first), second,
CHECK(clipboard_dataChunk(transfer, sizeof(first), second,
sizeof(second)) == LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataEnd(transfer, 4) ==
CHECK(clipboard_dataEnd(transfer, 4) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(p.data == 1);
CHECK(p.dataId[0] == 60);
@@ -1357,7 +1357,7 @@ static void testStreamLegacy(void)
initSink(&sink);
sink.beginResult = LG_CLIPBOARD_RESULT_BLOCKED;
LG_ClipboardRequest id;
CHECK(lgClipboard_requestStream(
CHECK(clipboard_requestStream(
LG_CLIPBOARD_DATA_TEXT, &sinkOps, &sink, &id));
const uint8_t remote[] = { 9, 8, 7 };
remoteData(&p, id, LG_CLIPBOARD_DATA_TEXT, remote, sizeof(remote));
@@ -1365,7 +1365,7 @@ static void testStreamLegacy(void)
CHECK(sink.chunk == 0);
sink.beginResult = LG_CLIPBOARD_RESULT_ACCEPTED;
CHECK(lgClipboard_requestReady(id));
CHECK(clipboard_requestReady(id));
CHECK(p.ready == 0);
CHECK(sink.begin == 2);
CHECK(sink.chunk == 1);
@@ -1373,7 +1373,7 @@ static void testStreamLegacy(void)
CHECK(sink.size == sizeof(remote));
CHECK(memcmp(sink.data, remote, sizeof(remote)) == 0);
lgClipboard_free();
clipboard_free();
}
struct Test

20
client/tests/spice_clipboard_test.c
View File

@@ -143,15 +143,15 @@ static SpiceClipboard * setup(void)
g_state.ds = &displayOps;
g_params.clipboardToVM = true;
g_params.clipboardToLocal = true;
CHECK(lgClipboard_init());
lgClipboard_setLocalAvailable(true);
lgClipboard_setFallback(spiceClipboard_getOps(), clipboard);
CHECK(clipboard_init());
clipboard_setLocalAvailable(true);
clipboard_setFallback(spiceClipboard_getOps(), clipboard);
return clipboard;
}
static void teardown(SpiceClipboard ** clipboard)
{
lgClipboard_free();
clipboard_free();
spiceClipboard_setCallbackTarget(NULL);
spiceClipboard_free(clipboard);
}
@@ -160,22 +160,22 @@ static void testOutbound(void)
{
SpiceClipboard * clipboard = setup();
const LG_ClipboardData types[] = { LG_CLIPBOARD_DATA_TEXT };
lgClipboard_notifyTypes(types, 1);
clipboard_notifyTypes(types, 1);
CHECK(test.grab == 1);
spiceClipboard_request(SPICE_DATA_TEXT);
CHECK(test.localRequest != LG_CLIPBOARD_REQUEST_INVALID);
const uint8_t first[] = { 1, 2 };
const uint8_t second[] = { 3, 4 };
CHECK(lgClipboard_dataBegin(test.localRequest,
CHECK(clipboard_dataBegin(test.localRequest,
LG_CLIPBOARD_DATA_TEXT, LG_CLIPBOARD_SIZE_UNKNOWN) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataChunk(test.localRequest,
CHECK(clipboard_dataChunk(test.localRequest,
0, first, sizeof(first)) == LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataChunk(test.localRequest,
CHECK(clipboard_dataChunk(test.localRequest,
sizeof(first), second, sizeof(second)) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(lgClipboard_dataEnd(test.localRequest, 4) ==
CHECK(clipboard_dataEnd(test.localRequest, 4) ==
LG_CLIPBOARD_RESULT_ACCEPTED);
CHECK(test.dataStart == 1);
@@ -191,7 +191,7 @@ static void testInbound(void)
SpiceClipboard * clipboard = setup();
spiceClipboard_notice(SPICE_DATA_TEXT);
CHECK(test.notice == 1);
CHECK(lgClipboard_request(LG_CLIPBOARD_DATA_TEXT, reply, NULL));
CHECK(clipboard_request(LG_CLIPBOARD_DATA_TEXT, reply, NULL));
CHECK(test.request == 1);
CHECK(test.requestType == SPICE_DATA_TEXT);

4
client/tests/transport_fallback_test.c
View File

@@ -400,12 +400,12 @@ void lgAudio_dropFallback(void)
}
#endif
void lgClipboard_setFallback(const LG_ClipboardOps * ops, void * opaque)
void clipboard_setFallback(const LG_ClipboardOps * ops, void * opaque)
{
setProvider(&pClipboard, ops, &clipboardOps, opaque);
}
void lgClipboard_dropFallback(void)
void clipboard_dropFallback(void)
{
atomic_fetch_add(&pClipboard.drop, 1);
}

30
client/tests/wayland_clipboard_test.c
View File

@@ -443,7 +443,7 @@ static void pollFire(unsigned int no, uint32_t events)
pollCleanup(&rec.poll[i]);
}
void lgClipboard_notifyTypes(
void clipboard_notifyTypes(
const LG_ClipboardData types[], size_t count)
{
CHECK(rec.noticeN < ARRAY_LENGTH(rec.notice));
@@ -453,7 +453,7 @@ void lgClipboard_notifyTypes(
notice->count = count;
}
void lgClipboard_release(void)
void clipboard_release(void)
{
if (rec.expectReleaseLocked)
{
@@ -464,13 +464,13 @@ void lgClipboard_release(void)
++rec.releaseN;
}
void lgClipboard_abort(LG_ClipboardRequest request)
void clipboard_abort(LG_ClipboardRequest request)
{
CHECK(rec.abortN < ARRAY_LENGTH(rec.abort));
rec.abort[rec.abortN++] = request;
}
void lgClipboard_data(LG_ClipboardRequest request,
void clipboard_data(LG_ClipboardRequest request,
LG_ClipboardData type, const void * data, size_t size)
{
CHECK(rec.dataN < ARRAY_LENGTH(rec.data));
@@ -482,7 +482,7 @@ void lgClipboard_data(LG_ClipboardRequest request,
memcpy(notice->data, data, size);
}
LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest request,
LG_ClipboardResult clipboard_dataBegin(LG_ClipboardRequest request,
LG_ClipboardData type, uint64_t sizeHint)
{
struct StreamNotice * stream = &rec.streamData;
@@ -493,7 +493,7 @@ LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest request,
return rec.beginResult;
}
LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest request,
LG_ClipboardResult clipboard_dataChunk(LG_ClipboardRequest request,
uint64_t offset, const void * data, size_t size)
{
const LG_ClipboardResult result = rec.chunkResult;
@@ -518,7 +518,7 @@ LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest request,
return result;
}
LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest request,
LG_ClipboardResult clipboard_dataEnd(LG_ClipboardRequest request,
uint64_t finalSize)
{
const LG_ClipboardResult result = rec.endResult;
@@ -535,7 +535,7 @@ LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest request,
return result;
}
bool lgClipboard_requestStream(LG_ClipboardData type,
bool clipboard_requestStream(LG_ClipboardData type,
const LG_ClipboardStreamOps * stream, void * opaque,
LG_ClipboardRequest * request)
{
@@ -562,14 +562,14 @@ bool lgClipboard_requestStream(LG_ClipboardData type,
return rec.requestOK;
}
bool lgClipboard_requestReady(LG_ClipboardRequest request)
bool clipboard_requestReady(LG_ClipboardRequest request)
{
CHECK(request == rec.requestId);
++rec.requestReadyN;
return true;
}
bool lgClipboardFiles_setLocal(const char * mime,
bool clipboardFiles_setLocal(const char * mime,
const void * data, size_t size)
{
CHECK(mime);
@@ -583,18 +583,18 @@ bool lgClipboardFiles_setLocal(const char * mime,
return rec.fileSetOK;
}
void lgClipboardFiles_clearLocal(void)
void clipboardFiles_clearLocal(void)
{
++rec.fileClearN;
}
uint64_t lgClipboardFiles_remotePresentationAcquire(void)
uint64_t clipboardFiles_remotePresentationAcquire(void)
{
++rec.presentationAcquireN;
return rec.presentationOK ? 1000U + rec.presentationAcquireN : 0;
}
bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
bool clipboardFiles_getRemotePresentation(uint64_t presentation,
const char * mime, char ** data, size_t * size)
{
CHECK(presentation >= 1001U);
@@ -614,7 +614,7 @@ bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
return true;
}
void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
void clipboardFiles_remotePresentationDelivered(uint64_t presentation)
{
CHECK(presentation);
CHECK(rec.presentationDeliveredN <
@@ -622,7 +622,7 @@ void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
rec.presentationDelivered[rec.presentationDeliveredN++] = presentation;
}
void lgClipboardFiles_remotePresentationRelease(uint64_t presentation)
void clipboardFiles_remotePresentationRelease(uint64_t presentation)
{
CHECK(presentation);
CHECK(rec.presentationReleaseN <

30
client/tests/x11_clipboard_test.c
View File

@@ -438,7 +438,7 @@ int XFree(void * data)
return Success;
}
void lgClipboard_notifyTypes(
void clipboard_notifyTypes(
const LG_ClipboardData types[], size_t count)
{
CHECK(rec.noticeN < ARRAY_LENGTH(rec.notice));
@@ -448,7 +448,7 @@ void lgClipboard_notifyTypes(
memcpy(notice->type, types, count * sizeof(*types));
}
void lgClipboard_data(LG_ClipboardRequest request,
void clipboard_data(LG_ClipboardRequest request,
LG_ClipboardData type, const void * data, size_t size)
{
CHECK(rec.dataN < ARRAY_LENGTH(rec.data));
@@ -462,7 +462,7 @@ void lgClipboard_data(LG_ClipboardRequest request,
memcpy(notice->data, data, size);
}
LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest request,
LG_ClipboardResult clipboard_dataBegin(LG_ClipboardRequest request,
LG_ClipboardData type, uint64_t sizeHint)
{
++rec.streamBeginN;
@@ -481,7 +481,7 @@ LG_ClipboardResult lgClipboard_dataBegin(LG_ClipboardRequest request,
return rec.beginResult;
}
LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest request,
LG_ClipboardResult clipboard_dataChunk(LG_ClipboardRequest request,
uint64_t offset, const void * data, size_t size)
{
const LG_ClipboardResult result = rec.chunkResult;
@@ -519,7 +519,7 @@ LG_ClipboardResult lgClipboard_dataChunk(LG_ClipboardRequest request,
return result;
}
LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest request,
LG_ClipboardResult clipboard_dataEnd(LG_ClipboardRequest request,
uint64_t finalSize)
{
const LG_ClipboardResult result = rec.endResult;
@@ -540,18 +540,18 @@ LG_ClipboardResult lgClipboard_dataEnd(LG_ClipboardRequest request,
return result;
}
void lgClipboard_abort(LG_ClipboardRequest request)
void clipboard_abort(LG_ClipboardRequest request)
{
CHECK(rec.abortN < ARRAY_LENGTH(rec.abort));
rec.abort[rec.abortN++] = request;
}
void lgClipboard_release(void)
void clipboard_release(void)
{
++rec.releaseN;
}
bool lgClipboard_requestStream(LG_ClipboardData type,
bool clipboard_requestStream(LG_ClipboardData type,
const LG_ClipboardStreamOps * stream, void * opaque,
LG_ClipboardRequest * request)
{
@@ -570,14 +570,14 @@ bool lgClipboard_requestStream(LG_ClipboardData type,
return rec.requestOK;
}
bool lgClipboard_requestReady(LG_ClipboardRequest request)
bool clipboard_requestReady(LG_ClipboardRequest request)
{
CHECK(request == rec.requestId);
++rec.requestReadyN;
return true;
}
bool lgClipboardFiles_setLocal(const char * mime,
bool clipboardFiles_setLocal(const char * mime,
const void * data, size_t size)
{
CHECK(mime);
@@ -591,18 +591,18 @@ bool lgClipboardFiles_setLocal(const char * mime,
return rec.fileSetOK;
}
void lgClipboardFiles_clearLocal(void)
void clipboardFiles_clearLocal(void)
{
++rec.fileClearN;
}
uint64_t lgClipboardFiles_remotePresentationAcquire(void)
uint64_t clipboardFiles_remotePresentationAcquire(void)
{
++rec.presentationAcquireN;
return rec.presentationOK ? 2001U : 0;
}
bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
bool clipboardFiles_getRemotePresentation(uint64_t presentation,
const char * mime, char ** data, size_t * size)
{
CHECK(presentation >= 2001U);
@@ -622,7 +622,7 @@ bool lgClipboardFiles_getRemotePresentation(uint64_t presentation,
return true;
}
void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
void clipboardFiles_remotePresentationDelivered(uint64_t presentation)
{
CHECK(presentation);
CHECK(rec.presentationDeliveredN <
@@ -630,7 +630,7 @@ void lgClipboardFiles_remotePresentationDelivered(uint64_t presentation)
rec.presentationDelivered[rec.presentationDeliveredN++] = presentation;
}
void lgClipboardFiles_remotePresentationRelease(uint64_t presentation)
void clipboardFiles_remotePresentationRelease(uint64_t presentation)
{
CHECK(presentation);
CHECK(rec.presentationReleaseN <