Skip to content

Commit 62f3be3

Browse files
hazzikhazzik
committed
Treat all non-virtual methods of System.Object as not proxiable
1 parent f25b398 commit 62f3be3

File tree

4 files changed

+145
-102
lines changed

4 files changed

+145
-102
lines changed

‎src/NHibernate.Test/NHSpecificTest/ProxyValidator/Fixture.cs

Lines changed: 49 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,6 @@
11
using System;
22
using NHibernate.Proxy;
33
using NUnit.Framework;
4-
using System.Collections.Generic;
54

65
namespace NHibernate.Test.NHSpecificTest.ProxyValidator
76
{
@@ -10,15 +9,6 @@ public class Fixture
109
{
1110
private readonly IProxyValidator pv = new DynProxyTypeValidator();
1211

13-
private void Validate(System.Type type)
14-
{
15-
ICollection<string> errors = pv.ValidateType(type);
16-
if (errors != null)
17-
{
18-
throw new InvalidProxyTypeException(errors);
19-
}
20-
}
21-
2212
public class ValidClass
2313
{
2414
private int privateField;
@@ -64,12 +54,35 @@ protected int NonVirtualPrivateProperty
6454
#pragma warning restore 67
6555
}
6656

57+
[Test]
58+
public void ObjectIsValid()
59+
{
60+
var errors = pv.ValidateType(typeof(object));
61+
Assert.That(errors, Is.Null);
62+
}
63+
6764
[Test]
6865
public void ValidClassTest()
6966
{
70-
Validate(typeof(ValidClass));
67+
var errors = pv.ValidateType(typeof(ValidClass));
68+
Assert.That(errors, Is.Null);
7169
}
7270

71+
public class InvalidSealedToString : ValidClass
72+
{
73+
public sealed override string ToString()
74+
{
75+
return base.ToString();
76+
}
77+
}
78+
79+
[Test]
80+
public void SealedObjectOverride()
81+
{
82+
var errors = pv.ValidateType(typeof(InvalidSealedToString));
83+
Assert.That(errors, Has.Count.EqualTo(1));
84+
}
85+
7386
public class InvalidPrivateConstructor : ValidClass
7487
{
7588
private InvalidPrivateConstructor()
@@ -80,7 +93,8 @@ private InvalidPrivateConstructor()
8093
[Test]
8194
public void PrivateConstructor()
8295
{
83-
Assert.Throws<InvalidProxyTypeException>(() => Validate(typeof(InvalidPrivateConstructor)));
96+
var errors = pv.ValidateType(typeof(InvalidPrivateConstructor));
97+
Assert.That(errors, Has.Count.EqualTo(1));
8498
}
8599

86100
public class InvalidNonVirtualProperty : ValidClass
@@ -95,7 +109,8 @@ public int NonVirtualProperty
95109
[Test]
96110
public void NonVirtualProperty()
97111
{
98-
Assert.Throws<InvalidProxyTypeException>(() => Validate(typeof(InvalidNonVirtualProperty)));
112+
var errors = pv.ValidateType(typeof(InvalidNonVirtualProperty));
113+
Assert.That(errors, Has.Count.EqualTo(2));
99114
}
100115

101116
public class InvalidPublicField : ValidClass
@@ -106,7 +121,8 @@ public class InvalidPublicField : ValidClass
106121
[Test]
107122
public void PublicField()
108123
{
109-
Assert.Throws<InvalidProxyTypeException>(() => Validate(typeof(InvalidPublicField)));
124+
var errors = pv.ValidateType(typeof(InvalidPublicField));
125+
Assert.That(errors, Has.Count.EqualTo(1));
110126
}
111127

112128
public class InvalidNonVirtualEvent : ValidClass
@@ -119,7 +135,8 @@ public class InvalidNonVirtualEvent : ValidClass
119135
[Test]
120136
public void NonVirtualEvent()
121137
{
122-
Assert.Throws<InvalidProxyTypeException>(() => Validate(typeof(InvalidNonVirtualEvent)));
138+
var errors = pv.ValidateType(typeof(InvalidNonVirtualEvent));
139+
Assert.That(errors, Has.Count.EqualTo(2));
123140
}
124141

125142
public interface ValidInterface
@@ -129,7 +146,8 @@ public interface ValidInterface
129146
[Test]
130147
public void Interface()
131148
{
132-
Validate(typeof(ValidInterface));
149+
var errors = pv.ValidateType(typeof(ValidInterface));
150+
Assert.That(errors, Is.Null);
133151
}
134152

135153
public class MultipleErrors
@@ -153,15 +171,8 @@ public int NonVirtualProperty
153171
[Test]
154172
public void MultipleErrorsReported()
155173
{
156-
try
157-
{
158-
Validate(typeof(MultipleErrors));
159-
Assert.Fail("Should have failed validation");
160-
}
161-
catch (InvalidProxyTypeException e)
162-
{
163-
Assert.IsTrue(e.Errors.Count > 1);
164-
}
174+
var errors = pv.ValidateType(typeof(MultipleErrors));
175+
Assert.That(errors, Has.Count.GreaterThan(1));
165176
}
166177

167178
public class InvalidNonVirtualInternalProperty : ValidClass
@@ -183,16 +194,18 @@ public class InvalidInternalField : ValidClass
183194
[Test]
184195
public void NonVirtualInternal()
185196
{
186-
Assert.Throws<InvalidProxyTypeException>(() => Validate(typeof(InvalidNonVirtualInternalProperty)));
197+
var errors = pv.ValidateType(typeof(InvalidNonVirtualInternalProperty));
198+
Assert.That(errors, Has.Count.EqualTo(2));
187199
}
188200

189201
[Test]
190202
public void InternalField()
191203
{
192-
Assert.Throws<InvalidProxyTypeException>(() => Validate(typeof(InvalidInternalField)));
204+
var errors = pv.ValidateType(typeof(InvalidInternalField));
205+
Assert.That(errors, Has.Count.EqualTo(1));
193206
}
194207

195-
public class InvalidNonVirtualProtectedProperty : ValidClass
208+
public class ValidNonVirtualProtectedProperty : ValidClass
196209
{
197210
protected int NonVirtualProperty
198211
{
@@ -204,8 +217,8 @@ protected int NonVirtualProperty
204217
[Test]
205218
public void NonVirtualProtected()
206219
{
207-
Validate(typeof(InvalidNonVirtualProtectedProperty));
208-
Assert.IsTrue(true, "Always should pass, protected members do not need to be virtual.");
220+
var errors = pv.ValidateType(typeof(ValidNonVirtualProtectedProperty));
221+
Assert.That(errors, Is.Null);
209222
}
210223

211224
public class InvalidNonVirtualProtectedInternalProperty : ValidClass
@@ -220,7 +233,8 @@ protected internal int NonVirtualProperty
220233
[Test]
221234
public void NonVirtualProtectedInternal()
222235
{
223-
Assert.Throws<InvalidProxyTypeException>(() => Validate(typeof(InvalidNonVirtualProtectedInternalProperty)));
236+
var errors = pv.ValidateType(typeof(InvalidNonVirtualProtectedInternalProperty));
237+
Assert.That(errors, Has.Count.EqualTo(2));
224238
}
225239

226240
interface INonVirtualPublicImplementsInterface
@@ -239,7 +253,8 @@ public int NonVirtualMethodImplementsInterface
239253
[Test]
240254
public void VirtualPublicImplementsInterface()
241255
{
242-
Assert.Throws<InvalidProxyTypeException>(() => Validate(typeof(NonVirtualPublicImplementsInterface)));
256+
var errors = pv.ValidateType(typeof(NonVirtualPublicImplementsInterface));
257+
Assert.That(errors, Has.Count.EqualTo(1));
243258
}
244259

245260
public class InvalidVirtualPrivateAutoProperty : ValidClass
@@ -254,7 +269,8 @@ public virtual int NonVirtualSetterProperty
254269
[Test]
255270
public void PrivateSetterOnVirtualPropertyShouldThrows()
256271
{
257-
Assert.Throws<InvalidProxyTypeException>(() => Validate(typeof(InvalidVirtualPrivateAutoProperty)));
272+
var errors = pv.ValidateType(typeof(InvalidVirtualPrivateAutoProperty));
273+
Assert.That(errors, Has.Count.EqualTo(1));
258274
}
259275
}
260276
}

‎src/NHibernate.Test/NHSpecificTest/ProxyValidator/ShouldBeProxiableTests.cs

Lines changed: 86 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -46,80 +46,115 @@ protected internal void AProtectedInternal() { }
4646
}
4747

4848
[Test]
49-
public void GetTypeNotBeProxiable()
49+
public void ObjectToStringShouldBeProxiable()
5050
{
51-
var method = typeof(object).GetMethod("GetType");
52-
Assert.That(method.ShouldBeProxiable(), Is.False);
51+
var method = typeof(object).GetMethod(nameof(ToString));
52+
Assert.Multiple(
53+
() =>
54+
{
55+
Assert.That(method.ShouldBeProxiable(), Is.True);
56+
Assert.That(method.IsProxiable(), Is.True);
57+
});
5358
}
5459

5560
[Test]
56-
public void DisposeNotBeProxiable()
61+
public void ObjectGetHashCodeShouldBeProxiable()
5762
{
58-
var method = typeof(MyClass).GetMethod("Dispose");
59-
Assert.That(method.ShouldBeProxiable(), Is.False);
63+
var method = typeof(object).GetMethod(nameof(GetHashCode));
64+
Assert.Multiple(
65+
() =>
66+
{
67+
Assert.That(method.ShouldBeProxiable(), Is.True);
68+
Assert.That(method.IsProxiable(), Is.True);
69+
});
6070
}
6171

6272
[Test]
63-
public void ObjectDestructorShouldNotBeProxiable()
73+
public void ObjectEqualsShouldBeProxiable()
6474
{
65-
var method = typeof(object).GetMethod(
66-
"Finalize",
67-
BindingFlags.NonPublic | BindingFlags.Instance);
68-
69-
Assert.That(method.ShouldBeProxiable(), Is.False);
75+
var method = typeof(object).GetMethod(nameof(Equals), BindingFlags.Public | BindingFlags.Instance);
76+
Assert.Multiple(
77+
() =>
78+
{
79+
Assert.That(method.ShouldBeProxiable(), Is.True);
80+
Assert.That(method.IsProxiable(), Is.True);
81+
});
7082
}
7183

7284
[Test]
73-
public void ObjectDestructorIsNotProxiable()
85+
public void ObjectMemberwiseCloneShouldNotBeProxiable()
7486
{
7587
var method = typeof(object).GetMethod(
76-
"Finalize",
77-
BindingFlags.NonPublic | BindingFlags.Instance);
88+
nameof(MemberwiseClone),
89+
BindingFlags.Instance | BindingFlags.NonPublic);
7890

79-
Assert.That(method.IsProxiable(), Is.False);
91+
Assert.Multiple(
92+
() =>
93+
{
94+
Assert.That(method.ShouldBeProxiable(), Is.False);
95+
Assert.That(method.IsProxiable(), Is.False);
96+
});
8097
}
81-
98+
8299
[Test]
83-
public void MyClassDestructorShouldNotBeProxiable()
100+
public void ObjectGetTypeShouldNotBeProxiable()
84101
{
85-
var method = typeof(MyClass).GetMethod(
86-
"Finalize",
87-
BindingFlags.NonPublic | BindingFlags.Instance,
88-
null,
89-
System.Type.EmptyTypes,
90-
null);
102+
var method = typeof(object).GetMethod("GetType");
103+
Assert.Multiple(
104+
() =>
105+
{
106+
Assert.That(method.ShouldBeProxiable(), Is.False);
107+
Assert.That(method.IsProxiable(), Is.False);
108+
});
109+
}
91110

92-
Assert.That(method.ShouldBeProxiable(), Is.False);
111+
[Test]
112+
public void MyClassDisposeNotBeProxiable()
113+
{
114+
var method = typeof(MyClass).GetMethod("Dispose");
115+
Assert.Multiple(
116+
() =>
117+
{
118+
Assert.That(method.ShouldBeProxiable(), Is.False);
119+
Assert.That(method.IsProxiable(), Is.False);
120+
});
93121
}
94122

95123
[Test]
96-
public void MyClassDestructorIsNotProxiable()
124+
public void ObjectDestructorShouldNotBeProxiable()
97125
{
98-
var method = typeof(MyClass).GetMethod(
126+
var method = typeof(object).GetMethod(
99127
"Finalize",
100-
BindingFlags.NonPublic | BindingFlags.Instance,
101-
null,
102-
System.Type.EmptyTypes,
103-
null);
128+
BindingFlags.NonPublic | BindingFlags.Instance);
104129

105-
Assert.That(method.IsProxiable(), Is.False);
130+
Assert.Multiple(
131+
() =>
132+
{
133+
Assert.That(method.ShouldBeProxiable(), Is.False);
134+
Assert.That(method.IsProxiable(), Is.False);
135+
});
106136
}
107137

108138
[Test]
109-
public void MyClassLowerCaseFinalizeShouldBeProxiable()
139+
public void MyClassDestructorShouldNotBeProxiable()
110140
{
111141
var method = typeof(MyClass).GetMethod(
112-
"finalize",
113-
BindingFlags.Public | BindingFlags.Instance,
142+
"Finalize",
143+
BindingFlags.NonPublic | BindingFlags.Instance,
114144
null,
115145
System.Type.EmptyTypes,
116146
null);
117147

118-
Assert.That(method.ShouldBeProxiable(), Is.True);
148+
Assert.Multiple(
149+
() =>
150+
{
151+
Assert.That(method.ShouldBeProxiable(), Is.False);
152+
Assert.That(method.IsProxiable(), Is.False);
153+
});
119154
}
120155

121156
[Test]
122-
public void MyClassLowerCaseFinalizeIsProxiable()
157+
public void MyClassLowerCaseFinalizeShouldBeProxiable()
123158
{
124159
var method = typeof(MyClass).GetMethod(
125160
"finalize",
@@ -128,24 +163,16 @@ public void MyClassLowerCaseFinalizeIsProxiable()
128163
System.Type.EmptyTypes,
129164
null);
130165

131-
Assert.That(method.IsProxiable(), Is.True);
132-
}
133-
134-
[Test]
135-
public void MyClassFinalizeWithParametersShouldBeProxiable()
136-
{
137-
var method = typeof(MyClass).GetMethod(
138-
"Finalize",
139-
BindingFlags.Public | BindingFlags.Instance,
140-
null,
141-
new[] { typeof(int) },
142-
null);
143-
144-
Assert.That(method.ShouldBeProxiable(), Is.True);
166+
Assert.Multiple(
167+
() =>
168+
{
169+
Assert.That(method.ShouldBeProxiable(), Is.True);
170+
Assert.That(method.IsProxiable(), Is.True);
171+
});
145172
}
146173

147174
[Test]
148-
public void MyClassFinalizeWithParametersIsProxiable()
175+
public void MyClassFinalizeWithParametersShouldBeProxiable()
149176
{
150177
var method = typeof(MyClass).GetMethod(
151178
"Finalize",
@@ -154,14 +181,19 @@ public void MyClassFinalizeWithParametersIsProxiable()
154181
new[] { typeof(int) },
155182
null);
156183

157-
Assert.That(method.IsProxiable(), Is.True);
184+
Assert.Multiple(
185+
() =>
186+
{
187+
Assert.That(method.ShouldBeProxiable(), Is.True);
188+
Assert.That(method.IsProxiable(), Is.True);
189+
});
158190
}
159191

160192
[Test]
161193
public void WhenProtectedNoVirtualPropertyThenShouldntBeProxiable()
162194
{
163195
var prop = typeof(ProtectedNoVirtualProperty).GetProperty("Aprop", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
164-
Assert.That(prop.ShouldBeProxiable(), Is.False);
196+
Assert.That(prop.ShouldBeProxiable(), Is.False);
165197
}
166198

167199
[Test]

0 commit comments

Comments
 (0)