/* semantic_floating_reference.c generated by valac, the Vala compiler
 * generated from semantic_floating_reference.vala, do not modify */

#include <glib.h>
#include <stdlib.h>
#include <string.h>

#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif
#if !defined(VALA_EXTERN)
#if defined(_MSC_VER)
#define VALA_EXTERN __declspec(dllexport) extern
#elif __GNUC__ >= 4
#define VALA_EXTERN __attribute__((visibility("default"))) extern
#else
#define VALA_EXTERN extern
#endif
#endif

#define _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))
#define _g_free0(var) (var = (g_free (var), NULL))
#define _g_variant_type_free0(var) ((var == NULL) ? NULL : (var = (g_variant_type_free (var), NULL)))
#define _g_variant_builder_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_builder_unref (var), NULL)))
#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);

VALA_EXTERN GVariant* get_floating_variant (void);
VALA_EXTERN GVariant* get_floating_variant_with_error (GError** error);
VALA_EXTERN void test_variant (void);
static gchar* _variant_get1 (GVariant* value);
VALA_EXTERN void test_variant_builder (void);
static void _vala_main (void);

GVariant*
get_floating_variant (void)
{
	GVariant* _tmp0_;
	GVariant* result;
	_tmp0_ = g_variant_new_string ("foo");
	result = _tmp0_;
	return result;
}

GVariant*
get_floating_variant_with_error (GError** error)
{
	GVariant* _tmp0_;
	GVariant* result;
	_tmp0_ = g_variant_new_string ("bar");
	result = _tmp0_;
	return result;
}

static gpointer
_g_variant_ref0 (gpointer self)
{
	return self ? g_variant_ref (self) : NULL;
}

static gchar*
_variant_get1 (GVariant* value)
{
	return g_variant_dup_string (value, NULL);
}

void
test_variant (void)
{
	GError* _inner_error0_ = NULL;
	{
		gchar* value = NULL;
		gchar* _tmp0_;
		GVariant* _tmp1_ = NULL;
		const gchar* _tmp2_;
		GVariant* _tmp3_;
		GVariant* variant = NULL;
		GVariant* _tmp6_;
		GVariant* _tmp7_;
		const GVariantType* _tmp8_;
		GVariant* _tmp9_;
		_tmp0_ = g_strdup ("bar");
		value = _tmp0_;
		_tmp2_ = value;
		_tmp3_ = g_variant_new_string (_tmp2_);
		_tmp1_ = _tmp3_;
		if (_tmp1_ == NULL) {
			const gchar* _tmp4_;
			GVariant* _tmp5_;
			_tmp4_ = value;
			_tmp5_ = g_variant_new_string (_tmp4_);
			_g_variant_unref0 (_tmp1_);
			_tmp1_ = _tmp5_;
		}
		_tmp6_ = _tmp1_;
		_tmp1_ = NULL;
		if (_tmp6_ != NULL) {
			g_variant_ref_sink (_tmp6_);
		}
		variant = _tmp6_;
		_tmp7_ = variant;
		_tmp8_ = G_VARIANT_TYPE_STRING;
		_vala_assert (g_variant_is_of_type (_tmp7_, _tmp8_), "variant.is_of_type (VariantType.STRING)");
		_tmp9_ = variant;
		_vala_assert (!g_variant_is_floating (_tmp9_), "!variant.is_floating ()");
		_g_variant_unref0 (variant);
		_g_variant_unref0 (_tmp1_);
		_g_free0 (value);
	}
	{
		gchar* value = NULL;
		gchar* _tmp10_;
		GVariant* _tmp11_ = NULL;
		const gchar* _tmp12_;
		GVariant* variant = NULL;
		GVariant* _tmp15_;
		GVariant* _tmp16_;
		const GVariantType* _tmp17_;
		GVariant* _tmp18_;
		_tmp10_ = g_strdup ("foo");
		value = _tmp10_;
		_tmp12_ = value;
		if (_tmp12_ == NULL) {
			_g_variant_unref0 (_tmp11_);
			_tmp11_ = NULL;
		} else {
			const gchar* _tmp13_;
			GVariant* _tmp14_;
			_tmp13_ = value;
			_tmp14_ = g_variant_new_string (_tmp13_);
			g_variant_ref_sink (_tmp14_);
			_g_variant_unref0 (_tmp11_);
			_tmp11_ = _tmp14_;
		}
		_tmp15_ = _g_variant_ref0 (_tmp11_);
		variant = _tmp15_;
		_tmp16_ = variant;
		_tmp17_ = G_VARIANT_TYPE_STRING;
		_vala_assert (g_variant_is_of_type (_tmp16_, _tmp17_), "variant.is_of_type (VariantType.STRING)");
		_tmp18_ = variant;
		_vala_assert (!g_variant_is_floating (_tmp18_), "!variant.is_floating ()");
		_g_variant_unref0 (variant);
		_g_variant_unref0 (_tmp11_);
		_g_free0 (value);
	}
	{
		gchar* value = NULL;
		gchar* _tmp19_;
		GVariant* variant = NULL;
		const gchar* _tmp20_;
		GVariant* _tmp23_;
		const GVariantType* _tmp24_;
		GVariant* _tmp25_;
		_tmp19_ = g_strdup ("foo");
		value = _tmp19_;
		_tmp20_ = value;
		if (_tmp20_ == NULL) {
			_g_variant_unref0 (variant);
			variant = NULL;
		} else {
			const gchar* _tmp21_;
			GVariant* _tmp22_;
			_tmp21_ = value;
			_tmp22_ = g_variant_new_string (_tmp21_);
			g_variant_ref_sink (_tmp22_);
			_g_variant_unref0 (variant);
			variant = _tmp22_;
		}
		_tmp23_ = variant;
		_tmp24_ = G_VARIANT_TYPE_STRING;
		_vala_assert (g_variant_is_of_type (_tmp23_, _tmp24_), "variant.is_of_type (VariantType.STRING)");
		_tmp25_ = variant;
		_vala_assert (!g_variant_is_floating (_tmp25_), "!variant.is_floating ()");
		_g_variant_unref0 (variant);
		_g_free0 (value);
	}
	{
		gboolean value = FALSE;
		GVariant* variant = NULL;
		GVariant* _tmp26_;
		const GVariantType* _tmp27_;
		value = TRUE;
		_tmp26_ = g_variant_new_boolean (value);
		g_variant_ref_sink (_tmp26_);
		variant = _tmp26_;
		_tmp27_ = G_VARIANT_TYPE_BOOLEAN;
		_vala_assert (g_variant_is_of_type (variant, _tmp27_), "variant.is_of_type (VariantType.BOOLEAN)");
		_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
		_g_variant_unref0 (variant);
	}
	{
		gchar* value = NULL;
		gchar* _tmp28_;
		GVariant* variant = NULL;
		GVariant* _tmp29_;
		const GVariantType* _tmp30_;
		gchar* s = NULL;
		gchar* _tmp31_;
		_tmp28_ = g_strdup ("manam");
		value = _tmp28_;
		_tmp29_ = g_variant_new_string (value);
		g_variant_ref_sink (_tmp29_);
		variant = _tmp29_;
		_tmp30_ = G_VARIANT_TYPE_STRING;
		_vala_assert (g_variant_is_of_type (variant, _tmp30_), "variant.is_of_type (VariantType.STRING)");
		_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
		_tmp31_ = _variant_get1 (variant);
		s = _tmp31_;
		_vala_assert (g_strcmp0 (s, "manam") == 0, "s == \"manam\"");
		_g_free0 (s);
		_g_variant_unref0 (variant);
		_g_free0 (value);
	}
	{
		GVariant* variant = NULL;
		GVariant* _tmp32_;
		_tmp32_ = get_floating_variant ();
		g_variant_ref_sink (_tmp32_);
		variant = _tmp32_;
		_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
		_g_variant_unref0 (variant);
	}
	{
		GVariant* variant = NULL;
		GVariant* _tmp33_;
		_tmp33_ = get_floating_variant_with_error (&_inner_error0_);
		if (_tmp33_ != NULL) {
			g_variant_ref_sink (_tmp33_);
		}
		variant = _tmp33_;
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return;
		}
		_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
		_g_variant_unref0 (variant);
	}
	{
		{
			GVariant* variant = NULL;
			GVariant* _tmp34_;
			GVariant* _tmp35_;
			_tmp34_ = get_floating_variant_with_error (&_inner_error0_);
			if (_tmp34_ != NULL) {
				g_variant_ref_sink (_tmp34_);
			}
			variant = _tmp34_;
			if (G_UNLIKELY (_inner_error0_ != NULL)) {
				goto __catch0_g_error;
			}
			_tmp35_ = variant;
			_vala_assert (!g_variant_is_floating (_tmp35_), "!variant.is_floating ()");
			_g_variant_unref0 (variant);
		}
		goto __finally0;
		__catch0_g_error:
		{
			g_clear_error (&_inner_error0_);
			g_assert_not_reached ();
		}
		__finally0:
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return;
		}
	}
}

