//
// DO NOT EDIT.  THIS FILE IS GENERATED FROM ../../../dist/idl/xpctest_params.idl
//


/// `interface nsIXPCTestParams : nsISupports`
///


// The actual type definition for the interface. This struct has methods
// declared on it which will call through its vtable. You never want to pass
// this type around by value, always pass it behind a reference.

#[repr(C)]
pub struct nsIXPCTestParams {
    vtable: *const nsIXPCTestParamsVTable,

    /// This field is a phantomdata to ensure that the VTable type and any
    /// struct containing it is not safe to send across threads, as XPCOM is
    /// generally not threadsafe.
    ///
    /// XPCOM interfaces in general are not safe to send across threads.
    __nosync: ::std::marker::PhantomData<::std::rc::Rc<u8>>,
}

// Implementing XpCom for an interface exposes its IID, which allows for easy
// use of the `.query_interface<T>` helper method. This also defines that
// method for nsIXPCTestParams.
unsafe impl XpCom for nsIXPCTestParams {
    const IID: nsIID = nsID(0x812145c7, 0x9fcc, 0x425e,
        [0xa8, 0x78, 0x36, 0xad, 0x1b, 0x77, 0x30, 0xb7]);
}

// We need to implement the RefCounted trait so we can be used with `RefPtr`.
// This trait teaches `RefPtr` how to manage our memory.
unsafe impl RefCounted for nsIXPCTestParams {
    #[inline]
    unsafe fn addref(&self) {
        self.AddRef();
    }
    #[inline]
    unsafe fn release(&self) {
        self.Release();
    }
}

// This trait is implemented on all types which can be coerced to from nsIXPCTestParams.
// It is used in the implementation of `fn coerce<T>`. We hide it from the
// documentation, because it clutters it up a lot.
#[doc(hidden)]
pub trait nsIXPCTestParamsCoerce {
    /// Cheaply cast a value of this type from a `nsIXPCTestParams`.
    fn coerce_from(v: &nsIXPCTestParams) -> &Self;
}

// The trivial implementation: We can obviously coerce ourselves to ourselves.
impl nsIXPCTestParamsCoerce for nsIXPCTestParams {
    #[inline]
    fn coerce_from(v: &nsIXPCTestParams) -> &Self {
        v
    }
}

impl nsIXPCTestParams {
    /// Cast this `nsIXPCTestParams` to one of its base interfaces.
    #[inline]
    pub fn coerce<T: nsIXPCTestParamsCoerce>(&self) -> &T {
        T::coerce_from(self)
    }
}

// Every interface struct type implements `Deref` to its base interface. This
// causes methods on the base interfaces to be directly avaliable on the
// object. For example, you can call `.AddRef` or `.QueryInterface` directly
// on any interface which inherits from `nsISupports`.
impl ::std::ops::Deref for nsIXPCTestParams {
    type Target = nsISupports;
    #[inline]
    fn deref(&self) -> &nsISupports {
        unsafe {
            ::std::mem::transmute(self)
        }
    }
}

// Ensure we can use .coerce() to cast to our base types as well. Any type which
// our base interface can coerce from should be coercable from us as well.
impl<T: nsISupportsCoerce> nsIXPCTestParamsCoerce for T {
    #[inline]
    fn coerce_from(v: &nsIXPCTestParams) -> &Self {
        T::coerce_from(v)
    }
}

// This struct represents the interface's VTable. A pointer to a statically
// allocated version of this struct is at the beginning of every nsIXPCTestParams
// object. It contains one pointer field for each method in the interface. In
// the case where we can't generate a binding for a method, we include a void
// pointer.
#[doc(hidden)]
#[repr(C)]
pub struct nsIXPCTestParamsVTable {
    /// We need to include the members from the base interface's vtable at the start
    /// of the VTable definition.
    pub __base: nsISupportsVTable,

