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
|
// -----------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// -----------------------------------------------------------------------
using System;
using System.ComponentModel.Composition.Factories;
using System.ComponentModel.Composition.Hosting;
using System.ComponentModel.Composition.Primitives;
using System.ComponentModel.Composition.AttributedModel;
using System.Reflection;
using Microsoft.Internal;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
namespace System.ComponentModel.Composition.ReflectionModel
{
[TestClass]
public class ReflectionParameterImportDefinitionTests
{
[TestMethod]
public void Constructor()
{
Lazy<ParameterInfo> parameter = CreateLazyParameter();
IEnumerable<KeyValuePair<string, Type>> requiredMetadata = new KeyValuePair<string, Type>[] { new KeyValuePair<string, Type>("Foo", typeof(object)) };
ReflectionParameterImportDefinition definition = new ReflectionParameterImportDefinition(
parameter, "Contract", (string)null, requiredMetadata, ImportCardinality.ZeroOrMore, CreationPolicy.NonShared, null);
Assert.AreSame(parameter, definition.ImportingLazyParameter);
Assert.AreEqual("Contract", definition.ContractName);
Assert.AreSame(requiredMetadata, definition.RequiredMetadata);
Assert.AreEqual(CreationPolicy.NonShared, definition.RequiredCreationPolicy);
Assert.AreEqual(false, definition.IsRecomposable);
Assert.AreEqual(true, definition.IsPrerequisite);
Assert.IsNull(((ICompositionElement)definition).Origin);
Assert.IsNotNull(((ICompositionElement)definition).DisplayName);
}
[TestMethod]
public void Constructor_WithNullRequiredMetadata()
{
Lazy<ParameterInfo> parameter = CreateLazyParameter();
ReflectionParameterImportDefinition definition = new ReflectionParameterImportDefinition(
parameter, "Contract", (string)null, null, ImportCardinality.ZeroOrMore, CreationPolicy.NonShared, null);
Assert.IsNotNull(definition.RequiredMetadata);
Assert.AreEqual(0, definition.RequiredMetadata.Count());
}
[TestMethod]
public void SetDefinition_OriginIsSet()
{
Lazy<ParameterInfo> parameter = CreateLazyParameter();
var expectedPartDefinition = PartDefinitionFactory.CreateAttributed(typeof(object));
ReflectionParameterImportDefinition definition = new ReflectionParameterImportDefinition(
parameter, "Contract", (string)null, null, ImportCardinality.ZeroOrMore, CreationPolicy.NonShared, expectedPartDefinition);
Assert.AreSame(expectedPartDefinition, ((ICompositionElement)definition).Origin);
}
[TestMethod]
public void ICompositionElementDisplayName_ValueAsParameter_ShouldIncludeParameterName()
{
var names = Expectations.GetContractNamesWithEmpty();
foreach (var name in names)
{
var definition = CreateReflectionParameterImportDefinition(name);
var e = CreateDisplayNameExpectationFromParameterName(definition, name);
Assert.AreEqual(e, ((ICompositionElement)definition).DisplayName);
}
}
[TestMethod]
public void ICompositionElementDisplayName_ValueAsParameter_ShouldIncludeContractName()
{
var types = Expectations.GetTypes();
foreach (var type in types)
{
var definition = CreateReflectionParameterImportDefinition(type);
var e = CreateDisplayNameExpectationFromContractName(definition, type);
Assert.AreEqual(e, ((ICompositionElement)definition).DisplayName);
}
}
[TestMethod]
public void ToString_ShouldReturnICompositionElementDisplayName()
{
var types = Expectations.GetTypes();
foreach (var type in types)
{
var definition = CreateReflectionParameterImportDefinition(type);
Assert.AreEqual(((ICompositionElement)definition).DisplayName, definition.ToString());
}
}
private Lazy<ParameterInfo> CreateLazyParameter()
{
return typeof(SimpleConstructorInjectedObject).GetConstructors().First().GetParameters().First().AsLazy();
}
private static string CreateDisplayNameExpectationFromContractName(ReflectionParameterImportDefinition definition, Type type)
{
string contractName = AttributedModelServices.GetContractName(type);
return String.Format("{0} (Parameter=\"\", ContractName=\"{1}\")", definition.ImportingLazyParameter.Value.Member.GetDisplayName(), contractName);
}
private static string CreateDisplayNameExpectationFromParameterName(ReflectionParameterImportDefinition definition, string name)
{
return String.Format("{0} (Parameter=\"{1}\", ContractName=\"System.String\")", definition.ImportingLazyParameter.Value.Member.GetDisplayName(), name);
}
private static ReflectionParameterImportDefinition CreateReflectionParameterImportDefinition(Type parameterType)
{
var parameter = ReflectionFactory.CreateParameter(parameterType);
return CreateReflectionParameterImportDefinition(parameter);
}
private static ReflectionParameterImportDefinition CreateReflectionParameterImportDefinition(string name)
{
var parameter = ReflectionFactory.CreateParameter(name);
return CreateReflectionParameterImportDefinition(parameter);
}
private static ReflectionParameterImportDefinition CreateReflectionParameterImportDefinition(ParameterInfo parameter)
{
return new ReflectionParameterImportDefinition(
parameter.AsLazy(), AttributedModelServices.GetContractName(parameter.ParameterType), (string)null, null, ImportCardinality.ZeroOrMore, CreationPolicy.NonShared, null);
}
}
}
|