void
test_variant_builder (void)
{
	gchar* name = NULL;
	gchar* _tmp0_;
	gchar* key = NULL;
	gchar* _tmp1_;
	GVariant* value = NULL;
	GVariantBuilder* builder = NULL;
	GVariantType* _tmp2_;
	GVariantType* _tmp3_;
	GVariantBuilder* _tmp4_;
	GVariantBuilder* _tmp5_;
	GVariant* variant = NULL;
	GVariant* _tmp6_;
	GVariant* _tmp7_;
	GVariant* _tmp8_;
	GVariant* _tmp9_;
	_tmp0_ = g_strdup ("foo");
	name = _tmp0_;
	_tmp1_ = g_strdup ("bar");
	key = _tmp1_;
	value = NULL;
	_tmp2_ = g_variant_type_new ("a{smv}");
	_tmp3_ = _tmp2_;
	_tmp4_ = g_variant_builder_new (_tmp3_);
	_tmp5_ = _tmp4_;
	_g_variant_type_free0 (_tmp3_);
	builder = _tmp5_;
	g_variant_builder_add (builder, "{smv}", key, value, NULL);
	_tmp6_ = g_variant_builder_end (builder);
	g_variant_ref_sink (_tmp6_);
	_tmp7_ = _tmp6_;
	_tmp8_ = g_variant_new ("(s@a{smv})", name, _tmp7_, NULL);
	g_variant_ref_sink (_tmp8_);
	_tmp9_ = _tmp8_;
	_g_variant_unref0 (_tmp7_);
	variant = _tmp9_;
	_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
	_g_variant_unref0 (variant);
	_g_variant_builder_unref0 (builder);
	_g_variant_unref0 (value);
	_g_free0 (key);
	_g_free0 (name);
}

static void
_vala_main (void)
{
	test_variant ();
	test_variant_builder ();
}

int
main (int argc,
      char ** argv)
{
	_vala_main ();
	return 0;
}