luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-24 14:36:13 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'wfloat-conversion' into 'main'

Browse Source 
build: Enable -Wfloat-conversion and fix warnings

See merge request GNOME/glib!4126
This commit is contained in:
Philip Withnall 2024-09-17 17:57:11 +00:00
commit 7a7d8d548a
17 changed files with 258 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
gio/gtask.c
View File

@ -1537,7 +1537,7 @@ g_task_thread_setup (void)
if (tasks_running == G_TASK_POOL_SIZE)
task_wait_time = G_TASK_WAIT_TIME_BASE;
else if (tasks_running > G_TASK_POOL_SIZE && tasks_running < G_TASK_WAIT_TIME_MAX_POOL_SIZE)
task_wait_time *= G_TASK_WAIT_TIME_MULTIPLIER;
task_wait_time = (guint64) (task_wait_time * G_TASK_WAIT_TIME_MULTIPLIER);
if (tasks_running >= G_TASK_POOL_SIZE)
g_source_set_ready_time (task_pool_manager, g_get_monotonic_time () + task_wait_time);
@ -1562,7 +1562,7 @@ g_task_thread_cleanup (void)
g_source_set_ready_time (task_pool_manager, -1);
if (tasks_running > G_TASK_POOL_SIZE && tasks_running < G_TASK_WAIT_TIME_MAX_POOL_SIZE)
task_wait_time /= G_TASK_WAIT_TIME_MULTIPLIER;
task_wait_time = (guint64) (task_wait_time / G_TASK_WAIT_TIME_MULTIPLIER);
tasks_running--;

7
gio/tests/srvtarget.c
View File