    /* boolean testBoolean (in boolean a, inout boolean b); */
    pub TestBoolean: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: bool, b: *mut bool, _retval: *mut bool) -> nsresult,

    /* octet testOctet (in octet a, inout octet b); */
    pub TestOctet: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::uint8_t, b: *mut libc::uint8_t, _retval: *mut libc::uint8_t) -> nsresult,

    /* short testShort (in short a, inout short b); */
    pub TestShort: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::int16_t, b: *mut libc::int16_t, _retval: *mut libc::int16_t) -> nsresult,

    /* long testLong (in long a, inout long b); */
    pub TestLong: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::int32_t, b: *mut libc::int32_t, _retval: *mut libc::int32_t) -> nsresult,

    /* long long testLongLong (in long long a, inout long long b); */
    pub TestLongLong: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::int64_t, b: *mut libc::int64_t, _retval: *mut libc::int64_t) -> nsresult,

    /* unsigned short testUnsignedShort (in unsigned short a, inout unsigned short b); */
    pub TestUnsignedShort: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::uint16_t, b: *mut libc::uint16_t, _retval: *mut libc::uint16_t) -> nsresult,

    /* unsigned long testUnsignedLong (in unsigned long a, inout unsigned long b); */
    pub TestUnsignedLong: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::uint32_t, b: *mut libc::uint32_t, _retval: *mut libc::uint32_t) -> nsresult,

    /* unsigned long long testUnsignedLongLong (in unsigned long long a, inout unsigned long long b); */
    pub TestUnsignedLongLong: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::uint64_t, b: *mut libc::uint64_t, _retval: *mut libc::uint64_t) -> nsresult,

    /* float testFloat (in float a, inout float b); */
    pub TestFloat: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::c_float, b: *mut libc::c_float, _retval: *mut libc::c_float) -> nsresult,

    /* double testDouble (in double a, inout float b); */
    pub TestDouble: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::c_double, b: *mut libc::c_float, _retval: *mut libc::c_double) -> nsresult,

    /* char testChar (in char a, inout char b); */
    pub TestChar: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::c_char, b: *mut libc::c_char, _retval: *mut libc::c_char) -> nsresult,

    /* string testString (in string a, inout string b); */
    pub TestString: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: *const libc::c_char, b: *mut *const libc::c_char, _retval: *mut *const libc::c_char) -> nsresult,

    /* wchar testWchar (in wchar a, inout wchar b); */
    pub TestWchar: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: libc::int16_t, b: *mut libc::int16_t, _retval: *mut libc::int16_t) -> nsresult,

    /* wstring testWstring (in wstring a, inout wstring b); */
    pub TestWstring: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: *const libc::int16_t, b: *mut *const libc::int16_t, _retval: *mut *const libc::int16_t) -> nsresult,

    /* DOMString testDOMString (in DOMString a, inout DOMString b); */
    pub TestDOMString: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: &::nsstring::nsAString, b: &mut ::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* AString testAString (in AString a, inout AString b); */
    pub TestAString: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: &::nsstring::nsAString, b: &mut ::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult,

    /* AUTF8String testAUTF8String (in AUTF8String a, inout AUTF8String b); */
    pub TestAUTF8String: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: &::nsstring::nsACString, b: &mut ::nsstring::nsACString, _retval: &mut ::nsstring::nsACString) -> nsresult,

    /* ACString testACString (in ACString a, inout ACString b); */
    pub TestACString: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: &::nsstring::nsACString, b: &mut ::nsstring::nsACString, _retval: &mut ::nsstring::nsACString) -> nsresult,

    /* jsval testJsval (in jsval a, inout jsval b); */
    /// Unable to generate binding because `native type JS::Value is unsupported`
    pub TestJsval: *const ::libc::c_void,

    /* void testShortArray (in unsigned long aLength, [array, size_is (aLength)] in short a, inout unsigned long bLength, [array, size_is (bLength)] inout short b, out unsigned long rvLength, [array, size_is (rvLength), retval] out short rv); */
    pub TestShortArray: unsafe extern "system" fn (this: *const nsIXPCTestParams, aLength: libc::uint32_t, a: *mut libc::int16_t, bLength: *mut libc::uint32_t, b: *mut *mut libc::int16_t, rvLength: *mut libc::uint32_t, rv: *mut *mut libc::int16_t) -> nsresult,

    /* void testDoubleArray (in unsigned long aLength, [array, size_is (aLength)] in double a, inout unsigned long bLength, [array, size_is (bLength)] inout double b, out unsigned long rvLength, [array, size_is (rvLength), retval] out double rv); */
    pub TestDoubleArray: unsafe extern "system" fn (this: *const nsIXPCTestParams, aLength: libc::uint32_t, a: *mut libc::c_double, bLength: *mut libc::uint32_t, b: *mut *mut libc::c_double, rvLength: *mut libc::uint32_t, rv: *mut *mut libc::c_double) -> nsresult,

    /* void testStringArray (in unsigned long aLength, [array, size_is (aLength)] in string a, inout unsigned long bLength, [array, size_is (bLength)] inout string b, out unsigned long rvLength, [array, size_is (rvLength), retval] out string rv); */
    pub TestStringArray: unsafe extern "system" fn (this: *const nsIXPCTestParams, aLength: libc::uint32_t, a: *mut *const libc::c_char, bLength: *mut libc::uint32_t, b: *mut *mut *const libc::c_char, rvLength: *mut libc::uint32_t, rv: *mut *mut *const libc::c_char) -> nsresult,

    /* void testWstringArray (in unsigned long aLength, [array, size_is (aLength)] in wstring a, inout unsigned long bLength, [array, size_is (bLength)] inout wstring b, out unsigned long rvLength, [array, size_is (rvLength), retval] out wstring rv); */
    pub TestWstringArray: unsafe extern "system" fn (this: *const nsIXPCTestParams, aLength: libc::uint32_t, a: *mut *const libc::int16_t, bLength: *mut libc::uint32_t, b: *mut *mut *const libc::int16_t, rvLength: *mut libc::uint32_t, rv: *mut *mut *const libc::int16_t) -> nsresult,

    /* void testInterfaceArray (in unsigned long aLength, [array, size_is (aLength)] in nsIXPCTestInterfaceA a, inout unsigned long bLength, [array, size_is (bLength)] inout nsIXPCTestInterfaceA b, out unsigned long rvLength, [array, size_is (rvLength), retval] out nsIXPCTestInterfaceA rv); */
    pub TestInterfaceArray: unsafe extern "system" fn (this: *const nsIXPCTestParams, aLength: libc::uint32_t, a: *mut *const nsIXPCTestInterfaceA, bLength: *mut libc::uint32_t, b: *mut *mut *const nsIXPCTestInterfaceA, rvLength: *mut libc::uint32_t, rv: *mut *mut *const nsIXPCTestInterfaceA) -> nsresult,

    /* void testSizedString (in unsigned long aLength, [size_is (aLength)] in string a, inout unsigned long bLength, [size_is (bLength)] inout string b, out unsigned long rvLength, [size_is (rvLength), retval] out string rv); */
    pub TestSizedString: unsafe extern "system" fn (this: *const nsIXPCTestParams, aLength: libc::uint32_t, a: *const libc::c_char, bLength: *mut libc::uint32_t, b: *mut *const libc::c_char, rvLength: *mut libc::uint32_t, rv: *mut *const libc::c_char) -> nsresult,

    /* void testSizedWstring (in unsigned long aLength, [size_is (aLength)] in wstring a, inout unsigned long bLength, [size_is (bLength)] inout wstring b, out unsigned long rvLength, [size_is (rvLength), retval] out wstring rv); */
    pub TestSizedWstring: unsafe extern "system" fn (this: *const nsIXPCTestParams, aLength: libc::uint32_t, a: *const libc::int16_t, bLength: *mut libc::uint32_t, b: *mut *const libc::int16_t, rvLength: *mut libc::uint32_t, rv: *mut *const libc::int16_t) -> nsresult,

    /* void testInterfaceIs (in nsIIDPtr aIID, [iid_is (aIID)] in nsQIResult a, inout nsIIDPtr bIID, [iid_is (bIID)] inout nsQIResult b, out nsIIDPtr rvIID, [iid_is (rvIID), retval] out nsQIResult rv); */
    pub TestInterfaceIs: unsafe extern "system" fn (this: *const nsIXPCTestParams, aIID: *const nsIID, a: *mut libc::c_void, bIID: *mut *mut nsIID, b: *mut *mut libc::c_void, rvIID: *mut *mut nsIID, rv: *mut *mut libc::c_void) -> nsresult,

    /* void testInterfaceIsArray (in unsigned long aLength, in nsIIDPtr aIID, [array, size_is (aLength), iid_is (aIID)] in nsQIResult a, inout unsigned long bLength, inout nsIIDPtr bIID, [array, size_is (bLength), iid_is (bIID)] inout nsQIResult b, out unsigned long rvLength, out nsIIDPtr rvIID, [retval, array, size_is (rvLength), iid_is (rvIID)] out nsQIResult rv); */
    pub TestInterfaceIsArray: unsafe extern "system" fn (this: *const nsIXPCTestParams, aLength: libc::uint32_t, aIID: *const nsIID, a: *mut *mut libc::c_void, bLength: *mut libc::uint32_t, bIID: *mut *mut nsIID, b: *mut *mut *mut libc::c_void, rvLength: *mut libc::uint32_t, rvIID: *mut *mut nsIID, rv: *mut *mut *mut libc::c_void) -> nsresult,

    /* void testOutAString (out AString o); */
    pub TestOutAString: unsafe extern "system" fn (this: *const nsIXPCTestParams, o: &mut ::nsstring::nsAString) -> nsresult,

    /* ACString testStringArrayOptionalSize ([array, size_is (aLength)] in string a, [optional] in unsigned long aLength); */
    pub TestStringArrayOptionalSize: unsafe extern "system" fn (this: *const nsIXPCTestParams, a: *mut *const libc::c_char, aLength: libc::uint32_t, _retval: &mut ::nsstring::nsACString) -> nsresult,
}


