3 |
4 |
5 | This project monitors support for different features across multiple libraries.
8 |
9 | You can find the code behind this site at net-feature-tests GitHub project .
10 |
11 | Please note the following:
12 |
13 | The list of features is based on what I consider to be important. It is not an objective measure on which library is "better".
14 | It is not possible to test for all features automatically. For example, extensibility is very important, but impossible to test/measure.
15 | The test about might not necessary be up to date (see the version for each library).
16 | The test code should not be seen as best practice for each library — it forces all of them to the same test interface.
17 | I am not an expert on all libraries and not all adapters were reviewed by authors. So feature may fail because of incorrect adapter.
18 |
19 |
20 | Thanks for reading!
--------------------------------------------------------------------------------
/#framework/Runner/Outputs/Html/Templates/Results.cshtml:
--------------------------------------------------------------------------------
1 | @using System.Linq
2 | @using AshMind.Extensions
3 | @using FeatureTests.Runner.Sources
4 | @inherits FeatureTests.Runner.Outputs.Html.HtmlTemplateBase
5 |
6 | @Html.Raw(Model.HtmlBeforeAll)
7 |
8 | @foreach (var table in Model.Tables) {
9 |
10 | @table.DisplayName
11 | @Format.Description(table.Description)
12 |
13 |
14 |
15 | Name
16 | @foreach (var library in table.Libraries) {
17 | @library.Name
20 |
21 | @foreach (var row in table.GetFeatureRows()) {
22 | var feature = row.Item1;
23 | var rowClass = (string)null;
24 | if (feature.Key == MetadataKeys.TotalFeature && !Model.TotalVisible) {
25 | rowClass = "total-hidden";
26 | }
27 |
28 |
29 | @feature.Name
32 | @if (cell.HasDetails) {
33 | @Format.DisplayValue(cell.DisplayValue)
34 | }
35 | else if (cell.DisplayUri != null) {
36 | @Format.DisplayValue(cell.DisplayValue)
37 | }
38 | else {
39 | @Format.DisplayValue(cell.DisplayValue)
40 | }
41 |
42 | }
43 |
44 | }
45 |
46 |
47 | }
48 |
49 | @Html.Raw(Model.HtmlAfterAll)
50 |
51 |
--------------------------------------------------------------------------------
/#framework/Runner/Outputs/Html/Templates/_Layout.cshtml:
--------------------------------------------------------------------------------
1 | @using System.Linq
2 | @inherits FeatureTests.Runner.Outputs.Html.HtmlTemplateBase
3 |
4 |
5 | @* Metanote: Ignore the following note in Razor template, it is only relevant to the result. *@
6 |
7 |
8 |
9 | @Model.Title
10 |
42 | @Model.Title
43 |
44 | @RenderBody()
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
62 |
63 |
--------------------------------------------------------------------------------
/#framework/Runner/Outputs/IResultOutput.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.IO;
4 | using System.Linq;
5 |
6 | namespace FeatureTests.Runner.Outputs {
7 | public interface IResultOutput : IDisposable {
8 | void Write(DirectoryInfo outputDirectory, IReadOnlyCollection results, bool keepUpdatingIfTemplatesChange = false);
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/#framework/Runner/Outputs/JsonOutput.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.IO;
4 | using System.Linq;
5 | using System.Reflection;
6 | using System.Runtime.Versioning;
7 | using FeatureTests.Shared.ResultData;
8 | using Newtonsoft.Json;
9 | using NuGet;
10 | using FeatureTests.Runner.Sources;
11 | using FeatureTests.Shared;
12 |
13 | namespace FeatureTests.Runner.Outputs {
14 | public class JsonOutput : IResultOutput {
15 | public void Write(DirectoryInfo outputDirectory, IReadOnlyCollection results, bool keepUpdatingIfTemplatesChange = false) {
16 | foreach (var result in results) {
17 | Write(outputDirectory, result);
18 | }
19 | }
20 |
21 | private void Write(DirectoryInfo outputDirectory, ResultForAssembly result) {
22 | var tableList = result.Tables.ToArray();
23 |
24 | var general = tableList.First(t => t.Key == MetadataKeys.GeneralInfoTable);
25 | var netFxVersions = tableList.First(t => t.Key == MetadataKeys.NetFxSupportTable);
26 | var data = tableList[0].Libraries.Select(l => new {
27 | name = l.Name,
28 | url = general[l, MetadataKeys.UrlFeature].DisplayUri,
29 | version = general[l, MetadataKeys.VersionFeature].DisplayValue,
30 | supports = GetNetFxVersions(l, netFxVersions),
31 | features = GetAllFeatureData(l, tableList)
32 | });
33 |
34 | var json = JsonConvert.SerializeObject(data, Formatting.Indented, new JsonSerializerSettings {
35 | NullValueHandling = NullValueHandling.Ignore
36 | });
37 | File.WriteAllText(Path.Combine(outputDirectory.FullName, result.OutputNamePrefix + ".json"), json);
38 | }
39 |
40 | private string[] GetNetFxVersions(ILibrary library, FeatureTable table) {
41 | return table.Features.Where(f => table[library, f].State == FeatureState.Success)
42 | .Select(f => (IGrouping)f.Key)
43 | .Select(g => VersionUtility.GetShortFrameworkName(g.First()))
44 | .ToArray();
45 | }
46 |
47 | private IDictionary GetAllFeatureData(ILibrary library, IEnumerable tables) {
48 | var featuresByName = tables.Where(t => t.Key != MetadataKeys.GeneralInfoTable && t.Key != MetadataKeys.NetFxSupportTable)
49 | .SelectMany(t => t.Features.Select(f => this.GetSingleFeatureData(f, t[library, f])))
50 | .GroupBy(p => p.Key)
51 | .ToArray();
52 |
53 | var duplicate = featuresByName.FirstOrDefault(g => g.Count() > 1);
54 | if (duplicate != null)
55 | throw new Exception("Feature name " + duplicate.Key + " was used more than once.");
56 |
57 | return featuresByName.ToDictionary(p => p.Key, p => p.Single().Value);
58 | }
59 |
60 | private KeyValuePair GetSingleFeatureData(Feature feature, FeatureCell cell) {
61 | var key = this.GetFeatureName(feature);
62 | var value = new {
63 | result = cell.State.ToString().ToLowerInvariant(),
64 | comment = cell.Details,
65 | error = cell.RawError
66 | };
67 |
68 | return new KeyValuePair(key, value);
69 | }
70 |
71 | private string GetFeatureName(Feature feature) {
72 | // HACK :)
73 | var method = feature.Key as MethodInfo;
74 | return method != null ? method.Name : feature.Name;
75 | }
76 |
77 | #region IDisposable Members
78 |
79 | public void Dispose() {
80 | }
81 |
82 | #endregion
83 | }
84 | }
85 |
--------------------------------------------------------------------------------
/#framework/Runner/Outputs/ResultForAssembly.cs:
--------------------------------------------------------------------------------
1 | using System.Collections.Generic;
2 | using System.Reflection;
3 | using FeatureTests.Shared.ResultData;
4 |
5 | namespace FeatureTests.Runner.Outputs {
6 | public class ResultForAssembly {
7 | public ResultForAssembly(Assembly assembly, IReadOnlyList tables, string outputNamePrefix) {
8 | this.Assembly = assembly;
9 | this.Tables = tables;
10 | this.OutputNamePrefix = outputNamePrefix;
11 | }
12 |
13 | public Assembly Assembly { get; private set; }
14 | public IReadOnlyList Tables { get; private set; }
15 | public string OutputNamePrefix { get; private set; }
16 | }
17 | }
--------------------------------------------------------------------------------
/#framework/Runner/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
1 | using System.Reflection;
2 | using System.Runtime.InteropServices;
3 |
4 | // General Information about an assembly is controlled through the following
5 | // set of attributes. Change these attribute values to modify the information
6 | // associated with an assembly.
7 | [assembly: AssemblyCopyright("Copyright © Andrey Shchekin 2013")]
8 |
9 | // Setting ComVisible to false makes the types in this assembly not visible
10 | // to COM components. If you need to access a type in this assembly from
11 | // COM, set the ComVisible attribute to true on that type.
12 | [assembly: ComVisible(false)]
13 |
14 | // The following GUID is for the ID of the typelib if this project is exposed to COM
15 | [assembly: Guid("0f34cfb0-7802-4f0a-a540-c82d9a9bec0f")]
16 |
17 | // Version information for an assembly consists of the following four values:
18 | //
19 | // Major Version
20 | // Minor Version
21 | // Build Number
22 | // Revision
23 | //
24 | // You can specify all the values or you can default the Build and Revision Numbers
25 | // by using the '*' as shown below:
26 | // [assembly: AssemblyVersion("1.0.*")]
27 | [assembly: AssemblyVersion("1.0.0.0")]
28 | [assembly: AssemblyFileVersion("1.0.0.0")]
29 |
--------------------------------------------------------------------------------
/#framework/Runner/Sources/2_NetFxSupportTableSource.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using System.Runtime.Versioning;
6 | using FeatureTests.Shared.ResultData;
7 | using NuGet;
8 | using FeatureTests.Shared;
9 | using FeatureTests.Shared.InfrastructureSupport;
10 | using FeatureTests.Runner.Sources.MetadataSupport;
11 |
12 | namespace FeatureTests.Runner.Sources {
13 | public class NetFxSupportTableSource : IFeatureTableSource {
14 | private readonly LocalPackageCache packageCache;
15 |
16 | public NetFxSupportTableSource(LocalPackageCache packageCache) {
17 | this.packageCache = packageCache;
18 | }
19 |
20 | public IEnumerable GetTables(Assembly featureTestAssembly) {
21 | yield return this.GetTable(featureTestAssembly);
22 | }
23 |
24 | private FeatureTable GetTable(Assembly featureTestAssembly) {
25 | var libraries = LibraryProvider.GetAdapters(featureTestAssembly).ToArray();
26 | var allVersionsGrouped = libraries.Where(l => l.PackageId != null)
27 | .Select(l => this.packageCache.GetPackage(l.PackageId))
28 | .SelectMany(p => p.GetSupportedFrameworks())
29 | .SelectMany(NetFxVersionHelper.Split)
30 | .Where(NetFxVersionHelper.ShouldDisplay)
31 | .GroupBy(NetFxVersionHelper.GetDisplayName)
32 | .OrderBy(g => NetFxVersionHelper.GetDisplayOrder(g.First()))
33 | .ToList();
34 |
35 | var versionFeatures = allVersionsGrouped.Select(g => new Feature(g, g.Key));
36 | var table = new FeatureTable(MetadataKeys.NetFxSupportTable, "Supported .NET versions", libraries, versionFeatures) {
37 | Description = "This information is based on versions included in NuGet package.",
38 | Scoring = FeatureScoring.NotScored
39 | };
40 |
41 | foreach (var library in libraries) {
42 | this.FillNetVersionSupport(table, library, allVersionsGrouped);
43 | }
44 |
45 | return table;
46 | }
47 |
48 | private void FillNetVersionSupport(FeatureTable table, ILibrary library, IEnumerable> allVersionsGrouped) {
49 | if (library.PackageId == null) {
50 | // this is always intentional
51 | foreach (var versionGroup in allVersionsGrouped) {
52 | var cell = table[library, versionGroup];
53 | cell.State = FeatureState.Skipped;
54 | cell.DisplayValue = "n/a";
55 | }
56 |
57 | return;
58 | }
59 |
60 | var package = this.packageCache.GetPackage(library.PackageId);
61 | var supported = package.GetSupportedFrameworks().ToArray();
62 |
63 | foreach (var versionGroup in allVersionsGrouped) {
64 | var cell = table[library, versionGroup];
65 | if (versionGroup.Any(v => VersionUtility.IsCompatible(v, supported))) {
66 | cell.State = FeatureState.Success;
67 | cell.DisplayValue = "yes";
68 | }
69 | else {
70 | cell.State = FeatureState.Concern;
71 | cell.DisplayValue = "no";
72 | }
73 | }
74 | }
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/#framework/Runner/Sources/FeatureTestSupport/AttributeTextCleaner.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Text.RegularExpressions;
5 | using AshMind.Extensions;
6 |
7 | namespace FeatureTests.Runner.Sources.FeatureTestSupport {
8 | public class AttributeTextCleaner {
9 | public string CleanWhitespace(string attributeText) {
10 | if (attributeText.IsNullOrEmpty())
11 | return attributeText;
12 |
13 | // remove all spaces at the start of the line
14 | return Regex.Replace(attributeText, @"^ +", "", RegexOptions.Multiline);
15 | }
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/#framework/Runner/Sources/FeatureTestSupport/FeatureTestResult.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | namespace FeatureTests.Runner.Sources.FeatureTestSupport {
4 | public class FeatureTestResult {
5 | public FeatureTestResultKind Kind { get; private set; }
6 | public string Message { get; private set; }
7 | public Exception Exception { get; private set; }
8 |
9 | public FeatureTestResult(FeatureTestResultKind kind, string message = null, Exception exception = null) {
10 | this.Kind = kind;
11 | this.Message = message;
12 | this.Exception = exception;
13 | }
14 | }
15 | }
--------------------------------------------------------------------------------
/#framework/Runner/Sources/FeatureTestSupport/FeatureTestResultKind.cs:
--------------------------------------------------------------------------------
1 | namespace FeatureTests.Runner.Sources.FeatureTestSupport {
2 | public enum FeatureTestResultKind {
3 | Success,
4 | SkippedDueToDependency,
5 | SkippedDueToSpecialCase,
6 | Failure
7 | }
8 | }
--------------------------------------------------------------------------------
/#framework/Runner/Sources/FeatureTestSupport/FeatureTestRun.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Reflection;
3 | using System.Threading.Tasks;
4 |
5 | namespace FeatureTests.Runner.Sources.FeatureTestSupport {
6 | public class FeatureTestRun {
7 | public MethodInfo Method { get; private set; }
8 | public Type AdapterType { get; private set; }
9 | public Task Task { get; private set; }
10 |
11 | public FeatureTestRun(MethodInfo method, Type adapterType, Task task) {
12 | this.Method = method;
13 | this.AdapterType = adapterType;
14 | this.Task = task;
15 | }
16 | }
17 | }
--------------------------------------------------------------------------------
/#framework/Runner/Sources/IFeatureTableSource.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using FeatureTests.Shared.ResultData;
6 |
7 | namespace FeatureTests.Runner.Sources {
8 | public interface IFeatureTableSource {
9 | IEnumerable GetTables(Assembly featureTestAssembly);
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/#framework/Runner/Sources/MetadataKeys.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Runner.Sources {
6 | public static class MetadataKeys {
7 | public static readonly object GeneralInfoTable = "Metadata.GeneralInfo";
8 | public static readonly object VersionFeature = "Metadata.Version";
9 | public static readonly object UrlFeature = "Metadata.Url";
10 | public static readonly object NetFxSupportTable = "Metadata.NetFxSupport";
11 | public static readonly object TotalFeature = "Metadata.Total";
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/#framework/Runner/Sources/MetadataSupport/HttpDataProvider.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.IO;
4 | using System.Linq;
5 | using System.Net.Http;
6 | using System.Threading.Tasks;
7 | using CacheCow.Client;
8 |
9 | namespace FeatureTests.Runner.Sources.MetadataSupport {
10 | public class HttpDataProvider {
11 | private readonly DirectoryInfo cacheRoot;
12 |
13 | public HttpDataProvider(DirectoryInfo cacheRoot) {
14 | this.cacheRoot = cacheRoot;
15 | }
16 |
17 | public async Task GetDataAsync(Uri url) {
18 | using (var client = CreateHttpClient()) {
19 | var response = await client.GetAsync(url);
20 | response.EnsureSuccessStatusCode();
21 |
22 | return await response.Content.ReadAsAsync();
23 | }
24 | }
25 |
26 | public async Task GetStringAsync(Uri url) {
27 | using (var client = CreateHttpClient())
28 | using (var response = await client.GetAsync(url)) {
29 | if (!response.IsSuccessStatusCode)
30 | throw new HttpDataRequestException(response.StatusCode);
31 |
32 | return await response.Content.ReadAsStringAsync();
33 | }
34 | }
35 |
36 | public HttpClient CreateHttpClient() {
37 | var handler = new CachingHandler(new FlatFileCacheStore(cacheRoot)) {
38 | InnerHandler = new HttpClientHandler()
39 | };
40 | var baseValidator = handler.ResponseValidator;
41 | handler.ResponseValidator = m => {
42 | var result = baseValidator(m);
43 | if (result == ResponseValidationResult.NotExist || result == ResponseValidationResult.OK)
44 | return result;
45 |
46 | var sinceName = "X-Forced-Cache-Since";
47 | var sinceString = m.Headers.Contains(sinceName)
48 | ? m.Headers.GetValues(sinceName).SingleOrDefault()
49 | : null;
50 | if (sinceString == null) {
51 | m.Headers.Add(sinceName, DateTimeOffset.Now.ToString());
52 | return ResponseValidationResult.OK;
53 | }
54 |
55 | var since = DateTimeOffset.Parse(sinceString);
56 | return (DateTimeOffset.Now - since).TotalHours <= 1
57 | ? ResponseValidationResult.OK
58 | : ResponseValidationResult.Stale;
59 | };
60 |
61 | return new HttpClient(handler);
62 | }
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/#framework/Runner/Sources/MetadataSupport/HttpDataRequestException.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Net;
5 | using System.Runtime.Serialization;
6 |
7 | namespace FeatureTests.Runner.Sources.MetadataSupport {
8 | [Serializable]
9 | public class HttpDataRequestException : Exception {
10 | public HttpStatusCode StatusCode { get; private set; }
11 |
12 | public HttpDataRequestException(HttpStatusCode statusCode) {
13 | StatusCode = statusCode;
14 | }
15 |
16 | public HttpDataRequestException(string message, HttpStatusCode statusCode)
17 | : base(message)
18 | {
19 | StatusCode = statusCode;
20 | }
21 |
22 | public HttpDataRequestException(string message, HttpStatusCode statusCode, Exception inner)
23 | : base(message, inner)
24 | {
25 | StatusCode = statusCode;
26 | }
27 |
28 | protected HttpDataRequestException(SerializationInfo info, StreamingContext context) : base(info, context) { }
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/#framework/Runner/Sources/MetadataSupport/LicenseInfo.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Runner.Sources.MetadataSupport {
6 | public class LicenseInfo {
7 | public LicenseInfo() {
8 | this.Urls = new List();
9 | }
10 |
11 | public string ShortName { get; set; }
12 | public string Pattern { get; set; }
13 | public IList Urls { get; private set; }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/#framework/Runner/Sources/MetadataSupport/LicenseResolver.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.IO;
4 | using System.Linq;
5 | using System.Text.RegularExpressions;
6 | using System.Threading.Tasks;
7 | using Newtonsoft.Json;
8 |
9 | namespace FeatureTests.Runner.Sources.MetadataSupport {
10 | public class LicenseResolver {
11 | #region LicenseRoot Class
12 | private class LicenseRoot {
13 | public LicenseInfo[] Licenses { get; set; }
14 | }
15 | #endregion
16 |
17 | private readonly HttpDataProvider httpProvider;
18 | private readonly IList licenses;
19 |
20 | public LicenseResolver(HttpDataProvider httpProvider, Uri licensesJsonUrl) {
21 | this.httpProvider = httpProvider;
22 |
23 | var licensesJson = this.httpProvider.GetStringAsync(licensesJsonUrl).Result;
24 | this.licenses = JsonConvert.DeserializeObject(licensesJson).Licenses;
25 | }
26 |
27 | public async Task GetLicenseInfo(Uri licenseUrl) {
28 | var licenseInfo = this.licenses.FirstOrDefault(l => l.Urls.Contains(licenseUrl));
29 | if (licenseInfo != null)
30 | return licenseInfo;
31 |
32 | var licenseText = await httpProvider.GetStringAsync(licenseUrl);
33 | licenseText = Regex.Replace(licenseText, "<[^>]+>", ""); // in case it is HTML -- naive but let's not overengineer
34 | licenseInfo = this.licenses.Where(l => l.Pattern != null)
35 | .FirstOrDefault(l => IsMatch(l, licenseText));
36 |
37 | return licenseInfo;
38 | }
39 |
40 | private bool IsMatch(LicenseInfo licenseInfo, string licenseText) {
41 | var pattern = Regex.Replace(licenseInfo.Pattern, @"\s+", "\\s+");
42 | return Regex.IsMatch(licenseText, pattern, RegexOptions.Singleline | RegexOptions.IgnoreCase);
43 | }
44 | }
45 | }
--------------------------------------------------------------------------------
/#framework/Runner/Sources/MetadataSupport/LocalPackageCache.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Concurrent;
3 | using System.Collections.Generic;
4 | using System.Linq;
5 | using NuGet;
6 |
7 | namespace FeatureTests.Runner.Sources.MetadataSupport {
8 | public class LocalPackageCache {
9 | private readonly IPackageRepository packageRepository;
10 | private readonly ConcurrentDictionary packages = new ConcurrentDictionary();
11 |
12 | public LocalPackageCache(string nugetPackagesPath) {
13 | this.packageRepository = new SharedPackageRepository(nugetPackagesPath);
14 | }
15 |
16 | public IPackage GetPackage(string packageId) {
17 | return this.packages.GetOrAdd(packageId, _ => {
18 | var found = this.packageRepository.FindPackagesById(packageId).ToArray();
19 | if (found.Length > 1) {
20 | if (packageId == "ValueInjecter") { // special case/hack, remove when ValueInjecter is fixed
21 | var correct = found.SingleOrDefault(p => p.Version.ToString() == "2.3.3");
22 | if (correct != null)
23 | return correct;
24 | }
25 |
26 | throw new Exception(string.Format("Found more than one package '{0}' in '{1}': check if any of those are obsolete/unused.", packageId, this.packageRepository.Source));
27 | }
28 |
29 | if (found.Length == 0)
30 | throw new Exception(string.Format("Package '{0}' was not found in '{1}'.", packageId, this.packageRepository.Source));
31 |
32 | return found[0];
33 | });
34 | }
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/#framework/Runner/Sources/MetadataSupport/NuGetGalleryPackage.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Runner.Sources.MetadataSupport {
6 | public class NuGetGalleryPackage {
7 | public DateTime Published { get; set; }
8 | public int DownloadCount { get; set; }
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/#framework/Runner/packages.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/#framework/Runner/web.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
12 |
13 |
14 |
--------------------------------------------------------------------------------
/#framework/Shared/DependsOnFeatureAttribute.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Shared {
6 | ///
7 | /// Defines a feature that must succeed for this test to be run.
8 | /// This is not currently used by Xunit -- only by FeatureTests.Runner.
9 | ///
10 | [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
11 | public class DependsOnFeatureAttribute : Attribute {
12 | public Type DeclaringType { get; private set; }
13 | public string MethodName { get; private set; }
14 |
15 | public DependsOnFeatureAttribute(Type declaringType, string methodName) {
16 | this.MethodName = methodName;
17 | this.DeclaringType = declaringType;
18 | }
19 |
20 | // DeclaringType not provided = current type.
21 | public DependsOnFeatureAttribute(string methodName) {
22 | this.MethodName = methodName;
23 | }
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/#framework/Shared/DisplayOrderAttribute.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Shared {
6 | [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
7 | public class DisplayOrderAttribute : Attribute {
8 | public int Order { get; private set; }
9 |
10 | public DisplayOrderAttribute(int order) {
11 | this.Order = order;
12 | }
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/#framework/Shared/FeatureAttribute.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using FeatureTests.Shared.InfrastructureSupport;
5 | using Xunit;
6 | using Xunit.Sdk;
7 |
8 | namespace FeatureTests.Shared {
9 | [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
10 | public class FeatureAttribute : FactAttribute {
11 | protected override IEnumerable EnumerateTestCommands(IMethodInfo method) {
12 | return LibraryProvider.GetAdapters(method.Class.Type.Assembly)
13 | .Select(adapter => new FeatureTestCommand(method, adapter));
14 | }
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/#framework/Shared/FeatureScoring.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Shared {
6 | public enum FeatureScoring {
7 | NotScored,
8 | SinglePoint,
9 | PointPerFeature
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/#framework/Shared/FeatureScoringAttribute.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Shared {
6 | [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = true)]
7 | public class FeatureScoringAttribute : Attribute {
8 | public FeatureScoring Value { get; private set; }
9 |
10 | public FeatureScoringAttribute(FeatureScoring value) {
11 | this.Value = value;
12 | }
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/#framework/Shared/GenericApiSupport/GenericHelper.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Linq.Expressions;
5 | using System.Text.RegularExpressions;
6 | using AshMind.Extensions;
7 | using FeatureTests.Shared.GenericApiSupport.GenericPlaceholders;
8 |
9 | namespace FeatureTests.Shared.GenericApiSupport {
10 | public static class GenericHelper {
11 | public static void RewriteAndInvoke(Expression call, params Type[] genericArguments) {
12 | var rewritten = Rewrite(call, genericArguments);
13 | ((Action)rewritten.Compile())();
14 | }
15 |
16 | public static object RewriteAndInvoke(Expression> call, params Type[] genericArguments) {
17 | var rewritten = Rewrite(call, genericArguments);
18 | return ((Func)rewritten.Compile())();
19 | }
20 |
21 | private static LambdaExpression Rewrite(Expression call, Type[] genericArguments) {
22 | var visitor = new GenericRewritingVisitor(a => RewriteTypeIfPossible(a, genericArguments));
23 | return (LambdaExpression)visitor.Visit(call);
24 | }
25 |
26 | private static Type RewriteTypeIfPossible(Type type, Type[] rewriteTo) {
27 | if (type.IsDefined())
28 | return RewritePlaceholderType(type, rewriteTo);
29 |
30 | if (!type.IsGenericType)
31 | return type;
32 |
33 | var arguments = type.GetGenericArguments();
34 | var rewritten = arguments.Select(a => RewriteTypeIfPossible(a, rewriteTo)).ToArray();
35 | if (!rewritten.SequenceEqual(arguments))
36 | return type.GetGenericTypeDefinition().MakeGenericType(rewritten);
37 |
38 | return type;
39 | }
40 |
41 | private static Type RewritePlaceholderType(Type type, Type[] rewriteTo) {
42 | if (type.IsGenericType)
43 | type = type.GetGenericArguments()[0];
44 |
45 | var index = int.Parse(Regex.Match(type.Name, @"\d+").Value) - 1;
46 | return rewriteTo[index];
47 | }
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/#framework/Shared/GenericApiSupport/GenericPlaceholders.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | // ReSharper disable CheckNamespace
6 | namespace FeatureTests.Shared.GenericApiSupport.GenericPlaceholders {
7 | // ReSharper restore CheckNamespace
8 |
9 | [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Struct, AllowMultiple = false)]
10 | public class GenericPlaceholderAttribute : Attribute {}
11 |
12 | [GenericPlaceholder] public class X1 {}
13 | [GenericPlaceholder] public class X2 {}
14 |
15 | // ReSharper disable UnusedTypeParameter
16 |
17 | // Those classes provide hierarchy used to match generic inheritance constraints.
18 | [GenericPlaceholder] public class P {}
19 | [GenericPlaceholder] public class C : P {}
20 |
21 | // ReSharper restore UnusedTypeParameter
22 | }
23 |
--------------------------------------------------------------------------------
/#framework/Shared/ILibrary.cs:
--------------------------------------------------------------------------------
1 | using System.Reflection;
2 |
3 | namespace FeatureTests.Shared {
4 | public interface ILibrary {
5 | string Name { get; }
6 | Assembly Assembly { get; }
7 | string PackageId { get; }
8 | }
9 | }
--------------------------------------------------------------------------------
/#framework/Shared/InfrastructureSupport/FeatureTestAttributeHelper.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.ComponentModel;
4 | using System.Linq;
5 | using System.Reflection;
6 |
7 | namespace FeatureTests.Shared.InfrastructureSupport {
8 | // in real application it should not be static or helper
9 | public static class FeatureTestAttributeHelper {
10 | public static string GetDisplayName(MemberInfo member) {
11 | var displayNameAttribute = member.GetCustomAttributes().SingleOrDefault();
12 | if (displayNameAttribute == null)
13 | return member.Name;
14 |
15 | return displayNameAttribute.DisplayName;
16 | }
17 |
18 | public static int GetDisplayOrder(MemberInfo member) {
19 | var displayOrderAttribute = member.GetCustomAttributes().SingleOrDefault();
20 | if (displayOrderAttribute == null)
21 | return int.MaxValue;
22 |
23 | return displayOrderAttribute.Order;
24 | }
25 |
26 | public static FeatureScoring GetScoring(MemberInfo member) {
27 | var scoringAttribute = member.GetCustomAttributes().SingleOrDefault();
28 | if (scoringAttribute == null)
29 | return FeatureScoring.PointPerFeature;
30 |
31 | return (FeatureScoring)scoringAttribute.Value;
32 | }
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/#framework/Shared/InfrastructureSupport/FeatureTestCommand.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Reflection;
3 | using Xunit.Sdk;
4 |
5 | namespace FeatureTests.Shared.InfrastructureSupport {
6 | public class FeatureTestCommand : TestCommand {
7 | private readonly ILibrary adapter;
8 |
9 | public FeatureTestCommand(IMethodInfo method, ILibrary adapter)
10 | : base(method, adapter.Name, MethodUtility.GetTimeoutParameter(method))
11 | {
12 | this.adapter = adapter;
13 | }
14 |
15 | public override MethodResult Execute(object testClass) {
16 | try {
17 | var parameters = this.testMethod.MethodInfo.GetParameters();
18 | if (parameters.Length != 1)
19 | throw new InvalidOperationException("Feature test method must have a single parameter.");
20 |
21 | this.testMethod.Invoke(testClass, new[] {this.adapter});
22 | }
23 | catch (TargetInvocationException ex) {
24 | ExceptionUtility.RethrowWithNoStackTraceLoss(ex.InnerException);
25 | }
26 | catch (SkipException ex) {
27 | return new SkipResult(this.testMethod, this.DisplayName, ex.Message);
28 | }
29 |
30 | return new PassedResult(this.testMethod, this.DisplayName);
31 | }
32 | }
33 | }
--------------------------------------------------------------------------------
/#framework/Shared/InfrastructureSupport/LibraryProvider.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Concurrent;
3 | using System.Collections.Generic;
4 | using System.Linq;
5 | using System.Reflection;
6 | using AshMind.Extensions;
7 |
8 | namespace FeatureTests.Shared.InfrastructureSupport {
9 | public static class LibraryProvider {
10 | private static readonly ConcurrentDictionary cache = new ConcurrentDictionary();
11 |
12 | public static IReadOnlyCollection GetAdapterTypes(Assembly assembly) {
13 | return cache.GetOrAdd(assembly,
14 | a => assembly.GetTypes()
15 | .Where(t => t.HasInterface() && !t.IsAbstract)
16 | .OrderBy(t => t.Name)
17 | .ToArray()
18 | );
19 | }
20 |
21 | public static IEnumerable GetAdapters(Assembly assembly) {
22 | return GetAdapterTypes(assembly).Select(CreateAdapter);
23 | }
24 |
25 | public static ILibrary CreateAdapter(Type adapterType) {
26 | return (ILibrary)Activator.CreateInstance(adapterType);
27 | }
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/#framework/Shared/LibraryAdapterBase.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using System.Text.RegularExpressions;
6 | using JetBrains.Annotations;
7 |
8 | namespace FeatureTests.Shared {
9 | [UsedImplicitly(ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature)]
10 | public abstract class LibraryAdapterBase : ILibrary {
11 | public virtual string Name {
12 | get { return Regex.Match(GetType().Name, "^(.+?)(?:Adapter)?$").Groups[1].Value; }
13 | }
14 |
15 | [CanBeNull]
16 | public abstract Assembly Assembly { get; }
17 |
18 | public virtual string PackageId {
19 | get { return Assembly.GetName().Name; }
20 | }
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/#framework/Shared/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
1 | using System.Reflection;
2 | using System.Runtime.CompilerServices;
3 | using System.Runtime.InteropServices;
4 |
5 | // General Information about an assembly is controlled through the following
6 | // set of attributes. Change these attribute values to modify the information
7 | // associated with an assembly.
8 | [assembly: AssemblyTitle("FeatureTests.Support")]
9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("")]
12 | [assembly: AssemblyProduct("FeatureTests.Support")]
13 | [assembly: AssemblyCopyright("Copyright © 2013")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 |
17 | // Setting ComVisible to false makes the types in this assembly not visible
18 | // to COM components. If you need to access a type in this assembly from
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 |
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("a47121b3-99e2-49d9-a0ab-9e5cd3ede4ec")]
24 |
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | // Major Version
28 | // Minor Version
29 | // Build Number
30 | // Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 |
--------------------------------------------------------------------------------
/#framework/Shared/ResultData/Feature.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Shared.ResultData {
6 | public class Feature {
7 | public Feature(string name) : this(new object(), name) {
8 | }
9 |
10 | public Feature(object key, string name) {
11 | this.Key = key;
12 | this.Name = name;
13 | }
14 |
15 | public object Key { get; private set; }
16 | public string Name { get; private set; }
17 | public string Description { get; set; }
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/#framework/Shared/ResultData/FeatureCell.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | namespace FeatureTests.Shared.ResultData {
4 | public class FeatureCell {
5 | public object DisplayValue { get; set; }
6 | public Uri DisplayUri { get; set; }
7 | public string Details { get; set; }
8 | public FeatureState State { get; set; }
9 |
10 | public bool HasDetails {
11 | get { return !string.IsNullOrEmpty(this.Details); }
12 | }
13 |
14 | public string RawError { get; set; }
15 | }
16 | }
--------------------------------------------------------------------------------
/#framework/Shared/ResultData/FeatureState.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Shared.ResultData {
6 | public enum FeatureState {
7 | Neutral,
8 | Success,
9 | Skipped,
10 | Concern,
11 | Failure
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/#framework/Shared/ResultData/FeatureTable.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using AshMind.Extensions;
5 | using Newtonsoft.Json;
6 |
7 | namespace FeatureTests.Shared.ResultData {
8 | public class FeatureTable {
9 | private readonly IReadOnlyDictionary, FeatureCell> cells;
10 |
11 | public FeatureTable(string displayName, IEnumerable libraries, IEnumerable features)
12 | : this(new object(), displayName, libraries, features)
13 | {
14 | }
15 |
16 | public FeatureTable(object key, string displayName, IEnumerable libraries, IEnumerable features) {
17 | this.Key = key;
18 | this.DisplayName = displayName;
19 | this.Libraries = (libraries as IList ?? libraries.ToList()).AsReadOnly();
20 | this.Features = (features as IList ?? features.ToList()).AsReadOnly();
21 | this.Scoring = FeatureScoring.PointPerFeature;
22 | this.cells = (
23 | from adapter in this.Libraries
24 | from feature in this.Features
25 | select Tuple.Create(adapter.Name, feature.Key)
26 | ).ToDictionary(t => t, t => new FeatureCell());
27 | }
28 |
29 | public object Key { get; private set; }
30 | public string DisplayName { get; private set; }
31 | public FeatureScoring Scoring { get; set; }
32 | public string Description { get; set; }
33 | public IReadOnlyCollection Libraries { get; private set; }
34 | public IReadOnlyCollection Features { get; private set; }
35 |
36 | public FeatureCell this[ILibrary library, Feature feature] {
37 | get { return this[library, feature.Key]; }
38 | }
39 |
40 | public FeatureCell this[ILibrary library, object featureKey] {
41 | get { return this.cells[Tuple.Create(library.Name, featureKey)]; }
42 | }
43 |
44 | public IEnumerable>> GetFeatureRows() {
45 | return from feature in this.Features
46 | select Tuple.Create(feature, from library in this.Libraries select this[library, feature]);
47 | }
48 |
49 | public int GetScore(ILibrary library) {
50 | if (this.Scoring == FeatureScoring.NotScored)
51 | return 0;
52 |
53 | if (this.Scoring == FeatureScoring.SinglePoint)
54 | return this.Features.Any(f => this[library, f].State == FeatureState.Success) ? 1 : 0;
55 |
56 | return this.Features.Count(f => this[library, f].State == FeatureState.Success);
57 | }
58 |
59 | public int MaxScore {
60 | get {
61 | if (this.Scoring == FeatureScoring.NotScored)
62 | return 0;
63 |
64 | if (this.Scoring == FeatureScoring.SinglePoint)
65 | return 1;
66 |
67 | return this.Features.Count;
68 | }
69 | }
70 | }
71 | }
--------------------------------------------------------------------------------
/#framework/Shared/SkipException.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Runtime.Serialization;
5 |
6 | namespace FeatureTests.Shared {
7 | [Serializable]
8 | public class SkipException : Exception {
9 | public SkipException() {}
10 | public SkipException(string message) : base(message) {}
11 | public SkipException(string message, Exception inner) : base(message, inner) {}
12 | protected SkipException(SerializationInfo info, StreamingContext context) : base(info, context) {}
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/#framework/Shared/SpecialCaseAttribute.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.Shared {
6 | [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
7 | public class SpecialCaseAttribute : Attribute {
8 | public Type AdapterType { get; private set; }
9 | public string Comment { get; private set; }
10 |
11 | ///
12 | /// Defines whether to skip tests for this
14 | public bool Skip { get; set; }
15 |
16 | public SpecialCaseAttribute(Type adapterType, string comment) {
17 | this.AdapterType = adapterType;
18 | this.Comment = comment;
19 | }
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/#framework/Shared/packages.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/#generated/FeatureTests.css:
--------------------------------------------------------------------------------
1 | @import url(http://fonts.googleapis.com/css?family=Open+Sans);
2 |
3 | @media only screen and (max-width: 760px) {
4 | body {
5 | background-color: white;
6 | }
7 |
8 | .container {
9 | padding: 0;
10 | min-width: 0;
11 | }
12 | }
13 |
14 | html {
15 | margin: 0;
16 | padding: 0;
17 | }
18 |
19 | body {
20 | font-family: "Segoe UI", "Open Sans", sans-serif;
21 | margin: 0;
22 | padding: 0;
23 | }
24 |
25 | h1 {
26 | text-align: center;
27 | }
28 |
29 | .container {
30 | max-width: 1200px;
31 | margin: 0 auto;
32 | }
33 |
34 | .content {
35 | margin-left: 220px;
36 | }
37 |
38 | h1, h2 {
39 | font-weight: normal;
40 | }
41 |
42 | h1 {
43 | font-size: 160%;
44 | padding-bottom: 1rem;
45 | }
46 |
47 | h2 {
48 | font-size: 125%;
49 |
50 | margin: 0;
51 | margin-bottom: 0.1rem;
52 | margin-top: 2.5rem;
53 |
54 | padding-bottom: 0.2rem;
55 | border-bottom: 1px solid #eee;
56 | }
57 |
58 | section:first-of-type h2 {
59 | margin-top: 0;
60 | }
61 |
62 | .section-description {
63 | margin-bottom: 0.3rem;
64 | }
65 |
66 | .section-description, .feature-descriptions, .comments {
67 | max-width: 60rem;
68 | }
69 |
70 | dt, dd {
71 | margin: 0;
72 | padding: 0;
73 | }
74 |
75 | dt {
76 | font-size: 105%;
77 | }
78 |
79 | dd {
80 | margin-left: 0.8rem;
81 | margin-top: 0.2rem;
82 | }
83 |
84 | dd p {
85 | margin-top: 0;
86 | }
87 |
88 | dd + dt {
89 | margin-top: 0.5rem;
90 | }
91 |
92 | table {
93 | margin: 0;
94 | border: 0;
95 | border-collapse: collapse;
96 |
97 | margin-top: 1rem;
98 |
99 | font-size: 90%;
100 | }
101 |
102 | th {
103 | font-weight: normal;
104 | max-width: 10em;
105 | background-color: #ccc;
106 |
107 | overflow: hidden;
108 | text-overflow: ellipsis;
109 | }
110 |
111 | th, td {
112 | padding: 0.2rem;
113 | text-align: center;
114 | }
115 |
116 | td {
117 | background-color: #eee;
118 | }
119 |
120 | td.framework-name, th:first-child {
121 | text-align: left;
122 | padding-left: 0.6rem;
123 | padding-right: 0.6rem;
124 | }
125 |
126 | td.number, td.date {
127 | text-align: right;
128 | padding-left: 0.6rem;
129 | padding-right: 0.6rem;
130 | }
131 |
132 | td.success {
133 | background-color: #c6efce;
134 | color: #006100;
135 | }
136 |
137 | td.failure {
138 | background-color: #ffc7ce;
139 | color: #9c0006;
140 | }
141 |
142 | td.skipped {
143 | background-color: #eee;
144 | color: #c0c0c0;
145 | }
146 |
147 | td.concern {
148 | background-color: #ffeba5;
149 | color: #9c6500;
150 | }
151 |
152 | td > a:only-child {
153 | display: block;
154 | width: 100%;
155 | height: 100%;
156 | }
157 |
158 | a {
159 | text-decoration: none;
160 | }
161 |
162 | a:hover {
163 | text-decoration: underline;
164 | }
165 |
166 | td.success a, td.failure a, td.concern a, td.skipped a {
167 | color: inherit;
168 | }
169 |
170 | .toc-wrapper {
171 | position: absolute;
172 | }
173 |
174 | .toc {
175 | position: absolute;
176 | width: 200px;
177 | border: 1px solid #ccc;
178 | }
179 |
180 | .toc ul {
181 | margin: 0;
182 | padding: 0;
183 | list-style: none;
184 | }
185 |
186 | .toc a {
187 | color: #000;
188 | text-decoration: none;
189 | display: block;
190 | padding: 5px 10px;
191 | }
192 |
193 | .toc .toc-h2 a {
194 | padding-left: 10px;
195 | }
196 |
197 | .toc .toc-h3 a {
198 | padding-left: 20px;
199 | }
200 |
201 | .toc .toc-active {
202 | background-color: #eee;
203 | }
--------------------------------------------------------------------------------
/#generated/js/jquery.sticky.js:
--------------------------------------------------------------------------------
1 | (function(e){var t={topSpacing:0,bottomSpacing:0,className:"is-sticky",wrapperClassName:"sticky-wrapper",center:false,getWidthFrom:""},n=e(window),r=e(document),i=[],s=n.height(),o=function(){var t=n.scrollTop(),o=r.height(),u=o-s,a=t>u?u-t:0;for(var f=0;f").attr("id",n+"-sticky-wrapper").addClass(r.wrapperClassName);t.wrapAll(s);if(r.center){t.parent().css({width:t.outerWidth(),marginLeft:"auto",marginRight:"auto"})}if(t.css("float")=="right"){t.css({"float":"none"}).parent().css({"float":"right"})}var o=t.parent();o.css("height",t.outerHeight());i.push({topSpacing:r.topSpacing,bottomSpacing:r.bottomSpacing,stickyElement:t,currentTop:null,stickyWrapper:o,className:r.className,getWidthFrom:r.getWidthFrom})})},update:o};if(window.addEventListener){window.addEventListener("scroll",o,false);window.addEventListener("resize",u,false)}else if(window.attachEvent){window.attachEvent("onscroll",o);window.attachEvent("onresize",u)}e.fn.sticky=function(t){if(a[t]){return a[t].apply(this,Array.prototype.slice.call(arguments,1))}else if(typeof t==="object"||!t){return a.init.apply(this,arguments)}else{e.error("Method "+t+" does not exist on jQuery.sticky")}};e(function(){setTimeout(o,0)})})(jQuery)
--------------------------------------------------------------------------------
/#generated/js/jquery.toc.js:
--------------------------------------------------------------------------------
1 | /*!
2 | * toc - jQuery Table of Contents Plugin
3 | * v0.1.2
4 | * http://projects.jga.me/toc/
5 | * copyright Greg Allen 2013
6 | * MIT License
7 | */
8 | (function(t){t.fn.toc=function(e){var n,i=this,r=t.extend({},jQuery.fn.toc.defaults,e),o=t(r.container),a=t(r.selectors,o),l=[],h=r.prefix+"-active",s=function(e){if(r.smoothScrolling){e.preventDefault();var n=t(e.target).attr("href"),o=t(n);t("body,html").animate({scrollTop:o.offset().top},400,"swing",function(){location.hash=n})}t("li",i).removeClass(h),t(e.target).parent().addClass(h)},c=function(){n&&clearTimeout(n),n=setTimeout(function(){for(var e,n=t(window).scrollTop(),o=0,a=l.length;a>o;o++)if(l[o]>=n){t("li",i).removeClass(h),e=t("li:eq("+(o-1)+")",i).addClass(h),r.onHighlight(e);break}},50)};return r.highlightOnScroll&&(t(window).bind("scroll",c),c()),this.each(function(){var e=t(this),n=t("");a.each(function(i,o){var a=t(o);l.push(a.offset().top-r.highlightOffset),t("
3 |
4 |
6 |
7 |
9 |
--------------------------------------------------------------------------------
/.nuget/NuGet.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ashmind/net-feature-tests/c2dbf82a1b85ccfd3165f7950d710c345dbdb719/.nuget/NuGet.exe
--------------------------------------------------------------------------------
/.tgitconfig:
--------------------------------------------------------------------------------
1 | [bugtraq]
2 | url = https://github.com/ashmind/net-feature-tests/issues/%BUGID%
3 | warnifnoissue = false
4 | logregex = (gh-\\d+)\n(\\d+)
5 |
--------------------------------------------------------------------------------
/AppHarbor.sln:
--------------------------------------------------------------------------------
1 |
2 | Microsoft Visual Studio Solution File, Format Version 12.00
3 | # Visual Studio 2012
4 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Results.Web", "#framework\Results.Web\Results.Web.csproj", "{6D69D53C-1B6A-485A-B75B-00063BF820C7}"
5 | EndProject
6 | Global
7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution
8 | Debug|Any CPU = Debug|Any CPU
9 | Release|Any CPU = Release|Any CPU
10 | EndGlobalSection
11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | {6D69D53C-1B6A-485A-B75B-00063BF820C7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
13 | {6D69D53C-1B6A-485A-B75B-00063BF820C7}.Debug|Any CPU.Build.0 = Debug|Any CPU
14 | {6D69D53C-1B6A-485A-B75B-00063BF820C7}.Release|Any CPU.ActiveCfg = Release|Any CPU
15 | {6D69D53C-1B6A-485A-B75B-00063BF820C7}.Release|Any CPU.Build.0 = Release|Any CPU
16 | EndGlobalSection
17 | GlobalSection(SolutionProperties) = preSolution
18 | HideSolutionNode = FALSE
19 | EndGlobalSection
20 | EndGlobal
21 |
--------------------------------------------------------------------------------
/DependencyInjection.CodeOnlyPackages/DependencyInjection.CodeOnlyPackages.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
5 | Debug
6 | AnyCPU
7 | {78CAC086-F4A3-4DB0-A9F2-1851FEFE698B}
8 | Library
9 | Properties
10 | DependencyInjection.CodeOnlyPackages
11 | DependencyInjection.CodeOnlyPackages
12 | v4.5
13 | 512
14 | ..\
15 | true
16 |
17 |
18 | true
19 | full
20 | false
21 | bin\Debug\
22 | DEBUG;TRACE
23 | prompt
24 | 4
25 |
26 |
27 | pdbonly
28 | true
29 | bin\Release\
30 | TRACE
31 | prompt
32 | 4
33 |
34 |
35 |
43 |
44 |
47 |
48 |
50 |
53 |
54 | This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.
55 |
56 |
58 |
65 |
--------------------------------------------------------------------------------
/DependencyInjection.CodeOnlyPackages/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
1 | using System.Reflection;
2 | using System.Runtime.CompilerServices;
3 | using System.Runtime.InteropServices;
4 |
5 | // General Information about an assembly is controlled through the following
6 | // set of attributes. Change these attribute values to modify the information
7 | // associated with an assembly.
8 | [assembly: AssemblyTitle("DependencyInjection.CodeOnlyPackages")]
9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("")]
12 | [assembly: AssemblyProduct("DependencyInjection.CodeOnlyPackages")]
13 | [assembly: AssemblyCopyright("Copyright © 2015")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 |
17 | // Setting ComVisible to false makes the types in this assembly not visible
18 | // to COM components. If you need to access a type in this assembly from
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 |
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("91c3d06d-4658-436d-b832-66576b750e43")]
24 |
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | // Major Version
28 | // Minor Version
29 | // Build Number
30 | // Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 |
--------------------------------------------------------------------------------
/DependencyInjection.CodeOnlyPackages/packages.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/DependencyInjection/1_BasicTests.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.ComponentModel;
4 | using System.Linq;
5 | using Xunit;
6 | using FeatureTests.Shared;
7 | using FeatureTests.On.DependencyInjection.TestTypes;
8 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
9 |
10 | namespace FeatureTests.On.DependencyInjection {
11 | [DisplayOrder(1)]
12 | [DisplayName("Essential functionality")]
13 | [Description("These are the basic features that should be supported by all frameworks.")]
14 | public class BasicTests {
15 | [Feature]
16 | [DisplayName("Register/resolve independent service")]
17 | public void IndependentService(IContainerAdapter adapter) {
18 | adapter.RegisterType();
19 | var component = adapter.Resolve();
20 |
21 | Assert.NotNull(component);
22 | }
23 |
24 | [Feature]
25 | [DisplayName("Register/resolve independent service registered as itself")]
26 | public void IndependentServiceRegisteredAsSelf(IContainerAdapter adapter) {
27 | adapter.RegisterType();
28 | var component = adapter.Resolve();
29 |
30 | Assert.NotNull(component);
31 | }
32 |
33 | [Feature]
34 | [DisplayName("Singleton lifetime")]
35 | public void SingletonLifetime(IContainerAdapter adapter) {
36 | adapter.RegisterSingleton();
37 | var instance1 = adapter.Resolve();
38 | var instance2 = adapter.Resolve();
39 |
40 | Assert.Same(instance1, instance2);
41 | }
42 |
43 | [Feature]
44 | [DisplayName("Transient lifetime")]
45 | public void TransientLifetime(IContainerAdapter adapter) {
46 | adapter.RegisterTransient();
47 | var instance1 = adapter.Resolve();
48 | var instance2 = adapter.Resolve();
49 |
50 | Assert.NotSame(instance1, instance2);
51 | }
52 |
53 | [Feature]
54 | [DisplayName("Register/resolve instance")]
55 | public void PrebuiltInstance(IContainerAdapter adapter) {
56 | var instance = new IndependentService();
57 | adapter.RegisterInstance(instance);
58 |
59 | var resolved = adapter.Resolve();
60 |
61 | Assert.Same(instance, resolved);
62 | }
63 |
64 | [Feature]
65 | [DisplayName("Resolve constructor dependency")]
66 | public void ConstructorDependency(IContainerAdapter adapter) {
67 | adapter.RegisterType();
68 | adapter.RegisterType();
69 |
70 | var component = adapter.Resolve();
71 |
72 | Assert.NotNull(component.Service);
73 | Assert.IsAssignableFrom(component.Service);
74 | }
75 |
76 | [Feature]
77 | [DisplayName("Resolve constructor dependency using instance")]
78 | public void ConstructorDependencyUsingInstance(IContainerAdapter adapter) {
79 | var instance = new IndependentService();
80 | adapter.RegisterInstance(instance);
81 | adapter.RegisterType();
82 |
83 | var dependent = adapter.Resolve();
84 |
85 | Assert.Same(instance, dependent.Service);
86 | }
87 | }
88 | }
--------------------------------------------------------------------------------
/DependencyInjection/2_ListTests.cs:
--------------------------------------------------------------------------------
1 | using System.Collections.Generic;
2 | using System.ComponentModel;
3 | using System.Linq;
4 | using Xunit;
5 | using FeatureTests.Shared;
6 | using FeatureTests.On.DependencyInjection.Adapters;
7 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
8 | using FeatureTests.On.DependencyInjection.TestTypes;
9 |
10 | namespace FeatureTests.On.DependencyInjection {
11 | [DisplayOrder(2)]
12 | [DisplayName("List/array dependencies")]
13 | [Description(@"
14 | When several registrations of `IService` exist in a container, many
15 | frameworks automatically provide `IService[]` (or `List` etc).
16 |
17 | This is extremely important for open/closed principle. For example,
18 | UserValidator can have dependency on `IUserValidationRule[]`. Then new
19 | rules can be transparently added to the system without any changes to
20 | UserValidator.
21 | ")]
22 | [FeatureScoring(FeatureScoring.SinglePoint)]
23 | public class ListTests {
24 | [Feature]
25 | [DisplayName("IService[]")]
26 | [SpecialCase(typeof(UnityAdapter), "Note: Unity requires named registrations for list resolution to work.")]
27 | public void Array(IContainerAdapter adapter) {
28 | this.AssertResolvesListDependencyFor>(adapter);
29 | }
30 |
31 | [Feature]
32 | [DisplayName("IList")]
33 | public void List(IContainerAdapter adapter) {
34 | this.AssertResolvesListDependencyFor>>(adapter);
35 | }
36 |
37 | [Feature]
38 | [DisplayName("ICollection")]
39 | public void Collection(IContainerAdapter adapter) {
40 | this.AssertResolvesListDependencyFor>>(adapter);
41 | }
42 |
43 | [Feature]
44 | [DisplayName("IEnumerable")]
45 | public void Enumerable(IContainerAdapter adapter) {
46 | this.AssertResolvesListDependencyFor>>(adapter);
47 | }
48 |
49 | [Feature]
50 | [DisplayName("IReadOnlyCollection")]
51 | public void IReadOnlyCollection(IContainerAdapter adapter) {
52 | this.AssertResolvesListDependencyFor>>(adapter);
53 | }
54 |
55 | [Feature]
56 | [DisplayName("IReadOnlyList")]
57 | public void IReadOnlyList(IContainerAdapter adapter) {
58 | this.AssertResolvesListDependencyFor>>(adapter);
59 | }
60 |
61 | public void AssertResolvesListDependencyFor(IContainerAdapter adapter)
62 | where TTestComponent : IServiceWithListDependency>
63 | {
64 | adapter.RegisterType();
65 | adapter.RegisterType();
66 |
67 | var resolved = adapter.Resolve();
68 |
69 | Assert.NotNull(resolved);
70 | Assert.NotNull(resolved.Services);
71 | Assert.Equal(1, resolved.Services.Count());
72 | Assert.IsAssignableFrom(resolved.Services.First());
73 | }
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/DependencyInjection/3_GenericTests.cs:
--------------------------------------------------------------------------------
1 | using System.ComponentModel;
2 | using System.Linq;
3 | using Xunit;
4 | using FeatureTests.Shared;
5 | using FeatureTests.On.DependencyInjection.Adapters;
6 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
7 | using FeatureTests.On.DependencyInjection.TestTypes;
8 |
9 | namespace FeatureTests.On.DependencyInjection {
10 | [DisplayOrder(3)]
11 | [DisplayName("Open generics")]
12 | public class GenericTests {
13 | [Feature]
14 | [DisplayName("Open generic registration")]
15 | [Description(@"
16 | Allows registration of open generic types.
17 | For example, `Service<>` can be registered as `IService<>`, and then any
18 | request for `IService` should be resolved with `Service`.
19 | ")]
20 | public void OpenGenericTypes(IContainerAdapter adapter) {
21 | adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericService<>));
22 | var resolved = adapter.Resolve>();
23 |
24 | Assert.NotNull(resolved);
25 | }
26 |
27 | [Feature]
28 | [DependsOnFeature("OpenGenericTypes")]
29 | [DependsOnFeature(typeof(ListTests), "Enumerable")]
30 | [DisplayName("Constraint support for open generics")]
31 | [Description(@"
32 | For open generic registration, library does not use `Service` to resolve request
33 | for `IService` if `X` does not match generic constraints on `T`.
34 | ")]
35 | public void ConstrainsForOpenGenerics(IContainerAdapter adapter) {
36 | adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericService<>));
37 | adapter.RegisterTransient(typeof(IGenericService<>), typeof(GenericServiceWithIService2Constraint<>));
38 | var resolved = adapter.ResolveAll>().ToArray();
39 |
40 | Assert.Equal(1, resolved.Length);
41 | Assert.IsType>(resolved[0]);
42 | }
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/DependencyInjection/4_OptionalTests.cs:
--------------------------------------------------------------------------------
1 | using System.ComponentModel;
2 | using System.Linq;
3 | using Xunit;
4 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
5 | using FeatureTests.On.DependencyInjection.TestTypes;
6 | using FeatureTests.Shared;
7 |
8 | namespace FeatureTests.On.DependencyInjection {
9 | [DisplayOrder(4)]
10 | [DisplayName("Optional parameters")]
11 | [Description(@"
12 | Optional parameters can be used to specify an optional dependency, e.g.
13 |
14 | `Service(IService required, IOptionalService optional = null)`
15 | ")]
16 | [FeatureScoring(FeatureScoring.SinglePoint)]
17 | public class OptionalParameterTests {
18 | [Feature]
19 | [DisplayName("Missing primitive")]
20 | [Description("An `int` optional parameter, with no `int` values in container.")]
21 | public void MissingPrimitive(IContainerAdapter adapter) {
22 | adapter.RegisterType();
23 | adapter.RegisterType();
24 |
25 | var component = adapter.Resolve();
26 |
27 | Assert.NotNull(component);
28 | }
29 |
30 | [Feature]
31 | [DependsOnFeature("MissingPrimitive")]
32 | [DisplayName("Missing primitive with default value")]
33 | [Description("An `int` optional parameter with a default value that should be used.")]
34 | public void MissingPrimitiveDefaultValue(IContainerAdapter adapter) {
35 | adapter.RegisterType();
36 | adapter.RegisterType();
37 |
38 | var component = adapter.Resolve();
39 |
40 | Assert.Equal(5, component.Optional);
41 | }
42 |
43 | [Feature]
44 | [DisplayName("Missing dependency")]
45 | [Description("An interface optional parameter, with no matching registrations in container.")]
46 | public void MissingDependency(IContainerAdapter adapter) {
47 | adapter.RegisterType();
48 | adapter.RegisterType();
49 |
50 | var component = adapter.Resolve();
51 |
52 | Assert.NotNull(component);
53 | Assert.Null(component.Optional);
54 | }
55 | }
56 | }
57 |
--------------------------------------------------------------------------------
/DependencyInjection/6_LazyTests.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.ComponentModel;
4 | using System.Linq;
5 | using Xunit;
6 | using FeatureTests.Shared;
7 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
8 | using FeatureTests.On.DependencyInjection.TestTypes;
9 |
10 | namespace FeatureTests.On.DependencyInjection {
11 | [DisplayOrder(6)]
12 | [DisplayName("Lazy")]
13 | [FeatureScoring(FeatureScoring.SinglePoint)]
14 | [Description(@"
15 | When `TService` is registered in a container, some frameworks automatically provide `Lazy`.
16 |
17 | This might be useful for expensive initialization or resolution of circular dependencies (you should
18 | not have those btw).
19 | ")]
20 | public class LazyTests {
21 | [Feature]
22 | [DisplayName("Basic support")]
23 | public void BasicLazySupport(IContainerAdapter adapter) {
24 | adapter.RegisterType();
25 | adapter.RegisterType();
26 |
27 | var lazy = adapter.Resolve>();
28 |
29 | Assert.NotNull(lazy);
30 | Assert.NotNull(lazy.Value);
31 | }
32 |
33 | [Feature]
34 | [DisplayName("Not created prematurely")]
35 | [Description(@"
36 | The point of `Lazy` is to delay creation of value until `Value` is requested.
37 | This test verifies that value is not created prematurely.
38 | ")]
39 | [DependsOnFeature("BasicLazySupport")]
40 | public void NotCreatingLazyPrematurely(IContainerAdapter adapter) {
41 | adapter.RegisterType();
42 | adapter.RegisterType();
43 |
44 | var lazy = adapter.Resolve>();
45 |
46 | Assert.NotNull(lazy);
47 | Assert.False(lazy.IsValueCreated);
48 | }
49 |
50 | [Feature]
51 | [DisplayName("Circular dependency")]
52 | [DependsOnFeature("BasicLazySupport")]
53 | public void LazyanBeUsedToResolveCircularDepenendency(IContainerAdapter adapter) {
54 | adapter.RegisterSingleton();
55 | adapter.RegisterSingleton();
56 |
57 | var resolved1 = adapter.Resolve();
58 | var resolved2 = adapter.Resolve();
59 |
60 | Assert.Same(resolved2, resolved1.Dependency);
61 | Assert.Same(resolved1, resolved2.Dependency);
62 | }
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/DependencyInjection/7_PropertyTests.cs:
--------------------------------------------------------------------------------
1 | using System.ComponentModel;
2 | using System.Linq;
3 | using Xunit;
4 | using FeatureTests.On.DependencyInjection.Adapters;
5 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
6 | using FeatureTests.On.DependencyInjection.TestTypes;
7 | using FeatureTests.Shared;
8 |
9 | namespace FeatureTests.On.DependencyInjection
10 | {
11 | [DisplayOrder(7)]
12 | [DisplayName("Property dependencies")]
13 | [Description(@"
14 | While property dependencies are a nice feature, it is rarely a good practice to actually use them.
15 |
16 | I have not yet decided whether this table is worth keeping, so do not assign much weight to these tests.
17 | ")]
18 | [FeatureScoring(FeatureScoring.NotScored)]
19 | [SpecialCase(typeof(SimpleInjectorAdapter), @"
20 | Simple Injector does not inject properties out of the box, but this behavior
21 | can be changed by replacing the Container.Options.PropertySelectionBehavior.
22 |
23 | For more info see: https://simpleinjector.org/noprop.
24 | ", Skip = true)]
25 | public class PropertyTests {
26 | [Feature]
27 | [DisplayName("Simple dependency")]
28 | public void PropertyDependency(IContainerAdapter adapter) {
29 | adapter.RegisterType();
30 | adapter.RegisterType();
31 |
32 | var component = adapter.Resolve();
33 |
34 | Assert.NotNull(component.Service);
35 | Assert.IsAssignableFrom(component.Service);
36 | }
37 |
38 | [Feature]
39 | [DependsOnFeature("PropertyDependency")]
40 | [DisplayName("Optional by default")]
41 | public void PropertyDependencyIsOptional(IContainerAdapter adapter) {
42 | adapter.RegisterType();
43 | var component = adapter.Resolve();
44 |
45 | Assert.Null(component.Service);
46 | }
47 |
48 | [Feature]
49 | [DependsOnFeature("PropertyDependency")]
50 | [DisplayName("Dependency without attributes")]
51 | [Description(@"
52 | Normally, it is undesirable to reference DI framework from the most parts of the code.
53 | Requirement to use explicit attributes contributes to this problem.
54 | ")]
55 | public void PropertyDependencyDoesNotNeedCustomAttribute(IContainerAdapter adapter) {
56 | var property = typeof(ServiceWithSimplePropertyDependency).GetProperty("Service");
57 | var attributes = property.GetCustomAttributes(false);
58 | var attributesFromThisFramework = attributes.Where(a => a.GetType().Assembly == adapter.Assembly);
59 |
60 | Assert.Empty(attributesFromThisFramework);
61 | }
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/CastleAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using Castle.Core;
6 | using Castle.Facilities.TypedFactory;
7 | using Castle.MicroKernel.Lifestyle;
8 | using Castle.MicroKernel.Registration;
9 | using Castle.MicroKernel.Resolvers;
10 | using Castle.MicroKernel.Resolvers.SpecializedResolvers;
11 | using Castle.Windsor;
12 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
13 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
14 |
15 | namespace FeatureTests.On.DependencyInjection.Adapters {
16 | public class CastleAdapter : ContainerAdapterBase {
17 | private readonly IWindsorContainer container = new WindsorContainer();
18 |
19 | public CastleAdapter() {
20 | this.container.Kernel.Resolver.AddSubResolver(new CollectionResolver(this.container.Kernel));
21 | this.container.AddFacility();
22 | this.container.Register(Component.For().ImplementedBy());
23 | }
24 |
25 | public override Assembly Assembly {
26 | get { return typeof(IWindsorContainer).Assembly; }
27 | }
28 |
29 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
30 | this.Register(serviceType, implementationType, LifestyleType.Singleton);
31 | }
32 |
33 | public override void RegisterTransient(Type serviceType, Type implementationType) {
34 | this.Register(serviceType, implementationType, LifestyleType.Transient);
35 | }
36 |
37 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
38 | this.Register(serviceType, implementationType, LifestyleType.PerWebRequest);
39 | }
40 |
41 | public override void RegisterInstance(Type serviceType, object instance) {
42 | var registration = Component.For(serviceType).Instance(instance);
43 | this.container.Register(registration);
44 | }
45 |
46 | private void Register(Type serviceType, Type implementationType, LifestyleType lifestyle) {
47 | var registration = Component.For(serviceType)
48 | .ImplementedBy(implementationType)
49 | .LifeStyle.Is(lifestyle);
50 |
51 | this.container.Register(registration);
52 | }
53 |
54 | public override void BeforeAllWebRequests(WebRequestTestHelper helper) {
55 | helper.RegisterModule();
56 | }
57 |
58 | public override object Resolve(Type serviceType) {
59 | return this.container.Resolve(serviceType);
60 | }
61 |
62 | public override IEnumerable ResolveAll(Type serviceType) {
63 | return this.container.ResolveAll(serviceType).Cast();
64 | }
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/CatelAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using Catel.IoC;
6 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
7 |
8 | namespace FeatureTests.On.DependencyInjection.Adapters {
9 | public class CatelAdapter : ContainerAdapterBase {
10 | private readonly ServiceLocator locator = new ServiceLocator();
11 |
12 | public CatelAdapter() {
13 | this.locator.RegisterInstance(new TypeFactory(this.locator));
14 | }
15 |
16 | public override Assembly Assembly {
17 | get { return typeof(ServiceLocator).Assembly; }
18 | }
19 |
20 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
21 | this.locator.RegisterType(serviceType, implementationType, registrationType: RegistrationType.Singleton);
22 | }
23 |
24 | public override void RegisterTransient(Type serviceType, Type implementationType) {
25 | this.locator.RegisterType(serviceType, implementationType, registrationType: RegistrationType.Transient);
26 | }
27 |
28 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
29 | throw PerWebRequestMayNotBePossible();
30 | }
31 |
32 | public override void RegisterInstance(Type serviceType, object instance) {
33 | this.locator.RegisterInstance(serviceType, instance);
34 | }
35 |
36 | public override object Resolve(Type serviceType) {
37 | return this.locator.ResolveType(serviceType);
38 | }
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/DryIocAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Reflection;
3 | using System.Collections.Generic;
4 | using DryIoc;
5 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
6 |
7 | namespace FeatureTests.On.DependencyInjection.Adapters {
8 | public class DryIocAdapter : ContainerAdapterBase {
9 | private readonly Container container = new Container(
10 | rules => rules.With(
11 | FactoryMethod.ConstructorWithResolvableArguments,
12 | propertiesAndFields: PropertiesAndFields.Auto),
13 | new AsyncExecutionFlowScopeContext());
14 |
15 | private IContainer webRequestScoped;
16 |
17 | public override Assembly Assembly {
18 | get { return typeof(Container).Assembly; }
19 | }
20 |
21 | public override string PackageId {
22 | get { return "DryIoc.dll"; }
23 | }
24 |
25 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
26 | container.Register(serviceType, implementationType, Reuse.Singleton);
27 | }
28 |
29 | public override void RegisterTransient(Type serviceType, Type implementationType) {
30 | container.Register(serviceType, implementationType);
31 | }
32 |
33 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
34 | container.Register(serviceType, implementationType, Reuse.InCurrentScope);
35 | }
36 |
37 | public override void RegisterInstance(Type serviceType, object instance) {
38 | container.RegisterInstance(serviceType, instance);
39 | }
40 |
41 | public override void AfterBeginWebRequest() {
42 | this.webRequestScoped = container.OpenScope();
43 | }
44 |
45 | public override void BeforeEndWebRequest() {
46 | this.webRequestScoped.Dispose();
47 | }
48 |
49 | public override object Resolve(Type serviceType) {
50 | return container.Resolve(serviceType);
51 | }
52 |
53 | public override IEnumerable ResolveAll(Type serviceType) {
54 | return container.ResolveMany(serviceType);
55 | }
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/DynamoIocAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using Dynamo.Ioc;
6 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
7 |
8 | namespace FeatureTests.On.DependencyInjection.Adapters {
9 | public class DynamoIocAdapter : ContainerAdapterBase {
10 | private readonly IocContainer container = new IocContainer();
11 |
12 | public override string Name {
13 | get { return "Dynamo.Ioc"; }
14 | }
15 |
16 | public override Assembly Assembly {
17 | get { return typeof(IocContainer).Assembly; }
18 | }
19 |
20 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
21 | this.container.Register(serviceType, implementationType).SetLifetime(new ContainerLifetime());
22 | }
23 |
24 | public override void RegisterTransient(Type serviceType, Type implementationType) {
25 | this.container.Register(serviceType, implementationType).SetLifetime(new TransientLifetime());
26 | }
27 |
28 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
29 | throw PerWebRequestMayNotBeProvidedButPerThreadIs();
30 | }
31 |
32 | public override void RegisterInstance(Type serviceType, object instance) {
33 | this.container.RegisterInstance(serviceType, instance);
34 | }
35 |
36 | public override object Resolve(Type serviceType) {
37 | return this.container.Resolve(serviceType);
38 | }
39 |
40 | public override bool CrashesOnRecursion {
41 | get { return true; }
42 | }
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/EndjinCompositionAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using Endjin.Core.Container;
6 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
7 |
8 | namespace FeatureTests.On.DependencyInjection.Adapters {
9 | public class EndjinCompositionAdapter : ContainerAdapterBase {
10 | private readonly Container container = new Container();
11 |
12 | public override void RegisterTransient(Type serviceType, Type implementationType) {
13 | this.container.Register(
14 | Component.For(serviceType)
15 | .ImplementedByType(implementationType)
16 | .AsTransient()
17 | );
18 | }
19 |
20 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
21 | this.container.Register(
22 | Component.For(serviceType)
23 | .ImplementedByType(implementationType)
24 | .AsSingleton()
25 | );
26 | }
27 |
28 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
29 | throw PerWebRequestMayNotBePossible();
30 | }
31 |
32 | public override void RegisterInstance(Type serviceType, object instance) {
33 | this.container.Register(
34 | Component.For(serviceType).ImplementedBy(instance)
35 | );
36 | }
37 |
38 | public override object Resolve(Type serviceType) {
39 | return this.container.Resolve(serviceType);
40 | }
41 |
42 | public override string PackageId {
43 | get { return "Endjin.Core.Composition"; }
44 | }
45 |
46 | public override Assembly Assembly {
47 | get { return typeof(IContainer).Assembly; }
48 | }
49 |
50 | public override string Name {
51 | get { return "Endjin Composition"; }
52 | }
53 |
54 | public override bool CrashesOnRecursion {
55 | get { return true; }
56 | }
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/GraceAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
6 | using Grace.DependencyInjection;
7 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
8 | using Grace.MVC.DependencyInjection;
9 | using Grace.MVC.Extensions;
10 |
11 | namespace FeatureTests.On.DependencyInjection.Adapters {
12 | public class GraceAdapter : ContainerAdapterBase {
13 | private readonly DependencyInjectionContainer container;
14 |
15 | public GraceAdapter() {
16 | this.container = new DependencyInjectionContainer ();
17 | this.container.Configure(c => c.Export().ByInterfaces());
18 | }
19 |
20 | public override Assembly Assembly {
21 | get { return typeof(DependencyInjectionContainer).Assembly; }
22 | }
23 |
24 | public override void RegisterTransient(Type serviceType, Type implementationType) {
25 | this.container.Configure(c => c.Export(implementationType).As(serviceType).AutoWireProperties());
26 | }
27 |
28 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
29 | this.container.Configure(c => c.Export(implementationType).As(serviceType).Lifestyle.Singleton());
30 | }
31 |
32 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
33 | this.container.Configure(c => c.Export(implementationType).As(serviceType).Lifestyle.SingletonPerRequest());
34 | }
35 |
36 | public override void RegisterInstance(Type serviceType, object instance) {
37 | this.container.Configure(c => c.ExportInstance(instance).As(serviceType));
38 | }
39 |
40 | public override void BeforeAllWebRequests(WebRequestTestHelper helper) {
41 | helper.RegisterModule(new DisposableHttpModule());
42 | }
43 |
44 | public override object Resolve(Type serviceType) {
45 | return this.container.Locate(serviceType);
46 | }
47 |
48 | public override IEnumerable ResolveAll(Type serviceType) {
49 | return this.container.LocateAll(serviceType);
50 | }
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/HaveBoxAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using HaveBox;
6 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
7 |
8 | namespace FeatureTests.On.DependencyInjection.Adapters {
9 | public class HaveBoxAdapter : ContainerAdapterBase {
10 | private readonly Container container = new Container();
11 |
12 | public override Assembly Assembly {
13 | get { return typeof(Container).Assembly; }
14 | }
15 |
16 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
17 | this.container.Configure(r => r.For(serviceType).Use(implementationType).AsSingleton());
18 | }
19 |
20 | public override void RegisterTransient(Type serviceType, Type implementationType) {
21 | this.container.Configure(r => r.For(serviceType).Use(implementationType));
22 | }
23 |
24 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
25 | throw PerWebRequestMayNotBePossible();
26 | }
27 |
28 | public override void RegisterInstance(Type serviceType, object instance) {
29 | this.container.Configure(r => r.For(serviceType).Use(() => instance));
30 | }
31 |
32 | public override object Resolve(Type serviceType) {
33 | return this.container.GetInstance(serviceType);
34 | }
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/IfInjectorAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using IfInjector;
6 | using FeatureTests.Shared.GenericApiSupport;
7 | using FeatureTests.Shared.GenericApiSupport.GenericPlaceholders;
8 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
9 |
10 | namespace FeatureTests.On.DependencyInjection.Adapters {
11 | public class IfInjectorAdapter : ContainerAdapterBase {
12 | private readonly Injector injector = new Injector();
13 |
14 | public override Assembly Assembly {
15 | get { return typeof(Injector).Assembly; }
16 | }
17 |
18 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
19 | GenericHelper.RewriteAndInvoke(
20 | () => this.injector.Register(Binding.For>().To>().AsSingleton(true)),
21 | serviceType, implementationType
22 | );
23 | }
24 |
25 | public override void RegisterTransient(Type serviceType, Type implementationType) {
26 | GenericHelper.RewriteAndInvoke(
27 | () => this.injector.Register(Binding.For>().To>()),
28 | serviceType, implementationType
29 | );
30 | }
31 |
32 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
33 | throw PerWebRequestMayNotBeProvided();
34 | }
35 |
36 | public override void RegisterInstance(Type serviceType, object instance) {
37 | GenericHelper.RewriteAndInvoke(
38 | () => this.injector.Register(Binding.For().SetFactory(() => (X1)instance).AsSingleton(true)),
39 | serviceType
40 | );
41 | }
42 |
43 | public override object Resolve(Type serviceType) {
44 | return this.injector.Resolve(serviceType);
45 | }
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/Interface/ContainerAdapterBase.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections;
3 | using System.Collections.Generic;
4 | using System.Linq;
5 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
6 | using FeatureTests.Shared;
7 |
8 | namespace FeatureTests.On.DependencyInjection.Adapters.Interface {
9 | public abstract class ContainerAdapterBase : LibraryAdapterBase, IContainerAdapter {
10 | public abstract void RegisterTransient(Type serviceType, Type implementationType);
11 | public abstract void RegisterSingleton(Type serviceType, Type implementationType);
12 | public abstract void RegisterPerWebRequest(Type serviceType, Type implementationType);
13 | public abstract void RegisterInstance(Type serviceType, object instance);
14 |
15 | public virtual void BeforeAllWebRequests(WebRequestTestHelper helper) { }
16 | public virtual void AfterBeginWebRequest() {}
17 | public virtual void BeforeEndWebRequest() {}
18 |
19 | public abstract object Resolve(Type serviceType);
20 |
21 | public virtual IEnumerable ResolveAll(Type serviceType) {
22 | var enumerableType = typeof(IEnumerable<>).MakeGenericType(serviceType);
23 | return ((IEnumerable)this.Resolve(enumerableType)).Cast();
24 | }
25 |
26 | public virtual bool CrashesOnRecursion {
27 | get { return false; }
28 | }
29 |
30 | public virtual bool CrashesOnListRecursion {
31 | get { return this.CrashesOnRecursion; }
32 | }
33 |
34 | protected Exception PerWebRequestMayNotBeProvided() {
35 | return new NotSupportedException("I am not sure if " + Name + " provides PerRequest lifetime out of the box.");
36 | }
37 |
38 | protected Exception PerWebRequestMayNotBeProvidedButPerThreadIs() {
39 | return new NotSupportedException(
40 | PerWebRequestMayNotBeProvided().Message + Environment.NewLine +
41 | "It does provide PerThread, but a web request is not guaranteed to stay in one thread."
42 | );
43 | }
44 |
45 | protected Exception PerWebRequestMayNotBePossible() {
46 | return new NotSupportedException("I am not sure if " + Name + " can support PerRequest lifetime.");
47 | }
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/Interface/ContainerAdapterExtensions.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.Adapters.Interface {
6 | public static class ContainerAdapterExtensions {
7 | public static void RegisterType(this IContainerAdapter container) {
8 | container.RegisterTransient();
9 | }
10 |
11 | public static void RegisterType(this IContainerAdapter container)
12 | where TImplementation : TService
13 | {
14 | container.RegisterTransient();
15 | }
16 |
17 | public static void RegisterSingleton(this IContainerAdapter container) {
18 | container.RegisterSingleton();
19 | }
20 |
21 | public static void RegisterSingleton(this IContainerAdapter container)
22 | where TImplementation : TService
23 | {
24 | container.RegisterSingleton(typeof(TService), typeof(TImplementation));
25 | }
26 |
27 | public static void RegisterTransient(this IContainerAdapter container) {
28 | container.RegisterSingleton();
29 | }
30 |
31 | public static void RegisterTransient(this IContainerAdapter container)
32 | where TImplementation : TService
33 | {
34 | container.RegisterTransient(typeof(TService), typeof(TImplementation));
35 | }
36 |
37 | public static void RegisterPerWebRequest(this IContainerAdapter container) {
38 | container.RegisterPerWebRequest();
39 | }
40 |
41 | public static void RegisterPerWebRequest(this IContainerAdapter container)
42 | where TImplementation : TService
43 | {
44 | container.RegisterPerWebRequest(typeof(TService), typeof(TImplementation));
45 | }
46 |
47 | public static void RegisterInstance(this IContainerAdapter container, TService instance) {
48 | container.RegisterInstance(typeof(TService), instance);
49 | }
50 |
51 | public static void RegisterInstance(this IContainerAdapter container, object instance) {
52 | container.RegisterInstance(instance.GetType(), instance);
53 | }
54 |
55 | public static TService Resolve(this IContainerAdapter container) {
56 | return (TService)container.Resolve(typeof(TService));
57 | }
58 |
59 | public static IEnumerable ResolveAll(this IContainerAdapter container) {
60 | return container.ResolveAll(typeof(TService)).Cast();
61 | }
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/Interface/IContainerAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
5 | using FeatureTests.Shared;
6 |
7 | namespace FeatureTests.On.DependencyInjection.Adapters.Interface {
8 | public interface IContainerAdapter : ILibrary {
9 | void RegisterSingleton(Type serviceType, Type implementationType);
10 | void RegisterTransient(Type serviceType, Type implementationType);
11 |
12 | // it is weird to have a special case for this one, as it is normally handled
13 | // by some kind of general subcontainer/scope support -- but for widest reach
14 | // I want to start with the most common use case
15 | void RegisterPerWebRequest(Type serviceType, Type implementationType);
16 |
17 | void RegisterInstance(Type serviceType, object instance);
18 |
19 | void BeforeAllWebRequests(WebRequestTestHelper helper);
20 | void AfterBeginWebRequest();
21 | void BeforeEndWebRequest();
22 |
23 | object Resolve(Type serviceType);
24 | IEnumerable ResolveAll(Type serviceType);
25 |
26 | ///
27 | /// This test was run only once because there is no way to recover from StackOverflowException.
28 | ///
29 | bool CrashesOnRecursion { get; }
30 |
31 | ///
32 | /// This test was run only once because there is no way to recover from StackOverflowException.
33 | ///
34 | bool CrashesOnListRecursion { get; }
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/LightCoreAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using LightCore;
6 | using LightCore.Lifecycle;
7 | using FeatureTests.Shared.GenericApiSupport;
8 | using FeatureTests.Shared.GenericApiSupport.GenericPlaceholders;
9 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
10 |
11 | namespace FeatureTests.On.DependencyInjection.Adapters {
12 | public class LightCoreAdapter : ContainerAdapterBase {
13 | private IContainerBuilder builder = new ContainerBuilder();
14 | private IContainer container;
15 |
16 | public override Assembly Assembly {
17 | get { return typeof(IContainer).Assembly; }
18 | }
19 |
20 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
21 | this.builder.Register(serviceType, implementationType).ControlledBy();
22 | }
23 |
24 | public override void RegisterTransient(Type serviceType, Type implementationType) {
25 | this.builder.Register(serviceType, implementationType).ControlledBy();
26 | }
27 |
28 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
29 | throw PerWebRequestMayNotBeProvidedButPerThreadIs();
30 | }
31 |
32 | public override void RegisterInstance(Type serviceType, object instance) {
33 | GenericHelper.RewriteAndInvoke(() => this.builder.Register((X1)instance), serviceType);
34 | }
35 |
36 | public override object Resolve(Type serviceType) {
37 | this.FreezeContainer();
38 | return this.container.Resolve(serviceType);
39 | }
40 |
41 | private void FreezeContainer() {
42 | if (this.container != null)
43 | return;
44 |
45 | this.container = this.builder.Build();
46 | this.builder = null; // simple way to prevent accidental reuse of adapter
47 | }
48 |
49 | public override bool CrashesOnRecursion {
50 | get { return true; }
51 | }
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/LightInjectAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Reflection;
3 | using System.Collections.Generic;
4 | using LightInject;
5 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
6 |
7 | namespace FeatureTests.On.DependencyInjection.Adapters {
8 | public class LightInjectAdapter : ContainerAdapterBase {
9 | private readonly IServiceContainer container = new ServiceContainer();
10 | private Scope webRequestScope;
11 |
12 | public override Assembly Assembly {
13 | get { return typeof(IServiceContainer).Assembly; }
14 | }
15 |
16 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
17 | container.Register(serviceType, implementationType, new PerContainerLifetime());
18 | }
19 |
20 | public override void RegisterTransient(Type serviceType, Type implementationType) {
21 | container.Register(serviceType, implementationType, implementationType.Name);
22 | }
23 |
24 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
25 | container.Register(serviceType, implementationType, new PerScopeLifetime());
26 | }
27 |
28 | public override void RegisterInstance(Type serviceType, object instance) {
29 | container.RegisterInstance(serviceType, instance);
30 | }
31 |
32 | public override void AfterBeginWebRequest() {
33 | this.webRequestScope = container.BeginScope();
34 | }
35 |
36 | public override void BeforeEndWebRequest() {
37 | this.webRequestScope.Dispose();
38 | }
39 |
40 | public override object Resolve(Type serviceType) {
41 | return container.GetInstance(serviceType);
42 | }
43 |
44 | public override IEnumerable ResolveAll(Type serviceType) {
45 | return container.GetAllInstances(serviceType);
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/LinFuAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using LinFu.IoC;
6 | using LinFu.IoC.Configuration;
7 | using LinFu.IoC.Interfaces;
8 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
9 |
10 | namespace FeatureTests.On.DependencyInjection.Adapters {
11 | // thanks a lot to Philip Laureano for this adapter
12 | public class LinFuAdapter : ContainerAdapterBase {
13 | private readonly IServiceContainer container;
14 |
15 | public LinFuAdapter() {
16 | this.container = new ServiceContainer();
17 | this.container.LoadFrom(AppDomain.CurrentDomain.BaseDirectory, "LinFu*.dll");
18 | }
19 |
20 | public override Assembly Assembly {
21 | get { return typeof(IServiceContainer).Assembly; }
22 | }
23 |
24 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
25 | this.AddService(serviceType, implementationType, LifecycleType.Singleton);
26 | }
27 |
28 | public override void RegisterTransient(Type serviceType, Type implementationType) {
29 | this.AddService(serviceType, implementationType, LifecycleType.OncePerRequest);
30 | }
31 |
32 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
33 | throw PerWebRequestMayNotBeProvidedButPerThreadIs();
34 | }
35 |
36 | private void AddService(Type serviceType, Type implementationType, LifecycleType lifecycle) {
37 | this.container.AddService(serviceType, implementationType, lifecycle);
38 | }
39 |
40 | public override void RegisterInstance(Type serviceType, object instance) {
41 | this.container.AddService(serviceType, instance);
42 | }
43 |
44 | public override object Resolve(Type serviceType) {
45 | return this.container.GetService(serviceType);
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/MefAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.ComponentModel.Composition;
4 | using System.ComponentModel.Composition.Hosting;
5 | using System.ComponentModel.Composition.Registration;
6 | using System.Linq;
7 | using System.Reflection;
8 | using FeatureTests.Shared.GenericApiSupport;
9 | using FeatureTests.Shared.GenericApiSupport.GenericPlaceholders;
10 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
11 |
12 | namespace FeatureTests.On.DependencyInjection.Adapters {
13 | public class MefAdapter : ContainerAdapterBase {
14 | private readonly CompositionContainer container;
15 | private readonly AggregateCatalog catalog = new AggregateCatalog();
16 |
17 | public MefAdapter() {
18 | this.container = new CompositionContainer(this.catalog);
19 | }
20 |
21 | public override string Name {
22 | get { return "MEF"; }
23 | }
24 |
25 | public override Assembly Assembly {
26 | get { return typeof(RegistrationBuilder).Assembly; }
27 | }
28 |
29 | public override string PackageId {
30 | get { return null; }
31 | }
32 |
33 | public override void RegisterTransient(Type serviceType, Type implementationType) {
34 | var builder = new RegistrationBuilder();
35 | builder.ForType(implementationType)
36 | .Export(c => c.AsContractType(serviceType))
37 | .SetCreationPolicy(CreationPolicy.NonShared);
38 |
39 | this.catalog.Catalogs.Add(new TypeCatalog(new[] { implementationType }, builder));
40 | }
41 |
42 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
43 | var builder = new RegistrationBuilder();
44 | builder.ForType(implementationType)
45 | .Export(c => c.AsContractType(serviceType))
46 | .SetCreationPolicy(CreationPolicy.Shared);
47 |
48 | this.catalog.Catalogs.Add(new TypeCatalog(new[] { implementationType }, builder));
49 | }
50 |
51 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
52 | throw PerWebRequestMayNotBeProvided();
53 | }
54 |
55 | public override void RegisterInstance(Type serviceType, object instance) {
56 | GenericHelper.RewriteAndInvoke(() => this.container.ComposeExportedValue((X1)instance), serviceType);
57 | }
58 |
59 | public override object Resolve(Type serviceType) {
60 | return GenericHelper.RewriteAndInvoke(() => this.container.GetExportedValue(), serviceType);
61 | }
62 | }
63 | }
64 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/MicroSliverAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
6 | using FeatureTests.Shared.GenericApiSupport.GenericPlaceholders;
7 | using MicroSliver;
8 | using FeatureTests.Shared.GenericApiSupport;
9 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
10 |
11 | namespace FeatureTests.On.DependencyInjection.Adapters {
12 | public class MicroSliverAdapter : ContainerAdapterBase {
13 | private readonly IoC ioc = new IoC();
14 |
15 | #region DelegateCreator
16 |
17 | private class DelegateCreator : ICreator {
18 | private readonly Func create;
19 |
20 | public DelegateCreator(Func create) {
21 | this.create = create;
22 | }
23 |
24 | public object Create() {
25 | return this.create();
26 | }
27 | }
28 |
29 | #endregion
30 |
31 | public override Assembly Assembly {
32 | get { return typeof(IoC).Assembly; }
33 | }
34 |
35 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
36 | GenericHelper.RewriteAndInvoke(
37 | () => this.ioc.Map, C>().ToSingletonScope(),
38 | serviceType, implementationType
39 | );
40 | }
41 |
42 | public override void RegisterTransient(Type serviceType, Type implementationType) {
43 | GenericHelper.RewriteAndInvoke(
44 | () => this.ioc.Map, C>().ToInstanceScope(),
45 | serviceType, implementationType
46 | );
47 | }
48 |
49 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
50 | GenericHelper.RewriteAndInvoke(
51 | () => this.ioc.Map, C>().ToRequestScope(),
52 | serviceType, implementationType
53 | );
54 | }
55 |
56 | public override void RegisterInstance(Type serviceType, object instance) {
57 | GenericHelper.RewriteAndInvoke(
58 | () => this.ioc.Map(new DelegateCreator(() => instance)),
59 | serviceType
60 | );
61 | }
62 |
63 | public override void BeforeAllWebRequests(WebRequestTestHelper helper) {
64 | helper.RegisterModule();
65 | }
66 |
67 | public override object Resolve(Type serviceType) {
68 | return this.ioc.GetByType(serviceType);
69 | }
70 |
71 | public override bool CrashesOnRecursion {
72 | get { return true; }
73 | }
74 | }
75 | }
76 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/MugenAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using Microsoft.Practices.ServiceLocation;
6 | using MugenInjection;
7 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
8 | using MugenInjection.Interface;
9 |
10 | namespace FeatureTests.On.DependencyInjection.Adapters {
11 | public class MugenAdapter : ContainerAdapterBase {
12 | private readonly MugenInjector injector = new MugenInjector();
13 | private IInjector webRequestInjector;
14 |
15 | public override Assembly Assembly {
16 | get { return typeof(MugenInjector).Assembly; }
17 | }
18 |
19 | public override string PackageId {
20 | get { return "MugenInjection"; }
21 | }
22 |
23 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
24 | this.injector.Bind(serviceType).To(implementationType).InSingletonScope();
25 | }
26 |
27 | public override void RegisterTransient(Type serviceType, Type implementationType) {
28 | this.injector.Bind(serviceType).To(implementationType).InTransientScope();
29 | }
30 |
31 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
32 | this.injector.Bind(serviceType).To(implementationType).InUnitOfWorkScope();
33 | }
34 |
35 | public override void RegisterInstance(Type serviceType, object instance) {
36 | this.injector.Bind(serviceType).ToConstant(instance);
37 | }
38 |
39 | public override void AfterBeginWebRequest() {
40 | this.webRequestInjector = this.injector.CreateChild();
41 | }
42 |
43 | public override void BeforeEndWebRequest() {
44 | this.webRequestInjector.Dispose();
45 | this.webRequestInjector = null;
46 | }
47 |
48 | public override object Resolve(Type serviceType) {
49 | return (this.webRequestInjector ?? this.injector).Get(serviceType);
50 | }
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/MunqAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
6 | using Munq;
7 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
8 | using Munq.LifetimeManagers;
9 |
10 | namespace FeatureTests.On.DependencyInjection.Adapters {
11 | public class MunqAdapter : ContainerAdapterBase {
12 | private readonly IocContainer container = new IocContainer();
13 |
14 | public override Assembly Assembly {
15 | get { return typeof(IocContainer).Assembly; }
16 | }
17 |
18 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
19 | this.container.Register(serviceType, implementationType).AsContainerSingleton();
20 | }
21 |
22 | public override void RegisterTransient(Type serviceType, Type implementationType) {
23 | this.container.Register(serviceType, implementationType).AsAlwaysNew();
24 | }
25 |
26 | public override void RegisterInstance(Type serviceType, object instance) {
27 | this.container.RegisterInstance(serviceType, instance);
28 | }
29 |
30 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
31 | this.container.Register(serviceType, implementationType).AsRequestSingleton();
32 | }
33 |
34 | public override void BeforeAllWebRequests(WebRequestTestHelper helper) {
35 | helper.RegisterModule();
36 | }
37 |
38 | public override object Resolve(Type serviceType) {
39 | return this.container.Resolve(serviceType);
40 | }
41 |
42 | public override bool CrashesOnRecursion {
43 | get { return true; }
44 | }
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/NinjectAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using System.Web;
6 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
7 | using FeatureTests.Shared;
8 | using Ninject;
9 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
10 | using Ninject.Web.Common;
11 |
12 | namespace FeatureTests.On.DependencyInjection.Adapters {
13 | public class NinjectAdapter : ContainerAdapterBase {
14 | private readonly IKernel kernel;
15 |
16 | public NinjectAdapter() {
17 | this.kernel = new StandardKernel();
18 | }
19 |
20 | public override Assembly Assembly {
21 | get { return typeof(IKernel).Assembly; }
22 | }
23 |
24 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
25 | this.kernel.Bind(serviceType).To(implementationType).InSingletonScope();
26 | }
27 |
28 | public override void RegisterTransient(Type serviceType, Type implementationType) {
29 | this.kernel.Bind(serviceType).To(implementationType).InTransientScope();
30 | }
31 |
32 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
33 | this.kernel.Bind(serviceType).To(implementationType).InRequestScope();
34 | }
35 |
36 | public override void RegisterInstance(Type serviceType, object instance) {
37 | this.kernel.Bind(serviceType).ToConstant(instance);
38 | }
39 |
40 | public override void BeforeAllWebRequests(WebRequestTestHelper helper) {
41 | //this.kernel.Bind>()
42 | // .ToConstant>(() => this.kernel);
43 |
44 | //new Bootstrapper().Initialize(() => this.kernel);
45 | //WebRequestTestHelper.RegisterModule();
46 | throw new SkipException("It is obvious Ninject supports this, but I can't figure this out in a reasonable time.");
47 | }
48 |
49 | public override object Resolve(Type serviceType) {
50 | return this.kernel.Get(serviceType);
51 | }
52 |
53 | public override IEnumerable ResolveAll(Type serviceType) {
54 | return this.kernel.GetAll(serviceType);
55 | }
56 | }
57 | }
58 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/SimpleInjectorAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Reflection;
4 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
5 | using SimpleInjector;
6 | using SimpleInjector.Advanced;
7 | using SimpleInjector.Extensions;
8 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
9 | using SimpleInjector.Integration.Web;
10 |
11 | namespace FeatureTests.On.DependencyInjection.Adapters {
12 | public class SimpleInjectorAdapter : ContainerAdapterBase {
13 | private readonly Container container = new Container();
14 |
15 | public override string Name {
16 | get { return "Simple Injector"; }
17 | }
18 |
19 | public override Assembly Assembly {
20 | get { return typeof(Container).Assembly; }
21 | }
22 |
23 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
24 | this.Register(serviceType, implementationType, Lifestyle.Singleton);
25 | }
26 |
27 | public override void RegisterTransient(Type serviceType, Type implementationType) {
28 | this.Register(serviceType, implementationType, Lifestyle.Transient);
29 | }
30 |
31 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
32 | this.Register(serviceType, implementationType, new WebRequestLifestyle(true));
33 | }
34 |
35 | public override void RegisterInstance(Type serviceType, object instance) {
36 | this.container.RegisterSingleton(serviceType, instance);
37 | }
38 |
39 | public override void BeforeAllWebRequests(WebRequestTestHelper helper) {
40 | helper.RegisterModule();
41 | }
42 |
43 | public override object Resolve(Type serviceType) {
44 | return this.container.GetInstance(serviceType);
45 | }
46 |
47 | public override IEnumerable ResolveAll(Type serviceType) {
48 | return this.container.GetAllInstances(serviceType);
49 | }
50 |
51 | private void Register(Type serviceType, Type implementationType, Lifestyle lifestyle) {
52 | this.container.Register(serviceType, implementationType, lifestyle);
53 |
54 | // Registering collections in Simple Injector is done using the RegisterAll overloads, but
55 | // this forces all elements to be registered at once. For integration scenarios, the
56 | // AppendToCollection extension method can be used. This allows adding elements to a collection
57 | // one by one.
58 | this.container.AppendToCollection(serviceType, implementationType);
59 | }
60 | }
61 | }
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/SpeediocAdapter.Disabled.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using Speedioc;
6 | using Speedioc.Registration;
7 | using Speedioc.Registration.Builders;
8 |
9 | namespace FeatureTests.On.DependencyInjection.Adapters {
10 | //public class SpeediocAdapter : FrameworkAdapterBase {
11 | // private IContainerBuilder builder = DefaultContainerBuilderFactory.GetInstance();
12 | // private IContainer container;
13 |
14 | // public override Assembly FrameworkAssembly {
15 | // get { return typeof(DefaultContainerBuilderFactory).Assembly; }
16 | // }
17 |
18 | // // NOTE: Registration approach below is not the best approach.
19 | // // As far as I understand, the best approach is to inherit Registry.
20 | // // However that would not work for tests.
21 |
22 | // public override void RegisterSingleton(Type serviceType, Type implementationType) {
23 | // var registry = new Registry();
24 | // registry.Register(implementationType).As(serviceType).WithLifetime(Lifetime.Container);
25 | // this.builder.AddRegistry(registry);
26 | // }
27 |
28 | // public override void RegisterTransient(Type serviceType, Type implementationType) {
29 | // var registry = new Registry();
30 | // registry.Register(implementationType).As(serviceType).WithLifetime(Lifetime.Transient);
31 | // this.builder.AddRegistry(registry);
32 | // }
33 |
34 | // public override void RegisterInstance(Type serviceType, object instance) {
35 | // // How do I do that?
36 | // }
37 |
38 | // public override object Resolve(Type serviceType) {
39 | // this.FreezeContainer();
40 | // return this.container.GetInstance(serviceType);
41 | // }
42 |
43 | // private void FreezeContainer() {
44 | // if (this.container != null)
45 | // return;
46 |
47 | // this.container = this.builder.Build();
48 | // this.builder = null; // simple way to prevent accidental reuse of adapter
49 | // }
50 | //}
51 | }
52 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/SpringAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using FeatureTests.Shared;
6 | using Spring.Context.Support;
7 | using Spring.Objects.Factory.Config;
8 | using Spring.Objects.Factory.Support;
9 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
10 |
11 | // long names, Java heritage
12 | namespace FeatureTests.On.DependencyInjection.Adapters {
13 | public class SpringAdapter : ContainerAdapterBase {
14 | private readonly GenericApplicationContext context = new GenericApplicationContext();
15 | private readonly IObjectDefinitionFactory factory = new DefaultObjectDefinitionFactory();
16 |
17 | private bool contextRefreshed = false;
18 |
19 | public override Assembly Assembly {
20 | get { return typeof(IObjectDefinitionFactory).Assembly; }
21 | }
22 |
23 | public override string Name {
24 | get { return "Spring.NET"; }
25 | }
26 |
27 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
28 | this.Register(implementationType, serviceType, true);
29 | }
30 |
31 | public override void RegisterTransient(Type serviceType, Type implementationType) {
32 | this.Register(implementationType, serviceType, false);
33 | }
34 |
35 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
36 | throw new SkipException("It seems possible (scope='request' in XML) but I have no clue how to implement it in code.");
37 | }
38 |
39 | public override void RegisterInstance(Type serviceType, object instance) {
40 | var key = string.Format("{0} ({1})", serviceType, instance);
41 | this.context.ObjectFactory.RegisterSingleton(key, instance);
42 | }
43 |
44 | private void Register(Type implementationType, Type serviceType, bool singleton) {
45 | var builder = ObjectDefinitionBuilder.RootObjectDefinition(this.factory, implementationType)
46 | .SetAutowireMode(AutoWiringMode.AutoDetect)
47 | .SetSingleton(singleton);
48 |
49 | var key = string.Format("{0} ({1})", serviceType, implementationType);
50 | this.context.RegisterObjectDefinition(key, builder.ObjectDefinition);
51 | }
52 |
53 | private void EnsureContextRefreshed() {
54 | if (this.contextRefreshed)
55 | return;
56 |
57 | this.context.Refresh();
58 | this.contextRefreshed = true;
59 | }
60 |
61 | public override object Resolve(Type serviceType) {
62 | this.EnsureContextRefreshed();
63 | return this.context.GetObjectsOfType(serviceType).Values.Cast().Single();
64 | }
65 |
66 | public override IEnumerable ResolveAll(Type serviceType) {
67 | this.EnsureContextRefreshed();
68 | return this.context.GetObjectsOfType(serviceType).Values.Cast();
69 | }
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/StashboxAdapter.cs:
--------------------------------------------------------------------------------
1 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
2 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
3 | using Stashbox;
4 | using Stashbox.Infrastructure;
5 | using Stashbox.Web.Mvc;
6 | using System;
7 | using System.Collections.Generic;
8 | using System.Reflection;
9 |
10 | namespace FeatureTests.On.DependencyInjection.Adapters {
11 | public class StashboxAdapter : ContainerAdapterBase {
12 | private readonly IStashboxContainer container;
13 | private StashboxPerRequestScopeProvider perRequestScope;
14 |
15 | public StashboxAdapter() {
16 | this.container = new StashboxContainer(config => config
17 | .WithCircularDependencyTracking()
18 | .WithDisposableTransientTracking()
19 | .WithMemberInjectionWithoutAnnotation()
20 | .WithOptionalAndDefaultValueInjection()
21 | .WithUnknownTypeResolution()
22 | .WithCircularDependencyWithLazy());
23 |
24 | this.perRequestScope = new StashboxPerRequestScopeProvider(this.container);
25 | }
26 |
27 | public override Assembly Assembly => typeof(StashboxContainer).Assembly;
28 |
29 | public override string PackageId => "Stashbox";
30 |
31 | public override void RegisterInstance(Type serviceType, object instance) =>
32 | this.container.RegisterInstance(serviceType, instance);
33 |
34 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) =>
35 | this.container.RegisterType(serviceType, implementationType, context => context.WithLifetime(new PerRequestLifetime()));
36 |
37 | public override void RegisterSingleton(Type serviceType, Type implementationType) =>
38 | this.container.RegisterSingleton(serviceType, implementationType);
39 |
40 | public override void RegisterTransient(Type serviceType, Type implementationType) =>
41 | this.container.RegisterType(serviceType, implementationType);
42 |
43 | public override void AfterBeginWebRequest() =>
44 | this.perRequestScope.GetOrCreateScope();
45 |
46 | public override void BeforeAllWebRequests(WebRequestTestHelper helper) =>
47 | helper.RegisterModule();
48 |
49 | public override object Resolve(Type serviceType) => this.container.Resolve(serviceType);
50 |
51 | public override IEnumerable ResolveAll(Type serviceType) => this.container.ResolveAll(serviceType);
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/StructureMapAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using StructureMap;
6 | using StructureMap.Configuration.DSL;
7 | using StructureMap.Configuration.DSL.Expressions;
8 | using StructureMap.Pipeline;
9 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
10 |
11 | namespace FeatureTests.On.DependencyInjection.Adapters {
12 | public class StructureMapAdapter : ContainerAdapterBase {
13 | private Registry initialRegistry = new Registry();
14 | private Container container;
15 |
16 | public override Assembly Assembly {
17 | get { return typeof(Container).Assembly; }
18 | }
19 |
20 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
21 | RegisterInitialOrConfigure(serviceType, new SingletonLifecycle(), r => r.Use(implementationType));
22 | }
23 |
24 | public override void RegisterTransient(Type serviceType, Type implementationType) {
25 | RegisterInitialOrConfigure(serviceType, new TransientLifecycle(), r => r.Use(implementationType));
26 | }
27 |
28 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
29 | throw PerWebRequestMayNotBeProvided();
30 | }
31 |
32 | public override void RegisterInstance(Type serviceType, object instance) {
33 | RegisterInitialOrConfigure(serviceType, new SingletonLifecycle(), r => r.Use(instance));
34 | }
35 |
36 | private void RegisterInitialOrConfigure(Type serviceType, ILifecycle lifecycle, Action use) {
37 | var registry = this.initialRegistry ?? new Registry();
38 | use(registry.For(serviceType).LifecycleIs(lifecycle));
39 |
40 | if (this.container != null)
41 | this.container.Configure(c => c.AddRegistry(registry));
42 | }
43 |
44 | public override object Resolve(Type serviceType) {
45 | this.EnsureContainer();
46 | return this.container.GetInstance(serviceType);
47 | }
48 |
49 | public override IEnumerable ResolveAll(Type serviceType) {
50 | this.EnsureContainer();
51 | return this.container.GetAllInstances(serviceType).Cast();
52 | }
53 |
54 | private void EnsureContainer() {
55 | if (this.container != null)
56 | return;
57 |
58 | this.container = new Container(this.initialRegistry);
59 | this.initialRegistry = null;
60 | }
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/TinyIoCAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
6 | using TinyIoC;
7 |
8 | namespace FeatureTests.On.DependencyInjection.Adapters {
9 | public class TinyIoCAdapter : ContainerAdapterBase {
10 | private readonly TinyIoCContainer container = new TinyIoCContainer();
11 |
12 | public override Assembly Assembly {
13 | get { return null; }
14 | }
15 |
16 | public override string PackageId {
17 | get { return "TinyIoC"; }
18 | }
19 |
20 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
21 | this.container.Register(serviceType, implementationType).AsSingleton();
22 | }
23 |
24 | public override void RegisterTransient(Type serviceType, Type implementationType) {
25 | this.container.Register(serviceType, implementationType).AsMultiInstance();
26 | }
27 |
28 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
29 | throw PerWebRequestMayNotBeProvided();
30 | }
31 |
32 | public override void RegisterInstance(Type serviceType, object instance) {
33 | this.container.Register(serviceType, instance);
34 | }
35 |
36 | public override object Resolve(Type serviceType) {
37 | return this.container.Resolve(serviceType);
38 | }
39 |
40 | public override IEnumerable ResolveAll(Type serviceType) {
41 | return this.container.ResolveAll(serviceType);
42 | }
43 |
44 | public override bool CrashesOnRecursion {
45 | get { return true; }
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/UnityAdapter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport;
6 | using Microsoft.Practices.Unity;
7 | using FeatureTests.On.DependencyInjection.Adapters.Interface;
8 | using Microsoft.Practices.Unity.Mvc;
9 |
10 | namespace FeatureTests.On.DependencyInjection.Adapters {
11 | public class UnityAdapter : ContainerAdapterBase {
12 | private readonly IUnityContainer container = new UnityContainer();
13 |
14 | public override Assembly Assembly {
15 | get { return typeof(IUnityContainer).Assembly; }
16 | }
17 |
18 | public override string PackageId {
19 | get { return "Unity"; }
20 | }
21 |
22 | public override void RegisterSingleton(Type serviceType, Type implementationType) {
23 | this.Register(serviceType, implementationType, () => new ContainerControlledLifetimeManager());
24 | }
25 |
26 | public override void RegisterTransient(Type serviceType, Type implementationType) {
27 | this.Register(serviceType, implementationType, () => new TransientLifetimeManager());
28 | }
29 |
30 | public override void RegisterPerWebRequest(Type serviceType, Type implementationType) {
31 | this.Register(serviceType, implementationType, () => new PerRequestLifetimeManager());
32 | }
33 |
34 | private void Register(Type serviceType, Type implementationType, Func lifetime) {
35 | this.container.RegisterType(serviceType, implementationType, lifetime());
36 |
37 | var name = serviceType.AssemblyQualifiedName + " => " + implementationType.AssemblyQualifiedName;
38 | this.container.RegisterType(serviceType, implementationType, name, lifetime());
39 | }
40 |
41 | public override void RegisterInstance(Type serviceType, object instance) {
42 | this.container.RegisterInstance(serviceType, instance);
43 | this.container.RegisterInstance(serviceType, serviceType.AssemblyQualifiedName + " => " + instance, instance);
44 | }
45 |
46 | public override void BeforeAllWebRequests(WebRequestTestHelper helper) {
47 | helper.RegisterModule();
48 | }
49 |
50 | public override object Resolve(Type serviceType) {
51 | return this.container.Resolve(serviceType);
52 | }
53 |
54 | public override IEnumerable ResolveAll(Type serviceType) {
55 | return this.container.ResolveAll(serviceType);
56 | }
57 |
58 | public override bool CrashesOnRecursion {
59 | get { return true; }
60 | }
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/WebRequestSupport/TestHttpApplication.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using System.Web;
6 |
7 | namespace FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport {
8 | public class TestHttpApplication : HttpApplication {
9 | public void RaiseEvent(string name) {
10 | var handler = (EventHandler)this.Events[GetEventKey(name)];
11 | if (handler == null)
12 | return;
13 |
14 | handler(this, EventArgs.Empty);
15 | }
16 |
17 | private object GetEventKey(string name) {
18 | var keyField = typeof(HttpApplication).GetField("Event" + name, BindingFlags.Static | BindingFlags.NonPublic);
19 | return keyField.GetValue(null);
20 | }
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/DependencyInjection/Adapters/WebRequestSupport/WebRequestTestHelper.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.IO;
4 | using System.Linq;
5 | using System.Web;
6 | using AshMind.Extensions;
7 | using ReflectionMagic;
8 |
9 | namespace FeatureTests.On.DependencyInjection.Adapters.WebRequestSupport {
10 | public class WebRequestTestHelper : IDisposable {
11 | private readonly ISet modules = new HashSet();
12 | private readonly TestHttpApplication application;
13 |
14 | //public static WebRequestTestHelper Current {
15 | // get { return (WebRequestTestHelper)CallContext.LogicalGetData("WebRequestTestHelper.Current"); }
16 | // private set { CallContext.LogicalSetData("WebRequestTestHelper.Current", value); }
17 | //}
18 |
19 | //public WebRequestTestHelper() {
20 | // if (Current != null)
21 | // throw
22 | //}
23 |
24 | public WebRequestTestHelper() {
25 | this.application = new TestHttpApplication();
26 | }
27 |
28 | public void RegisterModule()
29 | where THttpModule : IHttpModule, new()
30 | {
31 | RegisterModule(new THttpModule());
32 | }
33 |
34 | public void RegisterModule(IHttpModule module) {
35 | module.Init(this.application);
36 | this.modules.Add(module);
37 | }
38 |
39 | public void BeginWebRequest() {
40 | var context = new HttpContext(
41 | new HttpRequest("", "http://only.test", ""),
42 | new HttpResponse(new StringWriter())
43 | ) { ApplicationInstance = this.application };
44 | this.application.AsDynamic()._context = context;
45 |
46 | HttpContext.Current = context;
47 |
48 | this.application.RaiseEvent("BeginRequest");
49 | }
50 |
51 | public void EndWebRequest() {
52 | this.application.RaiseEvent("EndRequest");
53 | HttpContext.Current = null;
54 | }
55 |
56 | public void Dispose() {
57 | HttpContext.Current = null;
58 | modules.ForEach(m => m.Dispose());
59 | modules.Clear();
60 | }
61 | }
62 | }
63 |
--------------------------------------------------------------------------------
/DependencyInjection/Html/AfterAll.html:
--------------------------------------------------------------------------------
1 |
2 | Not tested
3 |
4 |
List of containers I couldn't test, with corresponding reasons.
5 |
8 | fFastInjector
9 | Static only: would require an AppDomain to test properly.
10 |
11 | Funq
12 | Not found on NuGet.
13 |
14 | Griffin
15 | Complex API. Please feel free to do a pull request for it.
16 |
17 | Hiro
18 | Complex API.
19 |
20 | Petite
21 | Code-only NuGet package.
22 |
23 | Speedioc
24 | I can't quickly figure out how to register an instance.
25 |
26 | Stiletto
27 | Seems to use attribute-only registration.
28 |
29 |
--------------------------------------------------------------------------------
/DependencyInjection/Html/Options.json:
--------------------------------------------------------------------------------
1 | {
2 | "PageTitle": "Dependency Injection",
3 | "LinkTitle": "Dependency Injection"
4 | }
--------------------------------------------------------------------------------
/DependencyInjection/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
1 | using System.Reflection;
2 | using System.Runtime.InteropServices;
3 |
4 | // General Information about an assembly is controlled through the following
5 | // set of attributes. Change these attribute values to modify the information
6 | // associated with an assembly.
7 | [assembly: AssemblyCopyright("Copyright © Andrey Shchekin 2013")]
8 |
9 | // Setting ComVisible to false makes the types in this assembly not visible
10 | // to COM components. If you need to access a type in this assembly from
11 | // COM, set the ComVisible attribute to true on that type.
12 | [assembly: ComVisible(false)]
13 |
14 | // The following GUID is for the ID of the typelib if this project is exposed to COM
15 | [assembly: Guid("f6e292c8-b01e-44c8-ac80-5b8a5e2a9497")]
16 |
17 | // Version information for an assembly consists of the following four values:
18 | //
19 | // Major Version
20 | // Minor Version
21 | // Build Number
22 | // Revision
23 | //
24 | // You can specify all the values or you can default the Build and Revision Numbers
25 | // by using the '*' as shown below:
26 | // [assembly: AssemblyVersion("1.0.*")]
27 | [assembly: AssemblyVersion("1.0.0.0")]
28 | [assembly: AssemblyFileVersion("1.0.0.0")]
29 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/DisposableService.cs:
--------------------------------------------------------------------------------
1 | using System;
2 |
3 | namespace FeatureTests.On.DependencyInjection.TestTypes {
4 | public class DisposableService : IDisposable {
5 | public void Dispose() {
6 | this.Disposed = true;
7 | }
8 |
9 | public bool Disposed { get; private set; }
10 | }
11 | }
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/GenericService.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class GenericService : IGenericService {
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/GenericServiceWithIService2Constraint.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class GenericServiceWithIService2Constraint : IGenericService
7 | where T : IService2
8 | {
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/IGenericService.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public interface IGenericService {
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/IResolvableUnregisteredService.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public interface IResolvableUnregisteredService {
7 | }
8 | }
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/IService.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public interface IService {
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/IService2.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public interface IService2 {
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/IServiceWithListDependency.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public interface IServiceWithListDependency
7 | where TServiceList : IEnumerable
8 | {
9 | TServiceList Services { get; }
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/IUnregisteredService.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public interface IUnregisteredService {
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/IndependentService.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class IndependentService : IService {
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/IndependentService2.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class IndependentService2 : IService2 {
7 | }
8 | }
9 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceThatCreatesRecursiveArrayDependency.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceThatCreatesRecursiveArrayDependency : IService {
7 | public ServiceThatCreatesRecursiveArrayDependency(ServiceWithListConstructorDependency dependency) {}
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithDependencyAndOptionalInt32Parameter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Text;
5 | using System.Threading.Tasks;
6 |
7 | namespace FeatureTests.On.DependencyInjection.TestTypes {
8 | public class ServiceWithDependencyAndOptionalInt32Parameter {
9 | public int Optional { get; private set; }
10 |
11 | public ServiceWithDependencyAndOptionalInt32Parameter(IService service, int optional = 5) {
12 | Optional = optional;
13 | }
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithDependencyAndOptionalOtherServiceParameter.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithDependencyAndOptionalOtherServiceParameter {
7 | public IService2 Optional { get; private set; }
8 |
9 | public ServiceWithDependencyAndOptionalOtherServiceParameter(IService service, IService2 optional = null) {
10 | Optional = optional;
11 | }
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithDependencyOnServiceWithOtherDependency.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithDependencyOnServiceWithOtherDependency : IResolvableUnregisteredService {
7 | private readonly ServiceWithSimpleConstructorDependency service;
8 |
9 | public ServiceWithDependencyOnServiceWithOtherDependency(ServiceWithSimpleConstructorDependency service) {
10 | this.service = service;
11 | }
12 |
13 | public ServiceWithSimpleConstructorDependency Service {
14 | get { return this.service; }
15 | }
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithFuncConstructorDependency.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithFuncConstructorDependency {
7 | private readonly Func factory;
8 |
9 | public ServiceWithFuncConstructorDependency(Func factory) {
10 | this.factory = factory;
11 | }
12 |
13 | public Func Factory {
14 | get { return this.factory; }
15 | }
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithListConstructorDependency.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithListConstructorDependency : IServiceWithListDependency
7 | where TServiceList : IEnumerable
8 | {
9 | private readonly TServiceList services;
10 |
11 | public ServiceWithListConstructorDependency(TServiceList services) {
12 | this.services = services;
13 | }
14 |
15 | public TServiceList Services {
16 | get { return this.services; }
17 | }
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithMultipleConstructors.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithMultipleConstructors {
7 | public static class ConstructorNames {
8 | public const string Default = "Default";
9 | public const string MostResolvable = "Most resolvable";
10 | public const string MostDefined = "Most defined";
11 | public const string Unresolvable = "Unresolvable";
12 | }
13 |
14 | private readonly string usedConstructorName;
15 |
16 | public ServiceWithMultipleConstructors() {
17 | this.usedConstructorName = ConstructorNames.Default;
18 | }
19 |
20 | public ServiceWithMultipleConstructors(IService service) {
21 | this.usedConstructorName = ConstructorNames.MostResolvable;
22 | }
23 |
24 | public ServiceWithMultipleConstructors(IUnregisteredService service) {
25 | this.usedConstructorName = ConstructorNames.Unresolvable;
26 | }
27 |
28 | public ServiceWithMultipleConstructors(IService service1, IUnregisteredService service2) {
29 | this.usedConstructorName = ConstructorNames.MostDefined;
30 | }
31 |
32 | public string UsedConstructorName {
33 | get { return this.usedConstructorName; }
34 | }
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithRecursiveDependency1.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithRecursiveDependency1 {
7 | public ServiceWithRecursiveDependency1(ServiceWithRecursiveDependency2 dependency) {
8 | }
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithRecursiveDependency2.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithRecursiveDependency2 {
7 | public ServiceWithRecursiveDependency2(ServiceWithRecursiveDependency1 dependency) {
8 | }
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithRecursiveLazyDependency1.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithRecursiveLazyDependency1 {
7 | private readonly Lazy dependency;
8 |
9 | public ServiceWithRecursiveLazyDependency1(Lazy dependency) {
10 | this.dependency = dependency;
11 | }
12 |
13 | public ServiceWithRecursiveLazyDependency2 Dependency {
14 | get { return this.dependency.Value; }
15 | }
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithRecursiveLazyDependency2.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithRecursiveLazyDependency2 {
7 | private readonly Lazy dependency;
8 |
9 | public ServiceWithRecursiveLazyDependency2(Lazy dependency) {
10 | this.dependency = dependency;
11 | }
12 |
13 | public ServiceWithRecursiveLazyDependency1 Dependency {
14 | get { return this.dependency.Value; }
15 | }
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithSimpleConstructorDependency.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithSimpleConstructorDependency {
7 | private readonly IService service;
8 |
9 | public ServiceWithSimpleConstructorDependency(IService service) {
10 | this.service = service;
11 | }
12 |
13 | public IService Service {
14 | get { return this.service; }
15 | }
16 | }
17 | }
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithSimplePropertyDependency.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithSimplePropertyDependency {
7 | [Microsoft.Practices.Unity.Dependency]
8 | [StructureMap.Attributes.SetterProperty]
9 | [LinFu.IoC.Configuration.Inject]
10 | [Ninject.Inject]
11 | [MugenInjection.Attributes.Inject]
12 | [IfInjector.Inject]
13 | [System.ComponentModel.Composition.Import]
14 | public IService Service { get; set; }
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/DependencyInjection/TestTypes/ServiceWithTwoConstructorDependencies.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 |
5 | namespace FeatureTests.On.DependencyInjection.TestTypes {
6 | public class ServiceWithTwoConstructorDependencies {
7 | private readonly IService service1;
8 | private readonly IService2 service2;
9 |
10 | public ServiceWithTwoConstructorDependencies(IService service1, IService2 service2) {
11 | this.service1 = service1;
12 | this.service2 = service2;
13 | }
14 |
15 | public IService Service1 {
16 | get { return this.service1; }
17 | }
18 |
19 | public IService2 Service2 {
20 | get { return this.service2; }
21 | }
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/DependencyInjection/app.config:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
8 |
9 |
10 |
13 |
14 |
17 |
18 |
21 |
22 |
25 |
26 |
29 |
30 |
33 |
34 |
37 |
38 |
41 |
42 |
45 |
46 |
49 |
50 |
53 |
54 |
57 |
58 |
59 |
--------------------------------------------------------------------------------
/DependencyInjection/packages.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/FeatureTests.sln.DotSettings:
--------------------------------------------------------------------------------
1 |
2 | HINT
3 | DO_NOT_SHOW
4 | END_OF_LINE
5 | END_OF_LINE
6 | END_OF_LINE
7 | END_OF_LINE
8 | END_OF_LINE
9 | END_OF_LINE
10 | System
11 | System.Collections.Generic
12 | System.Linq
13 | AB
14 | <Policy Inspect="True" Prefix="" Suffix="" Style="AaBb"><ExtraRule Prefix="I" Suffix="" Style="AaBb" /></Policy>
15 | <Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" />
16 | True
17 | True
18 | True
--------------------------------------------------------------------------------
/JsonSerializers/1_SimpleTypeTests.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.ComponentModel;
4 | using System.Linq;
5 | using FeatureTests.On.JsonSerializers.Adapters;
6 | using FeatureTests.On.JsonSerializers.TestTypes;
7 | using FeatureTests.Shared;
8 | using Xunit;
9 |
10 | namespace FeatureTests.On.JsonSerializers {
11 | [DisplayOrder(1)]
12 | [DisplayName("Simple types")]
13 | [Description("Tests on simple types -- top level primitive.")]
14 | public class SimpleTypeTests {
15 | private const string Iso8601WithTimeZoneFormat = @"yyyy-MM-ddTHH\:mm\:ss.fffffffK";
16 |
17 | [Feature]
18 | [DisplayName("string")]
19 | public void String(IJsonSerializerAdapter adapter) {
20 | AssertDeserializesTo("ABC", "\"ABC\"", adapter);
21 | }
22 |
23 | [Feature]
24 | [DisplayName("int")]
25 | public void Int32(IJsonSerializerAdapter adapter) {
26 | AssertDeserializesTo(5, "5", adapter);
27 | }
28 |
29 | [Feature]
30 | [DisplayName("DateTime")]
31 | public void DateTime(IJsonSerializerAdapter adapter) {
32 | var date = new DateTime(2014, 08, 02, 12, 34, 56, DateTimeKind.Utc);
33 | AssertDeserializesTo(date, "\"" + date.ToString(Iso8601WithTimeZoneFormat) + "\"", adapter);
34 | }
35 |
36 | [Feature]
37 | [DisplayName("DateTimeOffset")]
38 | public void DateTimeOffset(IJsonSerializerAdapter adapter) {
39 | var date = new DateTimeOffset(2014, 08, 02, 12, 34, 56, TimeSpan.FromHours(3));
40 | AssertDeserializesTo(date, "\"" + date.ToString(Iso8601WithTimeZoneFormat) + "\"", adapter);
41 | }
42 |
43 | [Feature]
44 | [DisplayName("Uri")]
45 | public void Uri(IJsonSerializerAdapter adapter) {
46 | var uri = new Uri("http://google.com");
47 | AssertDeserializesTo(uri, "\"" + uri + "\"", adapter);
48 | }
49 |
50 | // ReSharper disable once UnusedParameter.Local
51 | private void AssertDeserializesTo(T expected, string json, IJsonSerializerAdapter adapter) {
52 | Assert.Equal(expected, adapter.Deserialize(json));
53 | }
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/JsonSerializers/2_CollectionTests.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections;
3 | using System.Collections.Generic;
4 | using System.ComponentModel;
5 | using System.Linq;
6 | using FeatureTests.On.JsonSerializers.Adapters;
7 | using FeatureTests.Shared;
8 | using Xunit;
9 |
10 | namespace FeatureTests.On.JsonSerializers {
11 | [DisplayOrder(2)]
12 | [DisplayName("Collections")]
13 | public class CollectionTests {
14 | private const string ABListJson = "[\"A\", \"B\"]";
15 |
16 | [Feature]
17 | [DisplayName("string[]")]
18 | public void ArrayOfString(IJsonSerializerAdapter adapter) {
19 | AssertDeserializesTo(new[] { "A", "B" }, ABListJson, adapter);
20 | }
21 |
22 | [Feature]
23 | [DisplayName("object[]")]
24 | [Description(@"This test verifies that a mixed-type array can be deserialized.")]
25 | public void ArrayOfObject(IJsonSerializerAdapter adapter) {
26 | AssertDeserializesTo(new object[] { "A", 5 }, "[\"A\", 5]", adapter);
27 | }
28 |
29 | [Feature]
30 | [DisplayName("List")]
31 | public void ListOfString(IJsonSerializerAdapter adapter) {
32 | AssertDeserializesTo(new List { "A", "B" }, ABListJson, adapter);
33 | }
34 |
35 | [Feature]
36 | [DisplayName("IList")]
37 | public void IListOfString(IJsonSerializerAdapter adapter) {
38 | AssertDeserializesTo((IList)new List { "A", "B" }, ABListJson, adapter);
39 | }
40 |
41 | [Feature]
42 | [DisplayName("HashSet")]
43 | public void HashSetOfString(IJsonSerializerAdapter adapter) {
44 | AssertDeserializesTo(new HashSet { "A", "B" }, ABListJson, adapter);
45 | }
46 |
47 | [Feature]
48 | [DisplayName("ISet")]
49 | public void ISetOfString(IJsonSerializerAdapter adapter) {
50 | AssertDeserializesTo((ISet)new HashSet { "A", "B" }, ABListJson, adapter);
51 | }
52 |
53 | [Feature]
54 | [DisplayName("IReadOnlyList")]
55 | public void IReadOnlyListOfString(IJsonSerializerAdapter adapter) {
56 | AssertDeserializesTo((IReadOnlyList)new[] { "A", "B" }, ABListJson, adapter);
57 | }
58 |
59 | [Feature]
60 | [DisplayName("IReadOnlyCollection")]
61 | public void IReadOnlyCollectionOfString(IJsonSerializerAdapter adapter) {
62 | AssertDeserializesTo((IReadOnlyCollection)new[] { "A", "B" }, ABListJson, adapter);
63 | }
64 |
65 | [Feature]
66 | [DisplayName("IEnumerable")]
67 | public void IEnumerableOfString(IJsonSerializerAdapter adapter) {
68 | AssertDeserializesTo((IEnumerable)new[] { "A", "B" }, ABListJson, adapter);
69 | }
70 |
71 | // ReSharper disable once UnusedParameter.Local
72 | private void AssertDeserializesTo(TCollection expected, string json, IJsonSerializerAdapter adapter)
73 | where TCollection : IEnumerable
74 | {
75 | var deserialized = adapter.Deserialize(json);
76 | Assert.Equal(
77 | expected.Cast().ToArray(),
78 | deserialized.Cast().ToArray()
79 | );
80 | }
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/JsonSerializers/3_DictionaryTests.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.ComponentModel;
4 | using AshMind.Extensions;
5 | using FeatureTests.On.JsonSerializers.Adapters;
6 | using FeatureTests.Shared;
7 | using Xunit;
8 |
9 | namespace FeatureTests.On.JsonSerializers {
10 | [DisplayOrder(3)]
11 | [DisplayName("Dictionaries")]
12 | [Description(@"
13 | Sometimes it is inconvenient or impossible to define schema as a static type in advance.
14 | This leaves two options -- dictionaries and dynamic types. These tests look at dictionary support.
15 | ")]
16 | public class DictionaryTests {
17 | [Feature]
18 | [DisplayName("Basic")]
19 | public void Basic(IJsonSerializerAdapter adapter) {
20 | var dictionary = adapter.Deserialize>("{ \"key\": \"value\" }");
21 | Assert.NotNull(dictionary);
22 | Assert.Equal("value", dictionary.GetValueOrDefault("key"));
23 | }
24 |
25 | [Feature]
26 | [DisplayName("Nested")]
27 | public void Nested(IJsonSerializerAdapter adapter) {
28 | var dictionary = adapter.Deserialize>("{ \"key\": { \"nested\": \"value\" } }");
29 | Assert.NotNull(dictionary);
30 | var nested = Assert.IsAssignableFrom>(dictionary.GetValueOrDefault("key"));
31 | Assert.Equal("value", nested.GetValueOrDefault("nested"));
32 | }
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/JsonSerializers/4_ReadOnlyPropertyTests.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Collections.ObjectModel;
4 | using System.ComponentModel;
5 | using System.Diagnostics;
6 | using System.Linq;
7 | using FeatureTests.On.JsonSerializers.Adapters;
8 | using FeatureTests.On.JsonSerializers.TestTypes;
9 | using FeatureTests.Shared;
10 | using Xunit;
11 |
12 | namespace FeatureTests.On.JsonSerializers {
13 | [DisplayOrder(4)]
14 | [DisplayName("Read-only properties")]
15 | [Description(@"
16 | It is often a good idea to avoid public setters for certain properties.
17 | One classic example is collection properties, which are often recommended
18 | to be readonly to ensure the collection is always non-null.
19 |
20 | Since there are other ways to set those properties (e.g. Add for collections),
21 | there should be no need for bad design just to satisfy the serializer.
22 | ")]
23 | public class ReadOnlyPropertyTests {
24 | [Feature]
25 | [DisplayName("ICollection property")]
26 | public void ICollection(IJsonSerializerAdapter adapter) {
27 | AssertCanBeRoundtripped, Collection>(
28 | adapter, new Collection { "A", "B" }
29 | );
30 | }
31 |
32 | [Feature]
33 | [DisplayName("ISet