Tools/Castle.DynamicProxy2/Castle.DynamicProxy.Tests/SerializableClassTestCase.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.DynamicProxy.Tests
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.IO;
  20         using System.Reflection;
  21         using System.Runtime.Serialization;
  22         using System.Runtime.Serialization.Formatters.Binary;
  23         using System.Text.RegularExpressions;
  24         using Castle.Core.Interceptor;
  25         using Castle.DynamicProxy.Serialization;
  26         using Castle.DynamicProxy.Tests.Classes;
  27         using Castle.DynamicProxy.Tests;
  28         using Castle.DynamicProxy.Tests.BugsReported;
  29         using Castle.DynamicProxy.Tests.InterClasses;
  30         using NUnit.Framework;
  31
  32 #if !MONO
  33
  34         [TestFixture]
  35         public class SerializableClassTestCase : BasePEVerifyTestCase
  36         {
  37                 public override void Init ()
  38                 {
  39                         base.Init ();
  40                         ProxyObjectReference.ResetScope ();
  41                 }
  42
  43                 public override void TearDown ()
  44                 {
  45                         base.TearDown ();
  46                         ProxyObjectReference.ResetScope ();
  47                 }
  48
  49                 [Test]
  50                 public void CreateSerializable()
  51                 {
  52                         MySerializableClass proxy = (MySerializableClass)
  53                                                     generator.CreateClassProxy(typeof(MySerializableClass), new StandardInterceptor());
  54
  55                         Assert.IsTrue(proxy.GetType().IsSerializable);
  56                 }
  57
  58                 [Test]
  59                 public void ImplementsISerializable()
  60                 {
  61                         MySerializableClass proxy = (MySerializableClass)
  62                                                     generator.CreateClassProxy(typeof(MySerializableClass), new StandardInterceptor());
  63
  64                         Assert.IsTrue(proxy is ISerializable);
  65                 }
  66
  67                 [Test]
  68                 public void SimpleProxySerialization()
  69                 {
  70                         MySerializableClass proxy = (MySerializableClass)
  71                                                     generator.CreateClassProxy(typeof(MySerializableClass), new StandardInterceptor());
  72
  73                         DateTime current = proxy.Current;
  74
  75                         MySerializableClass otherProxy = (MySerializableClass) SerializeAndDeserialize(proxy);
  76
  77                         Assert.AreEqual(current, otherProxy.Current);
  78                 }
  79
  80                 [Test]
  81                 public void SerializationDelegate()
  82                 {
  83                         MySerializableClass2 proxy = (MySerializableClass2)
  84                                                      generator.CreateClassProxy(typeof(MySerializableClass2), new StandardInterceptor());
  85
  86                         DateTime current = proxy.Current;
  87
  88                         MySerializableClass2 otherProxy = (MySerializableClass2) SerializeAndDeserialize(proxy);
  89
  90                         Assert.AreEqual(current, otherProxy.Current);
  91                 }
  92
  93                 [Test]
  94                 public void SimpleInterfaceProxy()
  95                 {
  96                         object proxy =
  97                                 generator.CreateInterfaceProxyWithTarget(typeof(IMyInterface2), new MyInterfaceImpl(), new StandardInterceptor());
  98
  99                         Assert.IsTrue(proxy.GetType().IsSerializable);
 100
 101                         IMyInterface2 inter = (IMyInterface2) proxy;
 102
 103                         inter.Name = "opa";
 104                         Assert.AreEqual("opa", inter.Name);
 105                         inter.Started = true;
 106                         Assert.AreEqual(true, inter.Started);
 107
 108                         IMyInterface2 otherProxy = (IMyInterface2) SerializeAndDeserialize(proxy);
 109
 110                         Assert.AreEqual(inter.Name, otherProxy.Name);
 111                         Assert.AreEqual(inter.Started, otherProxy.Started);
 112                 }
 113
 114
 115                 [Test]
 116                 public void SimpleInterfaceProxy_WithoutTarget()
 117                 {
 118                         object proxy =
 119                                 generator.CreateInterfaceProxyWithoutTarget(typeof(IMyInterface2), new Type[] {typeof(IMyInterface)},
 120                                                                             new StandardInterceptor());
 121
 122                         Assert.IsTrue(proxy is IMyInterface2);
 123                         Assert.IsTrue(proxy is IMyInterface);
 124
 125
 126                         object otherProxy = SerializeAndDeserialize(proxy);
 127
 128                         Assert.IsTrue(otherProxy is IMyInterface2);
 129                         Assert.IsTrue(otherProxy is IMyInterface);
 130                 }
 131
 132                 [Test]
 133                 public void CustomMarkerInterface()
 134                 {
 135                         object proxy = generator.CreateClassProxy(typeof(ClassWithMarkerInterface),
 136                                                                   new Type[] {typeof(IMarkerInterface)},
 137                                                                   new StandardInterceptor());
 138
 139                         Assert.IsNotNull(proxy);
 140                         Assert.IsTrue(proxy is IMarkerInterface);
 141
 142                         object otherProxy = SerializeAndDeserialize(proxy);
 143
 144                         Assert.IsTrue(otherProxy is IMarkerInterface);
 145                 }
 146
 147                 [Test]
 148                 public void HashtableSerialization()
 149                 {
 150                         object proxy = generator.CreateClassProxy(
 151                                 typeof(Hashtable), new StandardInterceptor());
 152
 153                         Assert.IsTrue(typeof(Hashtable).IsAssignableFrom(proxy.GetType()));
 154
 155                         (proxy as Hashtable).Add("key", "helloooo!");
 156
 157                         Hashtable otherProxy = (Hashtable) SerializeAndDeserialize(proxy);
 158
 159                         Assert.IsTrue(otherProxy.ContainsKey("key"));
 160                         Assert.AreEqual("helloooo!", otherProxy["key"]);
 161                 }
 162
 163                 public static T SerializeAndDeserialize<T>(T proxy)
 164                 {
 165                         MemoryStream stream = new MemoryStream();
 166                         BinaryFormatter formatter = new BinaryFormatter();
 167                         formatter.Serialize(stream, proxy);
 168                         stream.Position = 0;
 169                         return (T) formatter.Deserialize(stream);
 170                 }
 171
 172                 [Serializable]
 173                 public class C
 174                 {
 175                         public int I;
 176                         public C This;
 177
 178                         public C (int i)
 179                         {
 180                                 I = i;
 181                                 This = this;
 182                         }
 183                 }
 184
 185                 [Test]
 186                 public void SerializatingObjectsWithoutDefaultConstructor ()
 187                 {
 188                         C proxy = (C) generator.CreateClassProxy (typeof (C), new IInterceptor[] { new StandardInterceptor () }, 1);
 189                         C otherProxy = (C) SerializeAndDeserialize (proxy);
 190
 191                         Assert.AreEqual (proxy.I, otherProxy.I);
 192                         Assert.AreSame (otherProxy, otherProxy.This);
 193                 }
 194
 195                 [Serializable]
 196                 public class EventHandlerClass
 197                 {
 198                         public void TestHandler (object sender, EventArgs e)
 199                         {
 200                         }
 201
 202                 }
 203
 204                 [Serializable]
 205                 public class DelegateHolder
 206                 {
 207                         public EventHandler DelegateMember;
 208                         public ArrayList ComplexTypeMember;
 209
 210                         public DelegateHolder ()
 211                         {
 212                         }
 213
 214                         public void TestHandler (object sender, EventArgs e)
 215                         {
 216                         }
 217                 }
 218
 219                 [Serializable]
 220                 public class IndirectDelegateHolder
 221                 {
 222                         public DelegateHolder DelegateHolder = new DelegateHolder();
 223
 224                         public void TestHandler (object sender, EventArgs e)
 225                         {
 226                         }
 227                 }
 228
 229                 [Test]
 230                 public void SerializeObjectsWithDelegateToOtherObject ()
 231                 {
 232                         EventHandlerClass eventHandlerInstance = new EventHandlerClass();
 233                         DelegateHolder proxy = (DelegateHolder) generator.CreateClassProxy (typeof (DelegateHolder), new IInterceptor[] {new StandardInterceptor ()});
 234
 235                         proxy.DelegateMember = new EventHandler(eventHandlerInstance.TestHandler);
 236                         proxy.ComplexTypeMember = new ArrayList (new int[] { 1, 2, 3 });
 237                         proxy.ComplexTypeMember.Add (eventHandlerInstance);
 238
 239                         Assert.IsNotNull (proxy.DelegateMember);
 240                         Assert.IsNotNull (proxy.DelegateMember.Target);
 241
 242                         Assert.IsNotNull (proxy.ComplexTypeMember);
 243                         Assert.AreEqual (4, proxy.ComplexTypeMember.Count);
 244                         Assert.AreEqual (1, proxy.ComplexTypeMember[0]);
 245                         Assert.AreEqual (2, proxy.ComplexTypeMember[1]);
 246                         Assert.AreEqual (3, proxy.ComplexTypeMember[2]);
 247                         Assert.AreSame (proxy.ComplexTypeMember[3], proxy.DelegateMember.Target);
 248
 249                         DelegateHolder otherProxy = (DelegateHolder) (SerializeAndDeserialize (proxy));
 250
 251                         Assert.IsNotNull (otherProxy.DelegateMember);
 252                         Assert.IsNotNull (otherProxy.DelegateMember.Target);
 253
 254                         Assert.IsNotNull (otherProxy.ComplexTypeMember);
 255                         Assert.AreEqual (4, otherProxy.ComplexTypeMember.Count);
 256                         Assert.AreEqual (1, otherProxy.ComplexTypeMember[0]);
 257                         Assert.AreEqual (2, otherProxy.ComplexTypeMember[1]);
 258                         Assert.AreEqual (3, otherProxy.ComplexTypeMember[2]);
 259                         Assert.AreSame (otherProxy.ComplexTypeMember[3], otherProxy.DelegateMember.Target);
 260                 }
 261
 262                 [Test]
 263                 public void SerializeObjectsWithDelegateToThisObject ()
 264                 {
 265                         DelegateHolder proxy = (DelegateHolder) generator.CreateClassProxy (typeof (DelegateHolder), new IInterceptor[] { new StandardInterceptor () });
 266
 267                         proxy.DelegateMember = new EventHandler (proxy.TestHandler);
 268                         proxy.ComplexTypeMember = new ArrayList (new int[] { 1, 2, 3 });
 269
 270                         Assert.IsNotNull (proxy.DelegateMember);
 271                         Assert.AreSame (proxy, proxy.DelegateMember.Target);
 272
 273                         Assert.IsNotNull (proxy.ComplexTypeMember);
 274                         Assert.AreEqual (3, proxy.ComplexTypeMember.Count);
 275                         Assert.AreEqual (1, proxy.ComplexTypeMember[0]);
 276                         Assert.AreEqual (2, proxy.ComplexTypeMember[1]);
 277                         Assert.AreEqual (3, proxy.ComplexTypeMember[2]);
 278
 279                         DelegateHolder otherProxy = (DelegateHolder) (SerializeAndDeserialize (proxy));
 280
 281                         Assert.IsNotNull (otherProxy.DelegateMember);
 282                         Assert.AreSame (otherProxy, otherProxy.DelegateMember.Target);
 283
 284                         Assert.IsNotNull (otherProxy.ComplexTypeMember);
 285                         Assert.AreEqual (3, otherProxy.ComplexTypeMember.Count);
 286                         Assert.AreEqual (1, otherProxy.ComplexTypeMember[0]);
 287                         Assert.AreEqual (2, otherProxy.ComplexTypeMember[1]);
 288                         Assert.AreEqual (3, otherProxy.ComplexTypeMember[2]);
 289                 }
 290
 291                 [Test]
 292                 public void SerializeObjectsWithIndirectDelegateToThisObject ()
 293                 {
 294                         IndirectDelegateHolder proxy = (IndirectDelegateHolder) generator.CreateClassProxy (typeof (IndirectDelegateHolder),
 295                                 new IInterceptor[] { new StandardInterceptor () });
 296
 297                         proxy.DelegateHolder.DelegateMember = new EventHandler (proxy.TestHandler);
 298                         proxy.DelegateHolder.ComplexTypeMember = new ArrayList (new int[] { 1, 2, 3 });
 299
 300                         Assert.IsNotNull (proxy.DelegateHolder.DelegateMember);
 301                         Assert.AreSame (proxy, proxy.DelegateHolder.DelegateMember.Target);
 302
 303                         Assert.IsNotNull (proxy.DelegateHolder.ComplexTypeMember);
 304                         Assert.AreEqual (3, proxy.DelegateHolder.ComplexTypeMember.Count);
 305                         Assert.AreEqual (1, proxy.DelegateHolder.ComplexTypeMember[0]);
 306                         Assert.AreEqual (2, proxy.DelegateHolder.ComplexTypeMember[1]);
 307                         Assert.AreEqual (3, proxy.DelegateHolder.ComplexTypeMember[2]);
 308
 309                         IndirectDelegateHolder otherProxy = (IndirectDelegateHolder) (SerializeAndDeserialize (proxy));
 310
 311                         Assert.IsNotNull (otherProxy.DelegateHolder.DelegateMember);
 312                         Assert.AreSame (otherProxy, otherProxy.DelegateHolder.DelegateMember.Target);
 313
 314                         Assert.IsNotNull (otherProxy.DelegateHolder.ComplexTypeMember);
 315                         Assert.AreEqual (3, otherProxy.DelegateHolder.ComplexTypeMember.Count);
 316                         Assert.AreEqual (1, otherProxy.DelegateHolder.ComplexTypeMember[0]);
 317                         Assert.AreEqual (2, otherProxy.DelegateHolder.ComplexTypeMember[1]);
 318                         Assert.AreEqual (3, otherProxy.DelegateHolder.ComplexTypeMember[2]);
 319                 }
 320
 321                 [Test]
 322                 public void SerializeObjectsWithIndirectDelegateToMember ()
 323                 {
 324                         IndirectDelegateHolder proxy = (IndirectDelegateHolder) generator.CreateClassProxy (typeof (IndirectDelegateHolder),
 325                                 new IInterceptor[] { new StandardInterceptor () });
 326
 327                         proxy.DelegateHolder.DelegateMember = new EventHandler (proxy.DelegateHolder.TestHandler);
 328                         proxy.DelegateHolder.ComplexTypeMember = new ArrayList (new int[] { 1, 2, 3 });
 329
 330                         Assert.IsNotNull (proxy.DelegateHolder.DelegateMember);
 331                         Assert.AreSame (proxy.DelegateHolder, proxy.DelegateHolder.DelegateMember.Target);
 332
 333                         Assert.IsNotNull (proxy.DelegateHolder.ComplexTypeMember);
 334                         Assert.AreEqual (3, proxy.DelegateHolder.ComplexTypeMember.Count);
 335                         Assert.AreEqual (1, proxy.DelegateHolder.ComplexTypeMember[0]);
 336                         Assert.AreEqual (2, proxy.DelegateHolder.ComplexTypeMember[1]);
 337                         Assert.AreEqual (3, proxy.DelegateHolder.ComplexTypeMember[2]);
 338
 339                         IndirectDelegateHolder otherProxy = (IndirectDelegateHolder) (SerializeAndDeserialize (proxy));
 340
 341                         Assert.IsNotNull (otherProxy.DelegateHolder.DelegateMember);
 342                         Assert.AreSame (otherProxy.DelegateHolder, otherProxy.DelegateHolder.DelegateMember.Target);
 343
 344                         Assert.IsNotNull (otherProxy.DelegateHolder.ComplexTypeMember);
 345                         Assert.AreEqual (3, otherProxy.DelegateHolder.ComplexTypeMember.Count);
 346                         Assert.AreEqual (1, otherProxy.DelegateHolder.ComplexTypeMember[0]);
 347                         Assert.AreEqual (2, otherProxy.DelegateHolder.ComplexTypeMember[1]);
 348                         Assert.AreEqual (3, otherProxy.DelegateHolder.ComplexTypeMember[2]);
 349                 }
 350
 351                 [Serializable]
 352                 public class ClassWithIndirectSelfReference
 353                 {
 354                         public ArrayList List = new ArrayList();
 355
 356                         public ClassWithIndirectSelfReference()
 357                         {
 358                                 List.Add (this);
 359                         }
 360                 }
 361
 362                 [Test]
 363                 public void SerializeClassWithIndirectSelfReference ()
 364                 {
 365                         ClassWithIndirectSelfReference proxy = (ClassWithIndirectSelfReference) generator.CreateClassProxy (typeof (ClassWithIndirectSelfReference),
 366                                 new Type[0], new StandardInterceptor ());
 367                         Assert.AreSame (proxy, proxy.List[0]);
 368
 369                         ClassWithIndirectSelfReference otherProxy = (ClassWithIndirectSelfReference) SerializeAndDeserialize (proxy);
 370                         Assert.AreSame (otherProxy, otherProxy.List[0]);
 371                 }
 372
 373                 [Serializable]
 374                 public class ClassWithDirectAndIndirectSelfReference
 375                 {
 376                         public ClassWithDirectAndIndirectSelfReference This;
 377                         public ArrayList List = new ArrayList();
 378
 379                         public ClassWithDirectAndIndirectSelfReference ()
 380                         {
 381                                 This = this;
 382                                 List.Add (this);
 383                         }
 384                 }
 385
 386                 [Test]
 387                 public void SerializeClassWithDirectAndIndirectSelfReference ()
 388                 {
 389                         ClassWithDirectAndIndirectSelfReference proxy = (ClassWithDirectAndIndirectSelfReference) generator.CreateClassProxy (typeof (ClassWithDirectAndIndirectSelfReference),
 390                                 new Type[0], new StandardInterceptor ());
 391                         Assert.AreSame (proxy, proxy.This);
 392
 393                         ClassWithDirectAndIndirectSelfReference otherProxy = (ClassWithDirectAndIndirectSelfReference) SerializeAndDeserialize (proxy);
 394                         Assert.AreSame (otherProxy, otherProxy.List[0]);
 395                         Assert.AreSame (otherProxy, otherProxy.This);
 396                 }
 397
 398                                 [Test]
 399                 public void ProxyKnowsItsGenerationOptions ()
 400                 {
 401                         MethodFilterHook hook = new MethodFilterHook (".*");
 402                         ProxyGenerationOptions options = new ProxyGenerationOptions (hook);
 403                         options.AddMixinInstance (new SerializableMixin ());
 404
 405                         object proxy = generator.CreateClassProxy (
 406                                         typeof (MySerializableClass),
 407                                         new Type[0],
 408                                         options,
 409                                         new StandardInterceptor ());
 410
 411                         FieldInfo field = proxy.GetType ().GetField ("proxyGenerationOptions");
 412                         Assert.IsNotNull (field);
 413                         Assert.AreSame (options, field.GetValue (proxy));
 414
 415                         base.Init ();
 416
 417                         proxy = generator.CreateInterfaceProxyWithoutTarget (typeof (IService), new StandardInterceptor ());
 418                         field = proxy.GetType ().GetField ("proxyGenerationOptions");
 419                         Assert.AreSame (ProxyGenerationOptions.Default, field.GetValue (proxy));
 420
 421                         base.Init ();
 422
 423                         proxy = generator.CreateInterfaceProxyWithTarget (typeof (IService), new ServiceImpl(), options, new StandardInterceptor ());
 424                         field = proxy.GetType ().GetField ("proxyGenerationOptions");
 425                         Assert.AreSame (options, field.GetValue (proxy));
 426
 427                         base.Init ();
 428
 429                         proxy = generator.CreateInterfaceProxyWithTargetInterface (typeof (IService), new ServiceImpl(), new StandardInterceptor ());
 430                         field = proxy.GetType ().GetField ("proxyGenerationOptions");
 431                         Assert.AreSame (ProxyGenerationOptions.Default, field.GetValue (proxy));
 432                 }
 433
 434                 [Serializable]
 435                 class MethodFilterHook : IProxyGenerationHook
 436                 {
 437                         private string nameFilter;
 438
 439                         public MethodFilterHook (string nameFilter)
 440                         {
 441                                 this.nameFilter = nameFilter;
 442                         }
 443
 444                         public bool ShouldInterceptMethod (Type type, MethodInfo memberInfo)
 445                         {
 446                                 return Regex.IsMatch (memberInfo.Name, nameFilter);
 447                         }
 448
 449                         public void NonVirtualMemberNotification (Type type, MemberInfo memberInfo)
 450                         {
 451                         }
 452
 453                         public void MethodsInspected ()
 454                         {
 455                         }
 456                 }
 457
 458                 public interface IMixedInterface
 459                 {
 460                 }
 461
 462                 [Serializable]
 463                 public class SerializableMixin : IMixedInterface
 464                 {
 465                 }
 466
 467                 [Serializable]
 468                 public class SerializableInterceptorSelector : IInterceptorSelector
 469                 {
 470                         public IInterceptor[] SelectInterceptors (Type type, MethodInfo method, IInterceptor[] interceptors)
 471                         {
 472                                 return interceptors;
 473                         }
 474                 }
 475
 476                 [Test]
 477                 public void ProxyGenerationOptionsRespectedOnDeserialization ()
 478                 {
 479                         MethodFilterHook hook = new MethodFilterHook ("get_Current");
 480                         ProxyGenerationOptions options = new ProxyGenerationOptions (hook);
 481                         options.AddMixinInstance (new SerializableMixin());
 482                         options.Selector = new SerializableInterceptorSelector ();
 483
 484                         MySerializableClass proxy = (MySerializableClass) generator.CreateClassProxy (
 485                             typeof (MySerializableClass),
 486                             new Type[0],
 487                             options,
 488                             new StandardInterceptor());
 489
 490                         Assert.AreEqual (proxy.GetType(), proxy.GetType().GetMethod ("get_Current").DeclaringType);
 491                         Assert.AreNotEqual (proxy.GetType(), proxy.GetType().GetMethod ("CalculateSumDistanceNow").DeclaringType);
 492                         Assert.AreEqual (proxy.GetType().BaseType, proxy.GetType().GetMethod ("CalculateSumDistanceNow").DeclaringType);
 493                         ProxyGenerationOptions options2 = (ProxyGenerationOptions) proxy.GetType().GetField("proxyGenerationOptions").GetValue(null);
 494                         Assert.IsNotNull (Array.Find (options2.MixinsAsArray (), delegate (object o) { return o is SerializableMixin; }));
 495                         Assert.IsNotNull (options2.Selector);
 496
 497                         MySerializableClass otherProxy = (MySerializableClass) SerializeAndDeserialize (proxy);
 498                         Assert.AreEqual (otherProxy.GetType(), otherProxy.GetType().GetMethod ("get_Current").DeclaringType);
 499                         Assert.AreNotEqual (otherProxy.GetType(), otherProxy.GetType().GetMethod ("CalculateSumDistanceNow").DeclaringType);
 500                         Assert.AreEqual (otherProxy.GetType().BaseType, otherProxy.GetType().GetMethod ("CalculateSumDistanceNow").DeclaringType);
 501                         options2 = (ProxyGenerationOptions) otherProxy.GetType ().GetField ("proxyGenerationOptions").GetValue (null);
 502                         Assert.IsNotNull (Array.Find (options2.MixinsAsArray (), delegate (object o) { return o is SerializableMixin; }));
 503                         Assert.IsNotNull (options2.Selector);
 504                 }
 505
 506                 [Test]
 507                 [Ignore ("Checks serialization with mixins, un-ignore when these are implemented.")]
 508                 public void MixinsAppliedOnDeserialization ()
 509                 {
 510                         ProxyGenerationOptions options = new ProxyGenerationOptions ();
 511                         options.AddMixinInstance (new SerializableMixin ());
 512
 513                         MySerializableClass proxy = (MySerializableClass) generator.CreateClassProxy (
 514                                         typeof (MySerializableClass),
 515                                         new Type[0],
 516                                         options,
 517                                         new StandardInterceptor ());
 518
 519                         Assert.IsTrue (proxy is IMixedInterface);
 520
 521                         MySerializableClass otherProxy = (MySerializableClass) SerializeAndDeserialize (proxy);
 522                         Assert.IsTrue (otherProxy is IMixedInterface);
 523                 }
 524
 525                 [Serializable]
 526                 class ComplexHolder
 527                 {
 528                         public Type Type;
 529                         public object Element;
 530                 }
 531
 532                 // With naive serialization of ProxyGenerationOptions, the following test case fails due to problems with the order of deserialization:
 533                 // in ProxyObjectReference, the deserialized ProxyGenerationOptions will only contain null and default values. ProxyGenerationOptions must
 534                 // avoid serializing Type objects in order for this test case to pass.
 535                 [Test]
 536                 public void ProxyGenerationOptionsRespectedOnDeserializationComplex ()
 537                 {
 538                         MethodFilterHook hook = new MethodFilterHook ("get_Current");
 539                         ProxyGenerationOptions options = new ProxyGenerationOptions (hook);
 540                         options.AddMixinInstance (new SerializableMixin());
 541                         options.Selector = new SerializableInterceptorSelector ();
 542
 543                         ComplexHolder holder = new ComplexHolder();
 544                         holder.Type = typeof (MySerializableClass);
 545                         holder.Element = generator.CreateClassProxy (typeof (MySerializableClass), new Type[0], options, new StandardInterceptor ());
 546
 547                         // check holder elements
 548                         Assert.AreEqual (typeof (MySerializableClass), holder.Type);
 549                         Assert.IsNotNull (holder.Element);
 550                         Assert.IsTrue (holder.Element is MySerializableClass) ;
 551                         Assert.AreNotEqual (typeof (MySerializableClass), holder.Element.GetType ());
 552
 553                         // check whether options were applied correctly
 554                         Assert.AreEqual (holder.Element.GetType (), holder.Element.GetType ().GetMethod ("get_Current").DeclaringType);
 555                         Assert.AreNotEqual (holder.Element.GetType (), holder.Element.GetType ().GetMethod ("CalculateSumDistanceNow").DeclaringType);
 556                         Assert.AreEqual (holder.Element.GetType ().BaseType, holder.Element.GetType ().GetMethod ("CalculateSumDistanceNow").DeclaringType);
 557                         ProxyGenerationOptions options2 = (ProxyGenerationOptions) holder.Element.GetType ().GetField ("proxyGenerationOptions").GetValue (null);
 558                         Assert.IsNotNull (Array.Find (options2.MixinsAsArray (), delegate (object o) { return o is SerializableMixin; }));
 559                         Assert.IsNotNull (options2.Selector);
 560
 561                         ComplexHolder otherHolder = (ComplexHolder) SerializeAndDeserialize (holder);
 562
 563                         // check holder elements
 564                         Assert.AreEqual (typeof (MySerializableClass), otherHolder.Type);
 565                         Assert.IsNotNull (otherHolder.Element);
 566                         Assert.IsTrue (otherHolder.Element is MySerializableClass);
 567                         Assert.AreNotEqual(typeof (MySerializableClass), otherHolder.Element.GetType());
 568
 569                         // check whether options were applied correctly
 570                         Assert.AreEqual (otherHolder.Element.GetType (), otherHolder.Element.GetType ().GetMethod ("get_Current").DeclaringType);
 571                         Assert.AreNotEqual (otherHolder.Element.GetType (), otherHolder.Element.GetType ().GetMethod ("CalculateSumDistanceNow").DeclaringType);
 572                         Assert.AreEqual (otherHolder.Element.GetType ().BaseType, otherHolder.Element.GetType ().GetMethod ("CalculateSumDistanceNow").DeclaringType);
 573                         options2 = (ProxyGenerationOptions) otherHolder.Element.GetType ().GetField ("proxyGenerationOptions").GetValue (null);
 574                         Assert.IsNotNull (Array.Find (options2.MixinsAsArray (), delegate (object o) { return o is SerializableMixin; }));
 575                         Assert.IsNotNull (options2.Selector);
 576                 }
 577
 578                 [Test]
 579                 public void ReusingModuleScopeFromProxyObjectReference ()
 580                 {
 581                         ProxyGenerator generatorWithSpecificModuleScope = new ProxyGenerator (new DefaultProxyBuilder (ProxyObjectReference.ModuleScope));
 582                         Assert.AreSame (generatorWithSpecificModuleScope.ProxyBuilder.ModuleScope, ProxyObjectReference.ModuleScope);
 583                         MySerializableClass first = generatorWithSpecificModuleScope.CreateClassProxy<MySerializableClass> (new StandardInterceptor ());
 584                         MySerializableClass second = SerializeAndDeserialize (first);
 585                         Assert.AreSame (first.GetType (), second.GetType ());
 586                 }
 587
 588                 [Test]
 589                 public void DeserializationWithSpecificModuleScope ()
 590                 {
 591                         ProxyObjectReference.SetScope (generator.ProxyBuilder.ModuleScope);
 592                         MySerializableClass first = generator.CreateClassProxy<MySerializableClass> (new StandardInterceptor ());
 593                         MySerializableClass second = SerializeAndDeserialize (first);
 594                         Assert.AreSame (first.GetType (), second.GetType ());
 595                 }
 596         }
 597
 598 #endif
 599 }