END_TEST
START_TEST(modem_call_api2)
{
ModemCallService *call_service;
call_service = g_object_new(MODEM_TYPE_CALL_SERVICE, NULL);
fail_unless(call_service != NULL);
fail_unless(modem_call_service_connect(call_service, "/"));
modem_call_service_disconnect(call_service);
fail_if(modem_call_service_is_connected(call_service));
fail_if(modem_call_service_is_connecting(call_service));
g_object_unref(call_service);
call_service = g_object_new(MODEM_TYPE_CALL_SERVICE, NULL);
fail_unless(call_service != NULL);
fail_unless(modem_call_service_connect(call_service, "/"));
g_object_run_dispose(G_OBJECT(call_service));
fail_if(modem_call_service_is_connected(call_service));
fail_if(modem_call_service_is_connecting(call_service));
g_object_unref(call_service);
call_service = g_object_new(MODEM_TYPE_CALL_SERVICE, NULL);
fail_unless(call_service != NULL);
g_object_run_dispose(G_OBJECT(call_service));
fail_if(modem_call_service_connect(call_service, "/"));
fail_if(modem_call_service_is_connected(call_service));
fail_if(modem_call_service_is_connecting(call_service));
g_object_unref(call_service);
}
static void
dispose(GObject *base)
{
struct Private *priv = GET_PRIVATE(base);
if (priv->windows) {
for (GList *node = g_queue_peek_head_link(priv->windows);
node; node = node->next) {
JoyBubble *window = node->data;
g_object_run_dispose(G_OBJECT(window));
g_object_unref(window);
}
g_queue_free(priv->windows);
priv->windows = NULL;
}
if (priv->keyboard) {
g_object_run_dispose(G_OBJECT(priv->keyboard));
g_object_unref(priv->keyboard);
priv->keyboard = NULL;
}
if (priv->mouse) {
g_object_run_dispose(G_OBJECT(priv->mouse));
g_object_unref(priv->mouse);
priv->mouse = NULL;
}
G_OBJECT_CLASS(joy_gfx3d_screen_parent_class)->dispose(base);
}
/* The suite cleanup function.
* Closes the temporary file used by the tests.
* Returns zero on success, non-zero otherwise.
*/
int
ags_envelope_audio_signal_test_clean_suite()
{
g_object_run_dispose(devout);
g_object_unref(devout);
g_object_run_dispose(audio);
g_object_unref(audio);
return(0);
}
/* The suite cleanup function.
* Closes the temporary file used by the tests.
* Returns zero on success, non-zero otherwise.
*/
int
ags_mute_channel_test_clean_suite()
{
g_object_run_dispose(devout);
g_object_unref(devout);
g_object_run_dispose(audio);
g_object_unref(audio);
return(0);
}
static void
finish_editing (ETableClickToAdd *etcta)
{
if (etcta->row) {
ETableModel *one;
e_table_item_leave_edit (E_TABLE_ITEM (etcta->row));
e_table_one_commit (E_TABLE_ONE (etcta->one));
etcta_drop_one (etcta);
g_object_run_dispose (G_OBJECT (etcta->row));
etcta->row = NULL;
if (etcta->text) {
g_object_run_dispose (G_OBJECT (etcta->text));
etcta->text = NULL;
}
if (etcta->rect) {
g_object_run_dispose (G_OBJECT (etcta->rect));
etcta->rect = NULL;
}
one = e_table_one_new (etcta->model);
etcta_add_one (etcta, one);
g_object_unref (one);
e_selection_model_clear (E_SELECTION_MODEL (etcta->selection));
etcta->row = gnome_canvas_item_new (
GNOME_CANVAS_GROUP (etcta),
e_table_item_get_type (),
"ETableHeader", etcta->eth,
"ETableModel", etcta->one,
"minimum_width", etcta->width,
"horizontal_draw_grid", TRUE,
"vertical_draw_grid", TRUE,
"selection_model", etcta->selection,
"cursor_mode", E_CURSOR_SPREADSHEET,
NULL);
g_signal_connect (
etcta->row, "key_press",
G_CALLBACK (item_key_press), etcta);
e_signal_connect_notify (
etcta->row, "notify::is-editing",
G_CALLBACK (table_click_to_add_row_is_editing_changed_cb), etcta);
set_initial_selection (etcta);
g_object_notify (G_OBJECT (etcta), "is-editing");
}
}
static void
hippo_actions_dispose(GObject *object)
{
HippoActions *actions = HIPPO_ACTIONS(object);
if (actions->minute_timeout_id) {
g_source_remove(actions->minute_timeout_id);
actions->minute_timeout_id = 0;
}
if (actions->model) {
g_object_unref(actions->model);
actions->model = NULL;
}
if (actions->platform) {
g_object_unref(actions->platform);
actions->platform = NULL;
}
actions->stack_manager = NULL;
if (actions->entity_photo_cache) {
g_object_run_dispose(G_OBJECT(actions->entity_photo_cache));
g_object_unref(actions->entity_photo_cache);
actions->entity_photo_cache = NULL;
}
if (actions->favicon_cache) {
g_object_run_dispose(G_OBJECT(actions->favicon_cache));
g_object_unref(actions->favicon_cache);
actions->favicon_cache = NULL;
}
if (actions->thumbnail_cache) {
g_object_run_dispose(G_OBJECT(actions->thumbnail_cache));
g_object_unref(actions->thumbnail_cache);
actions->thumbnail_cache = NULL;
}
if (actions->music_thumbnail_cache) {
g_object_run_dispose(G_OBJECT(actions->music_thumbnail_cache));
g_object_unref(actions->music_thumbnail_cache);
actions->music_thumbnail_cache = NULL;
}
G_OBJECT_CLASS(hippo_actions_parent_class)->dispose(object);
}
static void
remove_modem (MMManager *manager,
MMBaseModem *modem)
{
gchar *path;
gchar *device;
device = g_strdup (mm_base_modem_get_device (modem));
path = g_strdup (g_dbus_object_get_object_path (G_DBUS_OBJECT (modem)));
/* If we get DBus object path, modem was exported */
if (path) {
g_dbus_object_manager_server_unexport (manager->priv->object_manager, path);
g_object_set (modem,
MM_BASE_MODEM_CONNECTION, NULL,
NULL);
mm_dbg ("Unexported modem '%s' from path '%s'", device, path);
g_free (path);
} else {
mm_dbg ("Removing modem '%s', which wasn't exported yet", device);
}
/* Run dispose before unref-ing, in order to cleanup the SIM object,
* if any (which also holds a reference to the modem object) */
g_object_run_dispose (G_OBJECT (modem));
g_hash_table_remove (manager->priv->modems, device);
g_free (device);
}
static void
cockpit_authenticated_free (gpointer data)
{
CockpitAuthenticated *authenticated = data;
GObject *object;
if (authenticated->timeout_tag)
g_source_remove (authenticated->timeout_tag);
g_free (authenticated->cookie);
cockpit_creds_poison (authenticated->creds);
cockpit_creds_unref (authenticated->creds);
if (authenticated->service)
{
if (authenticated->idling_sig)
g_signal_handler_disconnect (authenticated->service, authenticated->idling_sig);
if (authenticated->destroy_sig)
g_signal_handler_disconnect (authenticated->service, authenticated->destroy_sig);
object = G_OBJECT (authenticated->service);
g_object_weak_unref (object, on_web_service_gone, authenticated);
g_object_run_dispose (object);
g_object_unref (authenticated->service);
}
g_free (authenticated);
}
END_TEST
START_TEST(modem_sim_api2)
{
ModemSIMService *sim;
sim = g_object_new(MODEM_TYPE_SIM_SERVICE, NULL);
fail_unless(sim != NULL);
modem_sim_service_connect(sim);
g_object_unref(sim);
sim = g_object_new(MODEM_TYPE_SIM_SERVICE, NULL);
fail_unless(sim != NULL);
modem_sim_service_connect(sim);
modem_sim_service_disconnect(sim);
fail_if(modem_sim_service_is_connected(sim));
fail_if(modem_sim_service_is_connecting(sim));
modem_sim_service_connect(sim);
fail_if(modem_sim_service_is_connected(sim));
fail_if(modem_sim_service_is_connecting(sim));
modem_sim_service_disconnect(sim);
g_object_unref(sim);
sim = g_object_new(MODEM_TYPE_SIM_SERVICE, NULL);
fail_unless(sim != NULL);
modem_sim_service_connect(sim);
g_object_run_dispose(G_OBJECT(sim));
fail_if(modem_sim_service_is_connected(sim));
fail_if(modem_sim_service_is_connecting(sim));
modem_sim_service_connect(sim);
g_object_unref(sim);
}
static void
gdk_x11_screen_dispose (GObject *object)
{
GdkX11Screen *x11_screen = GDK_X11_SCREEN (object);
int i;
for (i = 0; i < 32; ++i)
{
if (x11_screen->subwindow_gcs[i])
{
XFreeGC (x11_screen->xdisplay, x11_screen->subwindow_gcs[i]);
x11_screen->subwindow_gcs[i] = 0;
}
}
_gdk_x11_xsettings_finish (x11_screen);
if (x11_screen->root_window)
_gdk_window_destroy (x11_screen->root_window, TRUE);
for (i = 0; i < x11_screen->nvisuals; i++)
g_object_run_dispose (G_OBJECT (x11_screen->visuals[i]));
G_OBJECT_CLASS (gdk_x11_screen_parent_class)->dispose (object);
x11_screen->xdisplay = NULL;
x11_screen->xscreen = NULL;
x11_screen->screen_num = -1;
x11_screen->xroot_window = None;
x11_screen->wmspec_check_window = None;
}
static gboolean
dispose_on_idle (gpointer object)
{
g_object_run_dispose (object);
g_object_unref (object);
return FALSE;
}
static void
storage_volume_group_dispose (GObject *obj)
{
StorageVolumeGroup *self = STORAGE_VOLUME_GROUP (obj);
GHashTableIter iter;
const gchar *path;
gpointer value;
self->need_publish = FALSE;
/* Dispose all the volumes, should unpublish */
g_hash_table_iter_init (&iter, self->logical_volumes);
while (g_hash_table_iter_next (&iter, NULL, &value))
g_object_run_dispose (value);
g_hash_table_remove_all (self->logical_volumes);
g_hash_table_remove_all (self->physical_volumes);
if (self->info)
{
g_variant_unref (self->info);
self->info = NULL;
}
update_all_blocks (self);
path = storage_volume_group_get_object_path (self);
if (path != NULL)
storage_daemon_unpublish (storage_daemon_get (), path, self);
G_OBJECT_CLASS (storage_volume_group_parent_class)->dispose (obj);
}
void
ags_audio_test_finalize()
{
AgsAudio *audio;
/* instantiate audio */
audio = ags_audio_new(devout);
/* set audio channels */
audio->audio_channels = AGS_AUDIO_TEST_FINALIZE_AUDIO_CHANNELS;
/* set input pads */
ags_audio_set_pads(audio,
AGS_TYPE_INPUT,
AGS_AUDIO_TEST_FINALIZE_INPUT_PADS, 0);
/* set output pads */
ags_audio_set_pads(audio,
AGS_TYPE_OUTPUT,
AGS_AUDIO_TEST_FINALIZE_OUTPUT_PADS, 0);
/* run dispose */
g_object_run_dispose(audio);
/* stub */
audio_test_finalized = FALSE;
G_OBJECT_GET_CLASS(audio)->finalize = ags_audio_test_finalize_stub;
/* unref and assert */
g_object_unref(audio);
CU_ASSERT(audio_test_finalized == TRUE);
}
static void
dispose_and_unref (gpointer object)
{
g_return_if_fail (G_IS_OBJECT (object));
g_object_run_dispose (G_OBJECT (object));
g_object_unref (object);
}
static void
do_idle_on_dispose_test (void)
{
SoupSession *session;
SoupMessage *msg;
GMainContext *async_context;
debug_printf (1, "\nTesting SoupSessionAsync dispose behavior\n");
async_context = g_main_context_new ();
session = soup_test_session_new (SOUP_TYPE_SESSION_ASYNC,
SOUP_SESSION_ASYNC_CONTEXT, async_context,
NULL);
msg = soup_message_new_from_uri ("GET", base_uri);
soup_session_send_message (session, msg);
g_object_unref (msg);
while (g_main_context_iteration (async_context, FALSE))
;
g_object_run_dispose (G_OBJECT (session));
if (g_main_context_iteration (async_context, FALSE)) {
debug_printf (1, " idle was queued!\n");
errors++;
}
g_object_unref (session);
g_main_context_unref (async_context);
}
static gboolean
on_cancelled_no_deadlock (gpointer user_data)
{
/* Brings any init to an orderly stop */
g_object_run_dispose (user_data);
return FALSE;
}
static void
gkd_secret_service_dispose (GObject *obj)
{
GkdSecretService *self = GKD_SECRET_SERVICE (obj);
if (self->name_owner_id) {
g_dbus_connection_signal_unsubscribe (self->connection, self->name_owner_id);
self->name_owner_id = 0;
}
if (self->filter_id) {
g_dbus_connection_remove_filter (self->connection, self->filter_id);
self->filter_id = 0;
}
/* Closes all the clients */
g_hash_table_remove_all (self->clients);
/* Hide all the objects */
if (self->objects) {
g_object_run_dispose (G_OBJECT (self->objects));
g_object_unref (self->objects);
self->objects = NULL;
}
g_clear_object (&self->connection);
if (self->internal_session) {
dispose_and_unref (self->internal_session);
self->internal_session = NULL;
}
G_OBJECT_CLASS (gkd_secret_service_parent_class)->dispose (obj);
}
static gboolean
process_logout (CockpitWebService *self,
JsonObject *options)
{
gboolean disconnect;
if (!cockpit_json_get_bool (options, "disconnect", FALSE, &disconnect))
{
g_warning ("received 'logout' command with invalid 'disconnect' field");
return FALSE;
}
/* Makes the credentials unusable */
cockpit_creds_poison (self->creds);
/* Destroys our web service, disconnects everything */
if (disconnect)
{
g_info ("Logging out session from %s", cockpit_creds_get_rhost (self->creds));
g_object_run_dispose (G_OBJECT (self));
}
else
{
g_info ("Deauthorizing session from %s", cockpit_creds_get_rhost (self->creds));
}
send_socket_hints (self, "credential", "none");
return TRUE;
}
static void
gkd_secret_service_dispose (GObject *obj)
{
GkdSecretService *self = GKD_SECRET_SERVICE (obj);
if (self->match_rule) {
g_return_if_fail (self->connection);
dbus_bus_remove_match (self->connection, self->match_rule, NULL);
g_free (self->match_rule);
self->match_rule = NULL;
}
/* Closes all the clients */
g_hash_table_remove_all (self->clients);
/* Hide all the objects */
if (self->objects) {
g_object_run_dispose (G_OBJECT (self->objects));
g_object_unref (self->objects);
self->objects = NULL;
}
if (self->connection) {
dbus_connection_remove_filter (self->connection, gkd_secret_service_filter_handler, self);
dbus_connection_unref (self->connection);
self->connection = NULL;
}
G_OBJECT_CLASS (gkd_secret_service_parent_class)->dispose (obj);
}
static void
goc_canvas_dispose (GObject *obj)
{
GocCanvas *canvas = GOC_CANVAS (obj);
g_object_run_dispose (G_OBJECT (canvas->root));
parent_klass->dispose (obj);
}
void
fs_session_destroy (FsSession *session)
{
g_return_if_fail (session);
g_return_if_fail (FS_IS_SESSION (session));
g_object_run_dispose (G_OBJECT (session));
}
static void
check_and_unref_assertion (gpointer data)
{
g_assert (GKM_IS_ASSERTION (data));
g_assert (g_object_get_qdata (data, QDATA_ASSERTION_KEY) != NULL);
g_object_run_dispose (data);
g_object_unref (data);
}
void
fs_stream_destroy (FsStream *stream)
{
g_return_if_fail (stream);
g_return_if_fail (FS_IS_STREAM (stream));
g_object_run_dispose (G_OBJECT (stream));
}
static void
st_scroll_view_dispose (GObject *object)
{
StScrollViewPrivate *priv = ST_SCROLL_VIEW (object)->priv;
if (priv->vfade_effect)
{
clutter_actor_remove_effect (CLUTTER_ACTOR (object), CLUTTER_EFFECT (priv->vfade_effect));
priv->vfade_effect = NULL;
}
if (priv->vscroll)
clutter_actor_destroy (priv->vscroll);
if (priv->hscroll)
clutter_actor_destroy (priv->hscroll);
/* For most reliable freeing of memory, an object with signals
* like StAdjustment should be explicitly disposed. Since we own
* the adjustments, we take care of that. This also disconnects
* the signal handlers that we established on creation.
*/
if (priv->hadjustment)
{
g_object_run_dispose (G_OBJECT (priv->hadjustment));
g_object_unref (priv->hadjustment);
priv->hadjustment = NULL;
}
if (priv->vadjustment)
{
g_object_run_dispose (G_OBJECT (priv->vadjustment));
g_object_unref (priv->vadjustment);
priv->vadjustment = NULL;
}
if (priv->setting_connect_id > 0) {
g_signal_handler_disconnect (priv->settings, priv->setting_connect_id);
priv->setting_connect_id = 0;
}
g_signal_handlers_disconnect_by_func (ST_SCROLL_VIEW (object), motion_event_cb, ST_SCROLL_VIEW (object));
G_OBJECT_CLASS (st_scroll_view_parent_class)->dispose (object);
}
void
gkd_dbus_secrets_cleanup (DBusConnection *conn)
{
if (secrets_service) {
g_object_run_dispose (G_OBJECT (secrets_service));
g_object_unref (secrets_service);
secrets_service = NULL;
}
}
void
ibus_object_destroy (IBusObject *obj)
{
IBusObjectPrivate *priv;
priv = IBUS_OBJECT_GET_PRIVATE (obj);
if (! (IBUS_OBJECT_FLAGS (obj) & IBUS_IN_DESTRUCTION)) {
g_object_run_dispose (G_OBJECT (obj));
}
}
/**
* ags_audiorec_wave_loader_completed_timeout:
* @widget: the widget
*
* Queue draw widget
*
* Returns: %TRUE if proceed poll completed, otherwise %FALSE
*
* Since: 2.0.13
*/
gboolean
ags_audiorec_wave_loader_completed_timeout(AgsAudiorec *audiorec)
{
if(g_hash_table_lookup(ags_audiorec_wave_loader_completed,
audiorec) != NULL){
if(audiorec->wave_loader != NULL){
if(ags_wave_loader_test_flags(audiorec->wave_loader, AGS_WAVE_LOADER_HAS_COMPLETED)){
g_object_run_dispose((GObject *) audiorec->wave_loader);
g_object_unref(audiorec->wave_loader);
audiorec->wave_loader = NULL;
audiorec->position = -1;
gtk_widget_hide((GtkWidget *) audiorec->loading);
}else{
if(audiorec->position == -1){
audiorec->position = 0;
gtk_widget_show((GtkWidget *) audiorec->loading);
}
switch(audiorec->position){
case 0:
{
audiorec->position = 1;
gtk_label_set_label(audiorec->loading,
"loading ... ");
}
break;
case 1:
{
audiorec->position = 2;
gtk_label_set_label(audiorec->loading,
"loading ... ");
}
break;
case 2:
{
audiorec->position = 0;
gtk_label_set_label(audiorec->loading,
"loading ...");
}
break;
}
}
}
return(TRUE);
}else{
return(FALSE);
}
}
static void
foreach_dispose (gpointer key,
gpointer _channel,
gpointer user_data)
{
/* Ensure "closed" has been emitted */
if (!tp_base_channel_is_destroyed (_channel))
{
g_object_run_dispose (_channel);
}
}
void
_gdk_screen_close (GdkScreen *screen)
{
g_return_if_fail (GDK_IS_SCREEN (screen));
if (!screen->closed)
{
screen->closed = TRUE;
g_object_run_dispose (G_OBJECT (screen));
}
}
void
ags_pulse_client_dispose(GObject *gobject)
{
AgsPulseClient *pulse_client;
GList *list;
pulse_client = AGS_PULSE_CLIENT(gobject);
/* pulse server */
if(pulse_client->pulse_server != NULL){
g_object_unref(pulse_client->pulse_server);
pulse_client->pulse_server = NULL;
}
/* device */
if(pulse_client->device != NULL){
list = pulse_client->device;
while(list != NULL){
g_object_set(G_OBJECT(list->data),
"pulse-client", NULL,
NULL);
list = list->next;
}
g_list_free_full(pulse_client->device,
g_object_unref);
pulse_client->device = NULL;
}
/* port */
if(pulse_client->port != NULL){
list = pulse_client->port;
while(list != NULL){
g_object_run_dispose(G_OBJECT(list->data));
list = list->next;
}
g_list_free_full(pulse_client->port,
g_object_unref);
pulse_client->port = NULL;
}
/* call parent */
G_OBJECT_CLASS(ags_pulse_client_parent_class)->dispose(gobject);
}
