Use G_GNUC_UNUSED from GLib instead of ATTRIBUTE_UNUSED.
Signed-off-by: Ján Tomko <jtomko@redhat.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
addr->addr[5] = 0;
}
-int virNetDevTapCreateInBridgePort(const char *brname ATTRIBUTE_UNUSED,
+int virNetDevTapCreateInBridgePort(const char *brname G_GNUC_UNUSED,
char **ifname,
- const virMacAddr *macaddr ATTRIBUTE_UNUSED,
- const unsigned char *vmuuid ATTRIBUTE_UNUSED,
- const char *tunpath ATTRIBUTE_UNUSED,
- int *tapfd ATTRIBUTE_UNUSED,
- size_t tapfdSize ATTRIBUTE_UNUSED,
- virNetDevVPortProfilePtr virtPortProfile ATTRIBUTE_UNUSED,
- virNetDevVlanPtr virtVlan ATTRIBUTE_UNUSED,
- virNetDevCoalescePtr coalesce ATTRIBUTE_UNUSED,
- unsigned int mtu ATTRIBUTE_UNUSED,
- unsigned int *actualMTU ATTRIBUTE_UNUSED,
- unsigned int fakeflags ATTRIBUTE_UNUSED)
+ const virMacAddr *macaddr G_GNUC_UNUSED,
+ const unsigned char *vmuuid G_GNUC_UNUSED,
+ const char *tunpath G_GNUC_UNUSED,
+ int *tapfd G_GNUC_UNUSED,
+ size_t tapfdSize G_GNUC_UNUSED,
+ virNetDevVPortProfilePtr virtPortProfile G_GNUC_UNUSED,
+ virNetDevVlanPtr virtVlan G_GNUC_UNUSED,
+ virNetDevCoalescePtr coalesce G_GNUC_UNUSED,
+ unsigned int mtu G_GNUC_UNUSED,
+ unsigned int *actualMTU G_GNUC_UNUSED,
+ unsigned int fakeflags G_GNUC_UNUSED)
{
VIR_FREE(*ifname);
if (VIR_STRDUP(*ifname, "vnet0") < 0)
return 0;
}
-char *virNetDevTapGetRealDeviceName(char *name ATTRIBUTE_UNUSED)
+char *virNetDevTapGetRealDeviceName(char *name G_GNUC_UNUSED)
{
char *fakename;
return fakename;
}
-int virNetDevSetOnline(const char *ifname ATTRIBUTE_UNUSED,
- bool online ATTRIBUTE_UNUSED)
+int virNetDevSetOnline(const char *ifname G_GNUC_UNUSED,
+ bool online G_GNUC_UNUSED)
{
return 0;
}
-int bind(int sockfd ATTRIBUTE_UNUSED,
- const struct sockaddr *addr ATTRIBUTE_UNUSED,
- socklen_t addrlen ATTRIBUTE_UNUSED)
+int bind(int sockfd G_GNUC_UNUSED,
+ const struct sockaddr *addr G_GNUC_UNUSED,
+ socklen_t addrlen G_GNUC_UNUSED)
{
return 0;
}
* Only stdin/out/err open
* No slot for return status must log error.
*/
-static int test0(const void *unused ATTRIBUTE_UNUSED)
+static int test0(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd;
int ret = -1;
* Only stdin/out/err open
* Capturing return status must not log error.
*/
-static int test1(const void *unused ATTRIBUTE_UNUSED)
+static int test1(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd;
int ret = -1;
* Run program (twice), no args, inherit all ENV, keep CWD.
* Only stdin/out/err open
*/
-static int test2(const void *unused ATTRIBUTE_UNUSED)
+static int test2(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
int ret;
* Run program, no args, inherit all ENV, keep CWD.
* stdin/out/err + two extra FD open
*/
-static int test3(const void *unused ATTRIBUTE_UNUSED)
+static int test3(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
int newfd1 = dup(STDERR_FILENO);
* Only stdin/out/err open.
* Daemonized
*/
-static int test4(const void *unused ATTRIBUTE_UNUSED)
+static int test4(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
char *pidfile = virPidFileBuildPath(abs_builddir, "commandhelper");
* Run program, no args, inherit filtered ENV, keep CWD.
* Only stdin/out/err open
*/
-static int test5(const void *unused ATTRIBUTE_UNUSED)
+static int test5(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
* Run program, no args, inherit filtered ENV, keep CWD.
* Only stdin/out/err open
*/
-static int test6(const void *unused ATTRIBUTE_UNUSED)
+static int test6(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
* Run program, no args, inherit filtered ENV, keep CWD.
* Only stdin/out/err open
*/
-static int test7(const void *unused ATTRIBUTE_UNUSED)
+static int test7(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
* Run program, no args, inherit filtered ENV, keep CWD.
* Only stdin/out/err open
*/
-static int test8(const void *unused ATTRIBUTE_UNUSED)
+static int test8(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
* Run program, some args, inherit all ENV, keep CWD.
* Only stdin/out/err open
*/
-static int test9(const void *unused ATTRIBUTE_UNUSED)
+static int test9(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
const char* const args[] = { "arg1", "arg2", NULL };
* Run program, some args, inherit all ENV, keep CWD.
* Only stdin/out/err open
*/
-static int test10(const void *unused ATTRIBUTE_UNUSED)
+static int test10(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
const char *const args[] = {
* Run program, some args, inherit all ENV, keep CWD.
* Only stdin/out/err open
*/
-static int test11(const void *unused ATTRIBUTE_UNUSED)
+static int test11(const void *unused G_GNUC_UNUSED)
{
const char *args[] = {
abs_builddir "/commandhelper",
* Run program, no args, inherit all ENV, keep CWD.
* Only stdin/out/err open. Set stdin data
*/
-static int test12(const void *unused ATTRIBUTE_UNUSED)
+static int test12(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
* Run program, no args, inherit all ENV, keep CWD.
* Only stdin/out/err open. Set stdin data
*/
-static int test13(const void *unused ATTRIBUTE_UNUSED)
+static int test13(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
char *outactual = NULL;
* Run program, no args, inherit all ENV, keep CWD.
* Only stdin/out/err open. Set stdin data
*/
-static int test14(const void *unused ATTRIBUTE_UNUSED)
+static int test14(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
char *outactual = NULL;
* Run program, no args, inherit all ENV, change CWD.
* Only stdin/out/err open
*/
-static int test15(const void *unused ATTRIBUTE_UNUSED)
+static int test15(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
char *cwd = NULL;
/*
* Don't run program; rather, log what would be run.
*/
-static int test16(const void *unused ATTRIBUTE_UNUSED)
+static int test16(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew("true");
char *outactual = NULL;
/*
* Test string handling when no output is present.
*/
-static int test17(const void *unused ATTRIBUTE_UNUSED)
+static int test17(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew("true");
int ret = -1;
/*
* Run long-running daemon, to ensure no hang.
*/
-static int test18(const void *unused ATTRIBUTE_UNUSED)
+static int test18(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNewArgList("sleep", "100", NULL);
char *pidfile = virPidFileBuildPath(abs_builddir, "commandhelper");
/*
* Asynchronously run long-running daemon, to ensure no hang.
*/
-static int test19(const void *unused ATTRIBUTE_UNUSED)
+static int test19(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNewArgList("sleep", "100", NULL);
pid_t pid;
* Run program, no args, inherit all ENV, keep CWD.
* Ignore huge stdin data, to provoke SIGPIPE or EPIPE in parent.
*/
-static int test20(const void *unused ATTRIBUTE_UNUSED)
+static int test20(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNewArgList(abs_builddir "/commandhelper",
"--close-stdin", NULL);
NULL
};
-static int test21(const void *unused ATTRIBUTE_UNUSED)
+static int test21(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
int ret = -1;
}
static int
-test22(const void *unused ATTRIBUTE_UNUSED)
+test22(const void *unused G_GNUC_UNUSED)
{
int ret = -1;
virCommandPtr cmd;
static int
-test23(const void *unused ATTRIBUTE_UNUSED)
+test23(const void *unused G_GNUC_UNUSED)
{
/* Not strictly a virCommand test, but this is the easiest place
* to test this lower-level interface. It takes a double fork to
return ret;
}
-static int test25(const void *unused ATTRIBUTE_UNUSED)
+static int test25(const void *unused G_GNUC_UNUSED)
{
int ret = -1;
int pipeFD[2] = { -1, -1};
/*
* Don't run program; rather, log what would be run.
*/
-static int test26(const void *unused ATTRIBUTE_UNUSED)
+static int test26(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew("true");
char *outactual = NULL;
return ret;
}
-static int test27(const void *unused ATTRIBUTE_UNUSED)
+static int test27(const void *unused G_GNUC_UNUSED)
{
virCommandPtr cmd = virCommandNew(abs_builddir "/commandhelper");
int pipe1[2];
}
static void
-virCommandTestFreeTimer(int timer ATTRIBUTE_UNUSED,
- void *opaque ATTRIBUTE_UNUSED)
+virCommandTestFreeTimer(int timer G_GNUC_UNUSED,
+ void *opaque G_GNUC_UNUSED)
{
/* nothing to be done here */
}
};
static int
-testParseDatastorePath(const void *data ATTRIBUTE_UNUSED)
+testParseDatastorePath(const void *data G_GNUC_UNUSED)
{
int result = 0;
size_t i;
};
static int
-testConvertDateTimeToCalendarTime(const void *data ATTRIBUTE_UNUSED)
+testConvertDateTimeToCalendarTime(const void *data G_GNUC_UNUSED)
{
size_t i;
esxVI_DateTime dateTime;
};
static int
-testEscapeDatastoreItem(const void *data ATTRIBUTE_UNUSED)
+testEscapeDatastoreItem(const void *data G_GNUC_UNUSED)
{
size_t i;
char *escaped = NULL;
};
static int
-testConvertWindows1252ToUTF8(const void *data ATTRIBUTE_UNUSED)
+testConvertWindows1252ToUTF8(const void *data G_GNUC_UNUSED)
{
size_t i;
char *utf8 = NULL;
static int eventThreadJobDone;
-G_GNUC_NORETURN static void *eventThreadLoop(void *data ATTRIBUTE_UNUSED) {
+G_GNUC_NORETURN static void *eventThreadLoop(void *data G_GNUC_UNUSED) {
while (1) {
pthread_mutex_lock(&eventThreadMutex);
while (!eventThreadRunOnce)
/* Test virIsVHBACapable */
static int
-test1(const void *data ATTRIBUTE_UNUSED)
+test1(const void *data G_GNUC_UNUSED)
{
if (virVHBAPathExists(TEST_FC_HOST_PREFIX, TEST_FC_HOST_NUM) &&
virVHBAPathExists(TEST_FC_HOST_PREFIX, TEST_FC_HOST_NUM_NO_FAB))
/* Test virVHBAIsVportCapable */
static int
-test2(const void *data ATTRIBUTE_UNUSED)
+test2(const void *data G_GNUC_UNUSED)
{
if (virVHBAIsVportCapable(TEST_FC_HOST_PREFIX, TEST_FC_HOST_NUM))
return 0;
/* Test virVHBAGetConfig */
static int
-test3(const void *data ATTRIBUTE_UNUSED)
+test3(const void *data G_GNUC_UNUSED)
{
const char *expect_wwnn = "2001001b32a9da4e";
const char *expect_wwpn = "2101001b32a9da4e";
/* Test virVHBAGetHostByWWN */
static int
-test4(const void *data ATTRIBUTE_UNUSED)
+test4(const void *data G_GNUC_UNUSED)
{
const char *expect_hostname = "host5";
char *hostname = NULL;
* NB: host4 is not Online, so it should not be found
*/
static int
-test5(const void *data ATTRIBUTE_UNUSED)
+test5(const void *data G_GNUC_UNUSED)
{
const char *expect_hostname = "host5";
char *hostname = NULL;
/* Test virVHBAGetConfig fabric name optional */
static int
-test6(const void *data ATTRIBUTE_UNUSED)
+test6(const void *data G_GNUC_UNUSED)
{
const char *expect_wwnn = "2002001b32a9da4e";
const char *expect_wwpn = "2102001b32a9da4e";
# endif
static void
-testCommandDryRun(const char *const*args ATTRIBUTE_UNUSED,
- const char *const*env ATTRIBUTE_UNUSED,
- const char *input ATTRIBUTE_UNUSED,
+testCommandDryRun(const char *const*args G_GNUC_UNUSED,
+ const char *const*env G_GNUC_UNUSED,
+ const char *input G_GNUC_UNUSED,
char **output,
char **error,
int *status,
- void *opaque ATTRIBUTE_UNUSED)
+ void *opaque G_GNUC_UNUSED)
{
*status = 0;
ignore_value(VIR_STRDUP_QUIET(*output, ""));
#include "internal.h"
#include "libvirt_nss.h"
-int main(int argc ATTRIBUTE_UNUSED,
- char *argv[] ATTRIBUTE_UNUSED)
+int main(int argc G_GNUC_UNUSED,
+ char *argv[] G_GNUC_UNUSED)
{
int err, herrno; /* Dummy variables to prevent SIGSEGV */
"ebtables -t nat -X libvirt-P-vnet0\n"
static int
-testNWFilterEBIPTablesAllTeardown(const void *opaque ATTRIBUTE_UNUSED)
+testNWFilterEBIPTablesAllTeardown(const void *opaque G_GNUC_UNUSED)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *expected =
static int
-testNWFilterEBIPTablesTearOldRules(const void *opaque ATTRIBUTE_UNUSED)
+testNWFilterEBIPTablesTearOldRules(const void *opaque G_GNUC_UNUSED)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *expected =
static int
-testNWFilterEBIPTablesRemoveBasicRules(const void *opaque ATTRIBUTE_UNUSED)
+testNWFilterEBIPTablesRemoveBasicRules(const void *opaque G_GNUC_UNUSED)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *expected =
static int
-testNWFilterEBIPTablesTearNewRules(const void *opaque ATTRIBUTE_UNUSED)
+testNWFilterEBIPTablesTearNewRules(const void *opaque G_GNUC_UNUSED)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *expected =
static int
-testNWFilterEBIPTablesApplyBasicRules(const void *opaque ATTRIBUTE_UNUSED)
+testNWFilterEBIPTablesApplyBasicRules(const void *opaque G_GNUC_UNUSED)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *expected =
static int
-testNWFilterEBIPTablesApplyDHCPOnlyRules(const void *opaque ATTRIBUTE_UNUSED)
+testNWFilterEBIPTablesApplyDHCPOnlyRules(const void *opaque G_GNUC_UNUSED)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *expected =
static int
-testNWFilterEBIPTablesApplyDropAllRules(const void *opaque ATTRIBUTE_UNUSED)
+testNWFilterEBIPTablesApplyDropAllRules(const void *opaque G_GNUC_UNUSED)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *expected =
static int
-domainLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom ATTRIBUTE_UNUSED,
+domainLifecycleCb(virConnectPtr conn G_GNUC_UNUSED,
+ virDomainPtr dom G_GNUC_UNUSED,
int event,
- int detail ATTRIBUTE_UNUSED,
+ int detail G_GNUC_UNUSED,
void *opaque)
{
lifecycleEventCounter *counter = opaque;
}
static void
-networkLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED,
- virNetworkPtr net ATTRIBUTE_UNUSED,
+networkLifecycleCb(virConnectPtr conn G_GNUC_UNUSED,
+ virNetworkPtr net G_GNUC_UNUSED,
int event,
- int detail ATTRIBUTE_UNUSED,
+ int detail G_GNUC_UNUSED,
void* opaque)
{
lifecycleEventCounter *counter = opaque;
}
static void
-storagePoolLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED,
- virStoragePoolPtr pool ATTRIBUTE_UNUSED,
+storagePoolLifecycleCb(virConnectPtr conn G_GNUC_UNUSED,
+ virStoragePoolPtr pool G_GNUC_UNUSED,
int event,
- int detail ATTRIBUTE_UNUSED,
+ int detail G_GNUC_UNUSED,
void* opaque)
{
lifecycleEventCounter *counter = opaque;
}
static void
-storagePoolRefreshCb(virConnectPtr conn ATTRIBUTE_UNUSED,
- virStoragePoolPtr pool ATTRIBUTE_UNUSED,
+storagePoolRefreshCb(virConnectPtr conn G_GNUC_UNUSED,
+ virStoragePoolPtr pool G_GNUC_UNUSED,
void* opaque)
{
int *counter = opaque;
}
static void
-nodeDeviceLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED,
- virNodeDevicePtr dev ATTRIBUTE_UNUSED,
+nodeDeviceLifecycleCb(virConnectPtr conn G_GNUC_UNUSED,
+ virNodeDevicePtr dev G_GNUC_UNUSED,
int event,
- int detail ATTRIBUTE_UNUSED,
+ int detail G_GNUC_UNUSED,
void* opaque)
{
lifecycleEventCounter *counter = opaque;
}
static void
-timeout(int id ATTRIBUTE_UNUSED, void *opaque ATTRIBUTE_UNUSED)
+timeout(int id G_GNUC_UNUSED, void *opaque G_GNUC_UNUSED)
{
fputs("test taking too long; giving up", stderr);
_exit(EXIT_FAILURE);
# define VIR_FROM_THIS VIR_FROM_OPENVZ
static int
-testLocateConfFile(int vpsid ATTRIBUTE_UNUSED, char **conffile,
- const char *ext ATTRIBUTE_UNUSED)
+testLocateConfFile(int vpsid G_GNUC_UNUSED, char **conffile,
+ const char *ext G_GNUC_UNUSED)
{
return virAsprintf(conffile, "%s/openvzutilstest.conf", abs_srcdir);
}
};
static int
-testReadConfigParam(const void *data ATTRIBUTE_UNUSED)
+testReadConfigParam(const void *data G_GNUC_UNUSED)
{
int result = -1;
size_t i;
}
static int
-testReadNetworkConf(const void *data ATTRIBUTE_UNUSED)
+testReadNetworkConf(const void *data G_GNUC_UNUSED)
{
int result = -1;
virDomainDefPtr def = NULL;
static int
-qemuAgentTimeoutTestMonitorHandler(qemuMonitorTestPtr test ATTRIBUTE_UNUSED,
- qemuMonitorTestItemPtr item ATTRIBUTE_UNUSED,
- const char *cmdstr ATTRIBUTE_UNUSED)
+qemuAgentTimeoutTestMonitorHandler(qemuMonitorTestPtr test G_GNUC_UNUSED,
+ qemuMonitorTestItemPtr item G_GNUC_UNUSED,
+ const char *cmdstr G_GNUC_UNUSED)
{
return 0;
}
static void
-eventLoop(void *opaque ATTRIBUTE_UNUSED)
+eventLoop(void *opaque G_GNUC_UNUSED)
{
while (1) {
if (virEventRunDefaultImpl() < 0) {
virCPUDefPtr
-virQEMUCapsProbeHostCPU(virArch hostArch ATTRIBUTE_UNUSED,
- virDomainCapsCPUModelsPtr models ATTRIBUTE_UNUSED)
+virQEMUCapsProbeHostCPU(virArch hostArch G_GNUC_UNUSED,
+ virDomainCapsCPUModelsPtr models G_GNUC_UNUSED)
{
const char *model = getenv("VIR_TEST_MOCK_FAKE_HOST_CPU");
static int
-testFWPrecedence(const void *opaque ATTRIBUTE_UNUSED)
+testFWPrecedence(const void *opaque G_GNUC_UNUSED)
{
VIR_AUTOFREE(char *) fakehome = NULL;
VIR_AUTOSTRINGLIST fwList = NULL;
static void
-qemuMonitorTestFreeTimer(int timer ATTRIBUTE_UNUSED,
- void *opaque ATTRIBUTE_UNUSED)
+qemuMonitorTestFreeTimer(int timer G_GNUC_UNUSED,
+ void *opaque G_GNUC_UNUSED)
{
/* nothing to be done here */
}
static int
qemuMonitorTestProcessGuestAgentSync(qemuMonitorTestPtr test,
- qemuMonitorTestItemPtr item ATTRIBUTE_UNUSED,
+ qemuMonitorTestItemPtr item G_GNUC_UNUSED,
const char *cmdstr)
{
virJSONValuePtr val = NULL;
static void
-qemuMonitorTestEOFNotify(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
- virDomainObjPtr vm ATTRIBUTE_UNUSED,
- void *opaque ATTRIBUTE_UNUSED)
+qemuMonitorTestEOFNotify(qemuMonitorPtr mon G_GNUC_UNUSED,
+ virDomainObjPtr vm G_GNUC_UNUSED,
+ void *opaque G_GNUC_UNUSED)
{
}
static void
-qemuMonitorTestErrorNotify(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
- virDomainObjPtr vm ATTRIBUTE_UNUSED,
- void *opaque ATTRIBUTE_UNUSED)
+qemuMonitorTestErrorNotify(qemuMonitorPtr mon G_GNUC_UNUSED,
+ virDomainObjPtr vm G_GNUC_UNUSED,
+ void *opaque G_GNUC_UNUSED)
{
}
static void
-qemuMonitorTestAgentNotify(qemuAgentPtr agent ATTRIBUTE_UNUSED,
- virDomainObjPtr vm ATTRIBUTE_UNUSED)
+qemuMonitorTestAgentNotify(qemuAgentPtr agent G_GNUC_UNUSED,
+ virDomainObjPtr vm G_GNUC_UNUSED)
{
}
#include "virmockstathelpers.c"
static int
-virMockStatRedirect(const char *path ATTRIBUTE_UNUSED, char **newpath ATTRIBUTE_UNUSED)
+virMockStatRedirect(const char *path G_GNUC_UNUSED, char **newpath G_GNUC_UNUSED)
{
return 0;
}
}
-int virFileLock(int fd ATTRIBUTE_UNUSED,
- bool shared ATTRIBUTE_UNUSED,
- off_t start ATTRIBUTE_UNUSED,
- off_t len ATTRIBUTE_UNUSED,
- bool waitForLock ATTRIBUTE_UNUSED)
+int virFileLock(int fd G_GNUC_UNUSED,
+ bool shared G_GNUC_UNUSED,
+ off_t start G_GNUC_UNUSED,
+ off_t len G_GNUC_UNUSED,
+ bool waitForLock G_GNUC_UNUSED)
{
return 0;
}
-int virFileUnlock(int fd ATTRIBUTE_UNUSED,
- off_t start ATTRIBUTE_UNUSED,
- off_t len ATTRIBUTE_UNUSED)
+int virFileUnlock(int fd G_GNUC_UNUSED,
+ off_t start G_GNUC_UNUSED,
+ off_t len G_GNUC_UNUSED)
{
return 0;
}
static int
-testVUPrecedence(const void *opaque ATTRIBUTE_UNUSED)
+testVUPrecedence(const void *opaque G_GNUC_UNUSED)
{
VIR_AUTOFREE(char *) fakehome = NULL;
VIR_AUTOSTRINGLIST vuList = NULL;
* variables that support it.
*/
unsigned long long
-virMemoryMaxValue(bool capped ATTRIBUTE_UNUSED)
+virMemoryMaxValue(bool capped G_GNUC_UNUSED)
{
return LLONG_MAX;
}
char *
-virSCSIDeviceGetSgName(const char *sysfs_prefix ATTRIBUTE_UNUSED,
- const char *adapter ATTRIBUTE_UNUSED,
- unsigned int bus ATTRIBUTE_UNUSED,
- unsigned int target ATTRIBUTE_UNUSED,
- unsigned long long unit ATTRIBUTE_UNUSED)
+virSCSIDeviceGetSgName(const char *sysfs_prefix G_GNUC_UNUSED,
+ const char *adapter G_GNUC_UNUSED,
+ unsigned int bus G_GNUC_UNUSED,
+ unsigned int target G_GNUC_UNUSED,
+ unsigned long long unit G_GNUC_UNUSED)
{
char *ret;
int
virNetDevTapCreate(char **ifname,
- const char *tunpath ATTRIBUTE_UNUSED,
+ const char *tunpath G_GNUC_UNUSED,
int *tapfd,
size_t tapfdSize,
- unsigned int flags ATTRIBUTE_UNUSED)
+ unsigned int flags G_GNUC_UNUSED)
{
size_t i;
}
int
-virNetDevSetMAC(const char *ifname ATTRIBUTE_UNUSED,
- const virMacAddr *macaddr ATTRIBUTE_UNUSED)
+virNetDevSetMAC(const char *ifname G_GNUC_UNUSED,
+ const virMacAddr *macaddr G_GNUC_UNUSED)
{
return 0;
}
}
-int virNetDevIPAddrAdd(const char *ifname ATTRIBUTE_UNUSED,
- virSocketAddr *addr ATTRIBUTE_UNUSED,
- virSocketAddr *peer ATTRIBUTE_UNUSED,
- unsigned int prefix ATTRIBUTE_UNUSED)
+int virNetDevIPAddrAdd(const char *ifname G_GNUC_UNUSED,
+ virSocketAddr *addr G_GNUC_UNUSED,
+ virSocketAddr *peer G_GNUC_UNUSED,
+ unsigned int prefix G_GNUC_UNUSED)
{
return 0;
}
int
-virNetDevSetOnline(const char *ifname ATTRIBUTE_UNUSED,
- bool online ATTRIBUTE_UNUSED)
+virNetDevSetOnline(const char *ifname G_GNUC_UNUSED,
+ bool online G_GNUC_UNUSED)
{
return 0;
}
int
-virNetDevRunEthernetScript(const char *ifname ATTRIBUTE_UNUSED,
- const char *script ATTRIBUTE_UNUSED)
+virNetDevRunEthernetScript(const char *ifname G_GNUC_UNUSED,
+ const char *script G_GNUC_UNUSED)
{
return 0;
}
}
int
-virNetDevOpenvswitchGetVhostuserIfname(const char *path ATTRIBUTE_UNUSED,
+virNetDevOpenvswitchGetVhostuserIfname(const char *path G_GNUC_UNUSED,
char **ifname)
{
return VIR_STRDUP(*ifname, "vhost-user0");
}
int
-qemuInterfaceOpenVhostNet(virDomainDefPtr def ATTRIBUTE_UNUSED,
+qemuInterfaceOpenVhostNet(virDomainDefPtr def G_GNUC_UNUSED,
virDomainNetDefPtr net,
int *vhostfd,
size_t *vhostfdSize)
int
-qemuOpenChrChardevUNIXSocket(const virDomainChrSourceDef *dev ATTRIBUTE_UNUSED)
+qemuOpenChrChardevUNIXSocket(const virDomainChrSourceDef *dev G_GNUC_UNUSED)
{
/* We need to return an FD number for a UNIX listener socket,
int
-qemuBuildTPMOpenBackendFDs(const char *tpmdev ATTRIBUTE_UNUSED,
- const char *cancel_path ATTRIBUTE_UNUSED,
+qemuBuildTPMOpenBackendFDs(const char *tpmdev G_GNUC_UNUSED,
+ const char *cancel_path G_GNUC_UNUSED,
int *tpmfd,
int *cancelfd)
{
static virQEMUDriver driver;
static unsigned char *
-fakeSecretGetValue(virSecretPtr obj ATTRIBUTE_UNUSED,
+fakeSecretGetValue(virSecretPtr obj G_GNUC_UNUSED,
size_t *value_size,
- unsigned int fakeflags ATTRIBUTE_UNUSED,
- unsigned int internalFlags ATTRIBUTE_UNUSED)
+ unsigned int fakeflags G_GNUC_UNUSED,
+ unsigned int internalFlags G_GNUC_UNUSED)
{
char *secret;
if (VIR_STRDUP(secret, "AQCVn5hO6HzFAhAAq0NCv8jtJcIcE+HOBlMQ1A") < 0)
static char *
fakeStoragePoolGetXMLDesc(virStoragePoolPtr pool,
- unsigned int flags_unused ATTRIBUTE_UNUSED)
+ unsigned int flags_unused G_GNUC_UNUSED)
{
char *xmlpath = NULL;
char *xmlbuf = NULL;
static int
-fakeNWFilterBindingDelete(virNWFilterBindingPtr binding ATTRIBUTE_UNUSED)
+fakeNWFilterBindingDelete(virNWFilterBindingPtr binding G_GNUC_UNUSED)
{
return 0;
}
/* Test virReadSCSIUniqueId */
static int
-testVirReadSCSIUniqueId(const void *data ATTRIBUTE_UNUSED)
+testVirReadSCSIUniqueId(const void *data G_GNUC_UNUSED)
{
int hostnum, unique_id;
/* Test virSCSIHostFindByPCI */
static int
-testVirFindSCSIHostByPCI(const void *data ATTRIBUTE_UNUSED)
+testVirFindSCSIHostByPCI(const void *data G_GNUC_UNUSED)
{
unsigned int unique_id1 = 1;
unsigned int unique_id2 = 2;
const char *role,
const char *type,
int sensMin,
- int sensMax ATTRIBUTE_UNUSED,
+ int sensMax G_GNUC_UNUSED,
int catMin,
int catMax)
{
#include "internal.h"
-static void shunloadError(void *userData ATTRIBUTE_UNUSED,
- virErrorPtr error ATTRIBUTE_UNUSED)
+static void shunloadError(void *userData G_GNUC_UNUSED,
+ virErrorPtr error G_GNUC_UNUSED)
{
}
* we don't want 'shunloadtest' itself to link against
* libvirt.so. We need to test dlopen()'ing of libvirt.so
*/
-int main(int argc ATTRIBUTE_UNUSED, char **argv)
+int main(int argc G_GNUC_UNUSED, char **argv)
{
void (*startup)(void);
pthread_t t;
}
#else /* !WIN32 */
int
-virTestCaptureProgramOutput(const char *const argv[] ATTRIBUTE_UNUSED,
- char **buf ATTRIBUTE_UNUSED,
- int maxlen ATTRIBUTE_UNUSED)
+virTestCaptureProgramOutput(const char *const argv[] G_GNUC_UNUSED,
+ char **buf G_GNUC_UNUSED,
+ int maxlen G_GNUC_UNUSED)
{
return -1;
}
}
static void
-virTestErrorFuncQuiet(void *data ATTRIBUTE_UNUSED,
- virErrorPtr err ATTRIBUTE_UNUSED)
+virTestErrorFuncQuiet(void *data G_GNUC_UNUSED,
+ virErrorPtr err G_GNUC_UNUSED)
{ }
static struct virtTestLogData testLog = { VIR_BUFFER_INITIALIZER };
static void
-virtTestLogOutput(virLogSourcePtr source ATTRIBUTE_UNUSED,
- virLogPriority priority ATTRIBUTE_UNUSED,
- const char *filename ATTRIBUTE_UNUSED,
- int lineno ATTRIBUTE_UNUSED,
- const char *funcname ATTRIBUTE_UNUSED,
+virtTestLogOutput(virLogSourcePtr source G_GNUC_UNUSED,
+ virLogPriority priority G_GNUC_UNUSED,
+ const char *filename G_GNUC_UNUSED,
+ int lineno G_GNUC_UNUSED,
+ const char *funcname G_GNUC_UNUSED,
const char *timestamp,
- virLogMetadataPtr metadata ATTRIBUTE_UNUSED,
+ virLogMetadataPtr metadata G_GNUC_UNUSED,
unsigned int flags,
- const char *rawstr ATTRIBUTE_UNUSED,
+ const char *rawstr G_GNUC_UNUSED,
const char *str,
void *data)
{
static int
-testQEMUSchemaValidateObjectMergeVariantMember(size_t pos ATTRIBUTE_UNUSED,
+testQEMUSchemaValidateObjectMergeVariantMember(size_t pos G_GNUC_UNUSED,
virJSONValuePtr item,
void *opaque)
{
static int
-testQEMUSchemaValidateObjectMandatoryMember(size_t pos ATTRIBUTE_UNUSED,
+testQEMUSchemaValidateObjectMandatoryMember(size_t pos G_GNUC_UNUSED,
virJSONValuePtr item,
- void *opaque ATTRIBUTE_UNUSED)
+ void *opaque G_GNUC_UNUSED)
{
struct testQEMUSchemaValidateObjectMemberData *data = opaque;
};
static int
-testIndexToDiskName(const void *data ATTRIBUTE_UNUSED)
+testIndexToDiskName(const void *data G_GNUC_UNUSED)
{
size_t i;
char *diskName = NULL;
static int
-testDiskNameToIndex(const void *data ATTRIBUTE_UNUSED)
+testDiskNameToIndex(const void *data G_GNUC_UNUSED)
{
size_t i;
int idx;
static int
-testDiskNameParse(const void *data ATTRIBUTE_UNUSED)
+testDiskNameParse(const void *data G_GNUC_UNUSED)
{
size_t i;
int idx;
};
static int
-testParseVersionString(const void *data ATTRIBUTE_UNUSED)
+testParseVersionString(const void *data G_GNUC_UNUSED)
{
int result;
size_t i;
};
static int
-testRoundValueToPowerOfTwo(const void *data ATTRIBUTE_UNUSED)
+testRoundValueToPowerOfTwo(const void *data G_GNUC_UNUSED)
{
unsigned int result;
size_t i;
}
static int
-testOverflowCheckMacro(const void *data ATTRIBUTE_UNUSED)
+testOverflowCheckMacro(const void *data G_GNUC_UNUSED)
{
long long tmp;
uint8_t luchar;
}
static int
-testAllocScalar(const void *opaque ATTRIBUTE_UNUSED)
+testAllocScalar(const void *opaque G_GNUC_UNUSED)
{
testDummyStruct *t;
int ret = -1;
static int
-testAllocArray(const void *opaque ATTRIBUTE_UNUSED)
+testAllocArray(const void *opaque G_GNUC_UNUSED)
{
testDummyStruct *t;
size_t nt = 10, i;
static int
-testReallocArray(const void *opaque ATTRIBUTE_UNUSED)
+testReallocArray(const void *opaque G_GNUC_UNUSED)
{
testDummyStruct *t;
size_t nt = 10, i;
static int
-testExpandArray(const void *opaque ATTRIBUTE_UNUSED)
+testExpandArray(const void *opaque G_GNUC_UNUSED)
{
testDummyStruct *t;
size_t nt = 10, i;
static int
-testResizeArray(const void *opaque ATTRIBUTE_UNUSED)
+testResizeArray(const void *opaque G_GNUC_UNUSED)
{
testDummyStruct *t;
size_t nt = 10, at, i;
static int
-testInsertArray(const void *opaque ATTRIBUTE_UNUSED)
+testInsertArray(const void *opaque G_GNUC_UNUSED)
{
testDummyStruct **t;
size_t nt = 10, i;
static int
-testDispose(const void *opaque ATTRIBUTE_UNUSED)
+testDispose(const void *opaque G_GNUC_UNUSED)
{
int *num = NULL;
int *nums = NULL;
#include "virthread.h"
static int
-testTypes(const void *data ATTRIBUTE_UNUSED)
+testTypes(const void *data G_GNUC_UNUSED)
{
unsigned int u, u2;
int s, s2;
}
static int
-testThreads(const void *data ATTRIBUTE_UNUSED)
+testThreads(const void *data G_GNUC_UNUSED)
{
int sum;
size_t i;
#include "virbitmap.h"
static int
-test1(const void *data ATTRIBUTE_UNUSED)
+test1(const void *data G_GNUC_UNUSED)
{
virBitmapPtr bitmap;
int size;
}
static int
-test2(const void *data ATTRIBUTE_UNUSED)
+test2(const void *data G_GNUC_UNUSED)
{
const char *bitsString1 = "1-32,50,88-99,1021-1023";
char *bitsString2 = NULL;
}
static int
-test3(const void *data ATTRIBUTE_UNUSED)
+test3(const void *data G_GNUC_UNUSED)
{
virBitmapPtr bitmap = NULL;
int ret = -1;
/* test for virBitmapNextSetBit, virBitmapLastSetBit, virBitmapNextClearBit */
static int
-test4(const void *data ATTRIBUTE_UNUSED)
+test4(const void *data G_GNUC_UNUSED)
{
const char *bitsString = "0, 2-4, 6-10, 12, 14-18, 20, 22, 25";
int size = 40;
/* test for virBitmapNewData/ToData/DataFormat */
static int
-test5(const void *v ATTRIBUTE_UNUSED)
+test5(const void *v G_GNUC_UNUSED)
{
char data[] = {0x01, 0x02, 0x00, 0x00, 0x04};
unsigned char *data2 = NULL;
/* test for virBitmapFormat */
static int
-test6(const void *v ATTRIBUTE_UNUSED)
+test6(const void *v G_GNUC_UNUSED)
{
virBitmapPtr bitmap = NULL;
char *str = NULL;
}
static int
-test7(const void *v ATTRIBUTE_UNUSED)
+test7(const void *v G_GNUC_UNUSED)
{
virBitmapPtr bitmap;
size_t i;
}
static int
-test8(const void *v ATTRIBUTE_UNUSED)
+test8(const void *v G_GNUC_UNUSED)
{
virBitmapPtr bitmap = NULL;
char data[108] = {0x00,};
/* test out of bounds conditions on virBitmapParse */
static int
-test9(const void *opaque ATTRIBUTE_UNUSED)
+test9(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
virBitmapPtr bitmap = NULL;
}
static int
-test10(const void *opaque ATTRIBUTE_UNUSED)
+test10(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
virBitmapPtr b1 = NULL, b2 = NULL, b3 = NULL, b4 = NULL;
/* test self-expanding bitmap APIs */
static int
-test12(const void *opaque ATTRIBUTE_UNUSED)
+test12(const void *opaque G_GNUC_UNUSED)
{
virBitmapPtr map = NULL;
int ret = -1;
/* virBitmap(New/To)String */
static int
-test13(const void *opaque ATTRIBUTE_UNUSED)
+test13(const void *opaque G_GNUC_UNUSED)
{
virBitmapPtr map = NULL;
const char *strings[] = { "1234feebee", "000c0fefe" };
return ret;
}
-static int testBufAutoIndent(const void *data ATTRIBUTE_UNUSED)
+static int testBufAutoIndent(const void *data G_GNUC_UNUSED)
{
virBuffer bufinit = VIR_BUFFER_INITIALIZER;
virBufferPtr buf = &bufinit;
return ret;
}
-static int testBufTrim(const void *data ATTRIBUTE_UNUSED)
+static int testBufTrim(const void *data G_GNUC_UNUSED)
{
virBuffer bufinit = VIR_BUFFER_INITIALIZER;
virBufferPtr buf = NULL;
return ret;
}
-static int testBufAddBuffer(const void *data ATTRIBUTE_UNUSED)
+static int testBufAddBuffer(const void *data G_GNUC_UNUSED)
{
virBuffer buf1 = VIR_BUFFER_INITIALIZER;
virBuffer buf2 = VIR_BUFFER_INITIALIZER;
}
static int
-testBufAddBuffer2(const void *opaque ATTRIBUTE_UNUSED)
+testBufAddBuffer2(const void *opaque G_GNUC_UNUSED)
{
VIR_AUTOCLEAN(virBuffer) buf1 = VIR_BUFFER_INITIALIZER;
VIR_AUTOCLEAN(virBuffer) buf2 = VIR_BUFFER_INITIALIZER;
};
static int
-testBufAddStr(const void *opaque ATTRIBUTE_UNUSED)
+testBufAddStr(const void *opaque G_GNUC_UNUSED)
{
const struct testBufAddStrData *data = opaque;
virBuffer buf = VIR_BUFFER_INITIALIZER;
static int
-testBufEscapeStr(const void *opaque ATTRIBUTE_UNUSED)
+testBufEscapeStr(const void *opaque G_GNUC_UNUSED)
{
const struct testBufAddStrData *data = opaque;
virBuffer buf = VIR_BUFFER_INITIALIZER;
static int
-testBufSetIndent(const void *opaque ATTRIBUTE_UNUSED)
+testBufSetIndent(const void *opaque G_GNUC_UNUSED)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
char *actual;
/* Result of this shows up only in valgrind or similar */
static int
-testBufferAutoclean(const void *opaque ATTRIBUTE_UNUSED)
+testBufferAutoclean(const void *opaque G_GNUC_UNUSED)
{
VIR_AUTOCLEAN(virBuffer) buf = VIR_BUFFER_INITIALIZER;
static int
-test_virCapabilitiesGetCpusForNodemask(const void *data ATTRIBUTE_UNUSED)
+test_virCapabilitiesGetCpusForNodemask(const void *data G_GNUC_UNUSED)
{
const char *nodestr = "3,4,5,6";
virBitmapPtr nodemask = NULL;
}
-static bool ATTRIBUTE_UNUSED
+static bool G_GNUC_UNUSED
doCapsExpectFailure(virCapsPtr caps,
int ostype,
virArch arch,
return true;
}
-static bool ATTRIBUTE_UNUSED
+static bool G_GNUC_UNUSED
doCapsCompare(virCapsPtr caps,
int ostype,
virArch arch,
#ifdef WITH_QEMU
static int
-test_virCapsDomainDataLookupQEMU(const void *data ATTRIBUTE_UNUSED)
+test_virCapsDomainDataLookupQEMU(const void *data G_GNUC_UNUSED)
{
int ret = 0;
virCapsPtr caps = NULL;
#ifdef WITH_LXC
static int
-test_virCapsDomainDataLookupLXC(const void *data ATTRIBUTE_UNUSED)
+test_virCapsDomainDataLookupLXC(const void *data G_GNUC_UNUSED)
{
int ret = 0;
virCapsPtr caps = NULL;
}
-static int testCgroupNewForSelf(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForSelf(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
int ret = -1;
/* Asking for impossible combination since CPU is co-mounted */
-static int testCgroupNewForPartition(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForPartition(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
int ret = -1;
}
-static int testCgroupNewForPartitionNested(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForPartitionNested(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
int ret = -1;
}
-static int testCgroupNewForPartitionNestedDeep(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForPartitionNestedDeep(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
int ret = -1;
-static int testCgroupNewForPartitionDomain(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForPartitionDomain(const void *args G_GNUC_UNUSED)
{
virCgroupPtr partitioncgroup = NULL;
virCgroupPtr domaincgroup = NULL;
return ret;
}
-static int testCgroupNewForPartitionDomainEscaped(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForPartitionDomainEscaped(const void *args G_GNUC_UNUSED)
{
virCgroupPtr partitioncgroup1 = NULL;
virCgroupPtr partitioncgroup2 = NULL;
return ret;
}
-static int testCgroupNewForSelfAllInOne(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForSelfAllInOne(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
int ret = -1;
}
-static int testCgroupNewForSelfLogind(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForSelfLogind(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
}
-static int testCgroupNewForSelfUnified(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForSelfUnified(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
int ret = -1;
}
-static int testCgroupNewForSelfHybrid(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupNewForSelfHybrid(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
int ret = -1;
return 0;
}
-static int testCgroupControllerAvailable(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupControllerAvailable(const void *args G_GNUC_UNUSED)
{
int ret = 0;
return ret;
}
-static int testCgroupGetPercpuStats(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupGetPercpuStats(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
size_t i;
return ret;
}
-static int testCgroupGetMemoryUsage(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupGetMemoryUsage(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
int rv, ret = -1;
static int
-testCgroupGetMemoryStat(const void *args ATTRIBUTE_UNUSED)
+testCgroupGetMemoryStat(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
int rv;
}
-static int testCgroupGetBlkioIoServiced(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupGetBlkioIoServiced(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
size_t i;
return ret;
}
-static int testCgroupGetBlkioIoDeviceServiced(const void *args ATTRIBUTE_UNUSED)
+static int testCgroupGetBlkioIoDeviceServiced(const void *args G_GNUC_UNUSED)
{
virCgroupPtr cgroup = NULL;
size_t i;
}
-static int testConfMemoryNoNewline(const void *opaque ATTRIBUTE_UNUSED)
+static int testConfMemoryNoNewline(const void *opaque G_GNUC_UNUSED)
{
const char *srcdata = \
"ullong = '123456789'\n" \
}
-static int testConfParseInt(const void *opaque ATTRIBUTE_UNUSED)
+static int testConfParseInt(const void *opaque G_GNUC_UNUSED)
{
const char *srcdata = \
"int = -1729\n" \
return 0;
}
-static int testConfParseBool(const void *opaque ATTRIBUTE_UNUSED)
+static int testConfParseBool(const void *opaque G_GNUC_UNUSED)
{
const char *srcdata = \
"false = 0\n" \
}
-static int testConfParseString(const void *opaque ATTRIBUTE_UNUSED)
+static int testConfParseString(const void *opaque G_GNUC_UNUSED)
{
const char *srcdata = \
"int = 6963472309248\n" \
}
-static int testConfParseStringList(const void *opaque ATTRIBUTE_UNUSED)
+static int testConfParseStringList(const void *opaque G_GNUC_UNUSED)
{
const char *srcdata = \
"string_list = [\"foo\", \"bar\"]\n" \
} \
} while (0)
-static int testMessageSimple(const void *args ATTRIBUTE_UNUSED)
+static int testMessageSimple(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
}
-static int testMessageVariant(const void *args ATTRIBUTE_UNUSED)
+static int testMessageVariant(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
return ret;
}
-static int testMessageArray(const void *args ATTRIBUTE_UNUSED)
+static int testMessageArray(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
return ret;
}
-static int testMessageEmptyArrayRef(const void *args ATTRIBUTE_UNUSED)
+static int testMessageEmptyArrayRef(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
return ret;
}
-static int testMessageSingleArrayRef(const void *args ATTRIBUTE_UNUSED)
+static int testMessageSingleArrayRef(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
return ret;
}
-static int testMessageArrayRef(const void *args ATTRIBUTE_UNUSED)
+static int testMessageArrayRef(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
return ret;
}
-static int testMessageStruct(const void *args ATTRIBUTE_UNUSED)
+static int testMessageStruct(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
}
-static int testMessageDict(const void *args ATTRIBUTE_UNUSED)
+static int testMessageDict(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
return ret;
}
-static int testMessageDictRef(const void *args ATTRIBUTE_UNUSED)
+static int testMessageDictRef(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
return ret;
}
-static int testMessageEmptyDictRef(const void *args ATTRIBUTE_UNUSED)
+static int testMessageEmptyDictRef(const void *args G_GNUC_UNUSED)
{
DBusMessage *msg = NULL;
int ret = -1;
uint32_t
virHashCodeGen(const void *key,
size_t len,
- uint32_t seed ATTRIBUTE_UNUSED)
+ uint32_t seed G_GNUC_UNUSED)
{
const uint8_t *k = key;
uint32_t h = 0;
#include "virendian.h"
static int
-test1(const void *data ATTRIBUTE_UNUSED)
+test1(const void *data G_GNUC_UNUSED)
{
/* Regular char should work, even if signed, and even with
* unaligned access. */
}
static int
-test2(const void *data ATTRIBUTE_UNUSED)
+test2(const void *data G_GNUC_UNUSED)
{
/* Unsigned char should work without cast, even if unaligned access. */
unsigned char array[] = { 1, 2, 3, 4, 5, 6, 7, 8,
static int
-virErrorTestMsgs(const void *opaque ATTRIBUTE_UNUSED)
+virErrorTestMsgs(const void *opaque G_GNUC_UNUSED)
{
const char *err_noinfo;
const char *err_info;
int
-unlink(const char *path ATTRIBUTE_UNUSED)
+unlink(const char *path G_GNUC_UNUSED)
{
return 0;
}
static void *
-testFileCacheNewData(const char *name ATTRIBUTE_UNUSED,
+testFileCacheNewData(const char *name G_GNUC_UNUSED,
void *priv)
{
testFileCachePrivPtr testPriv = priv;
static void *
testFileCacheLoadFile(const char *filename,
- const char *name ATTRIBUTE_UNUSED,
- void *priv ATTRIBUTE_UNUSED)
+ const char *name G_GNUC_UNUSED,
+ void *priv G_GNUC_UNUSED)
{
testFileCacheObjPtr obj;
char *data;
static int
-testFileCacheSaveFile(void *data ATTRIBUTE_UNUSED,
- const char *filename ATTRIBUTE_UNUSED,
+testFileCacheSaveFile(void *data G_GNUC_UNUSED,
+ const char *filename G_GNUC_UNUSED,
void *priv)
{
testFileCachePrivPtr testPriv = priv;
#else /* !HAVE_DECL_SEEK_HOLE || !defined(__linux__)*/
static int
-makeSparseFile(const off_t offsets[] ATTRIBUTE_UNUSED,
- const bool startData ATTRIBUTE_UNUSED)
+makeSparseFile(const off_t offsets[] G_GNUC_UNUSED,
+ const bool startData G_GNUC_UNUSED)
{
return -1;
}
};
static int
-testFileIsSharedFSType(const void *opaque ATTRIBUTE_UNUSED)
+testFileIsSharedFSType(const void *opaque G_GNUC_UNUSED)
{
#ifndef __linux__
return EXIT_AM_SKIP;
static int
-testFirewallManyGroups(const void *opaque ATTRIBUTE_UNUSED)
+testFirewallManyGroups(const void *opaque G_GNUC_UNUSED)
{
virBuffer cmdbuf = VIR_BUFFER_INITIALIZER;
virFirewallPtr fw = NULL;
static void
testFirewallRollbackHook(const char *const*args,
- const char *const*env ATTRIBUTE_UNUSED,
- const char *input ATTRIBUTE_UNUSED,
- char **output ATTRIBUTE_UNUSED,
- char **error ATTRIBUTE_UNUSED,
+ const char *const*env G_GNUC_UNUSED,
+ const char *input G_GNUC_UNUSED,
+ char **output G_GNUC_UNUSED,
+ char **error G_GNUC_UNUSED,
int *status,
- void *opaque ATTRIBUTE_UNUSED)
+ void *opaque G_GNUC_UNUSED)
{
bool isAdd = false;
while (*args) {
}
static int
-testFirewallIgnoreFailGroup(const void *opaque ATTRIBUTE_UNUSED)
+testFirewallIgnoreFailGroup(const void *opaque G_GNUC_UNUSED)
{
virBuffer cmdbuf = VIR_BUFFER_INITIALIZER;
virFirewallPtr fw = NULL;
static int
-testFirewallIgnoreFailRule(const void *opaque ATTRIBUTE_UNUSED)
+testFirewallIgnoreFailRule(const void *opaque G_GNUC_UNUSED)
{
virBuffer cmdbuf = VIR_BUFFER_INITIALIZER;
virFirewallPtr fw = NULL;
static int
-testFirewallNoRollback(const void *opaque ATTRIBUTE_UNUSED)
+testFirewallNoRollback(const void *opaque G_GNUC_UNUSED)
{
virBuffer cmdbuf = VIR_BUFFER_INITIALIZER;
virFirewallPtr fw = NULL;
}
static int
-testFirewallSingleRollback(const void *opaque ATTRIBUTE_UNUSED)
+testFirewallSingleRollback(const void *opaque G_GNUC_UNUSED)
{
virBuffer cmdbuf = VIR_BUFFER_INITIALIZER;
virFirewallPtr fw = NULL;
}
static int
-testFirewallManyRollback(const void *opaque ATTRIBUTE_UNUSED)
+testFirewallManyRollback(const void *opaque G_GNUC_UNUSED)
{
virBuffer cmdbuf = VIR_BUFFER_INITIALIZER;
virFirewallPtr fw = NULL;
}
static int
-testFirewallChainedRollback(const void *opaque ATTRIBUTE_UNUSED)
+testFirewallChainedRollback(const void *opaque G_GNUC_UNUSED)
{
virBuffer cmdbuf = VIR_BUFFER_INITIALIZER;
virFirewallPtr fw = NULL;
static void
testFirewallQueryHook(const char *const*args,
- const char *const*env ATTRIBUTE_UNUSED,
- const char *input ATTRIBUTE_UNUSED,
+ const char *const*env G_GNUC_UNUSED,
+ const char *input G_GNUC_UNUSED,
char **output,
- char **error ATTRIBUTE_UNUSED,
+ char **error G_GNUC_UNUSED,
int *status,
- void *opaque ATTRIBUTE_UNUSED)
+ void *opaque G_GNUC_UNUSED)
{
if (STREQ(args[0], IPTABLES_PATH) &&
STREQ(args[1], "-L")) {
testFirewallQueryCallback(virFirewallPtr fw,
virFirewallLayer layer,
const char *const *lines,
- void *opaque ATTRIBUTE_UNUSED)
+ void *opaque G_GNUC_UNUSED)
{
size_t i;
virFirewallAddRule(fw, layer,
}
static int
-testFirewallQuery(const void *opaque ATTRIBUTE_UNUSED)
+testFirewallQuery(const void *opaque G_GNUC_UNUSED)
{
virBuffer cmdbuf = VIR_BUFFER_INITIALIZER;
virFirewallPtr fw = NULL;
}
static int
-testHashCheckForEachCount(void *payload ATTRIBUTE_UNUSED,
- const void *name ATTRIBUTE_UNUSED,
- void *data ATTRIBUTE_UNUSED)
+testHashCheckForEachCount(void *payload G_GNUC_UNUSED,
+ const void *name G_GNUC_UNUSED,
+ void *data G_GNUC_UNUSED)
{
size_t *count = data;
*count += 1;
static int
-testHashUpdate(const void *data ATTRIBUTE_UNUSED)
+testHashUpdate(const void *data G_GNUC_UNUSED)
{
int count = ARRAY_CARDINALITY(uuids) + ARRAY_CARDINALITY(uuids_new);
virHashTablePtr hash;
static int
-testHashRemove(const void *data ATTRIBUTE_UNUSED)
+testHashRemove(const void *data G_GNUC_UNUSED)
{
int count = ARRAY_CARDINALITY(uuids) - ARRAY_CARDINALITY(uuids_subset);
virHashTablePtr hash;
ARRAY_CARDINALITY(uuids) - ARRAY_CARDINALITY(uuids_subset);
static int
-testHashRemoveForEachSome(void *payload ATTRIBUTE_UNUSED,
+testHashRemoveForEachSome(void *payload G_GNUC_UNUSED,
const void *name,
void *data)
{
const int testHashCountRemoveForEachAll = 0;
static int
-testHashRemoveForEachAll(void *payload ATTRIBUTE_UNUSED,
+testHashRemoveForEachAll(void *payload G_GNUC_UNUSED,
const void *name,
void *data)
{
static int
-testHashSteal(const void *data ATTRIBUTE_UNUSED)
+testHashSteal(const void *data G_GNUC_UNUSED)
{
int count = ARRAY_CARDINALITY(uuids) - ARRAY_CARDINALITY(uuids_subset);
virHashTablePtr hash;
static int
-testHashRemoveSetIter(const void *payload ATTRIBUTE_UNUSED,
+testHashRemoveSetIter(const void *payload G_GNUC_UNUSED,
const void *name,
const void *data)
{
}
static int
-testHashRemoveSet(const void *data ATTRIBUTE_UNUSED)
+testHashRemoveSet(const void *data G_GNUC_UNUSED)
{
virHashTablePtr hash;
int count = 0;
const int testSearchIndex = ARRAY_CARDINALITY(uuids_subset) / 2;
static int
-testHashSearchIter(const void *payload ATTRIBUTE_UNUSED,
+testHashSearchIter(const void *payload G_GNUC_UNUSED,
const void *name,
- const void *data ATTRIBUTE_UNUSED)
+ const void *data G_GNUC_UNUSED)
{
return STREQ(uuids_subset[testSearchIndex], name);
}
static int
-testHashSearch(const void *data ATTRIBUTE_UNUSED)
+testHashSearch(const void *data G_GNUC_UNUSED)
{
virHashTablePtr hash;
void *entry;
}
static int
-testHashGetItems(const void *data ATTRIBUTE_UNUSED)
+testHashGetItems(const void *data G_GNUC_UNUSED)
{
virHashTablePtr hash;
virHashKeyValuePairPtr array = NULL;
}
static int
-testHashEqual(const void *data ATTRIBUTE_UNUSED)
+testHashEqual(const void *data G_GNUC_UNUSED)
{
virHashTablePtr hash1, hash2 = NULL;
int ret = -1;
* 2. Reattach devices to the host
*/
static int
-testVirHostdevRoundtripNoGuest(const void *opaque ATTRIBUTE_UNUSED)
+testVirHostdevRoundtripNoGuest(const void *opaque G_GNUC_UNUSED)
{
if (testVirHostdevDetachPCINodeDevice() < 0)
return -1;
* 4. Reattach devices to the host
*/
static int
-testVirHostdevRoundtripUnmanaged(const void *opaque ATTRIBUTE_UNUSED)
+testVirHostdevRoundtripUnmanaged(const void *opaque G_GNUC_UNUSED)
{
if (testVirHostdevDetachPCINodeDevice() < 0)
return -1;
* 2. Detach devices from the guest as managed
*/
static int
-testVirHostdevRoundtripManaged(const void *opaque ATTRIBUTE_UNUSED)
+testVirHostdevRoundtripManaged(const void *opaque G_GNUC_UNUSED)
{
if (testVirHostdevPreparePCIHostdevs_managed(false) < 0)
return -1;
* 4. Reattach devices to the host
*/
static int
-testVirHostdevRoundtripMixed(const void *opaque ATTRIBUTE_UNUSED)
+testVirHostdevRoundtripMixed(const void *opaque G_GNUC_UNUSED)
{
if (testVirHostdevDetachPCINodeDevice() < 0)
return -1;
* 2. Update list of active devices
*/
static int
-testVirHostdevOther(const void *opaque ATTRIBUTE_UNUSED)
+testVirHostdevOther(const void *opaque G_GNUC_UNUSED)
{
if (testVirHostdevResetPCINodeDevice() < 0)
return -1;
VIR_LOG_INIT("tests.identitytest");
-static int testIdentityAttrs(const void *data ATTRIBUTE_UNUSED)
+static int testIdentityAttrs(const void *data G_GNUC_UNUSED)
{
g_autoptr(virIdentity) ident = virIdentityNew();
const char *val;
return 0;
}
-static int testSetFakeSELinuxContext(const void *data ATTRIBUTE_UNUSED)
+static int testSetFakeSELinuxContext(const void *data G_GNUC_UNUSED)
{
#if WITH_SELINUX
return setcon_raw((security_context_t)data);
#endif
}
-static int testDisableFakeSELinux(const void *data ATTRIBUTE_UNUSED)
+static int testDisableFakeSELinux(const void *data G_GNUC_UNUSED)
{
#if WITH_SELINUX
return security_disable();
};
static void testIscsiadmCb(const char *const*args,
- const char *const*env ATTRIBUTE_UNUSED,
- const char *input ATTRIBUTE_UNUSED,
+ const char *const*env G_GNUC_UNUSED,
+ const char *input G_GNUC_UNUSED,
char **output,
- char **error ATTRIBUTE_UNUSED,
+ char **error G_GNUC_UNUSED,
int *status,
void *opaque)
{
static int
-testJSONEscapeObj(const void *data ATTRIBUTE_UNUSED)
+testJSONEscapeObj(const void *data G_GNUC_UNUSED)
{
VIR_AUTOPTR(virJSONValue) json = NULL;
VIR_AUTOPTR(virJSONValue) nestjson = NULL;
static int
-testJSONObjectFormatSteal(const void *opaque ATTRIBUTE_UNUSED)
+testJSONObjectFormatSteal(const void *opaque G_GNUC_UNUSED)
{
VIR_AUTOPTR(virJSONValue) a1 = NULL;
VIR_AUTOPTR(virJSONValue) a2 = NULL;
VIR_LOG_INIT("tests.keycodetest");
-static int testKeycodeMapping(const void *data ATTRIBUTE_UNUSED)
+static int testKeycodeMapping(const void *data G_GNUC_UNUSED)
{
int ret = -1;
int got;
}
-static int testKeycodeStrings(const void *data ATTRIBUTE_UNUSED)
+static int testKeycodeStrings(const void *data G_GNUC_UNUSED)
{
int ret = -1;
int got;
VIR_LOG_INIT("tests.keyfiletest");
-static int testParse(const void *args ATTRIBUTE_UNUSED)
+static int testParse(const void *args G_GNUC_UNUSED)
{
static const char *cfg1 =
"# Some config\n"
# define VIR_FROM_THIS VIR_FROM_NONE
static int
-testKModConfig(const void *args ATTRIBUTE_UNUSED)
+testKModConfig(const void *args G_GNUC_UNUSED)
{
int ret = -1;
char *outbuf = NULL;
#define LOCKSPACE_DIR abs_builddir "/virlockspacedata"
-static int testLockSpaceCreate(const void *args ATTRIBUTE_UNUSED)
+static int testLockSpaceCreate(const void *args G_GNUC_UNUSED)
{
virLockSpacePtr lockspace;
int ret = -1;
}
-static int testLockSpaceResourceLifecycle(const void *args ATTRIBUTE_UNUSED)
+static int testLockSpaceResourceLifecycle(const void *args G_GNUC_UNUSED)
{
virLockSpacePtr lockspace;
int ret = -1;
}
-static int testLockSpaceResourceLockExcl(const void *args ATTRIBUTE_UNUSED)
+static int testLockSpaceResourceLockExcl(const void *args G_GNUC_UNUSED)
{
virLockSpacePtr lockspace;
int ret = -1;
}
-static int testLockSpaceResourceLockExclAuto(const void *args ATTRIBUTE_UNUSED)
+static int testLockSpaceResourceLockExclAuto(const void *args G_GNUC_UNUSED)
{
virLockSpacePtr lockspace;
int ret = -1;
}
-static int testLockSpaceResourceLockShr(const void *args ATTRIBUTE_UNUSED)
+static int testLockSpaceResourceLockShr(const void *args G_GNUC_UNUSED)
{
virLockSpacePtr lockspace;
int ret = -1;
}
-static int testLockSpaceResourceLockShrAuto(const void *args ATTRIBUTE_UNUSED)
+static int testLockSpaceResourceLockShrAuto(const void *args G_GNUC_UNUSED)
{
virLockSpacePtr lockspace;
int ret = -1;
}
-static int testLockSpaceResourceLockPath(const void *args ATTRIBUTE_UNUSED)
+static int testLockSpaceResourceLockPath(const void *args G_GNUC_UNUSED)
{
virLockSpacePtr lockspace;
int ret = -1;
#define VIR_MOCK_ARGNAME(a, b) b
#define VIR_MOCK_ARGTYPE(a, b) a
#define VIR_MOCK_ARGTYPENAME(a, b) a b
-#define VIR_MOCK_ARGTYPENAME_UNUSED(a, b) a b ATTRIBUTE_UNUSED
+#define VIR_MOCK_ARGTYPENAME_UNUSED(a, b) a b G_GNUC_UNUSED
#define VIR_MOCK_GET_ARG2(z, a, b) z(a, b)
#define VIR_MOCK_GET_ARG3(z, a, b, c) z(a, b)
static void *
-testClientNew(virNetServerClientPtr client ATTRIBUTE_UNUSED,
- void *opaque ATTRIBUTE_UNUSED)
+testClientNew(virNetServerClientPtr client G_GNUC_UNUSED,
+ void *opaque G_GNUC_UNUSED)
{
struct testClientPriv *priv;
static virJSONValuePtr
-testClientPreExec(virNetServerClientPtr client ATTRIBUTE_UNUSED,
+testClientPreExec(virNetServerClientPtr client G_GNUC_UNUSED,
void *data)
{
struct testClientPriv *priv = data;
};
static virNetServerPtr
-testNewServerPostExecRestart(virNetDaemonPtr dmn ATTRIBUTE_UNUSED,
+testNewServerPostExecRestart(virNetDaemonPtr dmn G_GNUC_UNUSED,
const char *name,
virJSONValuePtr object,
void *opaque)
VIR_LOG_INIT("tests.netmessagetest");
-static int testMessageHeaderEncode(const void *args ATTRIBUTE_UNUSED)
+static int testMessageHeaderEncode(const void *args G_GNUC_UNUSED)
{
virNetMessagePtr msg = virNetMessageNew(true);
static const char expect[] = {
return ret;
}
-static int testMessageHeaderDecode(const void *args ATTRIBUTE_UNUSED)
+static int testMessageHeaderDecode(const void *args G_GNUC_UNUSED)
{
virNetMessagePtr msg = virNetMessageNew(true);
static char input_buf [] = {
return ret;
}
-static int testMessagePayloadEncode(const void *args ATTRIBUTE_UNUSED)
+static int testMessagePayloadEncode(const void *args G_GNUC_UNUSED)
{
virNetMessageError err;
virNetMessagePtr msg = virNetMessageNew(true);
return ret;
}
-static int testMessagePayloadDecode(const void *args ATTRIBUTE_UNUSED)
+static int testMessagePayloadDecode(const void *args G_GNUC_UNUSED)
{
virNetMessageError err;
virNetMessagePtr msg = virNetMessageNew(true);
return ret;
}
-static int testMessagePayloadStreamEncode(const void *args ATTRIBUTE_UNUSED)
+static int testMessagePayloadStreamEncode(const void *args G_GNUC_UNUSED)
{
char stream[] = "The quick brown fox jumps over the lazy dog";
virNetMessagePtr msg = virNetMessageNew(true);
#include "virutil.h"
#include "internal.h"
-int virEventAddTimeout(int frequency ATTRIBUTE_UNUSED,
- virEventTimeoutCallback cb ATTRIBUTE_UNUSED,
- void *opaque ATTRIBUTE_UNUSED,
- virFreeCallback ff ATTRIBUTE_UNUSED)
+int virEventAddTimeout(int frequency G_GNUC_UNUSED,
+ virEventTimeoutCallback cb G_GNUC_UNUSED,
+ void *opaque G_GNUC_UNUSED,
+ virFreeCallback ff G_GNUC_UNUSED)
{
return 0;
}
-int virNetSocketGetUNIXIdentity(virNetSocketPtr sock ATTRIBUTE_UNUSED,
+int virNetSocketGetUNIXIdentity(virNetSocketPtr sock G_GNUC_UNUSED,
uid_t *uid,
gid_t *gid,
pid_t *pid,
return 0;
}
-char *virGetUserName(uid_t uid ATTRIBUTE_UNUSED)
+char *virGetUserName(uid_t uid G_GNUC_UNUSED)
{
return strdup("astrochicken");
}
-char *virGetGroupName(gid_t gid ATTRIBUTE_UNUSED)
+char *virGetGroupName(gid_t gid G_GNUC_UNUSED)
{
return strdup("fictionalusers");
}
-int virNetSocketGetSELinuxContext(virNetSocketPtr sock ATTRIBUTE_UNUSED,
+int virNetSocketGetSELinuxContext(virNetSocketPtr sock G_GNUC_UNUSED,
char **context)
{
if (!(*context = strdup("foo_u:bar_r:wizz_t:s0-s0:c0.c1023")))
#ifdef HAVE_SOCKETPAIR
static void *
-testClientNew(virNetServerClientPtr client ATTRIBUTE_UNUSED,
- void *opaque ATTRIBUTE_UNUSED)
+testClientNew(virNetServerClientPtr client G_GNUC_UNUSED,
+ void *opaque G_GNUC_UNUSED)
{
char *dummy;
VIR_FREE(opaque);
}
-static int testIdentity(const void *opaque ATTRIBUTE_UNUSED)
+static int testIdentity(const void *opaque G_GNUC_UNUSED)
{
int sv[2];
int ret = -1;
static void
testSocketIncoming(virNetSocketPtr sock,
- int events ATTRIBUTE_UNUSED,
+ int events G_GNUC_UNUSED,
void *opaque)
{
virNetSocketPtr *retsock = opaque;
#ifndef WIN32
-static int testSocketUNIXAddrs(const void *data ATTRIBUTE_UNUSED)
+static int testSocketUNIXAddrs(const void *data G_GNUC_UNUSED)
{
virNetSocketPtr lsock = NULL; /* Listen socket */
virNetSocketPtr ssock = NULL; /* Server socket */
return ret;
}
-static int testSocketCommandNormal(const void *data ATTRIBUTE_UNUSED)
+static int testSocketCommandNormal(const void *data G_GNUC_UNUSED)
{
virNetSocketPtr csock = NULL; /* Client socket */
char buf[100];
return ret;
}
-static int testSocketCommandFail(const void *data ATTRIBUTE_UNUSED)
+static int testSocketCommandFail(const void *data G_GNUC_UNUSED)
{
virNetSocketPtr csock = NULL; /* Client socket */
char buf[100];
}
int
-virNumaGetDistances(int node ATTRIBUTE_UNUSED,
+virNumaGetDistances(int node G_GNUC_UNUSED,
int **distances,
int *ndistances)
{
}
static int
-pci_driver_handle_change(int fd ATTRIBUTE_UNUSED, const char *path)
+pci_driver_handle_change(int fd G_GNUC_UNUSED, const char *path)
{
int ret;
const char *file = last_component(path);
}
static int
-testVirPCIDeviceNew(const void *opaque ATTRIBUTE_UNUSED)
+testVirPCIDeviceNew(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
virPCIDevicePtr dev;
}
static int
-testVirPCIDeviceDetach(const void *opaque ATTRIBUTE_UNUSED)
+testVirPCIDeviceDetach(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
virPCIDevicePtr dev[] = {NULL, NULL, NULL};
}
static int
-testVirPCIDeviceReset(const void *opaque ATTRIBUTE_UNUSED)
+testVirPCIDeviceReset(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
virPCIDevicePtr dev[] = {NULL, NULL, NULL};
}
static int
-testVirPCIDeviceReattach(const void *opaque ATTRIBUTE_UNUSED)
+testVirPCIDeviceReattach(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
virPCIDevicePtr dev[] = {NULL, NULL, NULL};
-static int testPolkitAuthSuccess(const void *opaque ATTRIBUTE_UNUSED)
+static int testPolkitAuthSuccess(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
}
-static int testPolkitAuthDenied(const void *opaque ATTRIBUTE_UNUSED)
+static int testPolkitAuthDenied(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
int rv;
}
-static int testPolkitAuthChallenge(const void *opaque ATTRIBUTE_UNUSED)
+static int testPolkitAuthChallenge(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
int rv;
}
-static int testPolkitAuthCancelled(const void *opaque ATTRIBUTE_UNUSED)
+static int testPolkitAuthCancelled(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
int rv;
}
-static int testPolkitAuthDetailsSuccess(const void *opaque ATTRIBUTE_UNUSED)
+static int testPolkitAuthDetailsSuccess(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
const char *details[] = {
}
-static int testPolkitAuthDetailsDenied(const void *opaque ATTRIBUTE_UNUSED)
+static int testPolkitAuthDetailsDenied(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
int rv;
return realsocket(domain, type, protocol);
}
-int bind(int sockfd ATTRIBUTE_UNUSED,
+int bind(int sockfd G_GNUC_UNUSED,
const struct sockaddr *addr,
- socklen_t addrlen ATTRIBUTE_UNUSED)
+ socklen_t addrlen G_GNUC_UNUSED)
{
struct sockaddr_in saddr;
VIR_LOG_INIT("tests.portallocatortest");
-static int testAllocAll(const void *args ATTRIBUTE_UNUSED)
+static int testAllocAll(const void *args G_GNUC_UNUSED)
{
virPortAllocatorRangePtr ports = virPortAllocatorRangeNew("test", 5900, 5909);
int ret = -1;
-static int testAllocReuse(const void *args ATTRIBUTE_UNUSED)
+static int testAllocReuse(const void *args G_GNUC_UNUSED)
{
virPortAllocatorRangePtr ports = virPortAllocatorRangeNew("test", 5900, 5910);
int ret = -1;
#include "virprocess.h"
int
-virProcessSetMaxMemLock(pid_t pid ATTRIBUTE_UNUSED, unsigned long long bytes ATTRIBUTE_UNUSED)
+virProcessSetMaxMemLock(pid_t pid G_GNUC_UNUSED, unsigned long long bytes G_GNUC_UNUSED)
{
return 0;
}
}
int virRandomGenerateWWN(char **wwn,
- const char *virt_type ATTRIBUTE_UNUSED)
+ const char *virt_type G_GNUC_UNUSED)
{
return virAsprintf(wwn, "5100000%09llx",
(unsigned long long)virRandomBits(36));
return 0;
}
-static int testRotatingFileWriterNew(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileWriterNew(const void *data G_GNUC_UNUSED)
{
virRotatingFileWriterPtr file;
int ret = -1;
}
-static int testRotatingFileWriterAppend(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileWriterAppend(const void *data G_GNUC_UNUSED)
{
virRotatingFileWriterPtr file;
int ret = -1;
}
-static int testRotatingFileWriterTruncate(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileWriterTruncate(const void *data G_GNUC_UNUSED)
{
virRotatingFileWriterPtr file;
int ret = -1;
}
-static int testRotatingFileWriterRolloverNone(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileWriterRolloverNone(const void *data G_GNUC_UNUSED)
{
virRotatingFileWriterPtr file;
int ret = -1;
}
-static int testRotatingFileWriterRolloverOne(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileWriterRolloverOne(const void *data G_GNUC_UNUSED)
{
virRotatingFileWriterPtr file;
int ret = -1;
}
-static int testRotatingFileWriterRolloverAppend(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileWriterRolloverAppend(const void *data G_GNUC_UNUSED)
{
virRotatingFileWriterPtr file;
int ret = -1;
}
-static int testRotatingFileWriterRolloverMany(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileWriterRolloverMany(const void *data G_GNUC_UNUSED)
{
virRotatingFileWriterPtr file;
int ret = -1;
}
-static int testRotatingFileWriterRolloverLineBreak(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileWriterRolloverLineBreak(const void *data G_GNUC_UNUSED)
{
virRotatingFileWriterPtr file;
int ret = -1;
}
-static int testRotatingFileWriterLargeFile(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileWriterLargeFile(const void *data G_GNUC_UNUSED)
{
virRotatingFileWriterPtr file;
int ret = -1;
}
-static int testRotatingFileReaderOne(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileReaderOne(const void *data G_GNUC_UNUSED)
{
virRotatingFileReaderPtr file;
int ret = -1;
return ret;
}
-static int testRotatingFileReaderAll(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileReaderAll(const void *data G_GNUC_UNUSED)
{
virRotatingFileReaderPtr file;
int ret = -1;
return ret;
}
-static int testRotatingFileReaderPartial(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileReaderPartial(const void *data G_GNUC_UNUSED)
{
virRotatingFileReaderPtr file;
int ret = -1;
return ret;
}
-static int testRotatingFileReaderSeek(const void *data ATTRIBUTE_UNUSED)
+static int testRotatingFileReaderSeek(const void *data G_GNUC_UNUSED)
{
virRotatingFileReaderPtr file;
int ret = -1;
static char *virscsi_prefix;
static int
-test1(const void *data ATTRIBUTE_UNUSED)
+test1(const void *data G_GNUC_UNUSED)
{
char *name = NULL;
int ret = -1;
* details.
*/
static int
-test2(const void *data ATTRIBUTE_UNUSED)
+test2(const void *data G_GNUC_UNUSED)
{
virSCSIDeviceListPtr list = NULL;
virSCSIDevicePtr dev = NULL;
"--connect", \
custom_uri
-static int testCompareListDefault(const void *data ATTRIBUTE_UNUSED)
+static int testCompareListDefault(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_DEFAULT, "list", NULL };
const char *exp = "\
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareListCustom(const void *data ATTRIBUTE_UNUSED)
+static int testCompareListCustom(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "list", NULL };
const char *exp = "\
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareNodeinfoDefault(const void *data ATTRIBUTE_UNUSED)
+static int testCompareNodeinfoDefault(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_DEFAULT, "nodeinfo", NULL };
const char *exp = "\
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareNodeinfoCustom(const void *data ATTRIBUTE_UNUSED)
+static int testCompareNodeinfoCustom(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = {
VIRSH_CUSTOM,
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareDominfoByID(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDominfoByID(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "dominfo", "2", NULL };
const char *exp = dominfo_fc4;
return testCompareOutputLit(exp, "\nCPU time:", argv);
}
-static int testCompareDominfoByUUID(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDominfoByUUID(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "dominfo", DOM_UUID, NULL };
const char *exp = dominfo_fc4;
return testCompareOutputLit(exp, "\nCPU time:", argv);
}
-static int testCompareDominfoByName(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDominfoByName(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "dominfo", "fc4", NULL };
const char *exp = dominfo_fc4;
return testCompareOutputLit(exp, "\nCPU time:", argv);
}
-static int testCompareDomuuidByID(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDomuuidByID(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "domuuid", "2", NULL };
const char *exp = domuuid_fc4;
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareDomuuidByName(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDomuuidByName(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "domuuid", "fc4", NULL };
const char *exp = domuuid_fc4;
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareDomidByName(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDomidByName(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "domid", "fc4", NULL };
const char *exp = domid_fc4;
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareDomidByUUID(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDomidByUUID(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "domid", DOM_UUID, NULL };
const char *exp = domid_fc4;
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareDomnameByID(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDomnameByID(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "domname", "2", NULL };
const char *exp = domname_fc4;
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareDomnameByUUID(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDomnameByUUID(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "domname", DOM_UUID, NULL };
const char *exp = domname_fc4;
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareDomstateByID(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDomstateByID(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "domstate", "2", NULL };
const char *exp = domstate_fc4;
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareDomstateByUUID(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDomstateByUUID(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "domstate", DOM_UUID, NULL };
const char *exp = domstate_fc4;
return testCompareOutputLit(exp, NULL, argv);
}
-static int testCompareDomstateByName(const void *data ATTRIBUTE_UNUSED)
+static int testCompareDomstateByName(const void *data G_GNUC_UNUSED)
{
const char *const argv[] = { VIRSH_CUSTOM, "domstate", "fc4", NULL };
const char *exp = domstate_fc4;
static int
testPathCanonicalizeReadlink(const char *path,
char **linkpath,
- void *data ATTRIBUTE_UNUSED)
+ void *data G_GNUC_UNUSED)
{
size_t i;
}
static int
-testStrdup(const void *data ATTRIBUTE_UNUSED)
+testStrdup(const void *data G_GNUC_UNUSED)
{
char *array[] = { NULL, NULL };
size_t i = 0;
}
static int
-testStrndupNegative(const void *opaque ATTRIBUTE_UNUSED)
+testStrndupNegative(const void *opaque G_GNUC_UNUSED)
{
int ret = -1;
char *dst;
static int
-testStringSortCompare(const void *opaque ATTRIBUTE_UNUSED)
+testStringSortCompare(const void *opaque G_GNUC_UNUSED)
{
const char *randlist[] = {
"tasty", "astro", "goat", "chicken", "turducken",
};
static int
-testStringReplace(const void *opaque ATTRIBUTE_UNUSED)
+testStringReplace(const void *opaque G_GNUC_UNUSED)
{
const struct stringReplaceData *data = opaque;
char *result;
/* The point of this test is to check whether all members of the array are
* freed. The test has to be checked using valgrind. */
static int
-testVirStringListFreeCount(const void *opaque ATTRIBUTE_UNUSED)
+testVirStringListFreeCount(const void *opaque G_GNUC_UNUSED)
{
char **list;
}
-static int testCreateContainer(const void *opaque ATTRIBUTE_UNUSED)
+static int testCreateContainer(const void *opaque G_GNUC_UNUSED)
{
unsigned char uuid[VIR_UUID_BUFLEN] = {
1, 1, 1, 1,
return 0;
}
-static int testTerminateContainer(const void *opaque ATTRIBUTE_UNUSED)
+static int testTerminateContainer(const void *opaque G_GNUC_UNUSED)
{
if (virSystemdTerminateMachine("lxc-demo") < 0) {
fprintf(stderr, "%s", "Failed to terminate LXC machine\n");
return 0;
}
-static int testCreateMachine(const void *opaque ATTRIBUTE_UNUSED)
+static int testCreateMachine(const void *opaque G_GNUC_UNUSED)
{
unsigned char uuid[VIR_UUID_BUFLEN] = {
1, 1, 1, 1,
return 0;
}
-static int testTerminateMachine(const void *opaque ATTRIBUTE_UNUSED)
+static int testTerminateMachine(const void *opaque G_GNUC_UNUSED)
{
if (virSystemdTerminateMachine("test-qemu-demo") < 0) {
fprintf(stderr, "%s", "Failed to terminate KVM machine\n");
return 0;
}
-static int testCreateNoSystemd(const void *opaque ATTRIBUTE_UNUSED)
+static int testCreateNoSystemd(const void *opaque G_GNUC_UNUSED)
{
unsigned char uuid[VIR_UUID_BUFLEN] = {
1, 1, 1, 1,
return 0;
}
-static int testCreateSystemdNotRunning(const void *opaque ATTRIBUTE_UNUSED)
+static int testCreateSystemdNotRunning(const void *opaque G_GNUC_UNUSED)
{
unsigned char uuid[VIR_UUID_BUFLEN] = {
1, 1, 1, 1,
return 0;
}
-static int testCreateBadSystemd(const void *opaque ATTRIBUTE_UNUSED)
+static int testCreateBadSystemd(const void *opaque G_GNUC_UNUSED)
{
unsigned char uuid[VIR_UUID_BUFLEN] = {
1, 1, 1, 1,
}
-static int testCreateNetwork(const void *opaque ATTRIBUTE_UNUSED)
+static int testCreateNetwork(const void *opaque G_GNUC_UNUSED)
{
unsigned char uuid[VIR_UUID_BUFLEN] = {
1, 1, 1, 1,
static int
-testGetMachineName(const void *opaque ATTRIBUTE_UNUSED)
+testGetMachineName(const void *opaque G_GNUC_UNUSED)
{
char *tmp = virSystemdGetMachineNameByPID(1234);
int ret = -1;
static int
-testActivationEmpty(const void *opaque ATTRIBUTE_UNUSED)
+testActivationEmpty(const void *opaque G_GNUC_UNUSED)
{
virSystemdActivationPtr act;
static int
-testActivationFDNames(const void *opaque ATTRIBUTE_UNUSED)
+testActivationFDNames(const void *opaque G_GNUC_UNUSED)
{
return testActivation(true);
}
static int
-testActivationFDAddrs(const void *opaque ATTRIBUTE_UNUSED)
+testActivationFDAddrs(const void *opaque G_GNUC_UNUSED)
{
return testActivation(false);
}
#include "virmockstathelpers.c"
-static int virMockStatRedirect(const char *path ATTRIBUTE_UNUSED, char **newpath ATTRIBUTE_UNUSED)
+static int virMockStatRedirect(const char *path G_GNUC_UNUSED, char **newpath G_GNUC_UNUSED)
{
return 0;
}
.nparams = PARAMS_SIZE(__VA_ARGS__),
static int
-testTypedParamsFilter(const void *opaque ATTRIBUTE_UNUSED)
+testTypedParamsFilter(const void *opaque G_GNUC_UNUSED)
{
size_t i, nfiltered;
int rv = -1;
}
static int
-testTypedParamsAddStringList(const void *opaque ATTRIBUTE_UNUSED)
+testTypedParamsAddStringList(const void *opaque G_GNUC_UNUSED)
{
int rv = 0;
virTypedParameterPtr params = NULL;
}
static int
-testTypedParamsGetStringList(const void *opaque ATTRIBUTE_UNUSED)
+testTypedParamsGetStringList(const void *opaque G_GNUC_UNUSED)
{
size_t i;
int picked;
static int testDeviceFileActor(virUSBDevicePtr dev,
const char *path,
- void *opaque ATTRIBUTE_UNUSED)
+ void *opaque G_GNUC_UNUSED)
{
char *str = NULL;
int ret = 0;
static int
-testUSBList(const void *opaque ATTRIBUTE_UNUSED)
+testUSBList(const void *opaque G_GNUC_UNUSED)
{
virUSBDeviceListPtr list = NULL;
virUSBDeviceListPtr devlist = NULL;
}
static char *
-testParseVMXFileName(const char *fileName, void *opaque ATTRIBUTE_UNUSED)
+testParseVMXFileName(const char *fileName, void *opaque G_GNUC_UNUSED)
{
char *copyOfFileName = NULL;
char *tmp = NULL;
#include "../tools/vsh-table.h"
static int
-testVshTableNew(const void *opaque ATTRIBUTE_UNUSED)
+testVshTableNew(const void *opaque G_GNUC_UNUSED)
{
if (vshTableNew(NULL)) {
fprintf(stderr, "expected failure when passing null to vshTableNew\n");
}
static int
-testVshTableHeader(const void *opaque ATTRIBUTE_UNUSED)
+testVshTableHeader(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
char *act = NULL;
}
static int
-testVshTableRowAppend(const void *opaque ATTRIBUTE_UNUSED)
+testVshTableRowAppend(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
}
static int
-testUnicode(const void *opaque ATTRIBUTE_UNUSED)
+testUnicode(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
char *act = NULL;
/* Point of this test is to see how table behaves with right to left writing*/
static int
-testUnicodeArabic(const void *opaque ATTRIBUTE_UNUSED)
+testUnicodeArabic(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
char *act = NULL;
/* Testing zero-width characters by inserting few zero-width spaces */
static int
-testUnicodeZeroWidthChar(const void *opaque ATTRIBUTE_UNUSED)
+testUnicodeZeroWidthChar(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
vshTablePtr table = NULL;
}
static int
-testUnicodeCombiningChar(const void *opaque ATTRIBUTE_UNUSED)
+testUnicodeCombiningChar(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
vshTablePtr table = NULL;
/* Testing zero-width characters by inserting few zero-width spaces */
static int
-testUnicodeNonPrintableChar(const void *opaque ATTRIBUTE_UNUSED)
+testUnicodeNonPrintableChar(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
vshTablePtr table = NULL;
}
static int
-testNTables(const void *opaque ATTRIBUTE_UNUSED)
+testNTables(const void *opaque G_GNUC_UNUSED)
{
int ret = 0;
vshTablePtr table1 = NULL;
}
static int
-testAutodetectSCSIControllerModel(virDomainDiskDefPtr def ATTRIBUTE_UNUSED,
- int *model, void *opaque ATTRIBUTE_UNUSED)
+testAutodetectSCSIControllerModel(virDomainDiskDefPtr def G_GNUC_UNUSED,
+ int *model, void *opaque G_GNUC_UNUSED)
{
*model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC;
}
static char *
-testFormatVMXFileName(const char *src, void *opaque ATTRIBUTE_UNUSED)
+testFormatVMXFileName(const char *src, void *opaque G_GNUC_UNUSED)
{
bool success = false;
char *copyOfDatastorePath = NULL;
projects / libvirt.git / commitdiff