@ -30,7 +30,8 @@
struct {
const char *order;
int expected, seen;
gdouble expected;
unsigned int seen;
} ordering[] = {
/* There are 32 legitimate orderings; the result always has to start
* with either "fe" (usually) or "ef" (rarely). For the remaining
@ -141,8 +142,8 @@ test_srv_target_ordering (void)
*/
for (o = 0; o < NUM_ORDERINGS; o++)
{
g_assert_cmpint (ordering[o].seen, >, ordering[o].expected / 2);
g_assert_cmpint (ordering[o].seen, <, ordering[o].expected * 2);
g_assert_cmpuint (ordering[o].seen, >, (guint64) (ordering[o].expected / 2));
g_assert_cmpuint (ordering[o].seen, <, (guint64) (ordering[o].expected * 2));
}
g_resolver_free_targets (targets);

2
girepository/girnode.c
View File

@ -2508,7 +2508,7 @@ gi_ir_node_build_typelib (GIIrNode *node,
break;
case GI_TYPE_TAG_FLOAT:
blob->size = sizeof (float);
DO_ALIGNED_COPY (&data[blob->offset], parse_float_value (constant->value), float);
DO_ALIGNED_COPY (&data[blob->offset], (float) parse_float_value (constant->value), float);
break;
case GI_TYPE_TAG_DOUBLE:
blob->size = sizeof (double);

12
glib/gdatetime.c
View File

@ -82,15 +82,11 @@
#include "gtestutils.h"
#include "gthread.h"
#include "gtimezone.h"
#include "gutilsprivate.h"
#ifndef G_OS_WIN32
#include <sys/time.h>
#include <time.h>
#else
#if defined (_MSC_VER) && (_MSC_VER < 1800)
/* fallback implementation for isnan() on VS2012 and earlier */
#define isnan _isnan
#endif
#endif /* !G_OS_WIN32 */
struct _GDateTime
@ -1645,7 +1641,7 @@ g_date_time_new (GTimeZone *tz,
day < 1 || day > days_in_months[GREGORIAN_LEAP (year)][month] ||
hour < 0 || hour > 23 ||
minute < 0 || minute > 59 ||
isnan (seconds) ||
g_isnan (seconds) ||
seconds < 0.0 || seconds >= 60.0)
return NULL;
@ -1670,7 +1666,7 @@ g_date_time_new (GTimeZone *tz,
* is 1000000. This is not a problem with precision, it's just how
* FP numbers work.
* See https://bugzilla.gnome.org/show_bug.cgi?id=697715. */
usec = seconds * USEC_PER_SECOND;
usec = (gint64) (seconds * USEC_PER_SECOND);
usecd = (usec + 1) * 1e-6;
if (usecd <= seconds) {
usec++;
@ -1973,7 +1969,7 @@ GDateTime*
g_date_time_add_seconds (GDateTime *datetime,
gdouble seconds)
{
return g_date_time_add (datetime, seconds * USEC_PER_SECOND);
return g_date_time_add (datetime, (GTimeSpan) (seconds * USEC_PER_SECOND));
}
/**

2
glib/ghash.c
View File

@ -818,7 +818,7 @@ g_hash_table_resize (GHashTable *hash_table)
* Immediately after growing, the load factor will be in the range
* .375 .. .469. After shrinking, it will be exactly .5. */
g_hash_table_set_shift_from_size (hash_table, hash_table->nnodes * 1.333);
g_hash_table_set_shift_from_size (hash_table, (gint) (hash_table->nnodes * 1.333));
if (hash_table->size > old_size)
{

5
glib/gnulib/meson.build
View File

@ -1,7 +1,10 @@
# glib enables -Werror=format-nonliteral by default, but the embedded gnulib
# needs to handle user provided format strings.
extra_gnulib_args = cc.get_supported_arguments([
'-Wno-format-nonliteral', '-Wno-duplicated-branches'])
'-Wno-format-nonliteral',
'-Wno-float-conversion',
'-Wno-duplicated-branches',
])
if host_system == 'windows' and cc.get_id() == 'clang'
extra_gnulib_args += cc.get_supported_arguments([

10
glib/gtestutils.c
View File

@ -745,9 +745,9 @@ static GPrintFunc g_default_print_func = NULL;
enum
{
G_TEST_CASE_LARGS_RESULT = 0,
G_TEST_CASE_LARGS_RUN_FORKS = 1,
G_TEST_CASE_LARGS_EXECUTION_TIME = 2,
G_TEST_CASE_LARGS_RESULT = 0, /* a GTestResult */
G_TEST_CASE_LARGS_RUN_FORKS = 1, /* a gint */
G_TEST_CASE_LARGS_EXECUTION_TIME = 2, /* a gdouble */
G_TEST_CASE_LARGS_MAX
};
@ -972,7 +972,7 @@ g_test_log (GTestLogType lbit,
break;
case G_TEST_LOG_STOP_CASE:
result = largs[G_TEST_CASE_LARGS_RESULT];
timing = largs[G_TEST_CASE_LARGS_EXECUTION_TIME];
timing = (gdouble) largs[G_TEST_CASE_LARGS_EXECUTION_TIME];
fail = result == G_TEST_RUN_FAILURE;
if (test_tap_log)
{
@ -4371,7 +4371,7 @@ g_test_log_dump (GTestLogMsg *msg,
g_string_append_len (gstring, msg->strings[ui], l);
}
for (ui = 0; ui < msg->n_nums; ui++)
gstring_append_double (gstring, msg->nums[ui]);
gstring_append_double (gstring, (gdouble) msg->nums[ui]);
*len = gstring->len;
gstring_overwrite_int (gstring, 0, *len); /* message length */
return (guint8*) g_string_free (gstring, FALSE);

4
glib/guri.c
View File

@ -2703,7 +2703,7 @@ g_uri_escape_string (const gchar *unescaped,
g_return_val_if_fail (unescaped != NULL, NULL);
s = g_string_sized_new (strlen (unescaped) * 1.25);
s = g_string_sized_new ((size_t) (strlen (unescaped) * 1.25));
g_string_append_uri_escaped (s, unescaped, reserved_chars_allowed, allow_utf8);
@ -2797,7 +2797,7 @@ g_uri_escape_bytes (const guint8 *unescaped,
g_return_val_if_fail (unescaped != NULL, NULL);
string = g_string_sized_new (length * 1.25);
string = g_string_sized_new ((size_t) (length * 1.25));
_uri_encoder (string, unescaped, length,
reserved_chars_allowed, FALSE);

18
glib/gutilsprivate.h
View File

@ -26,6 +26,7 @@
#include "gtypes.h"
#include "gtestutils.h"
#include <math.h>
#include <time.h>
G_BEGIN_DECLS
@ -61,6 +62,23 @@ gboolean _g_localtime (time_t timet, struct tm *tm);
gboolean g_set_prgname_once (const gchar *prgname);
/* Although isnan() is defined as a type-independent macro in C99, mingw32
* doesn’t seem to support that (it defines `isnan (float d)` only). Older
* MSVC toolchains don’t support C99 either. So we provide an internal
* abstraction macro.
*
* This should not be made public; toolchains will soon enough catch up with
* C99, so third party code should just use isnan(). */
static inline int
g_isnan (double d)
{
#if (defined (_MSC_VER) && (_MSC_VER < 1800)) || defined(__MINGW32__)
return _isnan (d);
#else
return isnan (d);
#endif
}
G_END_DECLS
#endif /* __G_UTILS_PRIVATE_H__ */

2
glib/tests/gdatetime.c
View File

@ -1409,7 +1409,7 @@ test_GDateTime_new_from_unix_utc (void)
g_assert (dt == NULL);
#endif
t = t / 1e6; /* oops, this was microseconds */
t = t / G_USEC_PER_SEC; /* oops, this was microseconds */
dt = g_date_time_new_from_unix_utc (t);
g_assert (dt != NULL);

8
glib/tests/strfuncs.c
View File

@ -34,11 +34,11 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "glib.h"
#include "gutilsprivate.h"
#if defined (_MSC_VER) && (_MSC_VER <= 1800)
#define isnan(x) _isnan(x)
#ifndef NAN
static const unsigned long __nan[2] = {0xffffffff, 0x7fffffff};
#define NAN (*(const float *) __nan)
@ -1625,7 +1625,7 @@ check_strtod_string (gchar *number,
setlocale (LC_NUMERIC, locales[l]);
d = g_ascii_strtod (number, &end);
g_assert_true (isnan (res) ? isnan (d) : (d == res));
g_assert_true (g_isnan (res) ? g_isnan (d) : (d == res));
g_assert_true ((gsize) (end - number) ==
(check_end ? correct_len : strlen (number)));
}
@ -1660,7 +1660,7 @@ test_ascii_strtod (void)
/* Do this before any call to setlocale. */
our_nan = atof ("NaN");
#endif
g_assert_true (isnan (our_nan));
g_assert_true (g_isnan (our_nan));
#ifdef INFINITY
our_inf = INFINITY;

4
gobject/gparamspecs.c
View File

@ -37,7 +37,7 @@
#include "gvaluearray.h"
#define G_FLOAT_EPSILON (1e-30)
#define G_FLOAT_EPSILON (1e-30f)
#define G_DOUBLE_EPSILON (1e-90)
@ -691,7 +691,7 @@ param_double_is_valid (GParamSpec *pspec,
const GValue *value)
{
GParamSpecDouble *dspec = G_PARAM_SPEC_DOUBLE (pspec);
gfloat oval = value->data[0].v_double;
gdouble oval = value->data[0].v_double;
return dspec->minimum <= oval && oval <= dspec->maximum;
}

2
gobject/gvaluetransform.c
View File

@ -51,7 +51,7 @@ static void \
value_transform_##func_name (const GValue *src_value, \
GValue *dest_value) \
{ \
ctype c_value = src_value->data[0].from_member; \
ctype c_value = (ctype) src_value->data[0].from_member; \
dest_value->data[0].to_member = c_value; \
} extern void glib_dummy_decl (void)
DEFINE_CAST (int_s8, v_int, gint8, v_int);

3
gobject/gvaluetypes.c
View File

@ -190,7 +190,8 @@ value_collect_float (GValue *value,
GTypeCValue *collect_values,
guint collect_flags)
{
value->data[0].v_float = collect_values[0].v_double;
/* This necessarily loses precision */
value->data[0].v_float = (gfloat) collect_values[0].v_double;
return NULL;
}

276
gobject/tests/param.c
View File

@ -267,7 +267,7 @@ test_param_spec_float (void)
g_value_set_float (&value, 0.0);
g_assert_false (g_param_value_is_valid (pspec, &value));
g_assert_true (g_param_value_validate (pspec, &value));
g_assert_cmpint (g_value_get_float (&value), ==, 20.0);
g_assert_cmpfloat (g_value_get_float (&value), ==, 20.0);
g_param_spec_unref (pspec);
}
@ -289,7 +289,21 @@ test_param_spec_double (void)
g_value_set_double (&value, 0.0);
g_assert_false (g_param_value_is_valid (pspec, &value));
g_assert_true (g_param_value_validate (pspec, &value));
g_assert_cmpint (g_value_get_double (&value), ==, 20.0);
g_assert_cmpfloat (g_value_get_double (&value), ==, 20.0);
g_param_spec_unref (pspec);
/* Test validation with some larger values, which fit in a double but not in a float.
* In particular, check there are no double → float conversions in the pipeline,
* by using a valid range which is entirely outside the range of numbers
* representable in a float. */
pspec = g_param_spec_double ("double", NULL, NULL,
1.2e308, 1.3e308, 1.21e308, G_PARAM_READWRITE);
g_param_value_set_default (pspec, &value);
g_assert_true (g_param_value_is_valid (pspec, &value));
g_assert_false (g_param_value_validate (pspec, &value));
g_assert_cmpfloat (g_value_get_double (&value), ==, 1.21e308);
g_param_spec_unref (pspec);
}
@ -805,13 +819,13 @@ test_value_transform (void)
GValue src = G_VALUE_INIT;
GValue dest = G_VALUE_INIT;
#define CHECK_INT_CONVERSION(type, getter, value) \
#define CHECK_INT_CONVERSION(type, cmpfunc, getter, value) \
g_assert_true (g_value_type_transformable (G_TYPE_INT, type)); \
g_value_init (&src, G_TYPE_INT); \
g_value_init (&dest, type); \
g_value_set_int (&src, value); \
g_assert_true (g_value_transform (&src, &dest)); \
g_assert_cmpint (g_value_get_##getter (&dest), ==, value); \
cmpfunc (g_value_get_##getter (&dest), ==, value); \
g_value_unset (&src); \
g_value_unset (&dest);
@ -820,197 +834,197 @@ test_value_transform (void)
* https://bugzilla.gnome.org/show_bug.cgi?id=659870
* for why it is broken.
*/
CHECK_INT_CONVERSION(G_TYPE_CHAR, char, 124)
CHECK_INT_CONVERSION(G_TYPE_CHAR, g_assert_cmpuint, char, 124)
CHECK_INT_CONVERSION(G_TYPE_CHAR, schar, -124)
CHECK_INT_CONVERSION(G_TYPE_CHAR, schar, 124)
CHECK_INT_CONVERSION(G_TYPE_UCHAR, uchar, 0)
CHECK_INT_CONVERSION(G_TYPE_UCHAR, uchar, 255)
CHECK_INT_CONVERSION(G_TYPE_INT, int, -12345)
CHECK_INT_CONVERSION(G_TYPE_INT, int, 12345)
CHECK_INT_CONVERSION(G_TYPE_UINT, uint, 0)
CHECK_INT_CONVERSION(G_TYPE_UINT, uint, 12345)
CHECK_INT_CONVERSION(G_TYPE_LONG, long, -12345678)
CHECK_INT_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
CHECK_INT_CONVERSION(G_TYPE_INT64, int64, -12345678)
CHECK_INT_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
CHECK_INT_CONVERSION(G_TYPE_FLOAT, float, 12345678)
CHECK_INT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
CHECK_INT_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, -124)
CHECK_INT_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, 124)
CHECK_INT_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 0)
CHECK_INT_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 255)
CHECK_INT_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, -12345)
CHECK_INT_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, 12345)
CHECK_INT_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 0)
CHECK_INT_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 12345)
CHECK_INT_CONVERSION(G_TYPE_LONG, g_assert_cmpint, long, -12345678)
CHECK_INT_CONVERSION(G_TYPE_ULONG, g_assert_cmpuint, ulong, 12345678)
CHECK_INT_CONVERSION(G_TYPE_INT64, g_assert_cmpint, int64, -12345678)
CHECK_INT_CONVERSION(G_TYPE_UINT64, g_assert_cmpuint, uint64, 12345678)
CHECK_INT_CONVERSION(G_TYPE_FLOAT, g_assert_cmpfloat, float, 12345678)
CHECK_INT_CONVERSION(G_TYPE_DOUBLE, g_assert_cmpfloat, double, 12345678)
#define CHECK_UINT_CONVERSION(type, getter, value) \
#define CHECK_UINT_CONVERSION(type, cmpfunc, getter, value) \
g_assert_true (g_value_type_transformable (G_TYPE_UINT, type)); \
g_value_init (&src, G_TYPE_UINT); \
g_value_init (&dest, type); \
g_value_set_uint (&src, value); \
g_assert_true (g_value_transform (&src, &dest)); \
g_assert_cmpuint (g_value_get_##getter (&dest), ==, value); \
cmpfunc (g_value_get_##getter (&dest), ==, value); \
g_value_unset (&src); \
g_value_unset (&dest);
CHECK_UINT_CONVERSION(G_TYPE_CHAR, char, 124)
CHECK_UINT_CONVERSION(G_TYPE_CHAR, char, 124)
CHECK_UINT_CONVERSION(G_TYPE_UCHAR, uchar, 0)
CHECK_UINT_CONVERSION(G_TYPE_UCHAR, uchar, 255)
CHECK_UINT_CONVERSION(G_TYPE_INT, int, 12345)
CHECK_UINT_CONVERSION(G_TYPE_INT, int, 12345)
CHECK_UINT_CONVERSION(G_TYPE_UINT, uint, 0)
CHECK_UINT_CONVERSION(G_TYPE_UINT, uint, 12345)
CHECK_UINT_CONVERSION(G_TYPE_LONG, long, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_INT64, int64, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_FLOAT, float, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, char, 124)
CHECK_UINT_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, char, 124)
CHECK_UINT_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 0)
CHECK_UINT_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 255)
CHECK_UINT_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, 12345)
CHECK_UINT_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, 12345)
CHECK_UINT_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 0)
CHECK_UINT_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 12345)
CHECK_UINT_CONVERSION(G_TYPE_LONG, g_assert_cmpint, long, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_ULONG, g_assert_cmpuint, ulong, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_INT64, g_assert_cmpint, int64, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_UINT64, g_assert_cmpuint, uint64, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_FLOAT, g_assert_cmpfloat, float, 12345678)
CHECK_UINT_CONVERSION(G_TYPE_DOUBLE, g_assert_cmpfloat, double, 12345678)
#define CHECK_LONG_CONVERSION(type, getter, value) \
#define CHECK_LONG_CONVERSION(type, cmpfunc, getter, value) \
g_assert_true (g_value_type_transformable (G_TYPE_LONG, type)); \
g_value_init (&src, G_TYPE_LONG); \
g_value_init (&dest, type); \
g_value_set_long (&src, value); \
g_assert_true (g_value_transform (&src, &dest)); \
g_assert_cmpint (g_value_get_##getter (&dest), ==, value); \
cmpfunc (g_value_get_##getter (&dest), ==, value); \
g_value_unset (&src); \
g_value_unset (&dest);
CHECK_LONG_CONVERSION(G_TYPE_CHAR, schar, -124)
CHECK_LONG_CONVERSION(G_TYPE_CHAR, schar, 124)
CHECK_LONG_CONVERSION(G_TYPE_UCHAR, uchar, 0)
CHECK_LONG_CONVERSION(G_TYPE_UCHAR, uchar, 255)
CHECK_LONG_CONVERSION(G_TYPE_INT, int, -12345)
CHECK_LONG_CONVERSION(G_TYPE_INT, int, 12345)
CHECK_LONG_CONVERSION(G_TYPE_UINT, uint, 0)
CHECK_LONG_CONVERSION(G_TYPE_UINT, uint, 12345)
CHECK_LONG_CONVERSION(G_TYPE_LONG, long, -12345678)
CHECK_LONG_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
CHECK_LONG_CONVERSION(G_TYPE_INT64, int64, -12345678)
CHECK_LONG_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
CHECK_LONG_CONVERSION(G_TYPE_FLOAT, float, 12345678)
CHECK_LONG_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
CHECK_LONG_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, -124)
CHECK_LONG_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, 124)
CHECK_LONG_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 0)
CHECK_LONG_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 255)
CHECK_LONG_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, -12345)
CHECK_LONG_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, 12345)
CHECK_LONG_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 0)
CHECK_LONG_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 12345)
CHECK_LONG_CONVERSION(G_TYPE_LONG, g_assert_cmpint, long, -12345678)
CHECK_LONG_CONVERSION(G_TYPE_ULONG, g_assert_cmpuint, ulong, 12345678)
CHECK_LONG_CONVERSION(G_TYPE_INT64, g_assert_cmpint, int64, -12345678)
CHECK_LONG_CONVERSION(G_TYPE_UINT64, g_assert_cmpuint, uint64, 12345678)
CHECK_LONG_CONVERSION(G_TYPE_FLOAT, g_assert_cmpfloat, float, 12345678)
CHECK_LONG_CONVERSION(G_TYPE_DOUBLE, g_assert_cmpfloat, double, 12345678)
#define CHECK_ULONG_CONVERSION(type, getter, value) \
#define CHECK_ULONG_CONVERSION(type, cmpfunc, getter, value) \
g_assert_true (g_value_type_transformable (G_TYPE_ULONG, type)); \
g_value_init (&src, G_TYPE_ULONG); \
g_value_init (&dest, type); \
g_value_set_ulong (&src, value); \
g_assert_true (g_value_transform (&src, &dest)); \
g_assert_cmpuint (g_value_get_##getter (&dest), ==, value); \
cmpfunc (g_value_get_##getter (&dest), ==, value); \
g_value_unset (&src); \
g_value_unset (&dest);
CHECK_ULONG_CONVERSION(G_TYPE_CHAR, char, 124)
CHECK_ULONG_CONVERSION(G_TYPE_CHAR, char, 124)
CHECK_ULONG_CONVERSION(G_TYPE_UCHAR, uchar, 0)
CHECK_ULONG_CONVERSION(G_TYPE_UCHAR, uchar, 255)
CHECK_ULONG_CONVERSION(G_TYPE_INT, int, -12345)
CHECK_ULONG_CONVERSION(G_TYPE_INT, int, 12345)
CHECK_ULONG_CONVERSION(G_TYPE_UINT, uint, 0)
CHECK_ULONG_CONVERSION(G_TYPE_UINT, uint, 12345)
CHECK_ULONG_CONVERSION(G_TYPE_LONG, long, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_INT64, int64, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_FLOAT, float, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, char, 124)
CHECK_ULONG_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, char, 124)
CHECK_ULONG_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 0)
CHECK_ULONG_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 255)
CHECK_ULONG_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, -12345)
CHECK_ULONG_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, 12345)
CHECK_ULONG_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 0)
CHECK_ULONG_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 12345)
CHECK_ULONG_CONVERSION(G_TYPE_LONG, g_assert_cmpint, long, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_ULONG, g_assert_cmpuint, ulong, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_INT64, g_assert_cmpint, int64, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_UINT64, g_assert_cmpuint, uint64, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_FLOAT, g_assert_cmpfloat, float, 12345678)
CHECK_ULONG_CONVERSION(G_TYPE_DOUBLE, g_assert_cmpfloat, double, 12345678)
#define CHECK_INT64_CONVERSION(type, getter, value) \
#define CHECK_INT64_CONVERSION(type, cmpfunc, getter, value) \
g_assert_true (g_value_type_transformable (G_TYPE_INT64, type)); \
g_value_init (&src, G_TYPE_INT64); \
g_value_init (&dest, type); \
g_value_set_int64 (&src, value); \
g_assert_true (g_value_transform (&src, &dest)); \
g_assert_cmpint (g_value_get_##getter (&dest), ==, value); \
cmpfunc (g_value_get_##getter (&dest), ==, value); \
g_value_unset (&src); \
g_value_unset (&dest);
CHECK_INT64_CONVERSION(G_TYPE_CHAR, schar, -124)
CHECK_INT64_CONVERSION(G_TYPE_CHAR, schar, 124)
CHECK_INT64_CONVERSION(G_TYPE_UCHAR, uchar, 0)
CHECK_INT64_CONVERSION(G_TYPE_UCHAR, uchar, 255)
CHECK_INT64_CONVERSION(G_TYPE_INT, int, -12345)
CHECK_INT64_CONVERSION(G_TYPE_INT, int, 12345)
CHECK_INT64_CONVERSION(G_TYPE_UINT, uint, 0)
CHECK_INT64_CONVERSION(G_TYPE_UINT, uint, 12345)
CHECK_INT64_CONVERSION(G_TYPE_LONG, long, -12345678)
CHECK_INT64_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
CHECK_INT64_CONVERSION(G_TYPE_INT64, int64, -12345678)
CHECK_INT64_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
CHECK_INT64_CONVERSION(G_TYPE_FLOAT, float, 12345678)
CHECK_INT64_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
CHECK_INT64_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, -124)
CHECK_INT64_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, 124)
CHECK_INT64_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 0)
CHECK_INT64_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 255)
CHECK_INT64_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, -12345)
CHECK_INT64_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, 12345)
CHECK_INT64_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 0)
CHECK_INT64_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 12345)
CHECK_INT64_CONVERSION(G_TYPE_LONG, g_assert_cmpint, long, -12345678)
CHECK_INT64_CONVERSION(G_TYPE_ULONG, g_assert_cmpuint, ulong, 12345678)
CHECK_INT64_CONVERSION(G_TYPE_INT64, g_assert_cmpint, int64, -12345678)
CHECK_INT64_CONVERSION(G_TYPE_UINT64, g_assert_cmpuint, uint64, 12345678)
CHECK_INT64_CONVERSION(G_TYPE_FLOAT, g_assert_cmpfloat, float, 12345678)
CHECK_INT64_CONVERSION(G_TYPE_DOUBLE, g_assert_cmpfloat, double, 12345678)
#define CHECK_UINT64_CONVERSION(type, getter, value) \
#define CHECK_UINT64_CONVERSION(type, cmpfunc, getter, value) \
g_assert_true (g_value_type_transformable (G_TYPE_UINT64, type)); \
g_value_init (&src, G_TYPE_UINT64); \
g_value_init (&dest, type); \
g_value_set_uint64 (&src, value); \
g_assert_true (g_value_transform (&src, &dest)); \
g_assert_cmpuint (g_value_get_##getter (&dest), ==, value); \
cmpfunc (g_value_get_##getter (&dest), ==, value); \
g_value_unset (&src); \
g_value_unset (&dest);
CHECK_UINT64_CONVERSION(G_TYPE_CHAR, schar, -124)
CHECK_UINT64_CONVERSION(G_TYPE_CHAR, schar, 124)
CHECK_UINT64_CONVERSION(G_TYPE_UCHAR, uchar, 0)
CHECK_UINT64_CONVERSION(G_TYPE_UCHAR, uchar, 255)
CHECK_UINT64_CONVERSION(G_TYPE_INT, int, -12345)
CHECK_UINT64_CONVERSION(G_TYPE_INT, int, 12345)
CHECK_UINT64_CONVERSION(G_TYPE_UINT, uint, 0)
CHECK_UINT64_CONVERSION(G_TYPE_UINT, uint, 12345)
CHECK_UINT64_CONVERSION(G_TYPE_LONG, long, -12345678)
CHECK_UINT64_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
CHECK_UINT64_CONVERSION(G_TYPE_INT64, int64, -12345678)
CHECK_UINT64_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
CHECK_UINT64_CONVERSION(G_TYPE_FLOAT, float, 12345678)
CHECK_UINT64_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
CHECK_UINT64_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, -124)
CHECK_UINT64_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, 124)
CHECK_UINT64_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 0)
CHECK_UINT64_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 255)
CHECK_UINT64_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, -12345)
CHECK_UINT64_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, 12345)
CHECK_UINT64_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 0)
CHECK_UINT64_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 12345)
CHECK_UINT64_CONVERSION(G_TYPE_LONG, g_assert_cmpint, long, -12345678)
CHECK_UINT64_CONVERSION(G_TYPE_ULONG, g_assert_cmpuint, ulong, 12345678)
CHECK_UINT64_CONVERSION(G_TYPE_INT64, g_assert_cmpint, int64, -12345678)
CHECK_UINT64_CONVERSION(G_TYPE_UINT64, g_assert_cmpuint, uint64, 12345678)
CHECK_UINT64_CONVERSION(G_TYPE_FLOAT, g_assert_cmpfloat, float, 12345678)
CHECK_UINT64_CONVERSION(G_TYPE_DOUBLE, g_assert_cmpfloat, double, 12345678)
#define CHECK_FLOAT_CONVERSION(type, getter, value) \
#define CHECK_FLOAT_CONVERSION(type, cmpfunc, getter, value) \
g_assert_true (g_value_type_transformable (G_TYPE_FLOAT, type)); \
g_value_init (&src, G_TYPE_FLOAT); \
g_value_init (&dest, type); \
g_value_set_float (&src, value); \
g_assert_true (g_value_transform (&src, &dest)); \
g_assert_cmpfloat (g_value_get_##getter (&dest), ==, value); \
cmpfunc (g_value_get_##getter (&dest), ==, value); \
g_value_unset (&src); \
g_value_unset (&dest);
CHECK_FLOAT_CONVERSION(G_TYPE_CHAR, schar, -124)
CHECK_FLOAT_CONVERSION(G_TYPE_CHAR, schar, 124)
CHECK_FLOAT_CONVERSION(G_TYPE_UCHAR, uchar, 0)
CHECK_FLOAT_CONVERSION(G_TYPE_UCHAR, uchar, 255)
CHECK_FLOAT_CONVERSION(G_TYPE_INT, int, -12345)
CHECK_FLOAT_CONVERSION(G_TYPE_INT, int, 12345)
CHECK_FLOAT_CONVERSION(G_TYPE_UINT, uint, 0)
CHECK_FLOAT_CONVERSION(G_TYPE_UINT, uint, 12345)
CHECK_FLOAT_CONVERSION(G_TYPE_LONG, long, -12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_INT64, int64, -12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_FLOAT, float, 12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, -124)
CHECK_FLOAT_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, 124)
CHECK_FLOAT_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 0)
CHECK_FLOAT_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 255)
CHECK_FLOAT_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, -12345)
CHECK_FLOAT_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, 12345)
CHECK_FLOAT_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 0)
CHECK_FLOAT_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 12345)
CHECK_FLOAT_CONVERSION(G_TYPE_LONG, g_assert_cmpint, long, -12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_ULONG, g_assert_cmpuint, ulong, 12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_INT64, g_assert_cmpint, int64, -12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_UINT64, g_assert_cmpuint, uint64, 12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_FLOAT, g_assert_cmpfloat, float, 12345678)
CHECK_FLOAT_CONVERSION(G_TYPE_DOUBLE, g_assert_cmpfloat, double, 12345678)
#define CHECK_DOUBLE_CONVERSION(type, getter, value) \
#define CHECK_DOUBLE_CONVERSION(type, cmpfunc, getter, value) \
g_assert_true (g_value_type_transformable (G_TYPE_DOUBLE, type)); \
g_value_init (&src, G_TYPE_DOUBLE); \
g_value_init (&dest, type); \
g_value_set_double (&src, value); \
g_assert_true (g_value_transform (&src, &dest)); \
g_assert_cmpfloat (g_value_get_##getter (&dest), ==, value); \
cmpfunc (g_value_get_##getter (&dest), ==, value); \
g_value_unset (&src); \
g_value_unset (&dest);
CHECK_DOUBLE_CONVERSION(G_TYPE_CHAR, schar, -124)
CHECK_DOUBLE_CONVERSION(G_TYPE_CHAR, schar, 124)
CHECK_DOUBLE_CONVERSION(G_TYPE_UCHAR, uchar, 0)
CHECK_DOUBLE_CONVERSION(G_TYPE_UCHAR, uchar, 255)
CHECK_DOUBLE_CONVERSION(G_TYPE_INT, int, -12345)
CHECK_DOUBLE_CONVERSION(G_TYPE_INT, int, 12345)
CHECK_DOUBLE_CONVERSION(G_TYPE_UINT, uint, 0)
CHECK_DOUBLE_CONVERSION(G_TYPE_UINT, uint, 12345)
CHECK_DOUBLE_CONVERSION(G_TYPE_LONG, long, -12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_INT64, int64, -12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_FLOAT, float, 12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, -124)
CHECK_DOUBLE_CONVERSION(G_TYPE_CHAR, g_assert_cmpint, schar, 124)
CHECK_DOUBLE_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 0)
CHECK_DOUBLE_CONVERSION(G_TYPE_UCHAR, g_assert_cmpuint, uchar, 255)
CHECK_DOUBLE_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, -12345)
CHECK_DOUBLE_CONVERSION(G_TYPE_INT, g_assert_cmpint, int, 12345)
CHECK_DOUBLE_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 0)
CHECK_DOUBLE_CONVERSION(G_TYPE_UINT, g_assert_cmpuint, uint, 12345)
CHECK_DOUBLE_CONVERSION(G_TYPE_LONG, g_assert_cmpint, long, -12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_ULONG, g_assert_cmpuint, ulong, 12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_INT64, g_assert_cmpint, int64, -12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_UINT64, g_assert_cmpuint, uint64, 12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_FLOAT, g_assert_cmpfloat, float, 12345678)
CHECK_DOUBLE_CONVERSION(G_TYPE_DOUBLE, g_assert_cmpfloat, double, 12345678)
#define CHECK_BOOLEAN_CONVERSION(type, setter, value) \
g_assert_true (g_value_type_transformable (type, G_TYPE_BOOLEAN)); \

