def METHOD_NAME(self):
    # Strip off '__nv_' from libdevice name to get Python name
    apiname = libname[5:]
    apifunc = getattr(libdevice, apiname)
    retty, args = functions[libname]
    sig = create_signature(retty, args)
    # Construct arguments to the libdevice function. These are all
    # non-pointer arguments to the underlying bitcode function.
    funcargs = ", ".join(['a%d' % i for i, arg in enumerate(args) if not
                          arg.is_ptr])
    # Arguments to the Python function (`pyfunc` in the template above) are
    # the arguments to the libdevice function, plus as many extra arguments
    # as there are in the return type of the libdevice function - one for
    # scalar-valued returns, or the length of the tuple for tuple-valued
    # returns.
    if isinstance(sig.return_type, (types.Tuple, types.UniTuple)):
        # Start with the parameters for the return values
        pyargs = ", ".join(['r%d' % i for i in
                            range(len(sig.return_type))])
        # Add the parameters for the argument values
        pyargs += ", " + funcargs
        # Generate the unpacking of the return value from the libdevice
        # function into the Python function return values (`r0`, `r1`,
        # etc.).
        retvars = ", ".join(['r%d[0]' % i for i in
                             range(len(sig.return_type))])
    else:
        # Scalar return is a more straightforward case
        pyargs = "r0, " + funcargs
        retvars = "r0[0]"
    # Create the string containing the function to compile
    d = { 'func': apiname,
          'pyargs': pyargs,
          'funcargs': funcargs,
          'retvars': retvars }
    code = function_template % d
    # Convert the string to a Python function
    locals = {}
    exec(code, globals(), locals)
    pyfunc = locals['pyfunc']
    # Compute the signature for compilation. This mirrors the creation of
    # arguments to the Python function above.
    pyargs = [ arg.ty for arg in args if not arg.is_ptr ]
    if isinstance(sig.return_type, (types.Tuple, types.UniTuple)):
        pyreturns = [ret[::1] for ret in sig.return_type]
        pyargs = pyreturns + pyargs
    else:
        pyargs.insert(0, sig.return_type[::1])
    pyargs = tuple(pyargs)
    ptx, resty = compile_ptx(pyfunc, pyargs)
    # If the function body was discarded by optimization (therefore making
    # the test a bit weak), there won't be any loading of parameters -
    # ensure that a load from parameters occurs somewhere in the PTX
    self.assertIn('ld.param', ptx)
    # Returning the result (through a passed-in array) should also require
    # a store to global memory, so check for at least one of those too.
    self.assertIn('st.global', ptx)