579 lines
18 KiB
C#
579 lines
18 KiB
C#
//
|
|
// System.Runtime.Remoting.RemotingServices NUnit V2.0 test class
|
|
//
|
|
// Author Jean-Marc ANDRE (jean-marc.andre@polymtl.ca)
|
|
//
|
|
// ToDo: I didn't write test functions for the method not yep
|
|
// implemented by Mono
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using NUnit.Framework;
|
|
using System.Reflection;
|
|
using System.Runtime.Remoting;
|
|
using System.Threading;
|
|
using System.Runtime.Remoting.Activation;
|
|
using System.Runtime.Remoting.Messaging;
|
|
using System.Runtime.Remoting.Proxies;
|
|
using System.Runtime.Remoting.Channels;
|
|
using System.Runtime.Remoting.Channels.Tcp;
|
|
|
|
namespace MonoTests.System.Runtime.Remoting.RemotingServicesInternal
|
|
{
|
|
// We need our own proxy to intercept messages to remote object
|
|
// and forward them using RemotingServices.ExecuteMessage
|
|
public class MyProxy : RealProxy
|
|
{
|
|
MarshalByRefObject target;
|
|
IMessageSink _sink;
|
|
MethodBase _mthBase;
|
|
bool methodOverloaded = false;
|
|
|
|
public MethodBase MthBase {
|
|
get { return _mthBase; }
|
|
}
|
|
|
|
public bool IsMethodOverloaded {
|
|
get { return methodOverloaded; }
|
|
}
|
|
|
|
public MyProxy (Type serverType, MarshalByRefObject target)
|
|
: base (serverType)
|
|
{
|
|
this.target = target;
|
|
|
|
IChannel [] registeredChannels = ChannelServices.RegisteredChannels;
|
|
string ObjectURI;
|
|
|
|
// A new IMessageSink chain has to be created
|
|
// since the RemotingServices.GetEnvoyChainForProxy() is not yet
|
|
// implemented.
|
|
foreach (IChannel channel in registeredChannels) {
|
|
IChannelSender channelSender = channel as IChannelSender;
|
|
if (channelSender != null) {
|
|
_sink = (IMessageSink) channelSender.CreateMessageSink (RemotingServices.GetObjectUri (target), null, out ObjectURI);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Messages will be intercepted here and redirected
|
|
// to another object.
|
|
public override IMessage Invoke (IMessage msg)
|
|
{
|
|
try {
|
|
if (msg is IConstructionCallMessage) {
|
|
IActivator remActivator = (IActivator) RemotingServices.Connect (typeof (IActivator), "tcp://localhost:1234/RemoteActivationService.rem");
|
|
IConstructionReturnMessage crm = remActivator.Activate ((IConstructionCallMessage) msg);
|
|
return crm;
|
|
} else {
|
|
methodOverloaded = RemotingServices.IsMethodOverloaded ((IMethodMessage) msg);
|
|
|
|
_mthBase = RemotingServices.GetMethodBaseFromMethodMessage ((IMethodMessage) msg);
|
|
MethodCallMessageWrapper mcm = new MethodCallMessageWrapper ((IMethodCallMessage) msg);
|
|
mcm.Uri = RemotingServices.GetObjectUri ((MarshalByRefObject) target);
|
|
MarshalByRefObject objRem = (MarshalByRefObject) Activator.CreateInstance (GetProxiedType ());
|
|
RemotingServices.ExecuteMessage ((MarshalByRefObject) objRem, (IMethodCallMessage) msg);
|
|
IMessage rtnMsg = null;
|
|
|
|
try {
|
|
rtnMsg = _sink.SyncProcessMessage (msg);
|
|
} catch (Exception e) {
|
|
Console.WriteLine (e.Message);
|
|
}
|
|
|
|
Console.WriteLine ("RR:" + rtnMsg);
|
|
return rtnMsg;
|
|
}
|
|
} catch (Exception ex) {
|
|
Console.WriteLine (ex);
|
|
return null;
|
|
}
|
|
}
|
|
} // end MyProxy
|
|
|
|
// This class is used to create "CAO"
|
|
public class MarshalObjectFactory : MarshalByRefObject
|
|
{
|
|
public MarshalObject GetNewMarshalObject ()
|
|
{
|
|
return new MarshalObject ();
|
|
}
|
|
}
|
|
|
|
// A class used by the tests
|
|
public class MarshalObject : ContextBoundObject
|
|
{
|
|
public MarshalObject ()
|
|
{
|
|
|
|
}
|
|
|
|
public MarshalObject (int id, string uri)
|
|
{
|
|
this.id = id;
|
|
this.uri = uri;
|
|
}
|
|
|
|
public int Id {
|
|
get { return id; }
|
|
set { id = value; }
|
|
}
|
|
|
|
public string Uri {
|
|
get { return uri; }
|
|
}
|
|
|
|
public void Method1 ()
|
|
{
|
|
_called++;
|
|
methodOneWay = RemotingServices.IsOneWay (MethodBase.GetCurrentMethod ());
|
|
}
|
|
|
|
public void Method2 ()
|
|
{
|
|
methodOneWay = RemotingServices.IsOneWay (MethodBase.GetCurrentMethod ());
|
|
}
|
|
|
|
public void Method2 (int i)
|
|
{
|
|
methodOneWay = RemotingServices.IsOneWay (MethodBase.GetCurrentMethod ());
|
|
}
|
|
|
|
[OneWay ()]
|
|
public void Method3 ()
|
|
{
|
|
methodOneWay = RemotingServices.IsOneWay (MethodBase.GetCurrentMethod ());
|
|
}
|
|
|
|
public static int Called {
|
|
get { return _called; }
|
|
}
|
|
|
|
public static bool IsMethodOneWay {
|
|
get { return methodOneWay; }
|
|
}
|
|
|
|
private static int _called;
|
|
private int id = 0;
|
|
private string uri;
|
|
private static bool methodOneWay = false;
|
|
}
|
|
|
|
// Another class used by the tests
|
|
public class DerivedMarshalObject : MarshalObject
|
|
{
|
|
public DerivedMarshalObject () { }
|
|
|
|
public DerivedMarshalObject (int id, string uri) : base (id, uri) { }
|
|
}
|
|
|
|
interface A
|
|
{
|
|
}
|
|
|
|
interface B : A
|
|
{
|
|
}
|
|
|
|
public class CC : MarshalByRefObject
|
|
{
|
|
}
|
|
|
|
public class DD : MarshalByRefObject
|
|
{
|
|
}
|
|
|
|
|
|
} // namespace MonoTests.System.Runtime.Remoting.RemotingServicesInternal
|
|
|
|
namespace MonoTests.Remoting
|
|
{
|
|
using MonoTests.System.Runtime.Remoting.RemotingServicesInternal;
|
|
|
|
// The main test class
|
|
[TestFixture]
|
|
public class RemotingServicesTest : Assertion
|
|
{
|
|
private static int MarshalObjectId = 0;
|
|
|
|
public RemotingServicesTest ()
|
|
{
|
|
MarshalObjectId = 0;
|
|
}
|
|
|
|
// Helper function that create a new
|
|
// MarshalObject with an unique ID
|
|
private static MarshalObject NewMarshalObject ()
|
|
{
|
|
string uri = "MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject" + MarshalObjectId.ToString ();
|
|
MarshalObject objMarshal = new MarshalObject (MarshalObjectId, uri);
|
|
|
|
MarshalObjectId++;
|
|
|
|
return objMarshal;
|
|
}
|
|
|
|
// Another helper function
|
|
private DerivedMarshalObject NewDerivedMarshalObject ()
|
|
{
|
|
string uri = "MonoTests.System.Runtime.Remoting.RemotingServicesTest.DerivedMarshalObject" + MarshalObjectId.ToString ();
|
|
DerivedMarshalObject objMarshal = new DerivedMarshalObject (MarshalObjectId, uri);
|
|
|
|
MarshalObjectId++;
|
|
|
|
return objMarshal;
|
|
}
|
|
|
|
// The two folling method test RemotingServices.Marshal()
|
|
[Test]
|
|
public void Marshal1 ()
|
|
{
|
|
|
|
MarshalObject objMarshal = NewMarshalObject ();
|
|
ObjRef objRef = RemotingServices.Marshal (objMarshal);
|
|
|
|
Assert ("#A01", objRef.URI != null);
|
|
|
|
MarshalObject objRem = (MarshalObject) RemotingServices.Unmarshal (objRef);
|
|
AssertEquals ("#A02", objMarshal.Id, objRem.Id);
|
|
|
|
objRem.Id = 2;
|
|
AssertEquals ("#A03", objMarshal.Id, objRem.Id);
|
|
|
|
// TODO: uncomment when RemotingServices.Disconnect is implemented
|
|
//RemotingServices.Disconnect(objMarshal);
|
|
|
|
objMarshal = NewMarshalObject ();
|
|
|
|
objRef = RemotingServices.Marshal (objMarshal, objMarshal.Uri);
|
|
|
|
Assert ("#A04", objRef.URI.EndsWith (objMarshal.Uri));
|
|
// TODO: uncomment when RemotingServices.Disconnect is implemented
|
|
//RemotingServices.Disconnect(objMarshal);
|
|
}
|
|
|
|
[Test]
|
|
public void Marshal2 ()
|
|
{
|
|
DerivedMarshalObject derivedObjMarshal = NewDerivedMarshalObject ();
|
|
|
|
ObjRef objRef = RemotingServices.Marshal (derivedObjMarshal, derivedObjMarshal.Uri, typeof (MarshalObject));
|
|
|
|
// Check that the type of the marshaled object is MarshalObject
|
|
Assert ("#A05", objRef.TypeInfo.TypeName.StartsWith ((typeof (MarshalObject)).ToString ()));
|
|
|
|
// TODO: uncomment when RemotingServices.Disconnect is implemented
|
|
//RemotingServices.Disconnect(derivedObjMarshal);
|
|
}
|
|
|
|
// Tests RemotingServices.GetObjectUri()
|
|
[Test]
|
|
public void GetObjectUri ()
|
|
{
|
|
MarshalObject objMarshal = NewMarshalObject ();
|
|
|
|
Assert ("#A06", RemotingServices.GetObjectUri (objMarshal) == null);
|
|
|
|
RemotingServices.Marshal (objMarshal);
|
|
|
|
Assert ("#A07", RemotingServices.GetObjectUri (objMarshal) != null);
|
|
// TODO: uncomment when RemotingServices.Disconnect is implemented
|
|
//RemotingServices.Disconnect(objMarshal);
|
|
}
|
|
|
|
// Tests RemotingServices.Connect
|
|
[Test]
|
|
public void Connect ()
|
|
{
|
|
MarshalObject objMarshal = NewMarshalObject ();
|
|
|
|
IDictionary props = new Hashtable ();
|
|
props ["name"] = objMarshal.Uri;
|
|
props ["port"] = 1236;
|
|
TcpChannel chn = new TcpChannel (props, null, null);
|
|
ChannelServices.RegisterChannel (chn);
|
|
|
|
try {
|
|
RemotingServices.Marshal (objMarshal, objMarshal.Uri);
|
|
MarshalObject objRem = (MarshalObject) RemotingServices.Connect (typeof (MarshalObject), "tcp://localhost:1236/" + objMarshal.Uri);
|
|
Assert ("#A08", RemotingServices.IsTransparentProxy (objRem));
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
RemotingServices.Disconnect (objMarshal);
|
|
}
|
|
}
|
|
|
|
// Tests RemotingServices.Marshal()
|
|
[Test]
|
|
public void MarshalThrowException ()
|
|
{
|
|
MarshalObject objMarshal = NewMarshalObject ();
|
|
|
|
IDictionary props = new Hashtable ();
|
|
props ["name"] = objMarshal.Uri;
|
|
props ["port"] = 1237;
|
|
TcpChannel chn = new TcpChannel (props, null, null);
|
|
ChannelServices.RegisterChannel (chn);
|
|
|
|
try {
|
|
RemotingServices.Marshal (objMarshal, objMarshal.Uri);
|
|
MarshalObject objRem = (MarshalObject) RemotingServices.Connect (typeof (MarshalObject), "tcp://localhost:1237/" + objMarshal.Uri);
|
|
// This line should throw a RemotingException
|
|
// It is forbidden to export an object which is not
|
|
// a real object
|
|
try {
|
|
RemotingServices.Marshal (objRem, objMarshal.Uri);
|
|
Fail ("#1");
|
|
} catch (RemotingException e) {
|
|
}
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
|
|
// TODO: uncomment when RemotingServices.Disconnect is implemented
|
|
//RemotingServices.Disconnect(objMarshal);
|
|
}
|
|
}
|
|
|
|
// Tests RemotingServices.ExecuteMessage()
|
|
// also tests GetMethodBaseFromMessage()
|
|
// IsMethodOverloaded()
|
|
[Test]
|
|
public void ExecuteMessage ()
|
|
{
|
|
TcpChannel chn = new TcpChannel (1235);
|
|
ChannelServices.RegisterChannel (chn);
|
|
try {
|
|
MarshalObject objMarshal = NewMarshalObject ();
|
|
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), objMarshal.Uri, WellKnownObjectMode.SingleCall);
|
|
|
|
// use a proxy to catch the Message
|
|
MyProxy proxy = new MyProxy (typeof (MarshalObject), (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1235/" + objMarshal.Uri));
|
|
|
|
MarshalObject objRem = (MarshalObject) proxy.GetTransparentProxy ();
|
|
|
|
objRem.Method1 ();
|
|
|
|
// Tests RemotingServices.GetMethodBaseFromMethodMessage()
|
|
AssertEquals ("#A09", "Method1", proxy.MthBase.Name);
|
|
Assert ("#A09.1", !proxy.IsMethodOverloaded);
|
|
|
|
objRem.Method2 ();
|
|
Assert ("#A09.2", proxy.IsMethodOverloaded);
|
|
|
|
// Tests RemotingServices.ExecuteMessage();
|
|
// If ExecuteMessage does it job well, Method1 should be called 2 times
|
|
AssertEquals ("#A10", 2, MarshalObject.Called);
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
}
|
|
}
|
|
|
|
// Tests the IsOneWay method
|
|
[Test]
|
|
public void IsOneWay ()
|
|
{
|
|
TcpChannel chn = new TcpChannel (1238);
|
|
ChannelServices.RegisterChannel (chn);
|
|
try {
|
|
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "MarshalObject.rem", WellKnownObjectMode.Singleton);
|
|
|
|
MarshalObject objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1238/MarshalObject.rem");
|
|
|
|
Assert ("#A10.1", RemotingServices.IsTransparentProxy (objRem));
|
|
|
|
objRem.Method1 ();
|
|
Thread.Sleep (20);
|
|
Assert ("#A10.2", !MarshalObject.IsMethodOneWay);
|
|
objRem.Method3 ();
|
|
Thread.Sleep (20);
|
|
Assert ("#A10.3", MarshalObject.IsMethodOneWay);
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void GetObjRefForProxy ()
|
|
{
|
|
TcpChannel chn = new TcpChannel (1239);
|
|
ChannelServices.RegisterChannel (chn);
|
|
try {
|
|
// Register le factory as a SAO
|
|
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObjectFactory), "MonoTests.System.Runtime.Remoting.RemotingServicesTest.Factory.soap", WellKnownObjectMode.Singleton);
|
|
|
|
MarshalObjectFactory objFactory = (MarshalObjectFactory) Activator.GetObject (typeof (MarshalObjectFactory), "tcp://localhost:1239/MonoTests.System.Runtime.Remoting.RemotingServicesTest.Factory.soap");
|
|
|
|
// Get a new "CAO"
|
|
MarshalObject objRem = objFactory.GetNewMarshalObject ();
|
|
|
|
ObjRef objRefRem = RemotingServices.GetObjRefForProxy ((MarshalByRefObject) objRem);
|
|
|
|
Assert ("#A11", objRefRem != null);
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
}
|
|
}
|
|
|
|
// Tests GetRealProxy
|
|
[Test]
|
|
public void GetRealProxy ()
|
|
{
|
|
TcpChannel chn = new TcpChannel (1241);
|
|
ChannelServices.RegisterChannel (chn);
|
|
try {
|
|
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject.soap", WellKnownObjectMode.Singleton);
|
|
|
|
MyProxy proxy = new MyProxy (typeof (MarshalObject), (MarshalByRefObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1241/MonoTests.System.Runtime.Remoting.RemotingServicesTest.MarshalObject.soap"));
|
|
MarshalObject objRem = (MarshalObject) proxy.GetTransparentProxy ();
|
|
|
|
RealProxy rp = RemotingServices.GetRealProxy (objRem);
|
|
|
|
Assert ("#A12", rp != null);
|
|
AssertEquals ("#A13", "MonoTests.System.Runtime.Remoting.RemotingServicesInternal.MyProxy", rp.GetType ().ToString ());
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
}
|
|
}
|
|
|
|
// Tests SetObjectUriForMarshal()
|
|
[Test]
|
|
public void SetObjectUriForMarshal ()
|
|
{
|
|
TcpChannel chn = new TcpChannel (1242);
|
|
ChannelServices.RegisterChannel (chn);
|
|
try {
|
|
MarshalObject objRem = NewMarshalObject ();
|
|
RemotingServices.SetObjectUriForMarshal (objRem, objRem.Uri);
|
|
RemotingServices.Marshal (objRem);
|
|
|
|
objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1242/" + objRem.Uri);
|
|
Assert ("#A14", objRem != null);
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
}
|
|
|
|
}
|
|
|
|
// Tests GetServeurTypeForUri()
|
|
[Test]
|
|
public void GetServeurTypeForUri ()
|
|
{
|
|
TcpChannel chn = new TcpChannel (1243);
|
|
Type type = typeof (MarshalObject);
|
|
ChannelServices.RegisterChannel (chn);
|
|
try {
|
|
MarshalObject objRem = NewMarshalObject ();
|
|
RemotingServices.SetObjectUriForMarshal (objRem, objRem.Uri);
|
|
RemotingServices.Marshal (objRem);
|
|
|
|
Type typeRem = RemotingServices.GetServerTypeForUri (RemotingServices.GetObjectUri (objRem));
|
|
AssertEquals ("#A15", type, typeRem);
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
}
|
|
}
|
|
|
|
// Tests IsObjectOutOfDomain
|
|
// Tests IsObjectOutOfContext
|
|
[Test]
|
|
[Category ("NotWorking")]
|
|
public void IsObjectOutOf ()
|
|
{
|
|
TcpChannel chn = new TcpChannel (1245);
|
|
ChannelServices.RegisterChannel (chn);
|
|
try {
|
|
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "MarshalObject2.rem", WellKnownObjectMode.Singleton);
|
|
|
|
MarshalObject objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1245/MarshalObject2.rem");
|
|
|
|
Assert ("#A16", RemotingServices.IsObjectOutOfAppDomain (objRem));
|
|
Assert ("#A17", RemotingServices.IsObjectOutOfContext (objRem));
|
|
|
|
MarshalObject objMarshal = new MarshalObject ();
|
|
Assert ("#A18", !RemotingServices.IsObjectOutOfAppDomain (objMarshal));
|
|
Assert ("#A19", !RemotingServices.IsObjectOutOfContext (objMarshal));
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void ApplicationNameTest ()
|
|
{
|
|
RemotingConfiguration.ApplicationName = "app";
|
|
TcpChannel chn = new TcpChannel (1246);
|
|
ChannelServices.RegisterChannel (chn);
|
|
try {
|
|
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "obj3.rem", WellKnownObjectMode.Singleton);
|
|
|
|
MarshalObject objRem = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1246/app/obj3.rem");
|
|
MarshalObject objRem2 = (MarshalObject) Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1246/obj3.rem");
|
|
|
|
Assert ("#AN1", RemotingServices.IsTransparentProxy (objRem));
|
|
Assert ("#AN2", RemotingServices.IsTransparentProxy (objRem2));
|
|
|
|
AssertNotNull ("#AN3", RemotingServices.GetServerTypeForUri ("obj3.rem"));
|
|
AssertNotNull ("#AN4", RemotingServices.GetServerTypeForUri ("/app/obj3.rem"));
|
|
AssertNull ("#AN5", RemotingServices.GetServerTypeForUri ("//app/obj3.rem"));
|
|
AssertNull ("#AN6", RemotingServices.GetServerTypeForUri ("app/obj3.rem"));
|
|
AssertNull ("#AN7", RemotingServices.GetServerTypeForUri ("/whatever/obj3.rem"));
|
|
AssertNotNull ("#AN8", RemotingServices.GetServerTypeForUri ("/obj3.rem"));
|
|
AssertNull ("#AN9", RemotingServices.GetServerTypeForUri ("//obj3.rem"));
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void GetObjectWithChannelDataTest ()
|
|
{
|
|
TcpChannel chn = new TcpChannel (1247);
|
|
ChannelServices.RegisterChannel (chn);
|
|
try {
|
|
RemotingConfiguration.RegisterWellKnownServiceType (typeof (MarshalObject), "getobjectwithchanneldata.rem", WellKnownObjectMode.Singleton);
|
|
|
|
string channelData = "test";
|
|
AssertNotNull ("#01", Activator.GetObject (typeof (MarshalObject), "tcp://localhost:1247/getobjectwithchanneldata.rem", channelData));
|
|
} finally {
|
|
ChannelServices.UnregisterChannel (chn);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[Ignore ("We cannot test RemotingConfiguration.Configure() because it keeps channels registered. If we really need to test it, do it as a standalone case")]
|
|
public void ConnectProxyCast ()
|
|
{
|
|
object o;
|
|
RemotingConfiguration.Configure (null);
|
|
|
|
o = RemotingServices.Connect (typeof (MarshalByRefObject), "tcp://localhost:3434/ff1.rem");
|
|
Assert ("#m1", o is DD);
|
|
Assert ("#m2", o is A);
|
|
Assert ("#m3", o is B);
|
|
Assert ("#m4", !(o is CC));
|
|
|
|
o = RemotingServices.Connect (typeof (A), "tcp://localhost:3434/ff3.rem");
|
|
Assert ("#a1", o is DD);
|
|
Assert ("#a2", o is A);
|
|
Assert ("#a3", o is B);
|
|
Assert ("#a4", !(o is CC));
|
|
|
|
o = RemotingServices.Connect (typeof (DD), "tcp://localhost:3434/ff4.rem");
|
|
Assert ("#d1", o is DD);
|
|
Assert ("#d2", o is A);
|
|
Assert ("#d3", o is B);
|
|
Assert ("#d4", !(o is CC));
|
|
|
|
o = RemotingServices.Connect (typeof (CC), "tcp://localhost:3434/ff5.rem");
|
|
Assert ("#c1", !(o is DD));
|
|
Assert ("#c2", o is A);
|
|
Assert ("#c3", o is B);
|
|
Assert ("#c4", o is CC);
|
|
}
|
|
// Don't add any tests that must create channels
|
|
// after ConnectProxyCast (), because this test calls
|
|
// RemotingConfiguration.Configure ().
|
|
} // end class RemotingServicesTest
|
|
} // end of namespace MonoTests.Remoting
|