// The implementations of the function wrappers which are exposed to rust code.
// Call these methods rather than manually calling through the VTable struct.
impl nsIXPCTestParams {


    /// `boolean testBoolean (in boolean a, inout boolean b);`
    #[inline]
    pub unsafe fn TestBoolean(&self, a: bool, b: *mut bool, _retval: *mut bool) -> nsresult {
        ((*self.vtable).TestBoolean)(self, a, b, _retval)
    }



    /// `octet testOctet (in octet a, inout octet b);`
    #[inline]
    pub unsafe fn TestOctet(&self, a: libc::uint8_t, b: *mut libc::uint8_t, _retval: *mut libc::uint8_t) -> nsresult {
        ((*self.vtable).TestOctet)(self, a, b, _retval)
    }



    /// `short testShort (in short a, inout short b);`
    #[inline]
    pub unsafe fn TestShort(&self, a: libc::int16_t, b: *mut libc::int16_t, _retval: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).TestShort)(self, a, b, _retval)
    }



    /// `long testLong (in long a, inout long b);`
    #[inline]
    pub unsafe fn TestLong(&self, a: libc::int32_t, b: *mut libc::int32_t, _retval: *mut libc::int32_t) -> nsresult {
        ((*self.vtable).TestLong)(self, a, b, _retval)
    }



    /// `long long testLongLong (in long long a, inout long long b);`
    #[inline]
    pub unsafe fn TestLongLong(&self, a: libc::int64_t, b: *mut libc::int64_t, _retval: *mut libc::int64_t) -> nsresult {
        ((*self.vtable).TestLongLong)(self, a, b, _retval)
    }



    /// `unsigned short testUnsignedShort (in unsigned short a, inout unsigned short b);`
    #[inline]
    pub unsafe fn TestUnsignedShort(&self, a: libc::uint16_t, b: *mut libc::uint16_t, _retval: *mut libc::uint16_t) -> nsresult {
        ((*self.vtable).TestUnsignedShort)(self, a, b, _retval)
    }



    /// `unsigned long testUnsignedLong (in unsigned long a, inout unsigned long b);`
    #[inline]
    pub unsafe fn TestUnsignedLong(&self, a: libc::uint32_t, b: *mut libc::uint32_t, _retval: *mut libc::uint32_t) -> nsresult {
        ((*self.vtable).TestUnsignedLong)(self, a, b, _retval)
    }



    /// `unsigned long long testUnsignedLongLong (in unsigned long long a, inout unsigned long long b);`
    #[inline]
    pub unsafe fn TestUnsignedLongLong(&self, a: libc::uint64_t, b: *mut libc::uint64_t, _retval: *mut libc::uint64_t) -> nsresult {
        ((*self.vtable).TestUnsignedLongLong)(self, a, b, _retval)
    }



    /// `float testFloat (in float a, inout float b);`
    #[inline]
    pub unsafe fn TestFloat(&self, a: libc::c_float, b: *mut libc::c_float, _retval: *mut libc::c_float) -> nsresult {
        ((*self.vtable).TestFloat)(self, a, b, _retval)
    }



    /// `double testDouble (in double a, inout float b);`
    #[inline]
    pub unsafe fn TestDouble(&self, a: libc::c_double, b: *mut libc::c_float, _retval: *mut libc::c_double) -> nsresult {
        ((*self.vtable).TestDouble)(self, a, b, _retval)
    }



    /// `char testChar (in char a, inout char b);`
    #[inline]
    pub unsafe fn TestChar(&self, a: libc::c_char, b: *mut libc::c_char, _retval: *mut libc::c_char) -> nsresult {
        ((*self.vtable).TestChar)(self, a, b, _retval)
    }



    /// `string testString (in string a, inout string b);`
    #[inline]
    pub unsafe fn TestString(&self, a: *const libc::c_char, b: *mut *const libc::c_char, _retval: *mut *const libc::c_char) -> nsresult {
        ((*self.vtable).TestString)(self, a, b, _retval)
    }



    /// `wchar testWchar (in wchar a, inout wchar b);`
    #[inline]
    pub unsafe fn TestWchar(&self, a: libc::int16_t, b: *mut libc::int16_t, _retval: *mut libc::int16_t) -> nsresult {
        ((*self.vtable).TestWchar)(self, a, b, _retval)
    }



    /// `wstring testWstring (in wstring a, inout wstring b);`
    #[inline]
    pub unsafe fn TestWstring(&self, a: *const libc::int16_t, b: *mut *const libc::int16_t, _retval: *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).TestWstring)(self, a, b, _retval)
    }



    /// `DOMString testDOMString (in DOMString a, inout DOMString b);`
    #[inline]
    pub unsafe fn TestDOMString(&self, a: &::nsstring::nsAString, b: &mut ::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).TestDOMString)(self, a, b, _retval)
    }



    /// `AString testAString (in AString a, inout AString b);`
    #[inline]
    pub unsafe fn TestAString(&self, a: &::nsstring::nsAString, b: &mut ::nsstring::nsAString, _retval: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).TestAString)(self, a, b, _retval)
    }



    /// `AUTF8String testAUTF8String (in AUTF8String a, inout AUTF8String b);`
    #[inline]
    pub unsafe fn TestAUTF8String(&self, a: &::nsstring::nsACString, b: &mut ::nsstring::nsACString, _retval: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).TestAUTF8String)(self, a, b, _retval)
    }



    /// `ACString testACString (in ACString a, inout ACString b);`
    #[inline]
    pub unsafe fn TestACString(&self, a: &::nsstring::nsACString, b: &mut ::nsstring::nsACString, _retval: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).TestACString)(self, a, b, _retval)
    }



    /// `jsval testJsval (in jsval a, inout jsval b);`
    const _TestJsval: () = ();


    /// `void testShortArray (in unsigned long aLength, [array, size_is (aLength)] in short a, inout unsigned long bLength, [array, size_is (bLength)] inout short b, out unsigned long rvLength, [array, size_is (rvLength), retval] out short rv);`
    #[inline]
    pub unsafe fn TestShortArray(&self, aLength: libc::uint32_t, a: *mut libc::int16_t, bLength: *mut libc::uint32_t, b: *mut *mut libc::int16_t, rvLength: *mut libc::uint32_t, rv: *mut *mut libc::int16_t) -> nsresult {
        ((*self.vtable).TestShortArray)(self, aLength, a, bLength, b, rvLength, rv)
    }



    /// `void testDoubleArray (in unsigned long aLength, [array, size_is (aLength)] in double a, inout unsigned long bLength, [array, size_is (bLength)] inout double b, out unsigned long rvLength, [array, size_is (rvLength), retval] out double rv);`
    #[inline]
    pub unsafe fn TestDoubleArray(&self, aLength: libc::uint32_t, a: *mut libc::c_double, bLength: *mut libc::uint32_t, b: *mut *mut libc::c_double, rvLength: *mut libc::uint32_t, rv: *mut *mut libc::c_double) -> nsresult {
        ((*self.vtable).TestDoubleArray)(self, aLength, a, bLength, b, rvLength, rv)
    }



    /// `void testStringArray (in unsigned long aLength, [array, size_is (aLength)] in string a, inout unsigned long bLength, [array, size_is (bLength)] inout string b, out unsigned long rvLength, [array, size_is (rvLength), retval] out string rv);`
    #[inline]
    pub unsafe fn TestStringArray(&self, aLength: libc::uint32_t, a: *mut *const libc::c_char, bLength: *mut libc::uint32_t, b: *mut *mut *const libc::c_char, rvLength: *mut libc::uint32_t, rv: *mut *mut *const libc::c_char) -> nsresult {
        ((*self.vtable).TestStringArray)(self, aLength, a, bLength, b, rvLength, rv)
    }



    /// `void testWstringArray (in unsigned long aLength, [array, size_is (aLength)] in wstring a, inout unsigned long bLength, [array, size_is (bLength)] inout wstring b, out unsigned long rvLength, [array, size_is (rvLength), retval] out wstring rv);`
    #[inline]
    pub unsafe fn TestWstringArray(&self, aLength: libc::uint32_t, a: *mut *const libc::int16_t, bLength: *mut libc::uint32_t, b: *mut *mut *const libc::int16_t, rvLength: *mut libc::uint32_t, rv: *mut *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).TestWstringArray)(self, aLength, a, bLength, b, rvLength, rv)
    }



    /// `void testInterfaceArray (in unsigned long aLength, [array, size_is (aLength)] in nsIXPCTestInterfaceA a, inout unsigned long bLength, [array, size_is (bLength)] inout nsIXPCTestInterfaceA b, out unsigned long rvLength, [array, size_is (rvLength), retval] out nsIXPCTestInterfaceA rv);`
    #[inline]
    pub unsafe fn TestInterfaceArray(&self, aLength: libc::uint32_t, a: *mut *const nsIXPCTestInterfaceA, bLength: *mut libc::uint32_t, b: *mut *mut *const nsIXPCTestInterfaceA, rvLength: *mut libc::uint32_t, rv: *mut *mut *const nsIXPCTestInterfaceA) -> nsresult {
        ((*self.vtable).TestInterfaceArray)(self, aLength, a, bLength, b, rvLength, rv)
    }



    /// `void testSizedString (in unsigned long aLength, [size_is (aLength)] in string a, inout unsigned long bLength, [size_is (bLength)] inout string b, out unsigned long rvLength, [size_is (rvLength), retval] out string rv);`
    #[inline]
    pub unsafe fn TestSizedString(&self, aLength: libc::uint32_t, a: *const libc::c_char, bLength: *mut libc::uint32_t, b: *mut *const libc::c_char, rvLength: *mut libc::uint32_t, rv: *mut *const libc::c_char) -> nsresult {
        ((*self.vtable).TestSizedString)(self, aLength, a, bLength, b, rvLength, rv)
    }



    /// `void testSizedWstring (in unsigned long aLength, [size_is (aLength)] in wstring a, inout unsigned long bLength, [size_is (bLength)] inout wstring b, out unsigned long rvLength, [size_is (rvLength), retval] out wstring rv);`
    #[inline]
    pub unsafe fn TestSizedWstring(&self, aLength: libc::uint32_t, a: *const libc::int16_t, bLength: *mut libc::uint32_t, b: *mut *const libc::int16_t, rvLength: *mut libc::uint32_t, rv: *mut *const libc::int16_t) -> nsresult {
        ((*self.vtable).TestSizedWstring)(self, aLength, a, bLength, b, rvLength, rv)
    }



    /// `void testInterfaceIs (in nsIIDPtr aIID, [iid_is (aIID)] in nsQIResult a, inout nsIIDPtr bIID, [iid_is (bIID)] inout nsQIResult b, out nsIIDPtr rvIID, [iid_is (rvIID), retval] out nsQIResult rv);`
    #[inline]
    pub unsafe fn TestInterfaceIs(&self, aIID: *const nsIID, a: *mut libc::c_void, bIID: *mut *mut nsIID, b: *mut *mut libc::c_void, rvIID: *mut *mut nsIID, rv: *mut *mut libc::c_void) -> nsresult {
        ((*self.vtable).TestInterfaceIs)(self, aIID, a, bIID, b, rvIID, rv)
    }



    /// `void testInterfaceIsArray (in unsigned long aLength, in nsIIDPtr aIID, [array, size_is (aLength), iid_is (aIID)] in nsQIResult a, inout unsigned long bLength, inout nsIIDPtr bIID, [array, size_is (bLength), iid_is (bIID)] inout nsQIResult b, out unsigned long rvLength, out nsIIDPtr rvIID, [retval, array, size_is (rvLength), iid_is (rvIID)] out nsQIResult rv);`
    #[inline]
    pub unsafe fn TestInterfaceIsArray(&self, aLength: libc::uint32_t, aIID: *const nsIID, a: *mut *mut libc::c_void, bLength: *mut libc::uint32_t, bIID: *mut *mut nsIID, b: *mut *mut *mut libc::c_void, rvLength: *mut libc::uint32_t, rvIID: *mut *mut nsIID, rv: *mut *mut *mut libc::c_void) -> nsresult {
        ((*self.vtable).TestInterfaceIsArray)(self, aLength, aIID, a, bLength, bIID, b, rvLength, rvIID, rv)
    }



    /// `void testOutAString (out AString o);`
    #[inline]
    pub unsafe fn TestOutAString(&self, o: &mut ::nsstring::nsAString) -> nsresult {
        ((*self.vtable).TestOutAString)(self, o)
    }



    /// `ACString testStringArrayOptionalSize ([array, size_is (aLength)] in string a, [optional] in unsigned long aLength);`
    #[inline]
    pub unsafe fn TestStringArrayOptionalSize(&self, a: *mut *const libc::c_char, aLength: libc::uint32_t, _retval: &mut ::nsstring::nsACString) -> nsresult {
        ((*self.vtable).TestStringArrayOptionalSize)(self, a, aLength, _retval)
    }


}