glib/gobject/tests/genmarshal.py

#!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# Copyright © 2019 Endless Mobile, Inc.
#
# SPDX-License-Identifier: LGPL-2.1-or-later
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA  02110-1301  USA

"""Integration tests for glib-genmarshal utility."""

import collections
import os
import shutil
import subprocess
import sys
import tempfile
from textwrap import dedent
import unittest

import taptestrunner


# Disable line length warnings as wrapping the C code templates would be hard
# flake8: noqa: E501


Result = collections.namedtuple("Result", ("info", "out", "err", "subs"))


class TestGenmarshal(unittest.TestCase):
    """Integration test for running glib-genmarshal.

    This can be run when installed or uninstalled. When uninstalled, it
    requires G_TEST_BUILDDIR and G_TEST_SRCDIR to be set.

    The idea with this test harness is to test the glib-genmarshal utility, its
    handling of command line arguments, its exit statuses, and its handling of
    various marshaller lists. In future we could split the core glib-genmarshal
    parsing and generation code out into a library and unit test that, and
    convert this test to just check command line behaviour.
    """

    # Track the cwd, we want to back out to that to clean up our tempdir
    cwd = ""

    def setUp(self):
        self.timeout_seconds = 10  # seconds per test
        self.tmpdir = tempfile.TemporaryDirectory()
        self.cwd = os.getcwd()
        os.chdir(self.tmpdir.name)
        print("tmpdir:", self.tmpdir.name)
        if "G_TEST_BUILDDIR" in os.environ:
            self.__genmarshal = os.path.join(
                os.environ["G_TEST_BUILDDIR"], "..", "glib-genmarshal"
            )
        else:
            self.__genmarshal = shutil.which("glib-genmarshal")
        print("genmarshal:", self.__genmarshal)

    def tearDown(self):
        os.chdir(self.cwd)
        self.tmpdir.cleanup()

    def runGenmarshal(self, *args):
        argv = [self.__genmarshal]

        # shebang lines are not supported on native
        # Windows consoles
        if os.name == "nt":
            argv.insert(0, sys.executable)

        argv.extend(args)
        print("Running:", argv)

        env = os.environ.copy()
        env["LC_ALL"] = "C.UTF-8"
        print("Environment:", env)

        # We want to ensure consistent line endings...
        info = subprocess.run(
            argv,
            timeout=self.timeout_seconds,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            env=env,
            universal_newlines=True,
        )
        info.check_returncode()
        out = info.stdout.strip()
        err = info.stderr.strip()

        # Known substitutions for standard boilerplate
        subs = {
            "standard_top_comment": "This file is generated by glib-genmarshal, do not modify "
            "it. This code is licensed under the same license as the "
            "containing project. Note that it links to GLib, so must "
            "comply with the LGPL linking clauses.",
            "standard_top_pragma": dedent(
                """
                #ifndef __G_CCLOSURE_USER_MARSHAL_MARSHAL_H__
                #define __G_CCLOSURE_USER_MARSHAL_MARSHAL_H__
                """
            ).strip(),
            "standard_bottom_pragma": dedent(
                """
                #endif /* __G_CCLOSURE_USER_MARSHAL_MARSHAL_H__ */
                """
            ).strip(),
            "standard_includes": dedent(
                """
                #include <glib-object.h>
                """
            ).strip(),
            "standard_marshal_peek_defines": dedent(
                """
                #ifdef G_ENABLE_DEBUG
                #define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
                #define g_marshal_value_peek_char(v)     g_value_get_schar (v)
                #define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
                #define g_marshal_value_peek_int(v)      g_value_get_int (v)
                #define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
                #define g_marshal_value_peek_long(v)     g_value_get_long (v)
                #define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
                #define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
                #define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
                #define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
                #define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
                #define g_marshal_value_peek_float(v)    g_value_get_float (v)
                #define g_marshal_value_peek_double(v)   g_value_get_double (v)
                #define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
                #define g_marshal_value_peek_param(v)    g_value_get_param (v)
                #define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
                #define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
                #define g_marshal_value_peek_object(v)   g_value_get_object (v)
                #define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
                #else /* !G_ENABLE_DEBUG */
                /* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
                 *          Do not access GValues directly in your code. Instead, use the
                 *          g_value_get_*() functions
                 */
                #define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
                #define g_marshal_value_peek_char(v)     (v)->data[0].v_int
                #define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
                #define g_marshal_value_peek_int(v)      (v)->data[0].v_int
                #define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
                #define g_marshal_value_peek_long(v)     (v)->data[0].v_long
                #define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
                #define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
                #define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
                #define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
                #define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
                #define g_marshal_value_peek_float(v)    (v)->data[0].v_float
                #define g_marshal_value_peek_double(v)   (v)->data[0].v_double
                #define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
                #define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
                #define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
                #define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
                #define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
                #define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
                #endif /* !G_ENABLE_DEBUG */
                """
            ).strip(),
        }

        result = Result(info, out, err, subs)

        print("Output:", result.out)
        return result

    def runGenmarshalWithList(self, list_contents, *args):
        with tempfile.NamedTemporaryFile(
            dir=self.tmpdir.name, suffix=".list", delete=False
        ) as list_file:
            # Write out the list.
            list_file.write(list_contents.encode("utf-8"))
            print(list_file.name + ":", list_contents)
            list_file.flush()

            header_result = self.runGenmarshal(list_file.name, "--header", *args)
            body_result = self.runGenmarshal(list_file.name, "--body", *args)

            header_result.subs["list_path"] = list_file.name
            body_result.subs["list_path"] = list_file.name

            return (header_result, body_result)

    def test_help(self):
        """Test the --help argument."""
        result = self.runGenmarshal("--help")
        self.assertIn("usage: glib-genmarshal", result.out)

    def test_no_args(self):
        """Test running with no arguments at all."""
        result = self.runGenmarshal()
        self.assertEqual("", result.err)
        self.assertEqual("", result.out)

    def test_empty_list(self):
        """Test running with an empty list."""
        (header_result, body_result) = self.runGenmarshalWithList("", "--quiet")

        self.assertEqual("", header_result.err)
        self.assertEqual("", body_result.err)

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_top_pragma}

            {standard_includes}

            G_BEGIN_DECLS


            G_END_DECLS

            {standard_bottom_pragma}
            """
            )
            .strip()
            .format(**header_result.subs),
            header_result.out.strip(),
        )

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_includes}

            {standard_marshal_peek_defines}
            """
            )
            .strip()
            .format(**body_result.subs),
            body_result.out.strip(),
        )

    def test_void_boolean(self):
        """Test running with a basic VOID:BOOLEAN list."""
        (header_result, body_result) = self.runGenmarshalWithList(
            "VOID:BOOLEAN", "--quiet"
        )

        self.assertEqual("", header_result.err)
        self.assertEqual("", body_result.err)

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_top_pragma}

            {standard_includes}

            G_BEGIN_DECLS

            /* VOID:BOOLEAN ({list_path}:1) */
            #define g_cclosure_user_marshal_VOID__BOOLEAN	g_cclosure_marshal_VOID__BOOLEAN


            G_END_DECLS

            {standard_bottom_pragma}
            """
            )
            .strip()
            .format(**header_result.subs),
            header_result.out.strip(),
        )

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_includes}

            {standard_marshal_peek_defines}
            """
            )
            .strip()
            .format(**body_result.subs),
            body_result.out.strip(),
        )

    def test_void_boolean_int64(self):
        """Test running with a non-trivial VOID:BOOLEAN,INT64 list."""
        (header_result, body_result) = self.runGenmarshalWithList(
            "VOID:BOOLEAN,INT64", "--quiet"
        )

        self.assertEqual("", header_result.err)
        self.assertEqual("", body_result.err)

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_top_pragma}

            {standard_includes}

            G_BEGIN_DECLS

            /* VOID:BOOLEAN,INT64 ({list_path}:1) */
            extern
            void g_cclosure_user_marshal_VOID__BOOLEAN_INT64 (GClosure     *closure,
                                                              GValue       *return_value,
                                                              guint         n_param_values,
                                                              const GValue *param_values,
                                                              gpointer      invocation_hint,
                                                              gpointer      marshal_data);


            G_END_DECLS

            {standard_bottom_pragma}
            """
            )
            .strip()
            .format(**header_result.subs),
            header_result.out.strip(),
        )

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_includes}

            {standard_marshal_peek_defines}

            /* VOID:BOOLEAN,INT64 ({list_path}:1) */
            void
            g_cclosure_user_marshal_VOID__BOOLEAN_INT64 (GClosure     *closure,
                                                         GValue       *return_value G_GNUC_UNUSED,
                                                         guint         n_param_values,
                                                         const GValue *param_values,
                                                         gpointer      invocation_hint G_GNUC_UNUSED,
                                                         gpointer      marshal_data)
            {{
              typedef void (*GMarshalFunc_VOID__BOOLEAN_INT64) (gpointer data1,
                                                                gboolean arg1,
                                                                gint64 arg2,
                                                                gpointer data2);
              GCClosure *cc = (GCClosure *) closure;
              gpointer data1, data2;
              GMarshalFunc_VOID__BOOLEAN_INT64 callback;

              g_return_if_fail (n_param_values == 3);

              if (G_CCLOSURE_SWAP_DATA (closure))
                {{
                  data1 = closure->data;
                  data2 = g_value_peek_pointer (param_values + 0);
                }}
              else
                {{
                  data1 = g_value_peek_pointer (param_values + 0);
                  data2 = closure->data;
                }}
              callback = (GMarshalFunc_VOID__BOOLEAN_INT64) (marshal_data ? marshal_data : cc->callback);

              callback (data1,
                        g_marshal_value_peek_boolean (param_values + 1),
                        g_marshal_value_peek_int64 (param_values + 2),
                        data2);
            }}
            """
            )
            .strip()
            .format(**body_result.subs),
            body_result.out.strip(),
        )

    def test_void_variant_nostdinc_valist_marshaller(self):
        """Test running with a basic VOID:VARIANT list, but without the
        standard marshallers, and with valist support enabled. This checks that
        the valist marshaller for VARIANT correctly sinks floating variants.

        See issue #1793.
        """
        (header_result, body_result) = self.runGenmarshalWithList(
            "VOID:VARIANT", "--quiet", "--nostdinc", "--valist-marshaller"
        )

        self.assertEqual("", header_result.err)
        self.assertEqual("", body_result.err)

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_top_pragma}

            G_BEGIN_DECLS

            /* VOID:VARIANT ({list_path}:1) */
            extern
            void g_cclosure_user_marshal_VOID__VARIANT (GClosure     *closure,
                                                        GValue       *return_value,
                                                        guint         n_param_values,
                                                        const GValue *param_values,
                                                        gpointer      invocation_hint,
                                                        gpointer      marshal_data);
            extern
            void g_cclosure_user_marshal_VOID__VARIANTv (GClosure *closure,
                                                         GValue   *return_value,
                                                         gpointer  instance,
                                                         va_list   args,
                                                         gpointer  marshal_data,
                                                         int       n_params,
                                                         GType    *param_types);


            G_END_DECLS

            {standard_bottom_pragma}
            """
            )
            .strip()
            .format(**header_result.subs),
            header_result.out.strip(),
        )

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_marshal_peek_defines}

            /* VOID:VARIANT ({list_path}:1) */
            void
            g_cclosure_user_marshal_VOID__VARIANT (GClosure     *closure,
                                                   GValue       *return_value G_GNUC_UNUSED,
                                                   guint         n_param_values,
                                                   const GValue *param_values,
                                                   gpointer      invocation_hint G_GNUC_UNUSED,
                                                   gpointer      marshal_data)
            {{
              typedef void (*GMarshalFunc_VOID__VARIANT) (gpointer data1,
                                                          gpointer arg1,
                                                          gpointer data2);
              GCClosure *cc = (GCClosure *) closure;
              gpointer data1, data2;
              GMarshalFunc_VOID__VARIANT callback;

              g_return_if_fail (n_param_values == 2);

              if (G_CCLOSURE_SWAP_DATA (closure))
                {{
                  data1 = closure->data;
                  data2 = g_value_peek_pointer (param_values + 0);
                }}
              else
                {{
                  data1 = g_value_peek_pointer (param_values + 0);
                  data2 = closure->data;
                }}
              callback = (GMarshalFunc_VOID__VARIANT) (marshal_data ? marshal_data : cc->callback);

              callback (data1,
                        g_marshal_value_peek_variant (param_values + 1),
                        data2);
            }}

            void
            g_cclosure_user_marshal_VOID__VARIANTv (GClosure *closure,
                                                    GValue   *return_value G_GNUC_UNUSED,
                                                    gpointer  instance,
                                                    va_list   args,
                                                    gpointer  marshal_data,
                                                    int       n_params,
                                                    GType    *param_types)
            {{
              typedef void (*GMarshalFunc_VOID__VARIANT) (gpointer data1,
                                                          gpointer arg1,
                                                          gpointer data2);
              GCClosure *cc = (GCClosure *) closure;
              gpointer data1, data2;
              GMarshalFunc_VOID__VARIANT callback;
              gpointer arg0;
              va_list args_copy;

              va_copy (args_copy, args);
              arg0 = (gpointer) va_arg (args_copy, gpointer);
              if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
                arg0 = g_variant_ref_sink (arg0);
              va_end (args_copy);


              if (G_CCLOSURE_SWAP_DATA (closure))
                {{
                  data1 = closure->data;
                  data2 = instance;
                }}
              else
                {{
                  data1 = instance;
                  data2 = closure->data;
                }}
              callback = (GMarshalFunc_VOID__VARIANT) (marshal_data ? marshal_data : cc->callback);

              callback (data1,
                        arg0,
                        data2);
              if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
                g_variant_unref (arg0);
            }}
            """
            )
            .strip()
            .format(**body_result.subs),
            body_result.out.strip(),
        )

    def test_void_string_nostdinc(self):
        """Test running with a basic VOID:STRING list, but without the
        standard marshallers, and with valist support enabled. This checks that
        the valist marshaller for STRING correctly skips a string copy if the
        argument is static.

        See issue #1792.
        """
        (header_result, body_result) = self.runGenmarshalWithList(
            "VOID:STRING", "--quiet", "--nostdinc", "--valist-marshaller"
        )

        self.assertEqual("", header_result.err)
        self.assertEqual("", body_result.err)

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_top_pragma}

            G_BEGIN_DECLS

            /* VOID:STRING ({list_path}:1) */
            extern
            void g_cclosure_user_marshal_VOID__STRING (GClosure     *closure,
                                                       GValue       *return_value,
                                                       guint         n_param_values,
                                                       const GValue *param_values,
                                                       gpointer      invocation_hint,
                                                       gpointer      marshal_data);
            extern
            void g_cclosure_user_marshal_VOID__STRINGv (GClosure *closure,
                                                        GValue   *return_value,
                                                        gpointer  instance,
                                                        va_list   args,
                                                        gpointer  marshal_data,
                                                        int       n_params,
                                                        GType    *param_types);


            G_END_DECLS

            {standard_bottom_pragma}
            """
            )
            .strip()
            .format(**header_result.subs),
            header_result.out.strip(),
        )

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_marshal_peek_defines}

            /* VOID:STRING ({list_path}:1) */
            void
            g_cclosure_user_marshal_VOID__STRING (GClosure     *closure,
                                                  GValue       *return_value G_GNUC_UNUSED,
                                                  guint         n_param_values,
                                                  const GValue *param_values,
                                                  gpointer      invocation_hint G_GNUC_UNUSED,
                                                  gpointer      marshal_data)
            {{
              typedef void (*GMarshalFunc_VOID__STRING) (gpointer data1,
                                                         gpointer arg1,
                                                         gpointer data2);
              GCClosure *cc = (GCClosure *) closure;
              gpointer data1, data2;
              GMarshalFunc_VOID__STRING callback;

              g_return_if_fail (n_param_values == 2);

              if (G_CCLOSURE_SWAP_DATA (closure))
                {{
                  data1 = closure->data;
                  data2 = g_value_peek_pointer (param_values + 0);
                }}
              else
                {{
                  data1 = g_value_peek_pointer (param_values + 0);
                  data2 = closure->data;
                }}
              callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);

              callback (data1,
                        g_marshal_value_peek_string (param_values + 1),
                        data2);
            }}

            void
            g_cclosure_user_marshal_VOID__STRINGv (GClosure *closure,
                                                   GValue   *return_value G_GNUC_UNUSED,
                                                   gpointer  instance,
                                                   va_list   args,
                                                   gpointer  marshal_data,
                                                   int       n_params,
                                                   GType    *param_types)
            {{
              typedef void (*GMarshalFunc_VOID__STRING) (gpointer data1,
                                                         gpointer arg1,
                                                         gpointer data2);
              GCClosure *cc = (GCClosure *) closure;
              gpointer data1, data2;
              GMarshalFunc_VOID__STRING callback;
              gpointer arg0;
              va_list args_copy;

              va_copy (args_copy, args);
              arg0 = (gpointer) va_arg (args_copy, gpointer);
              if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
                arg0 = g_strdup (arg0);
              va_end (args_copy);


              if (G_CCLOSURE_SWAP_DATA (closure))
                {{
                  data1 = closure->data;
                  data2 = instance;
                }}
              else
                {{
                  data1 = instance;
                  data2 = closure->data;
                }}
              callback = (GMarshalFunc_VOID__STRING) (marshal_data ? marshal_data : cc->callback);

              callback (data1,
                        arg0,
                        data2);
              if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
                g_free (arg0);
            }}
            """
            )
            .strip()
            .format(**body_result.subs),
            body_result.out.strip(),
        )

    def test_void_param_nostdinc(self):
        """Test running with a basic VOID:PARAM list, but without the
        standard marshallers, and with valist support enabled. This checks that
        the valist marshaller for PARAM correctly skips a param copy if the
        argument is static.

        See issue #1792.
        """
        self.maxDiff = None  # TODO
        (header_result, body_result) = self.runGenmarshalWithList(
            "VOID:PARAM", "--quiet", "--nostdinc", "--valist-marshaller"
        )

        self.assertEqual("", header_result.err)
        self.assertEqual("", body_result.err)

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_top_pragma}

            G_BEGIN_DECLS

            /* VOID:PARAM ({list_path}:1) */
            extern
            void g_cclosure_user_marshal_VOID__PARAM (GClosure     *closure,
                                                      GValue       *return_value,
                                                      guint         n_param_values,
                                                      const GValue *param_values,
                                                      gpointer      invocation_hint,
                                                      gpointer      marshal_data);
            extern
            void g_cclosure_user_marshal_VOID__PARAMv (GClosure *closure,
                                                       GValue   *return_value,
                                                       gpointer  instance,
                                                       va_list   args,
                                                       gpointer  marshal_data,
                                                       int       n_params,
                                                       GType    *param_types);


            G_END_DECLS

            {standard_bottom_pragma}
            """
            )
            .strip()
            .format(**header_result.subs),
            header_result.out.strip(),
        )

        self.assertEqual(
            dedent(
                """
            /* {standard_top_comment} */
            {standard_marshal_peek_defines}

            /* VOID:PARAM ({list_path}:1) */
            void
            g_cclosure_user_marshal_VOID__PARAM (GClosure     *closure,
                                                 GValue       *return_value G_GNUC_UNUSED,
                                                 guint         n_param_values,
                                                 const GValue *param_values,
                                                 gpointer      invocation_hint G_GNUC_UNUSED,
                                                 gpointer      marshal_data)
            {{
              typedef void (*GMarshalFunc_VOID__PARAM) (gpointer data1,
                                                        gpointer arg1,
                                                        gpointer data2);
              GCClosure *cc = (GCClosure *) closure;
              gpointer data1, data2;
              GMarshalFunc_VOID__PARAM callback;

              g_return_if_fail (n_param_values == 2);

              if (G_CCLOSURE_SWAP_DATA (closure))
                {{
                  data1 = closure->data;
                  data2 = g_value_peek_pointer (param_values + 0);
                }}
              else
                {{
                  data1 = g_value_peek_pointer (param_values + 0);
                  data2 = closure->data;
                }}
              callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);

              callback (data1,
                        g_marshal_value_peek_param (param_values + 1),
                        data2);
            }}

            void
            g_cclosure_user_marshal_VOID__PARAMv (GClosure *closure,
                                                  GValue   *return_value G_GNUC_UNUSED,
                                                  gpointer  instance,
                                                  va_list   args,
                                                  gpointer  marshal_data,
                                                  int       n_params,
                                                  GType    *param_types)
            {{
              typedef void (*GMarshalFunc_VOID__PARAM) (gpointer data1,
                                                        gpointer arg1,
                                                        gpointer data2);
              GCClosure *cc = (GCClosure *) closure;
              gpointer data1, data2;
              GMarshalFunc_VOID__PARAM callback;
              gpointer arg0;
              va_list args_copy;

              va_copy (args_copy, args);
              arg0 = (gpointer) va_arg (args_copy, gpointer);
              if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
                arg0 = g_param_spec_ref (arg0);
              va_end (args_copy);


              if (G_CCLOSURE_SWAP_DATA (closure))
                {{
                  data1 = closure->data;
                  data2 = instance;
                }}
              else
                {{
                  data1 = instance;
                  data2 = closure->data;
                }}
              callback = (GMarshalFunc_VOID__PARAM) (marshal_data ? marshal_data : cc->callback);

              callback (data1,
                        arg0,
                        data2);
              if ((param_types[0] & G_SIGNAL_TYPE_STATIC_SCOPE) == 0 && arg0 != NULL)
                g_param_spec_unref (arg0);
            }}
            """
            )
            .strip()
            .format(**body_result.subs),
            body_result.out.strip(),
        )


if __name__ == "__main__":
    unittest.main(testRunner=taptestrunner.TAPTestRunner())