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

   1 // Copyright 2004-2008 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.Runtime.CompilerServices;
  16
  17 [assembly :
  18         InternalsVisibleTo(
  19                 "DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7"
  20                 )]
  21
  22 namespace Castle.DynamicProxy.Tests
  23 {
  24         using System;
  25         using System.Collections.Generic;
  26         using System.Data;
  27         using System.Runtime.InteropServices;
  28         using Castle.Core.Interceptor;
  29         using Castle.DynamicProxy.Tests.Interceptors;
  30         using NUnit.Framework;
  31
  32 #if !MONO
  33
  34         [TestFixture]
  35         public class RhinoMocksTestCase : BasePEVerifyTestCase
  36         {
  37                 [Test]
  38                 public void GenericClassWithGenericMethod()
  39                 {
  40                         LogInvocationInterceptor logger = new LogInvocationInterceptor();
  41                         IDoubleGeneric<int> proxy =
  42                                 (IDoubleGeneric<int>) generator.CreateInterfaceProxyWithTarget(typeof(IDoubleGeneric<int>),
  43                                                                                                new DoubleGenericImpl<int>(), logger);
  44                         proxy.Call<string>(1, "");
  45                         Assert.AreEqual("Call", logger.Invocations[0]);
  46                 }
  47
  48                 [Test]
  49                 public void GenericClassWithGenericMethodWitoutTarget()
  50                 {
  51                         BasicInterfaceProxyWithoutTargetTestCase.ReturnThreeInterceptor interceptor =
  52                                 new BasicInterfaceProxyWithoutTargetTestCase.ReturnThreeInterceptor();
  53                         IDoubleGeneric<int> proxy =
  54                                 (IDoubleGeneric<int>) generator.CreateInterfaceProxyWithoutTarget(typeof(IDoubleGeneric<int>),
  55                                                                                                   interceptor);
  56                         object o = proxy.Call<string>(1, "");
  57                         Assert.AreEqual(3, o);
  58                 }
  59
  60                 [Test]
  61                 public void UsingEvents_Interface()
  62                 {
  63                         LogInvocationInterceptor logger = new LogInvocationInterceptor();
  64
  65                         IWithEvents proxy = (IWithEvents) generator.CreateInterfaceProxyWithTarget(typeof(IWithEvents),
  66                                                                                                    new FakeWithEvents(),
  67                                                                                                    logger);
  68
  69                         Assert.IsNotNull(proxy);
  70
  71                         proxy.Foo += null;
  72                         proxy.Foo -= null;
  73
  74                         Assert.AreEqual(2, logger.Invocations.Count);
  75                 }
  76
  77                 [Test]
  78                 public void UsingEvents_Class()
  79                 {
  80                         LogInvocationInterceptor logger = new LogInvocationInterceptor();
  81                         FakeWithEvents proxy = (FakeWithEvents) generator.CreateClassProxy(
  82                                                                         typeof(FakeWithEvents),
  83                                                                         ProxyGenerationOptions.Default,
  84                                                                         logger);
  85
  86                         Assert.IsNotNull(proxy);
  87
  88                         proxy.Foo += null;
  89                         proxy.Foo -= null;
  90
  91                         Assert.AreEqual(2, logger.Invocations.Count);
  92                 }
  93
  94                 [Test, Ignore("I dont think the effort to fix this edge case is worthwhile")]
  95                 public void NeedingToCreateNewMethodTableSlot()
  96                 {
  97                         generator.CreateClassProxy(typeof(MultiClass), new Type[] {typeof(ISpecialMulti)});
  98                 }
  99
 100                 [Test]
 101                 public void ProxyingInterfaceWithGuid()
 102                 {
 103                         object o = generator.CreateInterfaceProxyWithoutTarget(typeof(IWithGuid), new StandardInterceptor());
 104                         Assert.IsNotNull(o);
 105                 }
 106
 107                 [Test]
 108                 public void ProxyingInternalInterface()
 109                 {
 110                         object o = generator.CreateInterfaceProxyWithoutTarget(typeof(IFoo), new StandardInterceptor());
 111                         Assert.IsNotNull(o);
 112                 }
 113
 114                 [Test]
 115                 public void CanProxyDataSet()
 116                 {
 117                         generator.CreateClassProxy(typeof(DataSet), new Type[0], new StandardInterceptor());
 118                 }
 119
 120                 [Test]
 121                 public void ProxyingComInteraces()
 122                 {
 123                         object o = generator
 124                                 .CreateInterfaceProxyWithoutTarget(typeof(IComServiceProvider), new StandardInterceptor());
 125                         Assert.IsNotNull(o);
 126                 }
 127
 128                 [Test]
 129                 public void ProxyingGenericClassWithGenericClassConstraint()
 130                 {
 131                         object o = generator
 132                                 .CreateInterfaceProxyWithoutTarget(typeof(IFactory2), new StandardInterceptor());
 133                         Assert.IsNotNull(o);
 134                 }
 135
 136
 137                 [Test]
 138                 public void CanGetCorrectValuesFromIntPtr()
 139                 {
 140                         IFooWithIntPtr o = (IFooWithIntPtr)generator
 141                                 .CreateInterfaceProxyWithoutTarget(typeof(IFooWithIntPtr), new IntPtrInterceptor());
 142                         IntPtr buffer = o.Buffer(15);
 143                         Assert.AreEqual(IntPtr.Zero, buffer);
 144                 }
 145
 146                 [Test]
 147                 public void ProxyInternalMethod()
 148                 {
 149                         LogInvocationInterceptor logging = new LogInvocationInterceptor();
 150                         WithInternalMethod o = (WithInternalMethod) generator.CreateClassProxy(typeof(WithInternalMethod),
 151                                                                                                new Type[0], logging);
 152                         o.Foo();
 153                         Assert.AreEqual("Foo ", logging.LogContents);
 154                 }
 155
 156                 [Test]
 157                 public void ProxyingProtectedInternalAbstractMethod()
 158                 {
 159                         LogInvocationInterceptor logging = new LogInvocationInterceptor();
 160                         SomeClassWithProtectedInternalAbstractClass o =
 161                                 (SomeClassWithProtectedInternalAbstractClass)
 162                                 generator.CreateClassProxy(typeof(SomeClassWithProtectedInternalAbstractClass),
 163                                                            new Type[0], logging);
 164                         Assert.IsNotNull(o);
 165                 }
 166
 167                 [Test]
 168                 public void VirtualMethodCallsFromTheConstructor()
 169                 {
 170                         LogInvocationInterceptor logging = new LogInvocationInterceptor();
 171                         MakeVirtualCallFromCtor o = (MakeVirtualCallFromCtor) generator.CreateClassProxy(typeof(MakeVirtualCallFromCtor),
 172                                                                                                          new Type[0], logging);
 173                         Assert.AreEqual(1, logging.Invocations.Count);
 174                         Assert.IsNotNull(o);
 175                 }
 176
 177                 [Test]
 178                 public void InternalClassWithInternalMethodAndProperty()
 179                 {
 180                         LogInvocationInterceptor logging = new LogInvocationInterceptor();
 181                         InternalClassWithInternalMembers o =
 182                                 (InternalClassWithInternalMembers) generator.CreateClassProxy(typeof(InternalClassWithInternalMembers),
 183                                                                                               new Type[0], logging);
 184                         Assert.IsNotNull(o);
 185                         o.TestMethod();
 186                         Assert.AreEqual(1, logging.Invocations.Count);
 187                         string t = o.TestProperty;
 188                         Assert.AreEqual(2, logging.Invocations.Count);
 189                 }
 190
 191         [Test]
 192         public void CanProxyMethodWithOutIntPtrParamter()
 193         {
 194             IFooWithOutIntPtr o =
 195                 (IFooWithOutIntPtr)generator.CreateInterfaceProxyWithoutTarget(typeof(IFooWithOutIntPtr),
 196                                                                               new Type[0], new SkipCallingMethodInterceptorWithOutputParams());
 197             Assert.IsNotNull(o);
 198             IntPtr i;
 199             o.Bar(out i);
 200         }
 201
 202
 203         public class SkipCallingMethodInterceptorWithOutputParams : IInterceptor
 204         {
 205             public void Intercept(IInvocation invocation)
 206             {
 207                 invocation.Arguments[0] = IntPtr.Zero;
 208                 invocation.ReturnValue = 5;
 209             }
 210         }
 211
 212                 public interface IWithEvents
 213                 {
 214                         event EventHandler Foo;
 215                 }
 216
 217                 public class FakeWithEvents : IWithEvents
 218                 {
 219                         public virtual event EventHandler Foo;
 220
 221                         public void MethodToGetAroundFooNotUsedError()
 222                         {
 223                                 Foo(this, EventArgs.Empty);
 224                         }
 225                 }
 226
 227                 public interface IMulti
 228                 {
 229                         void OriginalMethod1();
 230                         void OriginalMethod2();
 231                 }
 232
 233                 public class MultiClass : IMulti
 234                 {
 235                         // NON-virtual method
 236                         public void OriginalMethod1()
 237                         {
 238                         }
 239
 240                         // VIRTUAL method
 241                         public virtual void OriginalMethod2()
 242                         {
 243                         }
 244                 }
 245
 246                 public interface ISpecialMulti : IMulti
 247                 {
 248                         void ExtraMethod();
 249                 }
 250
 251                 [Guid("AFCF8240-61AF-4089-BD98-3CD4D719EDBA")]
 252                 public interface IWithGuid
 253                 {
 254                 }
 255         }
 256
 257         public class WithInternalMethod
 258         {
 259                 internal virtual void Foo()
 260                 {
 261                 }
 262         }
 263
 264         public interface IDoubleGeneric<One>
 265         {
 266                 object Call<T>(One one, T two);
 267         }
 268
 269         internal interface IFoo
 270         {
 271                 int Bar();
 272         }
 273
 274         public class DoubleGenericImpl<One> : IDoubleGeneric<One>
 275         {
 276                 public object Call<T>(One one, T two)
 277                 {
 278                         return two;
 279                 }
 280         }
 281
 282         [ComImport, Guid("6D5140C1-7436-11CE-8034-00AA006009FA"),
 283          InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
 284         public interface IComServiceProvider
 285         {
 286                 [return : MarshalAs(UnmanagedType.IUnknown)]
 287                 object QueryService([In] ref Guid guidService, [In] ref Guid riid);
 288         }
 289
 290         public interface IFactory2
 291         {
 292                 T Create<T>() where T : List<T>;
 293         }
 294
 295         public interface IFooWithIntPtr
 296         {
 297                 IntPtr Buffer(UInt32 index);
 298         }
 299
 300         public abstract class
 301                 SomeClassWithProtectedInternalAbstractClass
 302         {
 303                 protected internal abstract void Quack();
 304         }
 305
 306         internal class InternalClassWithInternalMembers
 307         {
 308                 internal virtual string TestMethod()
 309                 {
 310                         return "TestMethod";
 311                 }
 312
 313                 internal virtual string TestProperty
 314                 {
 315                         get { return "TestProperty"; }
 316                 }
 317         }
 318
 319         public class MakeVirtualCallFromCtor
 320         {
 321                 private string name;
 322
 323                 public MakeVirtualCallFromCtor()
 324                 {
 325                         Name = "Blah";
 326                 }
 327
 328                 public virtual string Name
 329                 {
 330                         get { return name; }
 331                         set { name = value; }
 332                 }
 333         }
 334
 335         public class IntPtrInterceptor : IInterceptor
 336         {
 337                 public void Intercept(IInvocation invocation)
 338                 {
 339                         invocation.ReturnValue = IntPtr.Zero;
 340                 }
 341         }
 342
 343     public interface IFooWithOutIntPtr
 344     {
 345         int Bar(out IntPtr i);
 346     }
 347
 348     public class Foo : IFooWithOutIntPtr
 349     {
 350         public int Bar(out IntPtr i)
 351         {
 352             i = (IntPtr)Test();
 353             return 5;
 354         }
 355
 356         private object Test()
 357         {
 358             return new IntPtr(3);
 359         }
 360     }
 361 #endif
 362 }