Tools/Castle.DynamicProxy2/Castle.DynamicProxy.Tests/GenericInterfaceProxyTestCase.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 #if DOTNET2
  18         using System;
  19         using System.Collections.Generic;
  20         using Castle.DynamicProxy.Generators;
  21         using Castle.DynamicProxy.Tests.GenInterfaces;
  22         using Castle.DynamicProxy.Tests.Interceptors;
  23         using NUnit.Framework;
  24
  25         [TestFixture]
  26         public class GenericInterfaceProxyTestCase : BasePEVerifyTestCase
  27         {
  28                 private ProxyGenerator generator;
  29                 private LogInvocationInterceptor logger;
  30
  31                 [SetUp]
  32                 public void Init()
  33                 {
  34                         generator = new ProxyGenerator();
  35                         logger = new LogInvocationInterceptor();
  36                 }
  37
  38                 [Test]
  39                 public void ProxyWithGenericArgument()
  40                 {
  41                         GenInterface<int> proxy =
  42                                 generator.CreateInterfaceProxyWithTarget<GenInterface<int>>(
  43                                         new GenInterfaceImpl<int>(), logger);
  44
  45                         Assert.IsNotNull(proxy);
  46
  47                         Assert.AreEqual(1, proxy.DoSomething(1));
  48
  49                         Assert.AreEqual("DoSomething ", logger.LogContents);
  50                 }
  51
  52                 [Test]
  53                 public void ProxyWithGenericArgumentAndGenericMethod()
  54                 {
  55                         GenInterfaceWithGenMethods<int> proxy =
  56                                 generator.CreateInterfaceProxyWithTarget<GenInterfaceWithGenMethods<int>>(
  57                                         new GenInterfaceWithGenMethodsImpl<int>(), logger);
  58
  59                         Assert.IsNotNull(proxy);
  60
  61                         proxy.DoSomething<long>(10L, 1);
  62
  63                         Assert.AreEqual("DoSomething ", logger.LogContents);
  64                 }
  65
  66                 [Test]
  67                 public void ProxyWithGenericArgumentAndGenericMethodAndGenericReturn()
  68                 {
  69                         GenInterfaceWithGenMethodsAndGenReturn<int> proxy =
  70                                 generator.CreateInterfaceProxyWithTarget<GenInterfaceWithGenMethodsAndGenReturn<int>>(
  71                                         new GenInterfaceWithGenMethodsAndGenReturnImpl<int>(), logger);
  72
  73                         Assert.IsNotNull(proxy);
  74
  75                         Assert.AreEqual(10L, proxy.DoSomething<long>(10L, 1));
  76
  77                         Assert.AreEqual("DoSomething ", logger.LogContents);
  78                 }
  79
  80 //              [Test]
  81 //              public void ProxyWithGenInterfaceWithGenericTypes()
  82 //              {
  83 //                      GenInterfaceWithGenericTypes proxy =
  84 //                              generator.CreateInterfaceProxyWithTarget<GenInterfaceWithGenericTypes>(
  85 //                                      new GenInterfaceWithGenericTypesImpl(), logger);
  86 //
  87 //                      Assert.IsNotNull(proxy);
  88 //
  89 //                      Assert.IsNotNull(proxy.Find(""));
  90 //                      Assert.IsNotNull(proxy.Find<String>(""));
  91 //
  92 //                      proxy.Populate<String>(new List<String>());
  93 //
  94 //                      Assert.AreEqual("Find Find Populate ", logger.LogContents);
  95 //
  96 //              }
  97
  98                 [Test]
  99                 public void ProxyWithGenInterfaceWithGenericArrays()
 100                 {
 101                         IGenInterfaceWithGenArray<int> proxy =
 102                                 generator.CreateInterfaceProxyWithTarget<IGenInterfaceWithGenArray<int>>(
 103                                         new GenInterfaceWithGenArray<int>(), logger);
 104
 105                         Assert.IsNotNull(proxy);
 106
 107                         int[] items = new int[] { 1,2,3 };
 108                         proxy.CopyTo(items);
 109                         items = proxy.CreateItems();
 110                         Assert.IsNotNull(items);
 111                         Assert.AreEqual(3, items.Length);
 112
 113                         Assert.AreEqual("CopyTo CreateItems ", logger.LogContents);
 114                 }
 115
 116                 [Test]
 117                 public void ProxyWithGenInterfaceWithBase()
 118                 {
 119                         IGenInterfaceHierarchySpecialization<int> proxy =
 120                                 generator.CreateInterfaceProxyWithTarget<IGenInterfaceHierarchySpecialization<int>>(
 121                                         new GenInterfaceHierarchy<int>(), logger);
 122
 123                         Assert.IsNotNull(proxy);
 124
 125                         proxy.Add();
 126                         proxy.Add(1);
 127                         Assert.IsNotNull(proxy.FetchAll());
 128
 129                         Assert.AreEqual("Add Add FetchAll ", logger.LogContents);
 130                 }
 131
 132                 [Test]
 133                 [ExpectedException(typeof(GeneratorException), "DynamicProxy cannot create an interface (with target) proxy for 'InterfaceWithExplicitImpl`1' as the target 'GenExplicitImplementation`1' has an explicit implementation of one of the methods exposed by the interface. The runtime prevents use from invoking the private method on the target. Method Castle.DynamicProxy.Tests.GenInterfaces.InterfaceWithExplicitImpl<T>.GetEnum1")]
 134                 public void ProxyWithGenExplicitImplementation()
 135                 {
 136                         generator.CreateInterfaceProxyWithTarget<InterfaceWithExplicitImpl<int>>(
 137                                 new GenExplicitImplementation<int>(), logger);
 138                 }
 139
 140                 [Test]
 141                 public void TwoGenericsInterfaceWithoutTarget()
 142                 {
 143                         generator.CreateInterfaceProxyWithoutTarget(typeof(GenInterface<object>),
 144                                 new Type[] { typeof(InterfaceWithExplicitImpl<int>) }, new LogInvocationInterceptor());
 145                 }
 146
 147                 [Test]
 148                 public void NonGenInterfaceWithParentGenClassImplementingGenInterface()
 149                 {
 150                         generator.CreateInterfaceProxyWithoutTarget(typeof(IUserRepository),
 151                                 new Type[] { typeof(InterfaceWithExplicitImpl<int>) }, new LogInvocationInterceptor());
 152                 }
 153
 154                 [Test]
 155                 public void WithoutTarget()
 156                 {
 157                         generator.CreateInterfaceProxyWithoutTarget(typeof(InterfaceWithExplicitImpl<int>), new LogInvocationInterceptor());
 158                 }
 159         }
 160 #endif
 161 }