/*
 * DO NOT EDIT.  THIS FILE IS GENERATED FROM xpctest.idl
 */

#ifndef __gen_xpctest_h__
#define __gen_xpctest_h__


#ifndef __gen_nsISupports_h__
#include "nsISupports.h"
#endif

#ifndef __gen_xpcexception_h__
#include "xpcexception.h"
#endif

#ifndef __gen_nsIVariant_h__
#include "nsIVariant.h"
#endif

#ifndef __gen_nsIPropertyBag_h__
#include "nsIPropertyBag.h"
#endif

/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif
class nsITestXPCSomeUselessThing; /* forward declaration */


/* starting interface:    nsITestXPCFunctionCallback */
#define NS_ITESTXPCFUNCTIONCALLBACK_IID_STR "4407fc90-1e41-11d5-909d-0010a4e73d9a"

#define NS_ITESTXPCFUNCTIONCALLBACK_IID \
  {0x4407fc90, 0x1e41, 0x11d5, \
    { 0x90, 0x9d, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}

class NS_NO_VTABLE nsITestXPCFunctionCallback : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ITESTXPCFUNCTIONCALLBACK_IID)

  /* void call (in string s); */
  NS_IMETHOD Call(const char *s) = 0;

  /* void callWithThis (in nsISupports self, in string s); */
  NS_IMETHOD CallWithThis(nsISupports *self, const char *s) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSITESTXPCFUNCTIONCALLBACK \
  NS_IMETHOD Call(const char *s); \
  NS_IMETHOD CallWithThis(nsISupports *self, const char *s); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSITESTXPCFUNCTIONCALLBACK(_to) \
  NS_IMETHOD Call(const char *s) { return _to Call(s); } \
  NS_IMETHOD CallWithThis(nsISupports *self, const char *s) { return _to CallWithThis(self, s); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSITESTXPCFUNCTIONCALLBACK(_to) \
  NS_IMETHOD Call(const char *s) { return !_to ? NS_ERROR_NULL_POINTER : _to->Call(s); } \
  NS_IMETHOD CallWithThis(nsISupports *self, const char *s) { return !_to ? NS_ERROR_NULL_POINTER : _to->CallWithThis(self, s); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsTestXPCFunctionCallback : public nsITestXPCFunctionCallback
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSITESTXPCFUNCTIONCALLBACK

  nsTestXPCFunctionCallback();
  virtual ~nsTestXPCFunctionCallback();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsTestXPCFunctionCallback, nsITestXPCFunctionCallback)

nsTestXPCFunctionCallback::nsTestXPCFunctionCallback()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsTestXPCFunctionCallback::~nsTestXPCFunctionCallback()
{
  /* destructor code */
}

/* void call (in string s); */
NS_IMETHODIMP nsTestXPCFunctionCallback::Call(const char *s)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void callWithThis (in nsISupports self, in string s); */
NS_IMETHODIMP nsTestXPCFunctionCallback::CallWithThis(nsISupports *self, const char *s)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsITestXPCFoo */
#define NS_ITESTXPCFOO_IID_STR "159e36d0-991e-11d2-ac3f-00c09300144b"

#define NS_ITESTXPCFOO_IID \
  {0x159e36d0, 0x991e, 0x11d2, \
    { 0xac, 0x3f, 0x00, 0xc0, 0x93, 0x00, 0x14, 0x4b }}

class NS_NO_VTABLE nsITestXPCFoo : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ITESTXPCFOO_IID)

  /* long Test (in long p1, in long p2); */
  NS_IMETHOD Test(PRInt32 p1, PRInt32 p2, PRInt32 *_retval) = 0;

  /* void Test2 (); */
  NS_IMETHOD Test2(void) = 0;

  /* attribute string Foo; */
  NS_IMETHOD GetFoo(char * *aFoo) = 0;
  NS_IMETHOD SetFoo(const char * aFoo) = 0;

  enum { one = 1 };

  enum { five = 5 };

  enum { six = 6 };

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSITESTXPCFOO \
  NS_IMETHOD Test(PRInt32 p1, PRInt32 p2, PRInt32 *_retval); \
  NS_IMETHOD Test2(void); \
  NS_IMETHOD GetFoo(char * *aFoo); \
  NS_IMETHOD SetFoo(const char * aFoo); \

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSITESTXPCFOO(_to) \
  NS_IMETHOD Test(PRInt32 p1, PRInt32 p2, PRInt32 *_retval) { return _to Test(p1, p2, _retval); } \
  NS_IMETHOD Test2(void) { return _to Test2(); } \
  NS_IMETHOD GetFoo(char * *aFoo) { return _to GetFoo(aFoo); } \
  NS_IMETHOD SetFoo(const char * aFoo) { return _to SetFoo(aFoo); } \

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSITESTXPCFOO(_to) \
  NS_IMETHOD Test(PRInt32 p1, PRInt32 p2, PRInt32 *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->Test(p1, p2, _retval); } \
  NS_IMETHOD Test2(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->Test2(); } \
  NS_IMETHOD GetFoo(char * *aFoo) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetFoo(aFoo); } \
  NS_IMETHOD SetFoo(const char * aFoo) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetFoo(aFoo); } \

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsTestXPCFoo : public nsITestXPCFoo
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSITESTXPCFOO

  nsTestXPCFoo();
  virtual ~nsTestXPCFoo();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsTestXPCFoo, nsITestXPCFoo)

nsTestXPCFoo::nsTestXPCFoo()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsTestXPCFoo::~nsTestXPCFoo()
{
  /* destructor code */
}

/* long Test (in long p1, in long p2); */
NS_IMETHODIMP nsTestXPCFoo::Test(PRInt32 p1, PRInt32 p2, PRInt32 *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void Test2 (); */
NS_IMETHODIMP nsTestXPCFoo::Test2()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string Foo; */
NS_IMETHODIMP nsTestXPCFoo::GetFoo(char * *aFoo)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsTestXPCFoo::SetFoo(const char * aFoo)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsITestXPCFoo2 */
#define NS_ITESTXPCFOO2_IID_STR "5f9d20c0-9b6b-11d2-9ffe-000064657374"

#define NS_ITESTXPCFOO2_IID \
  {0x5f9d20c0, 0x9b6b, 0x11d2, \
    { 0x9f, 0xfe, 0x00, 0x00, 0x64, 0x65, 0x73, 0x74 }}

class NS_NO_VTABLE nsITestXPCFoo2 : public nsITestXPCFoo {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ITESTXPCFOO2_IID)

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSITESTXPCFOO2 \
  /* no methods! */

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSITESTXPCFOO2(_to) \
  /* no methods! */

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSITESTXPCFOO2(_to) \
  /* no methods! */

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsTestXPCFoo2 : public nsITestXPCFoo2
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSITESTXPCFOO2

  nsTestXPCFoo2();
  virtual ~nsTestXPCFoo2();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsTestXPCFoo2, nsITestXPCFoo2)