132
gobject/tests/performance/performance.c
View File

@ -169,7 +169,7 @@ run_test (PerformanceTest *test)
g_print ("Uncorrected round time: %.4f msecs, correction factor %.2f\n", 1000*min_elapsed, factor);
/* Calculate number of rounds needed */
num_rounds = (test_length / TARGET_ROUND_TIME) + 1;
num_rounds = (guint64) (test_length / TARGET_ROUND_TIME) + 1;
if (verbose)
g_print ("Running %"G_GINT64_MODIFIER"d rounds\n", num_rounds);
@ -505,7 +505,7 @@ complex_object_init (ComplexObject *complex_object)
struct ConstructionTest {
GObject **objects;
int n_objects;
unsigned int n_objects;
GType type;
};
@ -526,9 +526,9 @@ test_construction_init (PerformanceTest *test,
double count_factor)
{
struct ConstructionTest *data = _data;
int n;
unsigned int n;
n = NUM_OBJECT_TO_CONSTRUCT * count_factor;
n = (unsigned int) (NUM_OBJECT_TO_CONSTRUCT * count_factor);
if (data->n_objects != n)
{
data->n_objects = n;
@ -543,10 +543,10 @@ test_construction_run (PerformanceTest *test,
struct ConstructionTest *data = _data;
GObject **objects = data->objects;
GType type = data->type;
int i, n_objects;
unsigned int n_objects;
n_objects = data->n_objects;
for (i = 0; i < n_objects; i++)
for (unsigned int i = 0; i < n_objects; i++)
objects[i] = g_object_new (type, NULL);
}
@ -556,10 +556,10 @@ test_construction_run1 (PerformanceTest *test,
{
struct ConstructionTest *data = _data;
GObject **objects = data->objects;
int i, n_objects;
unsigned int n_objects;
n_objects = data->n_objects;
for (i = 0; i < n_objects; i++)
for (unsigned int i = 0; i < n_objects; i++)
objects[i] = (GObject *) g_slice_new0 (SimpleObject);
}
@ -570,10 +570,10 @@ test_complex_construction_run (PerformanceTest *test,
struct ConstructionTest *data = _data;
GObject **objects = data->objects;
GType type = data->type;
int i, n_objects;
unsigned int n_objects;
n_objects = data->n_objects;
for (i = 0; i < n_objects; i++)
for (unsigned int i = 0; i < n_objects; i++)
objects[i] = g_object_new (type, "val1", 5, "val2", "thousand", NULL);
}
@ -584,10 +584,10 @@ test_complex_construction_run1 (PerformanceTest *test,
struct ConstructionTest *data = _data;
GObject **objects = data->objects;
GType type = data->type;
int i, n_objects;
unsigned int n_objects;
n_objects = data->n_objects;
for (i = 0; i < n_objects; i++)
for (unsigned int i = 0; i < n_objects; i++)
{
ComplexObject *object;
object = (ComplexObject *)g_object_new (type, NULL);
@ -604,10 +604,10 @@ test_complex_construction_run2 (PerformanceTest *test,
struct ConstructionTest *data = _data;
GObject **objects = data->objects;
GType type = data->type;
int i, n_objects;
unsigned int n_objects;
n_objects = data->n_objects;
for (i = 0; i < n_objects; i++)
for (unsigned int i = 0; i < n_objects; i++)
{
objects[i] = g_object_new (type, NULL);
}
@ -618,9 +618,8 @@ test_construction_finish (PerformanceTest *test,
gpointer _data)
{
struct ConstructionTest *data = _data;
int i;
for (i = 0; i < data->n_objects; i++)
for (unsigned int i = 0; i < data->n_objects; i++)
g_object_unref (data->objects[i]);
}
@ -629,9 +628,8 @@ test_construction_finish1 (PerformanceTest *test,
gpointer _data)
{
struct ConstructionTest *data = _data;
int i;
for (i = 0; i < data->n_objects; i++)
for (unsigned int i = 0; i < data->n_objects; i++)
g_slice_free (SimpleObject, (SimpleObject *)data->objects[i]);
}
@ -650,16 +648,16 @@ test_finalization_init (PerformanceTest *test,
double count_factor)
{
struct ConstructionTest *data = _data;
int n;
unsigned int n;
n = NUM_OBJECT_TO_CONSTRUCT * count_factor;
n = (unsigned int) (NUM_OBJECT_TO_CONSTRUCT * count_factor);
if (data->n_objects != n)
{
data->n_objects = n;
data->objects = g_renew (GObject *, data->objects, n);
}
for (int i = 0; i < data->n_objects; i++)
for (unsigned int i = 0; i < data->n_objects; i++)
{
data->objects[i] = g_object_new (data->type, NULL);
}
@ -671,10 +669,10 @@ test_finalization_run (PerformanceTest *test,
{
struct ConstructionTest *data = _data;
GObject **objects = data->objects;
int i, n_objects;
unsigned int n_objects;
n_objects = data->n_objects;
for (i = 0; i < n_objects; i++)
for (unsigned int i = 0; i < n_objects; i++)
{
g_object_unref (objects[i]);
}
@ -716,7 +714,7 @@ test_finalization_print_result (PerformanceTest *test,
struct TypeCheckTest {
GObject *object;
int n_checks;
unsigned int n_checks;
};
static gpointer
@ -737,7 +735,7 @@ test_type_check_init (PerformanceTest *test,
{
struct TypeCheckTest *data = _data;
data->n_checks = factor * NUM_KILO_CHECKS_PER_ROUND;
data->n_checks = (unsigned int) (factor * NUM_KILO_CHECKS_PER_ROUND);
}
@ -753,7 +751,6 @@ test_type_check_run (PerformanceTest *test,
struct TypeCheckTest *data = _data;
GObject *object = data->object;
GType type, types[5];
int i, j;
types[0] = test_iface1_get_type ();
types[1] = test_iface2_get_type ();
@ -761,10 +758,10 @@ test_type_check_run (PerformanceTest *test,
types[3] = test_iface4_get_type ();
types[4] = test_iface5_get_type ();
for (i = 0; i < data->n_checks; i++)
for (unsigned int i = 0; i < data->n_checks; i++)
{
type = types[i%5];
for (j = 0; j < 1000; j++)
for (unsigned int j = 0; j < 1000; j++)
{
my_type_check_instance_is_a ((GTypeInstance *)object,
type);
@ -806,8 +803,8 @@ test_type_check_teardown (PerformanceTest *test,
struct EmissionTest {
GObject *object;
int n_checks;
int signal_id;
unsigned int n_checks;
unsigned int signal_id;
};
static void
@ -816,9 +813,8 @@ test_emission_run (PerformanceTest *test,
{
struct EmissionTest *data = _data;
GObject *object = data->object;
int i;
for (i = 0; i < data->n_checks; i++)
for (unsigned int i = 0; i < data->n_checks; i++)
g_signal_emit (object, data->signal_id, 0);
}
@ -828,9 +824,8 @@ test_emission_run_args (PerformanceTest *test,
{
struct EmissionTest *data = _data;
GObject *object = data->object;
int i;
for (i = 0; i < data->n_checks; i++)
for (unsigned int i = 0; i < data->n_checks; i++)
g_signal_emit (object, data->signal_id, 0, 0, NULL);
}
@ -845,7 +840,7 @@ test_emission_unhandled_setup (PerformanceTest *test)
data = g_new0 (struct EmissionTest, 1);
data->object = g_object_new (COMPLEX_TYPE_OBJECT, NULL);
data->signal_id = complex_signals[GPOINTER_TO_INT (test->extra_data)];
data->signal_id = complex_signals[GPOINTER_TO_UINT (test->extra_data)];
return data;
}
@ -856,7 +851,7 @@ test_emission_unhandled_init (PerformanceTest *test,
{
struct EmissionTest *data = _data;
data->n_checks = factor * NUM_EMISSIONS_PER_ROUND;
data->n_checks = (unsigned int) (factor * NUM_EMISSIONS_PER_ROUND);
}
static void
@ -902,7 +897,7 @@ test_emission_handled_setup (PerformanceTest *test)
data = g_new0 (struct EmissionTest, 1);
data->object = g_object_new (COMPLEX_TYPE_OBJECT, NULL);
data->signal_id = complex_signals[GPOINTER_TO_INT (test->extra_data)];
data->signal_id = complex_signals[GPOINTER_TO_UINT (test->extra_data)];
g_signal_connect (data->object, "signal",
G_CALLBACK (test_emission_handled_handler),
NULL);
@ -929,7 +924,7 @@ test_emission_handled_init (PerformanceTest *test,
{
struct EmissionTest *data = _data;
data->n_checks = factor * NUM_EMISSIONS_PER_ROUND;
data->n_checks = (unsigned int) (factor * NUM_EMISSIONS_PER_ROUND);
}
static void
@ -967,7 +962,7 @@ test_emission_handled_teardown (PerformanceTest *test,
struct NotifyTest {
GObject *object;
unsigned n_checks;
unsigned int n_checks;
};
static void
@ -977,7 +972,7 @@ test_notify_run (PerformanceTest *test,
struct NotifyTest *data = _data;
GObject *object = data->object;
for (unsigned i = 0; i < data->n_checks; i++)
for (unsigned int i = 0; i < data->n_checks; i++)
g_object_notify (object, "val1");
}
@ -988,7 +983,7 @@ test_notify_by_pspec_run (PerformanceTest *test,
struct NotifyTest *data = _data;
GObject *object = data->object;
for (unsigned i = 0; i < data->n_checks; i++)
for (unsigned int i = 0; i < data->n_checks; i++)
g_object_notify_by_pspec (object, pspecs[PROP_VAL1]);
}
@ -1013,7 +1008,7 @@ test_notify_unhandled_init (PerformanceTest *test,
{
struct NotifyTest *data = _data;
data->n_checks = factor * NUM_NOTIFY_PER_ROUND;
data->n_checks = (unsigned int) (factor * NUM_NOTIFY_PER_ROUND);
}
static void
@ -1075,7 +1070,7 @@ test_notify_handled_init (PerformanceTest *test,
{
struct NotifyTest *data = _data;
data->n_checks = factor * NUM_NOTIFY_PER_ROUND;
data->n_checks = (unsigned int) (factor * NUM_NOTIFY_PER_ROUND);
}
static void
@ -1117,7 +1112,7 @@ test_notify_handled_teardown (PerformanceTest *test,
struct SetTest {
GObject *object;
unsigned n_checks;
unsigned int n_checks;
};
static void
@ -1127,7 +1122,7 @@ test_set_run (PerformanceTest *test,
struct SetTest *data = _data;
GObject *object = data->object;
for (unsigned i = 0; i < data->n_checks; i++)
for (unsigned int i = 0; i < data->n_checks; i++)
g_object_set (object, "val1", i, NULL);
}
@ -1155,7 +1150,7 @@ test_set_init (PerformanceTest *test,
{
struct SetTest *data = _data;
data->n_checks = factor * NUM_SET_PER_ROUND;
data->n_checks = (unsigned int) (factor * NUM_SET_PER_ROUND);
}
static void
@ -1194,7 +1189,7 @@ test_set_teardown (PerformanceTest *test,
struct GetTest {
GObject *object;
unsigned n_checks;
unsigned int n_checks;
};
static void
@ -1205,7 +1200,7 @@ test_get_run (PerformanceTest *test,
GObject *object = data->object;
int val;
for (unsigned i = 0; i < data->n_checks; i++)
for (unsigned int i = 0; i < data->n_checks; i++)
g_object_get (object, "val1", &val, NULL);
}
@ -1233,7 +1228,7 @@ test_get_init (PerformanceTest *test,
{
struct GetTest *data = _data;
data->n_checks = factor * NUM_GET_PER_ROUND;
data->n_checks = (unsigned int) (factor * NUM_GET_PER_ROUND);
}
static void
@ -1272,7 +1267,7 @@ test_get_teardown (PerformanceTest *test,
struct RefcountTest {
GObject *object;
int n_checks;
unsigned int n_checks;
gboolean is_toggle_ref;
};
@ -1308,7 +1303,7 @@ test_refcount_init (PerformanceTest *test,
{
struct RefcountTest *data = _data;
data->n_checks = factor * NUM_KILO_REFS_PER_ROUND;
data->n_checks = (unsigned int) (factor * NUM_KILO_REFS_PER_ROUND);
}
static void
@ -1317,9 +1312,8 @@ test_refcount_run (PerformanceTest *test,
{
struct RefcountTest *data = _data;
GObject *object = data->object;
int i;
for (i = 0; i < data->n_checks; i++)
for (unsigned int i = 0; i < data->n_checks; i++)
{
g_object_ref (object);
g_object_ref (object);
@ -1341,9 +1335,8 @@ test_refcount_1_run (PerformanceTest *test,
{
struct RefcountTest *data = _data;
GObject *object = data->object;
int i;
for (i = 0; i < data->n_checks; i++)
for (unsigned int i = 0; i < data->n_checks; i++)
{
g_object_ref (object);
g_object_unref (object);
@ -1457,7 +1450,7 @@ static PerformanceTest tests[] = {
},
{
"emit-unhandled",
GINT_TO_POINTER (COMPLEX_SIGNAL),
GUINT_TO_POINTER (COMPLEX_SIGNAL),
test_emission_unhandled_setup,
test_emission_unhandled_init,
test_emission_run,
@ -1467,7 +1460,7 @@ static PerformanceTest tests[] = {
},
{
"emit-unhandled-empty",
GINT_TO_POINTER (COMPLEX_SIGNAL_EMPTY),
GUINT_TO_POINTER (COMPLEX_SIGNAL_EMPTY),
test_emission_unhandled_setup,
test_emission_unhandled_init,
test_emission_run,
@ -1477,7 +1470,7 @@ static PerformanceTest tests[] = {
},
{
"emit-unhandled-generic",
GINT_TO_POINTER (COMPLEX_SIGNAL_GENERIC),
GUINT_TO_POINTER (COMPLEX_SIGNAL_GENERIC),
test_emission_unhandled_setup,
test_emission_unhandled_init,
test_emission_run,
@ -1487,7 +1480,7 @@ static PerformanceTest tests[] = {
},
{
"emit-unhandled-generic-empty",
GINT_TO_POINTER (COMPLEX_SIGNAL_GENERIC_EMPTY),
GUINT_TO_POINTER (COMPLEX_SIGNAL_GENERIC_EMPTY),
test_emission_unhandled_setup,
test_emission_unhandled_init,
test_emission_run,
@ -1497,7 +1490,7 @@ static PerformanceTest tests[] = {
},
{
"emit-unhandled-args",
GINT_TO_POINTER (COMPLEX_SIGNAL_ARGS),
GUINT_TO_POINTER (COMPLEX_SIGNAL_ARGS),
test_emission_unhandled_setup,
test_emission_unhandled_init,
test_emission_run_args,
@ -1507,7 +1500,7 @@ static PerformanceTest tests[] = {
},
{
"emit-handled",
GINT_TO_POINTER (COMPLEX_SIGNAL),
GUINT_TO_POINTER (COMPLEX_SIGNAL),
test_emission_handled_setup,
test_emission_handled_init,
test_emission_run,
@ -1517,7 +1510,7 @@ static PerformanceTest tests[] = {
},
{
"emit-handled-empty",
GINT_TO_POINTER (COMPLEX_SIGNAL_EMPTY),
GUINT_TO_POINTER (COMPLEX_SIGNAL_EMPTY),
test_emission_handled_setup,
test_emission_handled_init,
test_emission_run,
@ -1527,7 +1520,7 @@ static PerformanceTest tests[] = {
},
{
"emit-handled-generic",
GINT_TO_POINTER (COMPLEX_SIGNAL_GENERIC),
GUINT_TO_POINTER (COMPLEX_SIGNAL_GENERIC),
test_emission_handled_setup,
test_emission_handled_init,
test_emission_run,
@ -1537,7 +1530,7 @@ static PerformanceTest tests[] = {
},
{
"emit-handled-generic-empty",
GINT_TO_POINTER (COMPLEX_SIGNAL_GENERIC_EMPTY),
GUINT_TO_POINTER (COMPLEX_SIGNAL_GENERIC_EMPTY),
test_emission_handled_setup,
test_emission_handled_init,
test_emission_run,
@ -1547,7 +1540,7 @@ static PerformanceTest tests[] = {
},
{
"emit-handled-args",
GINT_TO_POINTER (COMPLEX_SIGNAL_ARGS),
GUINT_TO_POINTER (COMPLEX_SIGNAL_ARGS),
test_emission_handled_setup,
test_emission_handled_init,
test_emission_run_args,
@ -1650,8 +1643,7 @@ static PerformanceTest tests[] = {
static PerformanceTest *
find_test (const char *name)
{
gsize i;
for (i = 0; i < G_N_ELEMENTS (tests); i++)
for (size_t i = 0; i < G_N_ELEMENTS (tests); i++)
{
if (strcmp (tests[i].name, name) == 0)
return &tests[i];
@ -1666,7 +1658,6 @@ main (int argc,
GOptionContext *context;
GError *error = NULL;
const char *str;
int i;
if ((str = g_getenv ("GLIB_PERFORMANCE_FACTOR")) && str[0])
{
@ -1691,7 +1682,7 @@ main (int argc,
if (argc > 1)
{
for (i = 1; i < argc; i++)
for (int i = 1; i < argc; i++)
{
test = find_test (argv[i]);
if (test)
@ -1700,8 +1691,7 @@ main (int argc,
}
else
{
gsize k;
for (k = 0; k < G_N_ELEMENTS (tests); k++)
for (size_t k = 0; k < G_N_ELEMENTS (tests); k++)
run_test (&tests[k]);
}

1
meson.build
View File

@ -550,6 +550,7 @@ endforeach
if cc.get_id() == 'gcc' or cc.get_id() == 'clang'
warning_common_args = [
'-Wduplicated-branches',
'-Wfloat-conversion',
'-Wimplicit-fallthrough',
'-Wmisleading-indentation',
'-Wmissing-field-initializers',