-
Notifications
You must be signed in to change notification settings - Fork 81
Expand file tree
/
Copy pathStaticTestTypes.cs
More file actions
203 lines (145 loc) · 7.3 KB
/
Copy pathStaticTestTypes.cs
File metadata and controls
203 lines (145 loc) · 7.3 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
using System;
using ArchUnitNET.Domain;
using ArchUnitNET.Domain.Extensions;
using Attribute = ArchUnitNET.Domain.Attribute;
namespace ArchUnitNETTests.Domain
{
public static class StaticTestTypes
{
private static readonly Architecture Architecture =
StaticTestArchitectures.ArchUnitNETTestArchitecture;
public static readonly IType TestEnum = Architecture.GetITypeOfType(typeof(TestEnum));
public static readonly IType TestStruct = Architecture.GetITypeOfType(typeof(TestStruct));
public static readonly Class SealedTestClass = Architecture.GetClassOfType(
typeof(SealedTestClass)
);
public static readonly Attribute TestAttribute = Architecture.GetAttributeOfType(
typeof(TestAttribute)
);
public static readonly Attribute ChildTestAttribute = Architecture.GetAttributeOfType(
typeof(ChildTestAttribute)
);
public static readonly Attribute SealedTestAttribute = Architecture.GetAttributeOfType(
typeof(SealedTestAttribute)
);
public static readonly Class PublicTestClass = Architecture.GetClassOfType(
typeof(PublicTestClass)
);
public static readonly Class InternalTestClass = Architecture.GetClassOfType(
typeof(InternalTestClass)
);
public static readonly Class NestedPublicTestClass = Architecture.GetClassOfType(
typeof(TestClassForVisibilityTest.NestedPublicTestClass)
);
public static readonly Class NestedPrivateTestClass = Architecture.GetClassOfType(
TestClassForVisibilityTest.TypeOfNestedPrivateTestClass
);
public static readonly Class NestedProtectedTestClass = Architecture.GetClassOfType(
TestClassForVisibilityTest.TypeOfNestedProtectedTestClass
);
public static readonly Class NestedInternalTestClass = Architecture.GetClassOfType(
typeof(TestClassForVisibilityTest.NestedInternalTestClass)
);
public static readonly Class NestedProtectedInternalTestClass = Architecture.GetClassOfType(
typeof(TestClassForVisibilityTest.NestedProtectedInternalTestClass)
);
public static readonly Class NestedPrivateProtectedTestClass = Architecture.GetClassOfType(
TestClassForVisibilityTest.TypeOfNestedPrivateProtectedTestClass
);
public static readonly Interface PublicTestInterface = Architecture.GetInterfaceOfType(
typeof(IPublicTestInterface)
);
public static readonly Interface InternalTestInterface = Architecture.GetInterfaceOfType(
typeof(IInternalTestInterface)
);
public static readonly Interface NestedPublicTestInterface =
Architecture.GetInterfaceOfType(
typeof(TestClassForVisibilityTest.INestedPublicTestInterface)
);
public static readonly Interface NestedPrivateTestInterface =
Architecture.GetInterfaceOfType(
TestClassForVisibilityTest.TypeOfNestedPrivateTestInterface
);
public static readonly Interface NestedProtectedTestInterface =
Architecture.GetInterfaceOfType(
TestClassForVisibilityTest.TypeOfNestedProtectedTestInterface
);
public static readonly Interface NestedInternalTestInterface =
Architecture.GetInterfaceOfType(
typeof(TestClassForVisibilityTest.INestedInternalTestInterface)
);
public static readonly Interface NestedProtectedInternalTestInterface =
Architecture.GetInterfaceOfType(
typeof(TestClassForVisibilityTest.INestedProtectedInternalTestInterface)
);
public static readonly Interface NestedPrivateProtectedTestInterface =
Architecture.GetInterfaceOfType(
TestClassForVisibilityTest.TypeOfNestedPrivateProtectedTestInterface
);
public static readonly Interface InheritedTestInterface = Architecture.GetInterfaceOfType(
typeof(IInheritedTestInterface)
);
public static readonly Interface InheritingInterface = Architecture.GetInterfaceOfType(
typeof(IInheritingInterface)
);
public static readonly Class InheritedType = Architecture.GetClassOfType(
typeof(InheritedType)
);
public static readonly Class InheritingType = Architecture.GetClassOfType(
typeof(InheritingType)
);
public static readonly Interface TestInterface1 = Architecture.GetInterfaceOfType(
typeof(ITestInterface1)
);
public static readonly Interface InheritedFromTestInterface12 =
Architecture.GetInterfaceOfType(typeof(IInheritedFromTestInterface12));
}
// ReSharper disable MemberCanBePrivate.Global
// ReSharper disable once ClassNeverInstantiated.Global
internal class TestClassForVisibilityTest
{
internal static readonly Type TypeOfNestedPrivateTestClass = typeof(NestedPrivateTestClass);
internal static readonly Type TypeOfNestedProtectedTestClass =
typeof(NestedProtectedTestClass);
internal static readonly Type TypeOfNestedPrivateProtectedTestClass =
typeof(NestedPrivateProtectedTestClass);
internal static readonly Type TypeOfNestedPrivateTestInterface =
typeof(INestedPrivateTestInterface);
internal static readonly Type TypeOfNestedProtectedTestInterface =
typeof(INestedProtectedTestInterface);
internal static readonly Type TypeOfNestedPrivateProtectedTestInterface =
typeof(INestedPrivateProtectedTestInterface);
public class NestedPublicTestClass { }
private class NestedPrivateTestClass { }
protected class NestedProtectedTestClass { }
internal class NestedInternalTestClass { }
protected internal class NestedProtectedInternalTestClass { }
private protected class NestedPrivateProtectedTestClass { }
public interface INestedPublicTestInterface { }
private interface INestedPrivateTestInterface { }
protected interface INestedProtectedTestInterface { }
internal interface INestedInternalTestInterface { }
protected internal interface INestedProtectedInternalTestInterface { }
private protected interface INestedPrivateProtectedTestInterface { }
}
public enum TestEnum { }
public struct TestStruct { }
public sealed class SealedTestClass { }
public class TestAttribute : System.Attribute { }
public class ChildTestAttribute : TestAttribute { }
public sealed class SealedTestAttribute : System.Attribute { }
public class PublicTestClass
{
public class ChildClass { }
}
internal class InternalTestClass { }
public interface IPublicTestInterface { }
internal interface IInternalTestInterface { }
internal interface IInheritedTestInterface { }
internal interface IInheritingInterface : IInheritedTestInterface { }
internal abstract class InheritedType : IInheritingInterface { }
internal class InheritingType : InheritedType { }
internal interface ITestInterface1 { }
internal interface ITestInterface12 { }
internal interface IInheritedFromTestInterface12 : ITestInterface12 { }
}