nsTestXPCFoo2::nsTestXPCFoo2()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsTestXPCFoo2::~nsTestXPCFoo2()
{
  /* destructor code */
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIEcho */
#define NS_IECHO_IID_STR "cd2f2f40-c5d9-11d2-9838-006008962422"

#define NS_IECHO_IID \
  {0xcd2f2f40, 0xc5d9, 0x11d2, \
    { 0x98, 0x38, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}

class NS_NO_VTABLE nsIEcho : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IECHO_IID)

  /* void SetReceiver (in nsIEcho aReceiver); */
  NS_IMETHOD SetReceiver(nsIEcho *aReceiver) = 0;

  /* void SendOneString (in string str); */
  NS_IMETHOD SendOneString(const char *str) = 0;

  /* long In2OutOneInt (in long input); */
  NS_IMETHOD In2OutOneInt(PRInt32 input, PRInt32 *_retval) = 0;

  /* long In2OutAddTwoInts (in long input1, in long input2, out long output1, out long output2); */
  NS_IMETHOD In2OutAddTwoInts(PRInt32 input1, PRInt32 input2, PRInt32 *output1, PRInt32 *output2, PRInt32 *_retval) = 0;

  /* string In2OutOneString (in string input); */
  NS_IMETHOD In2OutOneString(const char *input, char **_retval) = 0;

  /* DOMString In2OutOneDOMString (in DOMString input); */
  NS_IMETHOD In2OutOneDOMString(const nsAString & input, nsAString & _retval) = 0;

  /* DOMString EchoIn2OutOneDOMString (in DOMString input); */
  NS_IMETHOD EchoIn2OutOneDOMString(const nsAString & input, nsAString & _retval) = 0;

  /* void SimpleCallNoEcho (); */
  NS_IMETHOD SimpleCallNoEcho(void) = 0;

  /* void SendManyTypes (in octet p1, in short p2, in long p3, in long long p4, in octet p5, in unsigned short p6, in unsigned long p7, in unsigned long long p8, in float p9, in double p10, in boolean p11, in char p12, in wchar p13, in nsIDPtr p14, in string p15, in wstring p16); */
  NS_IMETHOD SendManyTypes(PRUint8 p1, PRInt16 p2, PRInt32 p3, PRInt64 p4, PRUint8 p5, PRUint16 p6, PRUint32 p7, PRUint64 p8, float p9, double p10, PRBool p11, char p12, PRUnichar p13, const nsID * p14, const char *p15, const PRUnichar *p16) = 0;

  /* void SendInOutManyTypes (inout octet p1, inout short p2, inout long p3, inout long long p4, inout octet p5, inout unsigned short p6, inout unsigned long p7, inout unsigned long long p8, inout float p9, inout double p10, inout boolean p11, inout char p12, inout wchar p13, inout nsIDPtr p14, inout string p15, inout wstring p16); */
  NS_IMETHOD SendInOutManyTypes(PRUint8 *p1, PRInt16 *p2, PRInt32 *p3, PRInt64 *p4, PRUint8 *p5, PRUint16 *p6, PRUint32 *p7, PRUint64 *p8, float *p9, double *p10, PRBool *p11, char *p12, PRUnichar *p13, nsID * *p14, char **p15, PRUnichar **p16) = 0;

  /* [noscript] void MethodWithNative (in long p1, in voidPtr p2); */
  NS_IMETHOD MethodWithNative(PRInt32 p1, void * p2) = 0;

  /* void ReturnCode (in long code); */
  NS_IMETHOD ReturnCode(PRInt32 code) = 0;

  /* void FailInJSTest (in long fail); */
  NS_IMETHOD FailInJSTest(PRInt32 fail) = 0;

  /* void SharedString ([shared, retval] out string str); */
  NS_IMETHOD SharedString(const char **str) = 0;

  /* void ReturnCode_NS_OK (); */
  NS_IMETHOD ReturnCode_NS_OK(void) = 0;

  /* void ReturnCode_NS_ERROR_NULL_POINTER (); */
  NS_IMETHOD ReturnCode_NS_ERROR_NULL_POINTER(void) = 0;

  /* void ReturnCode_NS_ERROR_UNEXPECTED (); */
  NS_IMETHOD ReturnCode_NS_ERROR_UNEXPECTED(void) = 0;

  /* void ReturnCode_NS_ERROR_OUT_OF_MEMORY (); */
  NS_IMETHOD ReturnCode_NS_ERROR_OUT_OF_MEMORY(void) = 0;

  /* nsISupports ReturnInterface (in nsISupports obj); */
  NS_IMETHOD ReturnInterface(nsISupports *obj, nsISupports **_retval) = 0;

  /* nsIStackFrame GetStack (); */
  NS_IMETHOD GetStack(nsIStackFrame **_retval) = 0;

  /* void SetReceiverReturnOldReceiver (inout nsIEcho aReceiver); */
  NS_IMETHOD SetReceiverReturnOldReceiver(nsIEcho **aReceiver) = 0;

  /* void MethodWithForwardDeclaredParam (in nsITestXPCSomeUselessThing sut); */
  NS_IMETHOD MethodWithForwardDeclaredParam(nsITestXPCSomeUselessThing *sut) = 0;

  /* void PseudoQueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result); */
  NS_IMETHOD PseudoQueryInterface(const nsIID & uuid, void * *result) = 0;

  /* void DebugDumpJSStack (); */
  NS_IMETHOD DebugDumpJSStack(void) = 0;

  /* void printArgTypes (); */
  NS_IMETHOD PrintArgTypes(void) = 0;

  /* void throwArg (); */
  NS_IMETHOD ThrowArg(void) = 0;

  /* void callReceiverSometimeLater (); */
  NS_IMETHOD CallReceiverSometimeLater(void) = 0;

  /* readonly attribute short throwInGetter; */
  NS_IMETHOD GetThrowInGetter(PRInt16 *aThrowInGetter) = 0;

  /* attribute string aString; */
  NS_IMETHOD GetAString(char * *aAString) = 0;
  NS_IMETHOD SetAString(const char * aAString) = 0;

  /* attribute PRInt32 SomeValue; */
  NS_IMETHOD GetSomeValue(PRInt32 *aSomeValue) = 0;
  NS_IMETHOD SetSomeValue(PRInt32 aSomeValue) = 0;

  enum { one = 1 };

  enum { five = 5 };

  enum { six = 6 };

  enum { medium = 12345U };

  enum { big = 4294967295U };

  /* void callFunction (in nsITestXPCFunctionCallback callback, in string s); */
  NS_IMETHOD CallFunction(nsITestXPCFunctionCallback *callback, const char *s) = 0;

  /* void callFunctionWithThis (in nsITestXPCFunctionCallback callback, in nsISupports self, in string s); */
  NS_IMETHOD CallFunctionWithThis(nsITestXPCFunctionCallback *callback, nsISupports *self, const char *s) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIECHO \
  NS_IMETHOD SetReceiver(nsIEcho *aReceiver); \
  NS_IMETHOD SendOneString(const char *str); \
  NS_IMETHOD In2OutOneInt(PRInt32 input, PRInt32 *_retval); \
  NS_IMETHOD In2OutAddTwoInts(PRInt32 input1, PRInt32 input2, PRInt32 *output1, PRInt32 *output2, PRInt32 *_retval); \
  NS_IMETHOD In2OutOneString(const char *input, char **_retval); \
  NS_IMETHOD In2OutOneDOMString(const nsAString & input, nsAString & _retval); \
  NS_IMETHOD EchoIn2OutOneDOMString(const nsAString & input, nsAString & _retval); \
  NS_IMETHOD SimpleCallNoEcho(void); \
  NS_IMETHOD SendManyTypes(PRUint8 p1, PRInt16 p2, PRInt32 p3, PRInt64 p4, PRUint8 p5, PRUint16 p6, PRUint32 p7, PRUint64 p8, float p9, double p10, PRBool p11, char p12, PRUnichar p13, const nsID * p14, const char *p15, const PRUnichar *p16); \
  NS_IMETHOD SendInOutManyTypes(PRUint8 *p1, PRInt16 *p2, PRInt32 *p3, PRInt64 *p4, PRUint8 *p5, PRUint16 *p6, PRUint32 *p7, PRUint64 *p8, float *p9, double *p10, PRBool *p11, char *p12, PRUnichar *p13, nsID * *p14, char **p15, PRUnichar **p16); \
  NS_IMETHOD MethodWithNative(PRInt32 p1, void * p2); \
  NS_IMETHOD ReturnCode(PRInt32 code); \
  NS_IMETHOD FailInJSTest(PRInt32 fail); \
  NS_IMETHOD SharedString(const char **str); \
  NS_IMETHOD ReturnCode_NS_OK(void); \
  NS_IMETHOD ReturnCode_NS_ERROR_NULL_POINTER(void); \
  NS_IMETHOD ReturnCode_NS_ERROR_UNEXPECTED(void); \
  NS_IMETHOD ReturnCode_NS_ERROR_OUT_OF_MEMORY(void); \
  NS_IMETHOD ReturnInterface(nsISupports *obj, nsISupports **_retval); \
  NS_IMETHOD GetStack(nsIStackFrame **_retval); \
  NS_IMETHOD SetReceiverReturnOldReceiver(nsIEcho **aReceiver); \
  NS_IMETHOD MethodWithForwardDeclaredParam(nsITestXPCSomeUselessThing *sut); \
  NS_IMETHOD PseudoQueryInterface(const nsIID & uuid, void * *result); \
  NS_IMETHOD DebugDumpJSStack(void); \
  NS_IMETHOD PrintArgTypes(void); \
  NS_IMETHOD ThrowArg(void); \
  NS_IMETHOD CallReceiverSometimeLater(void); \
  NS_IMETHOD GetThrowInGetter(PRInt16 *aThrowInGetter); \
  NS_IMETHOD GetAString(char * *aAString); \
  NS_IMETHOD SetAString(const char * aAString); \
  NS_IMETHOD GetSomeValue(PRInt32 *aSomeValue); \
  NS_IMETHOD SetSomeValue(PRInt32 aSomeValue); \
  NS_IMETHOD CallFunction(nsITestXPCFunctionCallback *callback, const char *s); \
  NS_IMETHOD CallFunctionWithThis(nsITestXPCFunctionCallback *callback, nsISupports *self, const char *s); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIECHO(_to) \
  NS_IMETHOD SetReceiver(nsIEcho *aReceiver) { return _to SetReceiver(aReceiver); } \
  NS_IMETHOD SendOneString(const char *str) { return _to SendOneString(str); } \
  NS_IMETHOD In2OutOneInt(PRInt32 input, PRInt32 *_retval) { return _to In2OutOneInt(input, _retval); } \
  NS_IMETHOD In2OutAddTwoInts(PRInt32 input1, PRInt32 input2, PRInt32 *output1, PRInt32 *output2, PRInt32 *_retval) { return _to In2OutAddTwoInts(input1, input2, output1, output2, _retval); } \
  NS_IMETHOD In2OutOneString(const char *input, char **_retval) { return _to In2OutOneString(input, _retval); } \
  NS_IMETHOD In2OutOneDOMString(const nsAString & input, nsAString & _retval) { return _to In2OutOneDOMString(input, _retval); } \
  NS_IMETHOD EchoIn2OutOneDOMString(const nsAString & input, nsAString & _retval) { return _to EchoIn2OutOneDOMString(input, _retval); } \
  NS_IMETHOD SimpleCallNoEcho(void) { return _to SimpleCallNoEcho(); } \
  NS_IMETHOD SendManyTypes(PRUint8 p1, PRInt16 p2, PRInt32 p3, PRInt64 p4, PRUint8 p5, PRUint16 p6, PRUint32 p7, PRUint64 p8, float p9, double p10, PRBool p11, char p12, PRUnichar p13, const nsID * p14, const char *p15, const PRUnichar *p16) { return _to SendManyTypes(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } \
  NS_IMETHOD SendInOutManyTypes(PRUint8 *p1, PRInt16 *p2, PRInt32 *p3, PRInt64 *p4, PRUint8 *p5, PRUint16 *p6, PRUint32 *p7, PRUint64 *p8, float *p9, double *p10, PRBool *p11, char *p12, PRUnichar *p13, nsID * *p14, char **p15, PRUnichar **p16) { return _to SendInOutManyTypes(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } \
  NS_IMETHOD MethodWithNative(PRInt32 p1, void * p2) { return _to MethodWithNative(p1, p2); } \
  NS_IMETHOD ReturnCode(PRInt32 code) { return _to ReturnCode(code); } \
  NS_IMETHOD FailInJSTest(PRInt32 fail) { return _to FailInJSTest(fail); } \
  NS_IMETHOD SharedString(const char **str) { return _to SharedString(str); } \
  NS_IMETHOD ReturnCode_NS_OK(void) { return _to ReturnCode_NS_OK(); } \
  NS_IMETHOD ReturnCode_NS_ERROR_NULL_POINTER(void) { return _to ReturnCode_NS_ERROR_NULL_POINTER(); } \
  NS_IMETHOD ReturnCode_NS_ERROR_UNEXPECTED(void) { return _to ReturnCode_NS_ERROR_UNEXPECTED(); } \
  NS_IMETHOD ReturnCode_NS_ERROR_OUT_OF_MEMORY(void) { return _to ReturnCode_NS_ERROR_OUT_OF_MEMORY(); } \
  NS_IMETHOD ReturnInterface(nsISupports *obj, nsISupports **_retval) { return _to ReturnInterface(obj, _retval); } \
  NS_IMETHOD GetStack(nsIStackFrame **_retval) { return _to GetStack(_retval); } \
  NS_IMETHOD SetReceiverReturnOldReceiver(nsIEcho **aReceiver) { return _to SetReceiverReturnOldReceiver(aReceiver); } \
  NS_IMETHOD MethodWithForwardDeclaredParam(nsITestXPCSomeUselessThing *sut) { return _to MethodWithForwardDeclaredParam(sut); } \
  NS_IMETHOD PseudoQueryInterface(const nsIID & uuid, void * *result) { return _to PseudoQueryInterface(uuid, result); } \
  NS_IMETHOD DebugDumpJSStack(void) { return _to DebugDumpJSStack(); } \
  NS_IMETHOD PrintArgTypes(void) { return _to PrintArgTypes(); } \
  NS_IMETHOD ThrowArg(void) { return _to ThrowArg(); } \
  NS_IMETHOD CallReceiverSometimeLater(void) { return _to CallReceiverSometimeLater(); } \
  NS_IMETHOD GetThrowInGetter(PRInt16 *aThrowInGetter) { return _to GetThrowInGetter(aThrowInGetter); } \
  NS_IMETHOD GetAString(char * *aAString) { return _to GetAString(aAString); } \
  NS_IMETHOD SetAString(const char * aAString) { return _to SetAString(aAString); } \
  NS_IMETHOD GetSomeValue(PRInt32 *aSomeValue) { return _to GetSomeValue(aSomeValue); } \
  NS_IMETHOD SetSomeValue(PRInt32 aSomeValue) { return _to SetSomeValue(aSomeValue); } \
  NS_IMETHOD CallFunction(nsITestXPCFunctionCallback *callback, const char *s) { return _to CallFunction(callback, s); } \
  NS_IMETHOD CallFunctionWithThis(nsITestXPCFunctionCallback *callback, nsISupports *self, const char *s) { return _to CallFunctionWithThis(callback, self, s); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIECHO(_to) \
  NS_IMETHOD SetReceiver(nsIEcho *aReceiver) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetReceiver(aReceiver); } \
  NS_IMETHOD SendOneString(const char *str) { return !_to ? NS_ERROR_NULL_POINTER : _to->SendOneString(str); } \
  NS_IMETHOD In2OutOneInt(PRInt32 input, PRInt32 *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->In2OutOneInt(input, _retval); } \
  NS_IMETHOD In2OutAddTwoInts(PRInt32 input1, PRInt32 input2, PRInt32 *output1, PRInt32 *output2, PRInt32 *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->In2OutAddTwoInts(input1, input2, output1, output2, _retval); } \
  NS_IMETHOD In2OutOneString(const char *input, char **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->In2OutOneString(input, _retval); } \
  NS_IMETHOD In2OutOneDOMString(const nsAString & input, nsAString & _retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->In2OutOneDOMString(input, _retval); } \
  NS_IMETHOD EchoIn2OutOneDOMString(const nsAString & input, nsAString & _retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->EchoIn2OutOneDOMString(input, _retval); } \
  NS_IMETHOD SimpleCallNoEcho(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->SimpleCallNoEcho(); } \
  NS_IMETHOD SendManyTypes(PRUint8 p1, PRInt16 p2, PRInt32 p3, PRInt64 p4, PRUint8 p5, PRUint16 p6, PRUint32 p7, PRUint64 p8, float p9, double p10, PRBool p11, char p12, PRUnichar p13, const nsID * p14, const char *p15, const PRUnichar *p16) { return !_to ? NS_ERROR_NULL_POINTER : _to->SendManyTypes(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } \
  NS_IMETHOD SendInOutManyTypes(PRUint8 *p1, PRInt16 *p2, PRInt32 *p3, PRInt64 *p4, PRUint8 *p5, PRUint16 *p6, PRUint32 *p7, PRUint64 *p8, float *p9, double *p10, PRBool *p11, char *p12, PRUnichar *p13, nsID * *p14, char **p15, PRUnichar **p16) { return !_to ? NS_ERROR_NULL_POINTER : _to->SendInOutManyTypes(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16); } \
  NS_IMETHOD MethodWithNative(PRInt32 p1, void * p2) { return !_to ? NS_ERROR_NULL_POINTER : _to->MethodWithNative(p1, p2); } \
  NS_IMETHOD ReturnCode(PRInt32 code) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReturnCode(code); } \
  NS_IMETHOD FailInJSTest(PRInt32 fail) { return !_to ? NS_ERROR_NULL_POINTER : _to->FailInJSTest(fail); } \
  NS_IMETHOD SharedString(const char **str) { return !_to ? NS_ERROR_NULL_POINTER : _to->SharedString(str); } \
  NS_IMETHOD ReturnCode_NS_OK(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReturnCode_NS_OK(); } \
  NS_IMETHOD ReturnCode_NS_ERROR_NULL_POINTER(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReturnCode_NS_ERROR_NULL_POINTER(); } \
  NS_IMETHOD ReturnCode_NS_ERROR_UNEXPECTED(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReturnCode_NS_ERROR_UNEXPECTED(); } \
  NS_IMETHOD ReturnCode_NS_ERROR_OUT_OF_MEMORY(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReturnCode_NS_ERROR_OUT_OF_MEMORY(); } \
  NS_IMETHOD ReturnInterface(nsISupports *obj, nsISupports **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReturnInterface(obj, _retval); } \
  NS_IMETHOD GetStack(nsIStackFrame **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStack(_retval); } \
  NS_IMETHOD SetReceiverReturnOldReceiver(nsIEcho **aReceiver) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetReceiverReturnOldReceiver(aReceiver); } \
  NS_IMETHOD MethodWithForwardDeclaredParam(nsITestXPCSomeUselessThing *sut) { return !_to ? NS_ERROR_NULL_POINTER : _to->MethodWithForwardDeclaredParam(sut); } \
  NS_IMETHOD PseudoQueryInterface(const nsIID & uuid, void * *result) { return !_to ? NS_ERROR_NULL_POINTER : _to->PseudoQueryInterface(uuid, result); } \
  NS_IMETHOD DebugDumpJSStack(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->DebugDumpJSStack(); } \
  NS_IMETHOD PrintArgTypes(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->PrintArgTypes(); } \
  NS_IMETHOD ThrowArg(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->ThrowArg(); } \
  NS_IMETHOD CallReceiverSometimeLater(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->CallReceiverSometimeLater(); } \
  NS_IMETHOD GetThrowInGetter(PRInt16 *aThrowInGetter) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetThrowInGetter(aThrowInGetter); } \
  NS_IMETHOD GetAString(char * *aAString) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAString(aAString); } \
  NS_IMETHOD SetAString(const char * aAString) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetAString(aAString); } \
  NS_IMETHOD GetSomeValue(PRInt32 *aSomeValue) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetSomeValue(aSomeValue); } \
  NS_IMETHOD SetSomeValue(PRInt32 aSomeValue) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetSomeValue(aSomeValue); } \
  NS_IMETHOD CallFunction(nsITestXPCFunctionCallback *callback, const char *s) { return !_to ? NS_ERROR_NULL_POINTER : _to->CallFunction(callback, s); } \
  NS_IMETHOD CallFunctionWithThis(nsITestXPCFunctionCallback *callback, nsISupports *self, const char *s) { return !_to ? NS_ERROR_NULL_POINTER : _to->CallFunctionWithThis(callback, self, s); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsEcho : public nsIEcho
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIECHO

  nsEcho();
  virtual ~nsEcho();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsEcho, nsIEcho)

