-
Notifications
You must be signed in to change notification settings - Fork 758
/
ConfigReader_Configuration.cs
149 lines (134 loc) · 6.94 KB
/
ConfigReader_Configuration.cs
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#if NETFRAMEWORK
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Globalization;
using System.IO;
namespace Xunit
{
/// <summary>
/// This class is used to read configuration information for a test assembly.
/// </summary>
public static class ConfigReader_Configuration
{
/// <summary/>
[EditorBrowsable(EditorBrowsableState.Never)]
public static TestAssemblyConfiguration Load(string assemblyFileName, string configFileName = null) =>
Load(assemblyFileName, configFileName, null);
/// <summary>
/// Loads the test assembly configuration for the given test assembly.
/// </summary>
/// <param name="assemblyFileName">The test assembly.</param>
/// <param name="configFileName">The test assembly configuration file.</param>
/// <param name="warnings">A container to receive loading warnings, if desired.</param>
/// <returns>The test assembly configuration.</returns>
public static TestAssemblyConfiguration Load(string assemblyFileName, string configFileName = null, List<string> warnings = null)
{
// If they provide a configuration file, we only read that, success or failure
if (configFileName != null)
{
if (!configFileName.EndsWith(".config", StringComparison.Ordinal))
return null;
if (!File.Exists(configFileName))
{
warnings?.Add(string.Format(CultureInfo.CurrentCulture, "Couldn't load config file '{0}': file not found", configFileName));
return null;
}
}
else
{
configFileName = assemblyFileName + ".config";
if (!File.Exists(configFileName))
return null;
}
try
{
var map = new ExeConfigurationFileMap { ExeConfigFilename = configFileName };
var config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None);
if (config != null && config.AppSettings != null)
{
var result = new TestAssemblyConfiguration();
var settings = config.AppSettings.Settings;
result.AppDomain = GetEnum<AppDomainSupport>(settings, Configuration.AppDomain) ?? result.AppDomain;
result.DiagnosticMessages = GetBoolean(settings, Configuration.DiagnosticMessages) ?? result.DiagnosticMessages;
result.InternalDiagnosticMessages = GetBoolean(settings, Configuration.InternalDiagnosticMessages) ?? result.InternalDiagnosticMessages;
result.MaxParallelThreads = GetInt(settings, Configuration.MaxParallelThreads) ?? result.MaxParallelThreads;
result.MethodDisplay = GetEnum<TestMethodDisplay>(settings, Configuration.MethodDisplay) ?? result.MethodDisplay;
result.MethodDisplayOptions = GetEnum<TestMethodDisplayOptions>(settings, Configuration.MethodDisplayOptions) ?? result.MethodDisplayOptions;
result.ParallelAlgorithm = GetEnum<ParallelAlgorithm>(settings, Configuration.ParallelAlgorithm) ?? result.ParallelAlgorithm;
result.ParallelizeAssembly = GetBoolean(settings, Configuration.ParallelizeAssembly) ?? result.ParallelizeAssembly;
result.ParallelizeTestCollections = GetBoolean(settings, Configuration.ParallelizeTestCollections) ?? result.ParallelizeTestCollections;
result.PreEnumerateTheories = GetBoolean(settings, Configuration.PreEnumerateTheories) ?? result.PreEnumerateTheories;
result.ShadowCopy = GetBoolean(settings, Configuration.ShadowCopy) ?? result.ShadowCopy;
result.StopOnFail = GetBoolean(settings, Configuration.StopOnFail) ?? result.StopOnFail;
result.LongRunningTestSeconds = GetInt(settings, Configuration.LongRunningTestSeconds) ?? result.LongRunningTestSeconds;
return result;
}
}
catch (Exception ex)
{
warnings?.Add(string.Format(CultureInfo.CurrentCulture, "Exception loading config file '{0}': {1}", configFileName, ex.Message));
}
return null;
}
static bool? GetBoolean(KeyValueConfigurationCollection settings, string key)
{
return GetValue<bool?>(settings, key,
value =>
{
switch (value.ToLowerInvariant())
{
case "true": return true;
case "false": return false;
default: return null;
}
});
}
static TValue? GetEnum<TValue>(KeyValueConfigurationCollection settings, string key)
where TValue : struct
{
return GetValue<TValue?>(settings, key,
value =>
{
try { return (TValue)Enum.Parse(typeof(TValue), value, true); }
catch { return null; }
});
}
static int? GetInt(KeyValueConfigurationCollection settings, string key)
{
return GetValue<int?>(settings, key,
ValueType =>
{
int result;
if (int.TryParse(ValueType, out result))
return result;
return null;
});
}
static T GetValue<T>(KeyValueConfigurationCollection settings, string key, Func<string, T> converter)
{
var setting = settings[key];
if (setting == null)
return default(T);
return converter(setting.Value);
}
static class Configuration
{
public const string AppDomain = "xunit.appDomain";
public const string DiagnosticMessages = "xunit.diagnosticMessages";
public const string InternalDiagnosticMessages = "xunit.internalDiagnosticMessages";
public const string MaxParallelThreads = "xunit.maxParallelThreads";
public const string MethodDisplay = "xunit.methodDisplay";
public const string MethodDisplayOptions = "xunit.methodDisplayOptions";
public const string ParallelAlgorithm = "xunit.parallelAlgorithm";
public const string ParallelizeAssembly = "xunit.parallelizeAssembly";
public const string ParallelizeTestCollections = "xunit.parallelizeTestCollections";
public const string PreEnumerateTheories = "xunit.preEnumerateTheories";
public const string ShadowCopy = "xunit.shadowCopy";
public const string StopOnFail = "xunit.stopOnFail";
public const string LongRunningTestSeconds = "xunit.longRunningTestSeconds";
}
}
}
#endif