Tools/Castle.DynamicProxy2/Castle.DynamicProxy.Tests/GenericClassProxyTestCase.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 Castle.DynamicProxy.Tests.GenClasses;
  20         using Castle.DynamicProxy.Tests.Interceptors;
  21         using NUnit.Framework;
  22
  23         [TestFixture]
  24         public class GenericClassProxyTestCase : BasePEVerifyTestCase
  25         {
  26                 private LogInvocationInterceptor logger;
  27
  28                 public override void Init()
  29                 {
  30                         base.Init();
  31                         logger = new LogInvocationInterceptor();
  32                 }
  33
  34                 [Test]
  35                 public void ProxyWithGenericArgument()
  36                 {
  37                         ClassWithGenArgs<int> proxy = generator.CreateClassProxy<ClassWithGenArgs<int>>(logger);
  38
  39                         Assert.IsNotNull(proxy);
  40
  41                         proxy.DoSomething();
  42
  43                         Assert.IsTrue(proxy.Invoked);
  44
  45                         proxy.AProperty = true;
  46                         Assert.IsTrue(proxy.AProperty);
  47
  48                         Assert.AreEqual("DoSomething set_AProperty get_AProperty ", logger.LogContents);
  49                 }
  50
  51                 [Test]
  52                 public void ProxyWithGenericArguments()
  53                 {
  54                         ClassWithGenArgs<int, string> proxy = generator.CreateClassProxy<ClassWithGenArgs<int, string>>(logger);
  55
  56                         Assert.IsNotNull(proxy);
  57
  58                         proxy.DoSomething();
  59
  60                         Assert.IsTrue(proxy.Invoked);
  61
  62                         proxy.AProperty = true;
  63                         Assert.IsTrue(proxy.AProperty);
  64
  65                         Assert.AreEqual("DoSomething set_AProperty get_AProperty ", logger.LogContents);
  66                 }
  67
  68                 [Test]
  69                 public void ProxyWithGenericArgumentsWithBaseGenericClass()
  70                 {
  71                         SubClassWithGenArgs<int, string, int> proxy =
  72                                 generator.CreateClassProxy<SubClassWithGenArgs<int, string, int>>(logger);
  73
  74                         Assert.IsNotNull(proxy);
  75
  76                         proxy.DoSomething();
  77
  78                         Assert.IsTrue(proxy.Invoked);
  79
  80                         proxy.AProperty = true;
  81                         Assert.IsTrue(proxy.AProperty);
  82
  83                         Assert.AreEqual("DoSomething set_AProperty get_AProperty ", logger.LogContents);
  84                 }
  85
  86                 [Test]
  87                 public void ProxyWithGenericArgumentsAndArgumentConstraints()
  88                 {
  89                         GenClassWithConstraints<int> proxy = generator.CreateClassProxy<GenClassWithConstraints<int>>(logger);
  90
  91                         Assert.IsNotNull(proxy);
  92
  93                         proxy.DoSomething();
  94
  95                         Assert.IsTrue(proxy.Invoked);
  96
  97                         Assert.AreEqual("DoSomething ", logger.LogContents);
  98                 }
  99
 100                 [Test]
 101                 public void GenericProxyWithIndexer()
 102                 {
 103                         object proxy = generator.CreateClassProxy<ClassWithIndexer<string, int>>(logger);
 104
 105                         Assert.IsNotNull(proxy);
 106
 107                         ClassWithIndexer<string, int> type = (ClassWithIndexer<string, int>) proxy;
 108
 109                         type["name"] = 10;
 110                         Assert.AreEqual(10, type["name"]);
 111
 112                         Assert.AreEqual("set_Item get_Item ", logger.LogContents);
 113                 }
 114
 115 #if !MONO
 116
 117                 [Test]
 118                 public void ProxyWithGenericArgumentsAndMethodGenericArguments()
 119                 {
 120                         GenClassWithGenMethods<ArrayList> proxy =
 121                                 generator.CreateClassProxy<GenClassWithGenMethods<ArrayList>>(logger);
 122
 123                         Assert.IsNotNull(proxy);
 124
 125                         proxy.DoSomething("z param");
 126
 127                         Assert.IsTrue(proxy.Invoked);
 128                         Assert.AreEqual("z param", proxy.SavedParam);
 129                         Assert.AreEqual("DoSomething ", logger.LogContents);
 130                 }
 131
 132                 [Test]
 133                 public void ProxyWithGenericArgumentsAndMethodGenericArgumentsWithConstraints()
 134                 {
 135                         GenClassWithGenMethodsConstrained<ArrayList> proxy =
 136                                 generator.CreateClassProxy<GenClassWithGenMethodsConstrained<ArrayList>>(logger);
 137
 138                         Assert.IsNotNull(proxy);
 139
 140                         proxy.DoSomething("z param");
 141
 142                         Assert.IsTrue(proxy.Invoked);
 143                         Assert.AreEqual("z param", proxy.SavedParam);
 144                         Assert.AreEqual("DoSomething ", logger.LogContents);
 145                 }
 146
 147                 [Test]
 148                 public void ProxyWithGenericArgumentsAndMethodGenericArgumentsWithOneNotDefinedOnType()
 149                 {
 150                         GenClassWithGenMethods<ArrayList> proxy =
 151                                 generator.CreateClassProxy<GenClassWithGenMethods<ArrayList>>(logger);
 152
 153                         Assert.IsNotNull(proxy);
 154
 155                         int value1 = 10;
 156
 157                         proxy.DoSomethingElse<string>(delegate(int param1) { return param1.ToString(); }, value1);
 158
 159                         Assert.IsTrue(proxy.Invoked);
 160                         Assert.AreEqual("10", proxy.SavedParam);
 161                         Assert.AreEqual("DoSomethingElse ", logger.LogContents);
 162                 }
 163
 164                 [Test]
 165                 public void ProxyWithGenericArgumentsAndMethodGenericReturn()
 166                 {
 167                         GenClassWithGenReturn<ArrayList, Hashtable> proxy =
 168                                 generator.CreateClassProxy<GenClassWithGenReturn<ArrayList, Hashtable>>(logger);
 169
 170                         Assert.IsNotNull(proxy);
 171
 172                         object ret1 = proxy.DoSomethingT();
 173                         object ret2 = proxy.DoSomethingZ();
 174
 175                         Assert.IsInstanceOfType(typeof(ArrayList), ret1);
 176                         Assert.IsInstanceOfType(typeof(Hashtable), ret2);
 177                         Assert.AreEqual("DoSomethingT DoSomethingZ ", logger.LogContents);
 178                 }
 179
 180                 [Test]
 181                 public void GenericMethodArgumentsAndTypeGenericArgumentsWithSameName()
 182                 {
 183                         GenClassNameClash<ArrayList, Hashtable> proxy =
 184                                 generator.CreateClassProxy<GenClassNameClash<ArrayList, Hashtable>>(logger);
 185
 186                         Assert.IsNotNull(proxy);
 187
 188                         proxy.DoSomethingT<int>(1);
 189                         proxy.DoSomethingZ<long>(1L);
 190                         proxy.DoSomethingTX<int, string>(1, "a");
 191                         proxy.DoSomethingZX<long, string>(1L, "b");
 192
 193                         Assert.AreEqual("DoSomethingT DoSomethingZ DoSomethingTX DoSomethingZX ", logger.LogContents);
 194                 }
 195
 196                 [Test]
 197                 public void ClassWithGenMethodOnly()
 198                 {
 199                         OnlyGenMethodsClass proxy =
 200                                 generator.CreateClassProxy<OnlyGenMethodsClass>(logger);
 201
 202                         Assert.IsNotNull(proxy);
 203
 204                         proxy.DoSomething(new ArrayList());
 205
 206                         Assert.IsTrue(proxy.Invoked);
 207                         Assert.AreEqual("DoSomething ", logger.LogContents);
 208                 }
 209
 210                 [Test]
 211                 public void MethodInfoClosedInGenTypeGenMethodRefType()
 212                 {
 213                         KeepDataInterceptor interceptor = new KeepDataInterceptor();
 214                         GenClassWithGenMethods<ArrayList> proxy = generator.CreateClassProxy<GenClassWithGenMethods<ArrayList>>(interceptor);
 215
 216                         proxy.DoSomething(1);
 217                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(ArrayList), typeof(int));
 218                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 219                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 220
 221                         proxy.DoSomething(new Hashtable());
 222                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(ArrayList),
 223                                                                    typeof(Hashtable));
 224                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 225                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 226                 }
 227
 228                 [Test]
 229                 public void MethodInfoClosedInGenTypeGenMethodValueType()
 230                 {
 231                         KeepDataInterceptor interceptor = new KeepDataInterceptor();
 232                         GenClassWithGenMethods<int> proxy = generator.CreateClassProxy<GenClassWithGenMethods<int>>(interceptor);
 233
 234                         proxy.DoSomething(1);
 235                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(int), typeof(int));
 236                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 237                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 238
 239                         proxy.DoSomething(new Hashtable());
 240                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(int), typeof(Hashtable));
 241                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 242                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 243                 }
 244
 245                 [Test]
 246                 public void MethodInfoClosedInGenTypeNongenMethodRefTypeRefType()
 247                 {
 248                         KeepDataInterceptor interceptor = new KeepDataInterceptor();
 249                         GenClassWithGenReturn<ArrayList, ArrayList> proxy =
 250                                 generator.CreateClassProxy<GenClassWithGenReturn<ArrayList, ArrayList>>(interceptor);
 251
 252                         proxy.DoSomethingT();
 253                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(ArrayList));
 254                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 255                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 256
 257                         proxy.DoSomethingZ();
 258                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(ArrayList));
 259                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 260                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 261                 }
 262
 263                 [Test]
 264                 public void MethodInfoClosedInGenTypeNongenMethodValueTypeValueType()
 265                 {
 266                         KeepDataInterceptor interceptor = new KeepDataInterceptor();
 267                         GenClassWithGenReturn<int, int> proxy = generator.CreateClassProxy<GenClassWithGenReturn<int, int>>(interceptor);
 268
 269                         proxy.DoSomethingT();
 270                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(int));
 271                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 272                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 273
 274                         proxy.DoSomethingZ();
 275                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(int));
 276                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 277                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 278                 }
 279
 280                 [Test]
 281                 public void MethodInfoClosedInGenTypeNongenMethodValueTypeRefType()
 282                 {
 283                         KeepDataInterceptor interceptor = new KeepDataInterceptor();
 284                         GenClassWithGenReturn<int, ArrayList> proxy =
 285                                 generator.CreateClassProxy<GenClassWithGenReturn<int, ArrayList>>(interceptor);
 286
 287                         proxy.DoSomethingT();
 288                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(int));
 289                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 290                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 291
 292                         proxy.DoSomethingZ();
 293                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(ArrayList));
 294                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 295                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 296                 }
 297
 298                 [Test]
 299                 public void MethodInfoClosedInNongenTypeGenMethod()
 300                 {
 301                         KeepDataInterceptor interceptor = new KeepDataInterceptor();
 302                         OnlyGenMethodsClass proxy = generator.CreateClassProxy<OnlyGenMethodsClass>(interceptor);
 303
 304                         proxy.DoSomething(1);
 305                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(int), typeof(int));
 306                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 307                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 308
 309                         proxy.DoSomething(new Hashtable());
 310                         GenericTestUtility.CheckMethodInfoIsClosed(interceptor.Invocation.GetConcreteMethod(), typeof(Hashtable),
 311                                                                    typeof(Hashtable));
 312                         Assert.AreEqual(interceptor.Invocation.GetConcreteMethod(),
 313                                         interceptor.Invocation.GetConcreteMethodInvocationTarget());
 314                 }
 315
 316                 [Test]
 317                 [ExpectedException(typeof(ArgumentException))]
 318                 public void ThrowsWhenProxyingGenericTypeDefNoTarget()
 319                 {
 320                         KeepDataInterceptor interceptor = new KeepDataInterceptor();
 321                         object o = generator.CreateClassProxy(typeof(GenClassWithGenReturn<,>), interceptor);
 322                 }
 323
 324 #endif
 325         }
 326 }