Tools/Castle.DynamicProxy2/Castle.DynamicProxy.Tests/OutRefParams.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
  16 namespace Castle.DynamicProxy.Tests
  17 {
  18         using System;
  19         using Castle.Core.Interceptor;
  20         using Castle.DynamicProxy.Tests.Interceptors;
  21         using NUnit.Framework;
  22
  23         [TestFixture]
  24         public class OutRefParams
  25         {
  26                 private ProxyGenerator generator;
  27
  28                 [SetUp]
  29                 public void Init()
  30                 {
  31                         generator = new ProxyGenerator();
  32                 }
  33
  34                 [Test]
  35                 public void CanCreateProxyOfInterfaceWithOutParameter()
  36                 {
  37                         KeepDataInterceptor interceptor = new KeepDataInterceptor();
  38                         object proxy = generator.CreateInterfaceProxyWithoutTarget(typeof(WithOut), interceptor);
  39                         Assert.IsNotNull(proxy);
  40                 }
  41
  42                 [Test]
  43                 public void CanCallMethodWithOutParameter()
  44                 {
  45                         int i;
  46                         InvocatingInterceptor interceptor = new InvocatingInterceptor(delegate { });
  47                         WithOut proxy = (WithOut) generator.CreateInterfaceProxyWithoutTarget(typeof(WithOut), interceptor);
  48                         proxy.Do(out i);
  49                 }
  50
  51                 [Test]
  52                 public void CanAffectValueOfOutParameter()
  53                 {
  54                         int i;
  55                         InvocatingInterceptor interceptor =
  56                                 new InvocatingInterceptor(delegate(IInvocation invocation) { invocation.Arguments[0] = 5; });
  57                         WithOut proxy = (WithOut) generator.CreateInterfaceProxyWithoutTarget(typeof(WithOut), interceptor);
  58                         proxy.Do(out i);
  59                         Assert.AreEqual(5, i);
  60                 }
  61
  62                 [Test]
  63                 public void CanCreateProxyWithRefParam()
  64                 {
  65                         int i = 3;
  66                         InvocatingInterceptor interceptor =
  67                                 new InvocatingInterceptor(delegate(IInvocation invocation) { invocation.Arguments[0] = 5; });
  68                         WithOut proxy = (WithOut) generator.CreateInterfaceProxyWithoutTarget(typeof(WithOut), interceptor);
  69                         proxy.Did(ref i);
  70                         Assert.AreEqual(5, i);
  71                 }
  72
  73
  74                 [Test]
  75                 public void CanCreateComplexOutRefProxyOnClass()
  76                 {
  77                         int i = 3;
  78                         string s1 = "2";
  79                         string s2;
  80                         InvocatingInterceptor interceptor = new InvocatingInterceptor(delegate(IInvocation invocation)
  81                                                                                         {
  82                                                                                                 invocation.Arguments[0] = 5;
  83                                                                                                 invocation.Arguments[1] = "aaa";
  84                                                                                                 invocation.Arguments[3] = "bbb";
  85                                                                                         });
  86                         MyClass proxy = (MyClass) generator.CreateClassProxy(typeof(MyClass), interceptor);
  87                         proxy.MyMethod(out i, ref s1, 1, out s2);
  88                         Assert.AreEqual(5, i);
  89                         Assert.AreEqual(s1, "aaa");
  90                         Assert.AreEqual(s2, "bbb");
  91                 }
  92
  93                 [Test, Explicit]
  94                 public void CanCreateProxyWithStructRefParam()
  95                 {
  96                         MyStruct s = new MyStruct(10);
  97                         MyClass proxy = (MyClass)generator.CreateClassProxy(typeof(MyClass), new StandardInterceptor());
  98                         proxy.MyMethodWithStruct(ref s);
  99                         Assert.AreEqual(20, s.Value);
 100                 }
 101
 102                 public struct MyStruct
 103                 {
 104                         public int Value;
 105                         public MyStruct(int value)
 106                         {
 107                                 Value = value;
 108                         }
 109                 }
 110
 111                 public interface WithOut
 112                 {
 113                         void Do(out int i);
 114                         void Did(ref int i);
 115                 }
 116
 117
 118                 public class MyClass
 119                 {
 120                         public virtual void MyMethod(out int i, ref string s, int i1, out string s2)
 121                         {
 122                                 throw new NotImplementedException();
 123                         }
 124
 125                         public virtual void MyMethodWithStruct(ref MyStruct s)
 126                         {
 127                                 s.Value = 2 * s.Value;
 128                         }
 129                 }
 130
 131                 public class InvocatingInterceptor : IInterceptor
 132                 {
 133                         public delegate void Invoked(IInvocation invocation);
 134
 135                         private Invoked invoked;
 136
 137                         public InvocatingInterceptor(Invoked invoked)
 138                         {
 139                                 this.invoked = invoked;
 140                         }
 141
 142
 143                         public void Intercept(IInvocation invocation)
 144                         {
 145                                 invoked(invocation);
 146                         }
 147                 }
 148         }
 149 }