nsEcho::nsEcho()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsEcho::~nsEcho()
{
  /* destructor code */
}

/* void SetReceiver (in nsIEcho aReceiver); */
NS_IMETHODIMP nsEcho::SetReceiver(nsIEcho *aReceiver)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void SendOneString (in string str); */
NS_IMETHODIMP nsEcho::SendOneString(const char *str)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* long In2OutOneInt (in long input); */
NS_IMETHODIMP nsEcho::In2OutOneInt(PRInt32 input, PRInt32 *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* long In2OutAddTwoInts (in long input1, in long input2, out long output1, out long output2); */
NS_IMETHODIMP nsEcho::In2OutAddTwoInts(PRInt32 input1, PRInt32 input2, PRInt32 *output1, PRInt32 *output2, PRInt32 *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* string In2OutOneString (in string input); */
NS_IMETHODIMP nsEcho::In2OutOneString(const char *input, char **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* DOMString In2OutOneDOMString (in DOMString input); */
NS_IMETHODIMP nsEcho::In2OutOneDOMString(const nsAString & input, nsAString & _retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* DOMString EchoIn2OutOneDOMString (in DOMString input); */
NS_IMETHODIMP nsEcho::EchoIn2OutOneDOMString(const nsAString & input, nsAString & _retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void SimpleCallNoEcho (); */
NS_IMETHODIMP nsEcho::SimpleCallNoEcho()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void SendManyTypes (in octet p1, in short p2, in long p3, in long long p4, in octet p5, in unsigned short p6, in unsigned long p7, in unsigned long long p8, in float p9, in double p10, in boolean p11, in char p12, in wchar p13, in nsIDPtr p14, in string p15, in wstring p16); */
NS_IMETHODIMP nsEcho::SendManyTypes(PRUint8 p1, PRInt16 p2, PRInt32 p3, PRInt64 p4, PRUint8 p5, PRUint16 p6, PRUint32 p7, PRUint64 p8, float p9, double p10, PRBool p11, char p12, PRUnichar p13, const nsID * p14, const char *p15, const PRUnichar *p16)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void SendInOutManyTypes (inout octet p1, inout short p2, inout long p3, inout long long p4, inout octet p5, inout unsigned short p6, inout unsigned long p7, inout unsigned long long p8, inout float p9, inout double p10, inout boolean p11, inout char p12, inout wchar p13, inout nsIDPtr p14, inout string p15, inout wstring p16); */
NS_IMETHODIMP nsEcho::SendInOutManyTypes(PRUint8 *p1, PRInt16 *p2, PRInt32 *p3, PRInt64 *p4, PRUint8 *p5, PRUint16 *p6, PRUint32 *p7, PRUint64 *p8, float *p9, double *p10, PRBool *p11, char *p12, PRUnichar *p13, nsID * *p14, char **p15, PRUnichar **p16)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* [noscript] void MethodWithNative (in long p1, in voidPtr p2); */
NS_IMETHODIMP nsEcho::MethodWithNative(PRInt32 p1, void * p2)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void ReturnCode (in long code); */
NS_IMETHODIMP nsEcho::ReturnCode(PRInt32 code)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void FailInJSTest (in long fail); */
NS_IMETHODIMP nsEcho::FailInJSTest(PRInt32 fail)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void SharedString ([shared, retval] out string str); */
NS_IMETHODIMP nsEcho::SharedString(const char **str)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void ReturnCode_NS_OK (); */
NS_IMETHODIMP nsEcho::ReturnCode_NS_OK()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void ReturnCode_NS_ERROR_NULL_POINTER (); */
NS_IMETHODIMP nsEcho::ReturnCode_NS_ERROR_NULL_POINTER()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void ReturnCode_NS_ERROR_UNEXPECTED (); */
NS_IMETHODIMP nsEcho::ReturnCode_NS_ERROR_UNEXPECTED()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void ReturnCode_NS_ERROR_OUT_OF_MEMORY (); */
NS_IMETHODIMP nsEcho::ReturnCode_NS_ERROR_OUT_OF_MEMORY()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsISupports ReturnInterface (in nsISupports obj); */
NS_IMETHODIMP nsEcho::ReturnInterface(nsISupports *obj, nsISupports **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsIStackFrame GetStack (); */
NS_IMETHODIMP nsEcho::GetStack(nsIStackFrame **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void SetReceiverReturnOldReceiver (inout nsIEcho aReceiver); */
NS_IMETHODIMP nsEcho::SetReceiverReturnOldReceiver(nsIEcho **aReceiver)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void MethodWithForwardDeclaredParam (in nsITestXPCSomeUselessThing sut); */
NS_IMETHODIMP nsEcho::MethodWithForwardDeclaredParam(nsITestXPCSomeUselessThing *sut)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void PseudoQueryInterface (in nsIIDRef uuid, [iid_is (uuid), retval] out nsQIResult result); */
NS_IMETHODIMP nsEcho::PseudoQueryInterface(const nsIID & uuid, void * *result)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void DebugDumpJSStack (); */
NS_IMETHODIMP nsEcho::DebugDumpJSStack()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void printArgTypes (); */
NS_IMETHODIMP nsEcho::PrintArgTypes()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void throwArg (); */
NS_IMETHODIMP nsEcho::ThrowArg()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void callReceiverSometimeLater (); */
NS_IMETHODIMP nsEcho::CallReceiverSometimeLater()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* readonly attribute short throwInGetter; */
NS_IMETHODIMP nsEcho::GetThrowInGetter(PRInt16 *aThrowInGetter)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute string aString; */
NS_IMETHODIMP nsEcho::GetAString(char * *aAString)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsEcho::SetAString(const char * aAString)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* attribute PRInt32 SomeValue; */
NS_IMETHODIMP nsEcho::GetSomeValue(PRInt32 *aSomeValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsEcho::SetSomeValue(PRInt32 aSomeValue)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void callFunction (in nsITestXPCFunctionCallback callback, in string s); */
NS_IMETHODIMP nsEcho::CallFunction(nsITestXPCFunctionCallback *callback, const char *s)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void callFunctionWithThis (in nsITestXPCFunctionCallback callback, in nsISupports self, in string s); */
NS_IMETHODIMP nsEcho::CallFunctionWithThis(nsITestXPCFunctionCallback *callback, nsISupports *self, const char *s)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIXPCTestParent */
#define NS_IXPCTESTPARENT_IID_STR "83849a30-0d6e-11d3-bab8-00805f8a5dd7"

#define NS_IXPCTESTPARENT_IID \
  {0x83849a30, 0x0d6e, 0x11d3, \
    { 0xba, 0xb8, 0x00, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 }}

/***************************************************************************/
class NS_NO_VTABLE nsIXPCTestParent : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCTESTPARENT_IID)

  /* void method1 (in short i); */
  NS_IMETHOD Method1(PRInt16 i) = 0;

  /* void method1a (in nsIXPCTestParent foo); */
  NS_IMETHOD Method1a(nsIXPCTestParent *foo) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIXPCTESTPARENT \
  NS_IMETHOD Method1(PRInt16 i); \
  NS_IMETHOD Method1a(nsIXPCTestParent *foo); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIXPCTESTPARENT(_to) \
  NS_IMETHOD Method1(PRInt16 i) { return _to Method1(i); } \
  NS_IMETHOD Method1a(nsIXPCTestParent *foo) { return _to Method1a(foo); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIXPCTESTPARENT(_to) \
  NS_IMETHOD Method1(PRInt16 i) { return !_to ? NS_ERROR_NULL_POINTER : _to->Method1(i); } \
  NS_IMETHOD Method1a(nsIXPCTestParent *foo) { return !_to ? NS_ERROR_NULL_POINTER : _to->Method1a(foo); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsXPCTestParent : public nsIXPCTestParent
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIXPCTESTPARENT

  nsXPCTestParent();
  virtual ~nsXPCTestParent();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsXPCTestParent, nsIXPCTestParent)

nsXPCTestParent::nsXPCTestParent()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsXPCTestParent::~nsXPCTestParent()
{
  /* destructor code */
}

/* void method1 (in short i); */
NS_IMETHODIMP nsXPCTestParent::Method1(PRInt16 i)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void method1a (in nsIXPCTestParent foo); */
NS_IMETHODIMP nsXPCTestParent::Method1a(nsIXPCTestParent *foo)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIXPCTestChild */
#define NS_IXPCTESTCHILD_IID_STR "9ddf0f00-0d6e-11d3-bab8-00805f8a5dd7"

#define NS_IXPCTESTCHILD_IID \
  {0x9ddf0f00, 0x0d6e, 0x11d3, \
    { 0xba, 0xb8, 0x00, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 }}

class NS_NO_VTABLE nsIXPCTestChild : public nsIXPCTestParent {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCTESTCHILD_IID)

  /* void method2 (in short i, in short j); */
  NS_IMETHOD Method2(PRInt16 i, PRInt16 j) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIXPCTESTCHILD \
  NS_IMETHOD Method2(PRInt16 i, PRInt16 j); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIXPCTESTCHILD(_to) \
  NS_IMETHOD Method2(PRInt16 i, PRInt16 j) { return _to Method2(i, j); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIXPCTESTCHILD(_to) \
  NS_IMETHOD Method2(PRInt16 i, PRInt16 j) { return !_to ? NS_ERROR_NULL_POINTER : _to->Method2(i, j); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsXPCTestChild : public nsIXPCTestChild
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIXPCTESTCHILD

  nsXPCTestChild();
  virtual ~nsXPCTestChild();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsXPCTestChild, nsIXPCTestChild)

nsXPCTestChild::nsXPCTestChild()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsXPCTestChild::~nsXPCTestChild()
{
  /* destructor code */
}

/* void method2 (in short i, in short j); */
NS_IMETHODIMP nsXPCTestChild::Method2(PRInt16 i, PRInt16 j)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIXPCTestOther */
#define NS_IXPCTESTOTHER_IID_STR "7bca65e0-0d73-11d3-bab8-00805f8a5dd7"

#define NS_IXPCTESTOTHER_IID \
  {0x7bca65e0, 0x0d73, 0x11d3, \
    { 0xba, 0xb8, 0x00, 0x80, 0x5f, 0x8a, 0x5d, 0xd7 }}

class NS_NO_VTABLE nsIXPCTestOther : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCTESTOTHER_IID)

  /* void method3 (in short i, in short j, in short k); */
  NS_IMETHOD Method3(PRInt16 i, PRInt16 j, PRInt16 k) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIXPCTESTOTHER \
  NS_IMETHOD Method3(PRInt16 i, PRInt16 j, PRInt16 k); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIXPCTESTOTHER(_to) \
  NS_IMETHOD Method3(PRInt16 i, PRInt16 j, PRInt16 k) { return _to Method3(i, j, k); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIXPCTESTOTHER(_to) \
  NS_IMETHOD Method3(PRInt16 i, PRInt16 j, PRInt16 k) { return !_to ? NS_ERROR_NULL_POINTER : _to->Method3(i, j, k); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsXPCTestOther : public nsIXPCTestOther
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIXPCTESTOTHER

  nsXPCTestOther();
  virtual ~nsXPCTestOther();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsXPCTestOther, nsIXPCTestOther)

nsXPCTestOther::nsXPCTestOther()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsXPCTestOther::~nsXPCTestOther()
{
  /* destructor code */
}

/* void method3 (in short i, in short j, in short k); */
NS_IMETHODIMP nsXPCTestOther::Method3(PRInt16 i, PRInt16 j, PRInt16 k)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIXPCTestNoisy */
#define NS_IXPCTESTNOISY_IID_STR "1e4cf7b0-237a-11d3-9879-006008962422"

#define NS_IXPCTESTNOISY_IID \
  {0x1e4cf7b0, 0x237a, 0x11d3, \
    { 0x98, 0x79, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}

class NS_NO_VTABLE nsIXPCTestNoisy : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCTESTNOISY_IID)

  /* void squawk (); */
  NS_IMETHOD Squawk(void) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIXPCTESTNOISY \
  NS_IMETHOD Squawk(void); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIXPCTESTNOISY(_to) \
  NS_IMETHOD Squawk(void) { return _to Squawk(); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIXPCTESTNOISY(_to) \
  NS_IMETHOD Squawk(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->Squawk(); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsXPCTestNoisy : public nsIXPCTestNoisy
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIXPCTESTNOISY

  nsXPCTestNoisy();
  virtual ~nsXPCTestNoisy();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsXPCTestNoisy, nsIXPCTestNoisy)

nsXPCTestNoisy::nsXPCTestNoisy()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsXPCTestNoisy::~nsXPCTestNoisy()
{
  /* destructor code */
}

/* void squawk (); */
NS_IMETHODIMP nsXPCTestNoisy::Squawk()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIXPCTestString */
#define NS_IXPCTESTSTRING_IID_STR "d970e910-30d8-11d3-9885-006008962422"

#define NS_IXPCTESTSTRING_IID \
  {0xd970e910, 0x30d8, 0x11d3, \
    { 0x98, 0x85, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}

class NS_NO_VTABLE nsIXPCTestString : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCTESTSTRING_IID)

  /* string GetStringA (); */
  NS_IMETHOD GetStringA(char **_retval) = 0;

  /* void GetStringB (out string s); */
  NS_IMETHOD GetStringB(char **s) = 0;

  /* void GetStringC ([shared, retval] out string s); */
  NS_IMETHOD GetStringC(const char **s) = 0;

  /* void GetWStringCopied ([retval] out wstring s); */
  NS_IMETHOD GetWStringCopied(PRUnichar **s) = 0;

  /* void GetWStringShared ([shared, retval] out wstring s); */
  NS_IMETHOD GetWStringShared(const PRUnichar **s) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIXPCTESTSTRING \
  NS_IMETHOD GetStringA(char **_retval); \
  NS_IMETHOD GetStringB(char **s); \
  NS_IMETHOD GetStringC(const char **s); \
  NS_IMETHOD GetWStringCopied(PRUnichar **s); \
  NS_IMETHOD GetWStringShared(const PRUnichar **s); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIXPCTESTSTRING(_to) \
  NS_IMETHOD GetStringA(char **_retval) { return _to GetStringA(_retval); } \
  NS_IMETHOD GetStringB(char **s) { return _to GetStringB(s); } \
  NS_IMETHOD GetStringC(const char **s) { return _to GetStringC(s); } \
  NS_IMETHOD GetWStringCopied(PRUnichar **s) { return _to GetWStringCopied(s); } \
  NS_IMETHOD GetWStringShared(const PRUnichar **s) { return _to GetWStringShared(s); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIXPCTESTSTRING(_to) \
  NS_IMETHOD GetStringA(char **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStringA(_retval); } \
  NS_IMETHOD GetStringB(char **s) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStringB(s); } \
  NS_IMETHOD GetStringC(const char **s) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStringC(s); } \
  NS_IMETHOD GetWStringCopied(PRUnichar **s) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWStringCopied(s); } \
  NS_IMETHOD GetWStringShared(const PRUnichar **s) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWStringShared(s); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsXPCTestString : public nsIXPCTestString
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIXPCTESTSTRING

  nsXPCTestString();
  virtual ~nsXPCTestString();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsXPCTestString, nsIXPCTestString)

nsXPCTestString::nsXPCTestString()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsXPCTestString::~nsXPCTestString()
{
  /* destructor code */
}

/* string GetStringA (); */
NS_IMETHODIMP nsXPCTestString::GetStringA(char **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void GetStringB (out string s); */
NS_IMETHODIMP nsXPCTestString::GetStringB(char **s)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void GetStringC ([shared, retval] out string s); */
NS_IMETHODIMP nsXPCTestString::GetStringC(const char **s)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void GetWStringCopied ([retval] out wstring s); */
NS_IMETHODIMP nsXPCTestString::GetWStringCopied(PRUnichar **s)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void GetWStringShared ([shared, retval] out wstring s); */
NS_IMETHODIMP nsXPCTestString::GetWStringShared(const PRUnichar **s)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIXPCTestOverloaded */
#define NS_IXPCTESTOVERLOADED_IID_STR "0ff4faf0-439a-11d3-988c-006008962422"

#define NS_IXPCTESTOVERLOADED_IID \
  {0x0ff4faf0, 0x439a, 0x11d3, \
    { 0x98, 0x8c, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}

class NS_NO_VTABLE nsIXPCTestOverloaded : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCTESTOVERLOADED_IID)

  /* void Foo1 (in PRInt32 p1); */
  NS_IMETHOD Foo1(PRInt32 p1) = 0;

  /* void Foo2 (in PRInt32 p1, in PRInt32 p2); */
  NS_IMETHOD Foo2(PRInt32 p1, PRInt32 p2) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIXPCTESTOVERLOADED \
  NS_IMETHOD Foo1(PRInt32 p1); \
  NS_IMETHOD Foo2(PRInt32 p1, PRInt32 p2); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIXPCTESTOVERLOADED(_to) \
  NS_IMETHOD Foo1(PRInt32 p1) { return _to Foo1(p1); } \
  NS_IMETHOD Foo2(PRInt32 p1, PRInt32 p2) { return _to Foo2(p1, p2); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIXPCTESTOVERLOADED(_to) \
  NS_IMETHOD Foo1(PRInt32 p1) { return !_to ? NS_ERROR_NULL_POINTER : _to->Foo1(p1); } \
  NS_IMETHOD Foo2(PRInt32 p1, PRInt32 p2) { return !_to ? NS_ERROR_NULL_POINTER : _to->Foo2(p1, p2); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsXPCTestOverloaded : public nsIXPCTestOverloaded
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIXPCTESTOVERLOADED

  nsXPCTestOverloaded();
  virtual ~nsXPCTestOverloaded();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsXPCTestOverloaded, nsIXPCTestOverloaded)

nsXPCTestOverloaded::nsXPCTestOverloaded()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsXPCTestOverloaded::~nsXPCTestOverloaded()
{
  /* destructor code */
}

/* void Foo1 (in PRInt32 p1); */
NS_IMETHODIMP nsXPCTestOverloaded::Foo1(PRInt32 p1)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void Foo2 (in PRInt32 p1, in PRInt32 p2); */
NS_IMETHODIMP nsXPCTestOverloaded::Foo2(PRInt32 p1, PRInt32 p2)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIXPCTestArray */
#define NS_IXPCTESTARRAY_IID_STR "3d2e64b0-6552-11d3-989e-006008962422"

#define NS_IXPCTESTARRAY_IID \
  {0x3d2e64b0, 0x6552, 0x11d3, \
    { 0x98, 0x9e, 0x00, 0x60, 0x08, 0x96, 0x24, 0x22 }}

class NS_NO_VTABLE nsIXPCTestArray : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IXPCTESTARRAY_IID)

  /* void SetReceiver (in nsIXPCTestArray aReceiver); */
  NS_IMETHOD SetReceiver(nsIXPCTestArray *aReceiver) = 0;

  /* void PrintIntegerArray (in PRUint32 count, [array, size_is (count)] in PRInt32 valueArray); */
  NS_IMETHOD PrintIntegerArray(PRUint32 count, PRInt32 *valueArray) = 0;

  /* void PrintStringArray (in PRUint32 count, [array, size_is (count)] in string valueArray); */
  NS_IMETHOD PrintStringArray(PRUint32 count, const char **valueArray) = 0;

  /* void MultiplyEachItemInIntegerArray (in PRInt32 val, in PRUint32 count, [array, size_is (count)] inout PRInt32 valueArray); */
  NS_IMETHOD MultiplyEachItemInIntegerArray(PRInt32 val, PRUint32 count, PRInt32 **valueArray) = 0;

  /* void MultiplyEachItemInIntegerArrayAndAppend (in PRInt32 val, inout PRUint32 count, [array, size_is (count)] inout PRInt32 valueArray); */
  NS_IMETHOD MultiplyEachItemInIntegerArrayAndAppend(PRInt32 val, PRUint32 *count, PRInt32 **valueArray) = 0;

  /* void CallEchoMethodOnEachInArray (inout nsIIDPtr uuid, inout PRUint32 count, [array, size_is (count), iid_is (uuid)] inout nsQIResult result); */
  NS_IMETHOD CallEchoMethodOnEachInArray(nsIID * *uuid, PRUint32 *count, void * **result) = 0;

  /* void CallEchoMethodOnEachInArray2 (inout PRUint32 count, [array, size_is (count)] inout nsIEcho result); */
  NS_IMETHOD CallEchoMethodOnEachInArray2(PRUint32 *count, nsIEcho ***result) = 0;

  /* void DoubleStringArray (inout PRUint32 count, [array, size_is (count)] inout string valueArray); */
  NS_IMETHOD DoubleStringArray(PRUint32 *count, char ***valueArray) = 0;

  /* void ReverseStringArray (in PRUint32 count, [array, size_is (count)] inout string valueArray); */
  NS_IMETHOD ReverseStringArray(PRUint32 count, char ***valueArray) = 0;

  /* void PrintStringWithSize (in PRUint32 count, [size_is (count)] in string str); */
  NS_IMETHOD PrintStringWithSize(PRUint32 count, const char *str) = 0;

  /* void DoubleString (inout PRUint32 count, [size_is (count)] inout string str); */
  NS_IMETHOD DoubleString(PRUint32 *count, char **str) = 0;

  /* void GetStrings (out PRUint32 count, [array, size_is (count), retval] out string str); */
  NS_IMETHOD GetStrings(PRUint32 *count, char ***str) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIXPCTESTARRAY \
  NS_IMETHOD SetReceiver(nsIXPCTestArray *aReceiver); \
  NS_IMETHOD PrintIntegerArray(PRUint32 count, PRInt32 *valueArray); \
  NS_IMETHOD PrintStringArray(PRUint32 count, const char **valueArray); \
  NS_IMETHOD MultiplyEachItemInIntegerArray(PRInt32 val, PRUint32 count, PRInt32 **valueArray); \
  NS_IMETHOD MultiplyEachItemInIntegerArrayAndAppend(PRInt32 val, PRUint32 *count, PRInt32 **valueArray); \
  NS_IMETHOD CallEchoMethodOnEachInArray(nsIID * *uuid, PRUint32 *count, void * **result); \
  NS_IMETHOD CallEchoMethodOnEachInArray2(PRUint32 *count, nsIEcho ***result); \
  NS_IMETHOD DoubleStringArray(PRUint32 *count, char ***valueArray); \
  NS_IMETHOD ReverseStringArray(PRUint32 count, char ***valueArray); \
  NS_IMETHOD PrintStringWithSize(PRUint32 count, const char *str); \
  NS_IMETHOD DoubleString(PRUint32 *count, char **str); \
  NS_IMETHOD GetStrings(PRUint32 *count, char ***str); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIXPCTESTARRAY(_to) \
  NS_IMETHOD SetReceiver(nsIXPCTestArray *aReceiver) { return _to SetReceiver(aReceiver); } \
  NS_IMETHOD PrintIntegerArray(PRUint32 count, PRInt32 *valueArray) { return _to PrintIntegerArray(count, valueArray); } \
  NS_IMETHOD PrintStringArray(PRUint32 count, const char **valueArray) { return _to PrintStringArray(count, valueArray); } \
  NS_IMETHOD MultiplyEachItemInIntegerArray(PRInt32 val, PRUint32 count, PRInt32 **valueArray) { return _to MultiplyEachItemInIntegerArray(val, count, valueArray); } \
  NS_IMETHOD MultiplyEachItemInIntegerArrayAndAppend(PRInt32 val, PRUint32 *count, PRInt32 **valueArray) { return _to MultiplyEachItemInIntegerArrayAndAppend(val, count, valueArray); } \
  NS_IMETHOD CallEchoMethodOnEachInArray(nsIID * *uuid, PRUint32 *count, void * **result) { return _to CallEchoMethodOnEachInArray(uuid, count, result); } \
  NS_IMETHOD CallEchoMethodOnEachInArray2(PRUint32 *count, nsIEcho ***result) { return _to CallEchoMethodOnEachInArray2(count, result); } \
  NS_IMETHOD DoubleStringArray(PRUint32 *count, char ***valueArray) { return _to DoubleStringArray(count, valueArray); } \
  NS_IMETHOD ReverseStringArray(PRUint32 count, char ***valueArray) { return _to ReverseStringArray(count, valueArray); } \
  NS_IMETHOD PrintStringWithSize(PRUint32 count, const char *str) { return _to PrintStringWithSize(count, str); } \
  NS_IMETHOD DoubleString(PRUint32 *count, char **str) { return _to DoubleString(count, str); } \
  NS_IMETHOD GetStrings(PRUint32 *count, char ***str) { return _to GetStrings(count, str); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIXPCTESTARRAY(_to) \
  NS_IMETHOD SetReceiver(nsIXPCTestArray *aReceiver) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetReceiver(aReceiver); } \
  NS_IMETHOD PrintIntegerArray(PRUint32 count, PRInt32 *valueArray) { return !_to ? NS_ERROR_NULL_POINTER : _to->PrintIntegerArray(count, valueArray); } \
  NS_IMETHOD PrintStringArray(PRUint32 count, const char **valueArray) { return !_to ? NS_ERROR_NULL_POINTER : _to->PrintStringArray(count, valueArray); } \
  NS_IMETHOD MultiplyEachItemInIntegerArray(PRInt32 val, PRUint32 count, PRInt32 **valueArray) { return !_to ? NS_ERROR_NULL_POINTER : _to->MultiplyEachItemInIntegerArray(val, count, valueArray); } \
  NS_IMETHOD MultiplyEachItemInIntegerArrayAndAppend(PRInt32 val, PRUint32 *count, PRInt32 **valueArray) { return !_to ? NS_ERROR_NULL_POINTER : _to->MultiplyEachItemInIntegerArrayAndAppend(val, count, valueArray); } \
  NS_IMETHOD CallEchoMethodOnEachInArray(nsIID * *uuid, PRUint32 *count, void * **result) { return !_to ? NS_ERROR_NULL_POINTER : _to->CallEchoMethodOnEachInArray(uuid, count, result); } \
  NS_IMETHOD CallEchoMethodOnEachInArray2(PRUint32 *count, nsIEcho ***result) { return !_to ? NS_ERROR_NULL_POINTER : _to->CallEchoMethodOnEachInArray2(count, result); } \
  NS_IMETHOD DoubleStringArray(PRUint32 *count, char ***valueArray) { return !_to ? NS_ERROR_NULL_POINTER : _to->DoubleStringArray(count, valueArray); } \
  NS_IMETHOD ReverseStringArray(PRUint32 count, char ***valueArray) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReverseStringArray(count, valueArray); } \
  NS_IMETHOD PrintStringWithSize(PRUint32 count, const char *str) { return !_to ? NS_ERROR_NULL_POINTER : _to->PrintStringWithSize(count, str); } \
  NS_IMETHOD DoubleString(PRUint32 *count, char **str) { return !_to ? NS_ERROR_NULL_POINTER : _to->DoubleString(count, str); } \
  NS_IMETHOD GetStrings(PRUint32 *count, char ***str) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetStrings(count, str); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsXPCTestArray : public nsIXPCTestArray
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIXPCTESTARRAY

  nsXPCTestArray();
  virtual ~nsXPCTestArray();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsXPCTestArray, nsIXPCTestArray)

nsXPCTestArray::nsXPCTestArray()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsXPCTestArray::~nsXPCTestArray()
{
  /* destructor code */
}

/* void SetReceiver (in nsIXPCTestArray aReceiver); */
NS_IMETHODIMP nsXPCTestArray::SetReceiver(nsIXPCTestArray *aReceiver)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void PrintIntegerArray (in PRUint32 count, [array, size_is (count)] in PRInt32 valueArray); */
NS_IMETHODIMP nsXPCTestArray::PrintIntegerArray(PRUint32 count, PRInt32 *valueArray)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void PrintStringArray (in PRUint32 count, [array, size_is (count)] in string valueArray); */
NS_IMETHODIMP nsXPCTestArray::PrintStringArray(PRUint32 count, const char **valueArray)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void MultiplyEachItemInIntegerArray (in PRInt32 val, in PRUint32 count, [array, size_is (count)] inout PRInt32 valueArray); */
NS_IMETHODIMP nsXPCTestArray::MultiplyEachItemInIntegerArray(PRInt32 val, PRUint32 count, PRInt32 **valueArray)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void MultiplyEachItemInIntegerArrayAndAppend (in PRInt32 val, inout PRUint32 count, [array, size_is (count)] inout PRInt32 valueArray); */
NS_IMETHODIMP nsXPCTestArray::MultiplyEachItemInIntegerArrayAndAppend(PRInt32 val, PRUint32 *count, PRInt32 **valueArray)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void CallEchoMethodOnEachInArray (inout nsIIDPtr uuid, inout PRUint32 count, [array, size_is (count), iid_is (uuid)] inout nsQIResult result); */
NS_IMETHODIMP nsXPCTestArray::CallEchoMethodOnEachInArray(nsIID * *uuid, PRUint32 *count, void * **result)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void CallEchoMethodOnEachInArray2 (inout PRUint32 count, [array, size_is (count)] inout nsIEcho result); */
NS_IMETHODIMP nsXPCTestArray::CallEchoMethodOnEachInArray2(PRUint32 *count, nsIEcho ***result)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void DoubleStringArray (inout PRUint32 count, [array, size_is (count)] inout string valueArray); */
NS_IMETHODIMP nsXPCTestArray::DoubleStringArray(PRUint32 *count, char ***valueArray)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void ReverseStringArray (in PRUint32 count, [array, size_is (count)] inout string valueArray); */
NS_IMETHODIMP nsXPCTestArray::ReverseStringArray(PRUint32 count, char ***valueArray)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void PrintStringWithSize (in PRUint32 count, [size_is (count)] in string str); */
NS_IMETHODIMP nsXPCTestArray::PrintStringWithSize(PRUint32 count, const char *str)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void DoubleString (inout PRUint32 count, [size_is (count)] inout string str); */
NS_IMETHODIMP nsXPCTestArray::DoubleString(PRUint32 *count, char **str)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* void GetStrings (out PRUint32 count, [array, size_is (count), retval] out string str); */
NS_IMETHODIMP nsXPCTestArray::GetStrings(PRUint32 *count, char ***str)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIWrappedJSObjectTest */
#define NS_IWRAPPEDJSOBJECTTEST_IID_STR "13082da0-643c-11d4-8fe0-0010a4e73d9a"

#define NS_IWRAPPEDJSOBJECTTEST_IID \
  {0x13082da0, 0x643c, 0x11d4, \
    { 0x8f, 0xe0, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}

class NS_NO_VTABLE nsIWrappedJSObjectTest : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IWRAPPEDJSOBJECTTEST_IID)

  /* void interfaceMember (); */
  NS_IMETHOD InterfaceMember(void) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIWRAPPEDJSOBJECTTEST \
  NS_IMETHOD InterfaceMember(void); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIWRAPPEDJSOBJECTTEST(_to) \
  NS_IMETHOD InterfaceMember(void) { return _to InterfaceMember(); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIWRAPPEDJSOBJECTTEST(_to) \
  NS_IMETHOD InterfaceMember(void) { return !_to ? NS_ERROR_NULL_POINTER : _to->InterfaceMember(); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsWrappedJSObjectTest : public nsIWrappedJSObjectTest
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIWRAPPEDJSOBJECTTEST

  nsWrappedJSObjectTest();
  virtual ~nsWrappedJSObjectTest();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsWrappedJSObjectTest, nsIWrappedJSObjectTest)

nsWrappedJSObjectTest::nsWrappedJSObjectTest()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsWrappedJSObjectTest::~nsWrappedJSObjectTest()
{
  /* destructor code */
}

/* void interfaceMember (); */
NS_IMETHODIMP nsWrappedJSObjectTest::InterfaceMember()
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIBogus1 */
#define NS_IBOGUS1_IID_STR "41d923d0-5bc1-11d5-90db-0010a4e73d9a"

#define NS_IBOGUS1_IID \
  {0x41d923d0, 0x5bc1, 0x11d5, \
    { 0x90, 0xdb, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}

class NS_NO_VTABLE nsIBogus1 : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IBOGUS1_IID)

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIBOGUS1 \
  /* no methods! */

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIBOGUS1(_to) \
  /* no methods! */

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIBOGUS1(_to) \
  /* no methods! */

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsBogus1 : public nsIBogus1
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIBOGUS1

  nsBogus1();
  virtual ~nsBogus1();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsBogus1, nsIBogus1)

nsBogus1::nsBogus1()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsBogus1::~nsBogus1()
{
  /* destructor code */
}

/* End of implementation class template. */
#endif


/* starting interface:    nsIBogus2 */
#define NS_IBOGUS2_IID_STR "8d8f4210-5bc1-11d5-90db-0010a4e73d9a"

#define NS_IBOGUS2_IID \
  {0x8d8f4210, 0x5bc1, 0x11d5, \
    { 0x90, 0xdb, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}

class NS_NO_VTABLE nsIBogus2 : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IBOGUS2_IID)

  /* attribute nsIBogus1 bogus; */
  NS_IMETHOD GetBogus(nsIBogus1 * *aBogus) = 0;
  NS_IMETHOD SetBogus(nsIBogus1 * aBogus) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIBOGUS2 \
  NS_IMETHOD GetBogus(nsIBogus1 * *aBogus); \
  NS_IMETHOD SetBogus(nsIBogus1 * aBogus); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIBOGUS2(_to) \
  NS_IMETHOD GetBogus(nsIBogus1 * *aBogus) { return _to GetBogus(aBogus); } \
  NS_IMETHOD SetBogus(nsIBogus1 * aBogus) { return _to SetBogus(aBogus); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIBOGUS2(_to) \
  NS_IMETHOD GetBogus(nsIBogus1 * *aBogus) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetBogus(aBogus); } \
  NS_IMETHOD SetBogus(nsIBogus1 * aBogus) { return !_to ? NS_ERROR_NULL_POINTER : _to->SetBogus(aBogus); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsBogus2 : public nsIBogus2
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSIBOGUS2

  nsBogus2();
  virtual ~nsBogus2();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsBogus2, nsIBogus2)

nsBogus2::nsBogus2()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsBogus2::~nsBogus2()
{
  /* destructor code */
}

/* attribute nsIBogus1 bogus; */
NS_IMETHODIMP nsBogus2::GetBogus(nsIBogus1 * *aBogus)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP nsBogus2::SetBogus(nsIBogus1 * aBogus)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


/* starting interface:    nsITestVariant */
#define NS_ITESTVARIANT_IID_STR "34bc9990-95af-11d5-90fc-0010a4e73d9a"

#define NS_ITESTVARIANT_IID \
  {0x34bc9990, 0x95af, 0x11d5, \
    { 0x90, 0xfc, 0x00, 0x10, 0xa4, 0xe7, 0x3d, 0x9a }}

class NS_NO_VTABLE nsITestVariant : public nsISupports {
 public: 

  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ITESTVARIANT_IID)

  /**
     * Just return the variant that was passed in.
     */
  /* nsIVariant passThruVariant (in nsIVariant value); */
  NS_IMETHOD PassThruVariant(nsIVariant *value, nsIVariant **_retval) = 0;

  /**
     * Just return the type of the passed in variant.
     */
  /* PRUint16 returnVariantType (in nsIVariant value); */
  NS_IMETHOD ReturnVariantType(nsIVariant *value, PRUint16 *_retval) = 0;

  /**
     * Construct and return a default xpcom variant instance using the
     * value of the passed in variant. Use the type of the passed in variant. 
     */
  /* nsIVariant copyVariant (in nsIVariant value); */
  NS_IMETHOD CopyVariant(nsIVariant *value, nsIVariant **_retval) = 0;

  /**
     * Construct and return a default xpcom variant instance using the
     * value of the passed in variant. Use the type as specified to get data 
     * from the passed in variant. 
     */
  /* nsIVariant copyVariantAsType (in nsIVariant value, in PRUint16 type); */
  NS_IMETHOD CopyVariantAsType(nsIVariant *value, PRUint16 type, nsIVariant **_retval) = 0;

  /**
     * Construct a default xpcom variant instance using the
     * value of the passed in variant. Use the type as specified in type1 to 
     * get data from the passed in variant. Then construct and return a default
     * xpcom variant based on that object using the type2. This allows for 
     * testing all the 'ConvertTo*' methods on the default xpcom variant class.
     */
  /* nsIVariant copyVariantAsTypeTwice (in nsIVariant value, in PRUint16 type1, in PRUint16 type2); */
  NS_IMETHOD CopyVariantAsTypeTwice(nsIVariant *value, PRUint16 type1, PRUint16 type2, nsIVariant **_retval) = 0;

  /**
     * Get a named property from object that will be QI'd to nsIPropertyBag.
     */
  /* nsIVariant getNamedProperty (in nsISupports aBag, in AString aName); */
  NS_IMETHOD GetNamedProperty(nsISupports *aBag, const nsAString & aName, nsIVariant **_retval) = 0;

  /**
     * Get a enumerator from object that will be QI'd to nsIPropertyBag.
     */
  /* nsISimpleEnumerator getEnumerator (in nsISupports aBag); */
  NS_IMETHOD GetEnumerator(nsISupports *aBag, nsISimpleEnumerator **_retval) = 0;

};

/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSITESTVARIANT \
  NS_IMETHOD PassThruVariant(nsIVariant *value, nsIVariant **_retval); \
  NS_IMETHOD ReturnVariantType(nsIVariant *value, PRUint16 *_retval); \
  NS_IMETHOD CopyVariant(nsIVariant *value, nsIVariant **_retval); \
  NS_IMETHOD CopyVariantAsType(nsIVariant *value, PRUint16 type, nsIVariant **_retval); \
  NS_IMETHOD CopyVariantAsTypeTwice(nsIVariant *value, PRUint16 type1, PRUint16 type2, nsIVariant **_retval); \
  NS_IMETHOD GetNamedProperty(nsISupports *aBag, const nsAString & aName, nsIVariant **_retval); \
  NS_IMETHOD GetEnumerator(nsISupports *aBag, nsISimpleEnumerator **_retval); 

/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSITESTVARIANT(_to) \
  NS_IMETHOD PassThruVariant(nsIVariant *value, nsIVariant **_retval) { return _to PassThruVariant(value, _retval); } \
  NS_IMETHOD ReturnVariantType(nsIVariant *value, PRUint16 *_retval) { return _to ReturnVariantType(value, _retval); } \
  NS_IMETHOD CopyVariant(nsIVariant *value, nsIVariant **_retval) { return _to CopyVariant(value, _retval); } \
  NS_IMETHOD CopyVariantAsType(nsIVariant *value, PRUint16 type, nsIVariant **_retval) { return _to CopyVariantAsType(value, type, _retval); } \
  NS_IMETHOD CopyVariantAsTypeTwice(nsIVariant *value, PRUint16 type1, PRUint16 type2, nsIVariant **_retval) { return _to CopyVariantAsTypeTwice(value, type1, type2, _retval); } \
  NS_IMETHOD GetNamedProperty(nsISupports *aBag, const nsAString & aName, nsIVariant **_retval) { return _to GetNamedProperty(aBag, aName, _retval); } \
  NS_IMETHOD GetEnumerator(nsISupports *aBag, nsISimpleEnumerator **_retval) { return _to GetEnumerator(aBag, _retval); } 

/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSITESTVARIANT(_to) \
  NS_IMETHOD PassThruVariant(nsIVariant *value, nsIVariant **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->PassThruVariant(value, _retval); } \
  NS_IMETHOD ReturnVariantType(nsIVariant *value, PRUint16 *_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->ReturnVariantType(value, _retval); } \
  NS_IMETHOD CopyVariant(nsIVariant *value, nsIVariant **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->CopyVariant(value, _retval); } \
  NS_IMETHOD CopyVariantAsType(nsIVariant *value, PRUint16 type, nsIVariant **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->CopyVariantAsType(value, type, _retval); } \
  NS_IMETHOD CopyVariantAsTypeTwice(nsIVariant *value, PRUint16 type1, PRUint16 type2, nsIVariant **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->CopyVariantAsTypeTwice(value, type1, type2, _retval); } \
  NS_IMETHOD GetNamedProperty(nsISupports *aBag, const nsAString & aName, nsIVariant **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetNamedProperty(aBag, aName, _retval); } \
  NS_IMETHOD GetEnumerator(nsISupports *aBag, nsISimpleEnumerator **_retval) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetEnumerator(aBag, _retval); } 

#if 0
/* Use the code below as a template for the implementation class for this interface. */

/* Header file */
class nsTestVariant : public nsITestVariant
{
public:
  NS_DECL_ISUPPORTS
  NS_DECL_NSITESTVARIANT

  nsTestVariant();
  virtual ~nsTestVariant();
  /* additional members */
};

/* Implementation file */
NS_IMPL_ISUPPORTS1(nsTestVariant, nsITestVariant)

nsTestVariant::nsTestVariant()
{
  NS_INIT_ISUPPORTS();
  /* member initializers and constructor code */
}

nsTestVariant::~nsTestVariant()
{
  /* destructor code */
}

/* nsIVariant passThruVariant (in nsIVariant value); */
NS_IMETHODIMP nsTestVariant::PassThruVariant(nsIVariant *value, nsIVariant **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* PRUint16 returnVariantType (in nsIVariant value); */
NS_IMETHODIMP nsTestVariant::ReturnVariantType(nsIVariant *value, PRUint16 *_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsIVariant copyVariant (in nsIVariant value); */
NS_IMETHODIMP nsTestVariant::CopyVariant(nsIVariant *value, nsIVariant **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsIVariant copyVariantAsType (in nsIVariant value, in PRUint16 type); */
NS_IMETHODIMP nsTestVariant::CopyVariantAsType(nsIVariant *value, PRUint16 type, nsIVariant **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsIVariant copyVariantAsTypeTwice (in nsIVariant value, in PRUint16 type1, in PRUint16 type2); */
NS_IMETHODIMP nsTestVariant::CopyVariantAsTypeTwice(nsIVariant *value, PRUint16 type1, PRUint16 type2, nsIVariant **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsIVariant getNamedProperty (in nsISupports aBag, in AString aName); */
NS_IMETHODIMP nsTestVariant::GetNamedProperty(nsISupports *aBag, const nsAString & aName, nsIVariant **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* nsISimpleEnumerator getEnumerator (in nsISupports aBag); */
NS_IMETHODIMP nsTestVariant::GetEnumerator(nsISupports *aBag, nsISimpleEnumerator **_retval)
{
    return NS_ERROR_NOT_IMPLEMENTED;
}

/* End of implementation class template. */
#endif


#endif /* __gen_xpctest_h__ */
