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

   1 namespace Castle.DynamicProxy.Tests
   2 {
   3         using System;
   4         using NUnit.Framework;
   5
   6         [TestFixture]
   7         public class ProxyGenerationOptionsTestCase
   8         {
   9                 ProxyGenerationOptions _options1;
  10                 ProxyGenerationOptions _options2;
  11
  12                 [SetUp]
  13                 public void Init()
  14                 {
  15                         _options1 = new ProxyGenerationOptions();
  16                         _options2 = new ProxyGenerationOptions();
  17                 }
  18
  19                 [Test]
  20                 public void Equals_EmptyOptions ()
  21                 {
  22                         Assert.AreEqual (_options1, _options2);
  23                 }
  24
  25                 [Test]
  26                 public void Equals_EqualNonEmptyOptions ()
  27                 {
  28                         _options1 = new ProxyGenerationOptions ();
  29                         _options2 = new ProxyGenerationOptions ();
  30
  31                         _options1.BaseTypeForInterfaceProxy = typeof (IConvertible);
  32                         _options2.BaseTypeForInterfaceProxy = typeof (IConvertible);
  33
  34                         object mixin = new object ();
  35                         _options1.AddMixinInstance (mixin);
  36                         _options2.AddMixinInstance (mixin);
  37
  38                         IProxyGenerationHook hook = new AllMethodsHook ();
  39                         _options1.Hook = hook;
  40                         _options2.Hook = hook;
  41
  42                         IInterceptorSelector selector = new Castle.DynamicProxy.Tests.SerializableClassTestCase.SerializableInterceptorSelector ();
  43                         _options1.Selector = selector;
  44                         _options2.Selector = selector;
  45
  46                         _options1.UseSelector = true;
  47                         _options2.UseSelector = true;
  48
  49                         _options1.UseSingleInterfaceProxy = true;
  50                         _options2.UseSingleInterfaceProxy = true;
  51
  52                         Assert.AreEqual (_options1, _options2);
  53                 }
  54
  55                 [Test]
  56                 public void Equals_DifferentOptions_BaseTypeForInterfaceProxy ()
  57                 {
  58                         _options1.BaseTypeForInterfaceProxy = typeof (IConvertible);
  59                         _options2.BaseTypeForInterfaceProxy = typeof (object);
  60
  61                         Assert.AreNotEqual (_options1, _options2);
  62                 }
  63
  64                 [Test]
  65                 public void Equals_DifferentOptions_AddMixinInstance ()
  66                 {
  67                         object mixin = new object ();
  68                         _options1.AddMixinInstance (mixin);
  69
  70                         Assert.AreNotEqual (_options1, _options2);
  71                 }
  72
  73                 [Test]
  74                 public void Equals_DifferentOptions_Hook ()
  75                 {
  76                         IProxyGenerationHook hook = new GenerationHookTestCase.LogHook (typeof (object), true);
  77                         _options1.Hook = hook;
  78
  79                         Assert.AreNotEqual (_options1, _options2);
  80                 }
  81
  82                 [Test]
  83                 public void Equals_DifferentOptions_Selector ()
  84                 {
  85                         IInterceptorSelector selector = new Castle.DynamicProxy.Tests.SerializableClassTestCase.SerializableInterceptorSelector ();
  86                         _options1.Selector = selector;
  87
  88                         Assert.AreNotEqual (_options1, _options2);
  89                 }
  90
  91                 [Test]
  92                 public void Equals_DifferentOptions_UseSelector ()
  93                 {
  94                         _options1.UseSelector = true;
  95                         _options2.UseSelector = false;
  96
  97                         Assert.AreNotEqual (_options1, _options2);
  98                 }
  99
 100                 [Test]
 101                 public void Equals_DifferentOptions_UseSingleInterfaceProxy ()
 102                 {
 103                         _options1.UseSingleInterfaceProxy = true;
 104                         _options2.UseSingleInterfaceProxy = false;
 105
 106                         Assert.AreNotEqual (_options1, _options2);
 107                 }
 108
 109                 [Test]
 110                 public void GetHashCode_EmptyOptions ()
 111                 {
 112                         Assert.AreEqual (_options1.GetHashCode(), _options2.GetHashCode());
 113                 }
 114
 115                 [Test]
 116                 public void GetHashCode_EqualNonEmptyOptions ()
 117                 {
 118                         _options1 = new ProxyGenerationOptions ();
 119                         _options2 = new ProxyGenerationOptions ();
 120
 121                         _options1.BaseTypeForInterfaceProxy = typeof (IConvertible);
 122                         _options2.BaseTypeForInterfaceProxy = typeof (IConvertible);
 123
 124                         object mixin = new object ();
 125                         _options1.AddMixinInstance (mixin);
 126                         _options2.AddMixinInstance (mixin);
 127
 128                         IProxyGenerationHook hook = new AllMethodsHook ();
 129                         _options1.Hook = hook;
 130                         _options2.Hook = hook;
 131
 132                         IInterceptorSelector selector = new Castle.DynamicProxy.Tests.SerializableClassTestCase.SerializableInterceptorSelector ();
 133                         _options1.Selector = selector;
 134                         _options2.Selector = selector;
 135
 136                         _options1.UseSelector = true;
 137                         _options2.UseSelector = true;
 138
 139                         _options1.UseSingleInterfaceProxy = true;
 140                         _options2.UseSingleInterfaceProxy = true;
 141
 142                         Assert.AreEqual (_options1.GetHashCode(), _options2.GetHashCode());
 143                 }
 144
 145                 [Test]
 146                 public void GetHashCode_DifferentOptions_BaseTypeForInterfaceProxy ()
 147                 {
 148                         _options1.BaseTypeForInterfaceProxy = typeof (IConvertible);
 149                         _options2.BaseTypeForInterfaceProxy = typeof (object);
 150
 151                         Assert.AreNotEqual (_options1.GetHashCode(), _options2.GetHashCode());
 152                 }
 153
 154                 [Test]
 155                 public void GetHashCode_DifferentOptions_AddMixinInstance ()
 156                 {
 157                         object mixin = new object ();
 158                         _options1.AddMixinInstance (mixin);
 159
 160                         Assert.AreNotEqual (_options1.GetHashCode(), _options2.GetHashCode());
 161                 }
 162
 163                 [Test]
 164                 public void GetHashCode_DifferentOptions_Hook ()
 165                 {
 166                         IProxyGenerationHook hook = new GenerationHookTestCase.LogHook (typeof (object), true);
 167                         _options1.Hook = hook;
 168
 169                         Assert.AreNotEqual (_options1.GetHashCode(), _options2.GetHashCode());
 170                 }
 171
 172                 [Test]
 173                 public void GetHashCode_DifferentOptions_Selector ()
 174                 {
 175                         IInterceptorSelector selector = new Castle.DynamicProxy.Tests.SerializableClassTestCase.SerializableInterceptorSelector ();
 176                         _options1.Selector = selector;
 177
 178                         Assert.AreNotEqual (_options1.GetHashCode(), _options2.GetHashCode());
 179                 }
 180
 181                 [Test]
 182                 public void GetHashCode_DifferentOptions_UseSelector ()
 183                 {
 184                         _options1.UseSelector = true;
 185                         _options2.UseSelector = false;
 186
 187                         Assert.AreNotEqual (_options1.GetHashCode(), _options2.GetHashCode());
 188                 }
 189
 190                 [Test]
 191                 public void GetHashCode_DifferentOptions_UseSingleInterfaceProxy ()
 192                 {
 193                         _options1.UseSingleInterfaceProxy = true;
 194                         _options2.UseSingleInterfaceProxy = false;
 195
 196                         Assert.AreNotEqual (_options1.GetHashCode(), _options2.GetHashCode());
 197                 }
 198         }
 199 }