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