/// <summary>
/// If this <see cref="Configuration"/> contains a mapping for the specified
/// <see cref="IConfigurationRequirement"/> <paramref name="requirement"/> and the mapped <see cref="object"/>
/// is of type <typeparamref name="T"/>, <paramref name="result"/> is set to the mapped <see cref="object"/>
/// and <see langword="true"/> is returned. Otherwise, <paramref name="result"/> is set to the return value of
/// invoking the <paramref name="defaultValueFactory"/>, and <see langword="false"/> is returned.
/// </summary>
/// <param name="requirement">
/// The <see cref="IConfigurationRequirement"/>.
/// </param>
/// <param name="defaultValueFactory">
/// The default value factory.
/// </param>
/// <param name="result">
/// The result.
/// </param>
/// <typeparam name="T">
/// The expected <see cref="Type"/> of the <see cref="object"/> to return. If the specified
/// <see cref="IConfigurationRequirement"/> is contained by this <see cref="Configuration"/>, but the mapped
/// <see cref="object"/> is of a <see cref="Type"/> not compatible with <typeparamref name="T"/>, then the
/// <paramref name="defaultValueFactory"/> will be invoked.
/// </typeparam>
/// <returns>
/// <see langword="true"/> if the <see cref="IConfigurationRequirement"/> <paramref name="requirement"/> is
/// contained by this <see cref="Configuration"/>, and <paramref name="result"/> is able to be
/// set to the expected <see cref="Type"/> <typeparamref name="T"/>; otherwise, <see langword="false"/>.
/// </returns>
public bool TryGetOrDefault <T>(
IConfigurationRequirement requirement,
Func <T> defaultValueFactory,
out T result)
{
return(this.backingConfiguration.TryGetOrDefault <T>(requirement, defaultValueFactory, out result));
}
public static object GetDefaultValidObjectForRequirement(IConfigurationRequirement requirement)
{
if (requirement == null)
{
throw new ArgumentNullException(nameof(requirement));
}
if (!TestUtil.defaultValidObjects.TryGetValue(requirement.OfType, out object result))
{
throw new ArgumentException(
string.Format(
CultureInfo.InvariantCulture,
"Unrecognized ConfigurationRequirementType '{0}'.",
requirement.OfType.Type.ToString()));
}
if (requirement.CollectionInfo == null)
{
return(result);
}
else
{
object[] buffer = new object[requirement.CollectionInfo.MinimumCount];
for (int counter = 0; counter < buffer.Length; counter++)
{
buffer[counter] = result;
}
return(buffer);
}
}
public static void Compare(
string expectedName,
string expectedDescription,
ConfigurationRequirementType expectedType,
bool expectedOptionality,
CollectionInfo collectionInfo,
IEnumerable <IConfigurationRequirement> dependsOn,
IEnumerable <IConfigurationRequirement> exclusiveWith,
Func <IConfigurationRequirement> requirementFactory,
object badInput,
object goodInput)
{
IConfigurationRequirement requirement = requirementFactory.Invoke();
Assert.AreEqual(expectedName, requirement.Name);
Assert.AreEqual(expectedDescription, requirement.Description);
Assert.AreEqual(expectedType, requirement.OfType);
Assert.AreEqual(expectedOptionality, requirement.IsOptional);
Assert.AreEqual(collectionInfo, requirement.CollectionInfo);
CollectionAssert.AreEquivalent(dependsOn.ToArray(), requirement.DependsOn.ToArray());
CollectionAssert.AreEquivalent(exclusiveWith.ToArray(), requirement.ExclusiveWith.ToArray());
Assert.AreEqual(typeof(ArgumentNullException), requirement.Validate(null).GetType());
Assert.AreEqual(typeof(ArgumentException), requirement.Validate(badInput).GetType());
Assert.IsNull(requirement.Validate(goodInput));
}
/// <summary>
/// Internal.
/// </summary>
/// <typeparam name="T">
/// Internal.
/// </typeparam>
/// <param name="requirement">
/// Internal.
/// </param>
/// <param name="defaultValueFactory">
/// Internal.
/// </param>
/// <param name="result">
/// Internal.
/// </param>
/// <returns>
/// Internal.
/// </returns>
public bool TryGetOrDefault <T>(
IConfigurationRequirement requirement,
Func <T> defaultValueFactory,
out T result)
{
if (requirement == null)
{
throw new ArgumentNullException(nameof(requirement));
}
if (defaultValueFactory == null)
{
throw new ArgumentNullException(nameof(defaultValueFactory));
}
if (this.backingDictionary.TryGetValue(requirement, out object actual))
{
if (actual is T buffer)
{
result = buffer;
return(true);
}
}
result = defaultValueFactory.Invoke();
return(false);
}
public void Configuration_Ctor_MultipleFailuresOccur_ThrowsAggregateException()
{
const string validationFailureMessage = "BOUNDCONFIGURATIONTESTS_MultipleFailuresOccur";
const string testFailureMessage = "Missing/too many matches for expected exception.";
const int expectedFailureCount = 4;
IConfigurationRequirement requiredButMissing = TestUtil.CreateConfigurationRequirement(
baseName: nameof(requiredButMissing),
isOptional: false);
IConfigurationRequirement dependsOnIsMissing = TestUtil.CreateConfigurationRequirement(
baseName: nameof(dependsOnIsMissing),
dependsOn: new IConfigurationRequirement[] { requiredButMissing });
IConfigurationRequirement failsValidation = TestUtil.CreateConfigurationRequirement(
baseName: nameof(failsValidation),
validator: (x, y, z) => throw new NotImplementedException(validationFailureMessage));
IConfigurationRequirement exclusiveWith = TestUtil.CreateConfigurationRequirement(
baseName: nameof(exclusiveWith),
exclusiveWith: new IConfigurationRequirement[] { failsValidation });
IConfigurationRequirement isFine = TestUtil.CreateConfigurationRequirement(
baseName: nameof(isFine),
validator: (x, y, z) => null);
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(
requiredButMissing,
dependsOnIsMissing,
failsValidation,
exclusiveWith,
isFine);
Dictionary <IConfigurationRequirement, object> bindings =
new IConfigurationRequirement[] { dependsOnIsMissing, failsValidation, exclusiveWith, isFine }
.Select(x => new KeyValuePair <IConfigurationRequirement, object>(x, null))
.ToDictionary(x => x.Key, x => x.Value);
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(configurable, bindings));
Assert.AreEqual(expectedFailureCount, exception.InnerExceptions.Count);
Assert.IsNotNull(
exception
.InnerExceptions
.SingleOrDefault(x => x.Message.Contains(validationFailureMessage)),
testFailureMessage);
Assert.IsNotNull(
exception
.InnerExceptions
.SingleOrDefault(x => x.Message.Contains("has conflicting requirements specified.")),
testFailureMessage);
Assert.IsNotNull(
exception
.InnerExceptions
.SingleOrDefault(x => x.Message.Contains("does not have its dependencies fulfilled.")),
testFailureMessage);
Assert.IsNotNull(
exception
.InnerExceptions
.SingleOrDefault(x => x.Message.Contains("Missing required requirement")),
testFailureMessage);
}
public void TestFolderDataSourceFactory()
{
IDataSourceFactory factory = this.Factories.Single(x => x.GetType() == typeof(FolderDataSourceFactory));
Dictionary <IConfigurationRequirement, object> inputs =
factory
.Requirements
.Select(
requirement =>
{
Console.Write(requirement.Name + " - (" + requirement.Description + "): ");
string input = Console.ReadLine();
if (input == "null")
{
input = null;
}
return(new KeyValuePair <IConfigurationRequirement, object>(requirement, input));
})
.ToDictionary(x => x.Key, x => x.Value);
IConfigurationRequirement rootRequirement = factory.Requirements.Single(x => x.Name == "Root Path");
inputs[rootRequirement] = new FilePath((string)inputs[rootRequirement]);
IConfigurationRequirement tickRequirement =
factory.Requirements.Single(x => x.Name == "Change Filter Ticks");
inputs[tickRequirement] = inputs[tickRequirement] ==
null ? 0L : long.Parse((string)inputs[tickRequirement]);
IDataSource dataSource = factory.MakeDataSource(inputs);
dataSource.OnChange +=
(obj, e) =>
{
DataSourceChangeEventType type = e.EventType;
IDataInformation information = e.GetImageInformation();
if (type == DataSourceChangeEventType.Added)
{
Console.WriteLine("Added: " + information.Name);
}
else if (type == DataSourceChangeEventType.Changed)
{
Console.WriteLine("Changed: " + information.Name);
}
else if (type == DataSourceChangeEventType.Removed)
{
Console.WriteLine("Removed: " + information.Name);
}
else
{
throw new InvalidOperationException("Unexpected DataSourceChangeEventType value.");
}
};
Console.WriteLine("Monitoring folder '" + dataSource.Name + "'. Press enter to stop.");
Console.ReadLine();
dataSource.Dispose();
}
public void Configuration_Ctor_DependsOn_PropagatesDependencies()
{
IConfigurationRequirement parent1 = TestUtil.CreateConfigurationRequirement(baseName: "ParentOne");
IConfigurationRequirement parent2 = TestUtil.CreateConfigurationRequirement(baseName: "ParentTwo");
IConfigurationRequirement child1 = TestUtil.CreateConfigurationRequirement(
baseName: "ChildOne",
dependsOn: new IConfigurationRequirement[] { parent1 },
validator: (x, y, z) =>
{
CollectionAssert.Contains(z.Keys.ToArray(), parent1);
return(null);
});
IConfigurationRequirement child2 = TestUtil.CreateConfigurationRequirement(
baseName: "ChildTwo",
dependsOn: new IConfigurationRequirement[] { child1 },
validator: (x, y, z) =>
{
CollectionAssert.Contains(z.Keys.ToArray(), child1);
return(null);
});
IConfigurationRequirement child3 = TestUtil.CreateConfigurationRequirement(
baseName: "ChildThree",
dependsOn: new IConfigurationRequirement[] { parent2, child2 },
validator: (x, y, z) =>
{
CollectionAssert.Contains(z.Keys.ToArray(), parent2);
CollectionAssert.Contains(z.Keys.ToArray(), child2);
return(null);
});
Dictionary <IConfigurationRequirement, object> supplied =
new Dictionary <IConfigurationRequirement, object>()
{
[parent1] = TestUtil.GetDefaultValidObjectForRequirement(parent1),
[parent2] = TestUtil.GetDefaultValidObjectForRequirement(parent2),
[child1] = TestUtil.GetDefaultValidObjectForRequirement(child1),
[child2] = TestUtil.GetDefaultValidObjectForRequirement(child2),
[child3] = TestUtil.GetDefaultValidObjectForRequirement(child3)
};
MockRequirementSource configurable = new MockRequirementSource(
new IConfigurationRequirement[]
{
parent1,
parent2,
child1,
child2,
child3
});
Configuration configuration = new Configuration(configurable, supplied);
Assert.IsNotNull(configuration);
CollectionAssert.AreEquivalent(
supplied.Select(x => new Mapping(x.Key, x.Value)).ToArray(),
configuration.ToArray());
}
public void Mapping_Equals_ValuesDoNotMatch_ReturnsFalse()
{
IConfigurationRequirement requirement = ConfigurationRequirement.String("Name", "Description");
Mapping first = new Mapping(requirement, "Hello World");
Mapping second = new Mapping(requirement, "Goodbye World");
Assert.IsFalse(first.Equals(second));
Assert.IsFalse(second.Equals(first));
}
public void Mapping_Equals_OneHasValueNull_ReturnsFalse()
{
IConfigurationRequirement requirement = ConfigurationRequirement.String("Name", "Description");
Mapping first = new Mapping(requirement, "Hello World");
Mapping second = new Mapping(requirement, null);
Assert.IsFalse(first.Equals(second));
Assert.IsFalse(second.Equals(first));
}
public void Mapping_GetHashCode_DifferentInstances_ReturnsSameHash()
{
IConfigurationRequirement requirement = TestUtil.CreateConfigurationRequirement();
object value = "Hello world";
Mapping first = new Mapping(requirement, value);
Mapping second = new Mapping(requirement, value);
Assert.AreEqual(first.GetHashCode(), second.GetHashCode());
}
public void Mapping_Ctor_Success()
{
const string value = "Valid";
IConfigurationRequirement requirement = ConfigurationRequirement.String("Name", "Description");
Mapping mapping = new Mapping(requirement, value);
Assert.AreEqual(requirement, mapping.Requirement);
Assert.AreEqual(value, mapping.Value);
}
public void Mapping_Equals_Succeeds()
{
const string value = "Hello World";
IConfigurationRequirement requirement = ConfigurationRequirement.String("Name", "Description");
Mapping first = new Mapping(requirement, value);
Mapping second = new Mapping(requirement, value);
Assert.IsTrue(first.Equals(second));
Assert.IsTrue(second.Equals(first));
}
public void Mapping_Equals_RequirementsDoNotMatch_ReturnsFalse()
{
const string value = "Hello World";
IConfigurationRequirement requirement1 = ConfigurationRequirement.String("Name1", "Description");
IConfigurationRequirement requirement2 = ConfigurationRequirement.String("Name2", "Description");
Mapping first = new Mapping(requirement1, value);
Mapping second = new Mapping(requirement2, value);
Assert.IsFalse(first.Equals(second));
Assert.IsFalse(second.Equals(first));
}
public void ConfigurationRequirement_SimpleValidator_AdditionalValidation_ReturnsNull()
{
IConfigurationRequirement requirement = TestUtil.CreateConfigurationRequirement();
Assert.IsNull(
ConfigurationRequirement
.SimpleValidator(
requirement.OfType,
TestUtil.GetDefaultValidObjectForRequirement(requirement),
requirement,
new MockConfiguration(),
(x, y, z) => null));
}
public void Configuration_Ctor_RequiredRequirementIsNotPresent_ThrowsAggregate()
{
IConfigurationRequirement required =
TestUtil.CreateConfigurationRequirement(isOptional: false);
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(required);
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(configurable, new Dictionary <IConfigurationRequirement, object>()));
Assert.AreEqual(1, exception.InnerExceptions.Count);
StringAssert.Contains(exception.InnerExceptions.Single().Message, "Missing required requirement");
}
public void ConfigurationRequirement_SimpleValidator_Collection_ValidObject()
{
IConfigurationRequirement requirement =
TestUtil.CreateConfigurationRequirement(collectionInfo: new CollectionInfo(1));
object value = TestUtil.GetDefaultValidObjectForRequirement(requirement);
Assert.IsNull(
ConfigurationRequirement
.SimpleValidator(
requirement.OfType,
value,
requirement,
new MockConfiguration()));
}
public void ConfigurationRequirement_SimpleValidator_NullObject()
{
IConfigurationRequirement requirement = TestUtil.CreateConfigurationRequirement();
Assert.AreEqual(
typeof(ArgumentNullException),
ConfigurationRequirement
.SimpleValidator(
requirement.OfType,
null,
requirement,
new MockConfiguration())
?.GetType());
}
public void Configuration_TryGetOrDefault_ValueNotPresent_UsesValueFactory()
{
ConfigurationRequirementType type = ConfigurationRequirementType.Uri;
Configuration configuration = ConfigurationTests.CreateConfiguration(
TestUtil.GetDefaultValidObjectForRequirement,
out IConfigurationRequirement present);
IConfigurationRequirement notPresent = TestUtil.CreateConfigurationRequirement(type: type);
Uri expected = (Uri)TestUtil.GetDefaultValidObjectForRequirement(notPresent);
Assert.IsFalse(configuration.TryGetOrDefault(notPresent, () => expected, out Uri actual));
Assert.AreEqual(expected, actual);
}
public void ConfigurationRequirement_SimpleValidator_Collection_CollectionIsEmpty()
{
object[] value = new object[0];
IConfigurationRequirement requirement = TestUtil.CreateConfigurationRequirement(
collectionInfo: new CollectionInfo(0));
Exception result = ConfigurationRequirement.SimpleValidator(
requirement.OfType,
value,
requirement,
new MockConfiguration());
Assert.IsNull(result);
}
public void ConfigurationRequirement_SimpleValidator_Collection_CollectionIsRightSizeButContainsWrongType()
{
object[] value = new object[] { 8675309L, "Not assignable to expected type" };
ConfigurationRequirementType type = ConfigurationRequirementType.Int64;
IConfigurationRequirement requirement = TestUtil.CreateConfigurationRequirement(
type: type,
collectionInfo: new CollectionInfo(1, 3));
Exception result = ConfigurationRequirement.SimpleValidator(
type,
value,
requirement,
new MockConfiguration());
Assert.AreEqual(typeof(ArgumentException), result?.GetType());
}
public void Configuration_Indexer_Get_Succeeds()
{
IConfigurationRequirement requirement = TestUtil.CreateConfigurationRequirement();
object expected = TestUtil.GetDefaultValidObjectForRequirement(requirement);
Dictionary <IConfigurationRequirement, object> bindings =
new Dictionary <IConfigurationRequirement, object>()
{
[requirement] = expected
};
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(requirement);
Configuration configuration = new Configuration(configurable, bindings);
Assert.AreEqual(expected, configuration[requirement]);
}
private static Configuration CreateConfiguration(
Func <IConfigurationRequirement, object> valueFactory,
out IConfigurationRequirement requirement,
Func <IConfigurationRequirement> requirementFactory = null)
{
requirement = (requirementFactory ?? (() => TestUtil.CreateConfigurationRequirement())).Invoke();
Dictionary <IConfigurationRequirement, object> bindings =
new Dictionary <IConfigurationRequirement, object>()
{
[requirement] = valueFactory.Invoke(requirement)
};
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(requirement);
return(new Configuration(configurable, bindings));
}
public void ConfigurationRequirement_SimpleValidator_AdditionalValidation_ThrowsException()
{
Exception toReturn = new Exception("CONFIGURATIONREQUIREMENTTESTS_AdditionalValidation");
IConfigurationRequirement requirement = TestUtil.CreateConfigurationRequirement();
Assert.AreEqual(
toReturn.Message,
ConfigurationRequirement
.SimpleValidator(
requirement.OfType,
TestUtil.GetDefaultValidObjectForRequirement(requirement),
requirement,
new MockConfiguration(),
(x, y, z) => throw toReturn)
.Message);
}
public void ConfigurationRequirement_SimpleValidator_Collection_CollectionTooLarge()
{
string[] value = new string[] { "Too big", "Too big", "Too big" };
ConfigurationRequirementType type = ConfigurationRequirementType.String;
IConfigurationRequirement requirement = TestUtil.CreateConfigurationRequirement(
type: type,
collectionInfo: new CollectionInfo(1, 2));
Assert.AreEqual(
typeof(ArgumentException),
ConfigurationRequirement
.SimpleValidator(
type,
value,
requirement,
new MockConfiguration())
?.GetType());
}
public void Configuration_GetOrDefault_ValueNotPresent_UsesValueFactory()
{
const string fallbackValue = "Configuration_GetOrDefault";
IConfigurationRequirement present = TestUtil.CreateConfigurationRequirement();
IConfigurationRequirement notPresent = TestUtil.CreateConfigurationRequirement(isOptional: true);
object expected = TestUtil.GetDefaultValidObjectForRequirement(present);
Dictionary <IConfigurationRequirement, object> bindings =
new Dictionary <IConfigurationRequirement, object>()
{
[present] = expected
};
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(notPresent);
Configuration configuration = new Configuration(configurable, bindings);
Assert.AreEqual(fallbackValue, configuration.GetOrDefault(notPresent, () => fallbackValue));
}
public void ConfigurationRequirement_SimpleValidator_Collection_ObjectIsNotCollection()
{
const string value = "Invalid";
ConfigurationRequirementType type = ConfigurationRequirementType.String;
IConfigurationRequirement requirement =
TestUtil.CreateConfigurationRequirement(
type: type,
collectionInfo: new CollectionInfo(1));
Assert.AreEqual(
typeof(ArgumentException),
ConfigurationRequirement
.SimpleValidator(
type,
value,
requirement,
new MockConfiguration())
?.GetType());
}
/// <summary>
/// Internal.
/// </summary>
/// <param name="requirement">
/// Internal.
/// </param>
/// <param name="defaultValueFactory">
/// Internal.
/// </param>
/// <returns>
/// Internal.
/// </returns>
public object GetOrDefault(IConfigurationRequirement requirement, Func <object> defaultValueFactory)
{
if (requirement == null)
{
throw new ArgumentNullException(nameof(requirement));
}
if (defaultValueFactory == null)
{
throw new ArgumentNullException(nameof(defaultValueFactory));
}
if (!this.backingDictionary.TryGetValue(requirement, out object result))
{
result = defaultValueFactory.Invoke();
}
return(result);
}
public void Configuration_Ctor_RequirementFailsValidation_ThrowsAggregate()
{
const string exceptionMessage = "BOUNDCONFIGURATIONTESTS_RequirementFailsValidation";
IConfigurationRequirement required = TestUtil.CreateConfigurationRequirement(
validator: (x, y, z) => throw new NotImplementedException(exceptionMessage));
IRequirementSource configurable = ConfigurationTests.CreateRequirementSource(required);
AggregateException exception = Assert.ThrowsException <AggregateException>(() =>
new Configuration(
configurable,
new Dictionary <IConfigurationRequirement, object>()
{
[required] = "dontCare"
}));
Assert.AreEqual(1, exception.InnerExceptions.Count);
Assert.AreEqual(exceptionMessage, exception.InnerExceptions.Single().Message);
}
public static void Compare(
string expectedName,
string expectedDescription,
ConfigurationRequirementType expectedType,
Func <IConfigurationRequirement> requirementFactory,
object badInput,
object goodInput)
{
IConfigurationRequirement requirement = requirementFactory.Invoke();
Assert.AreEqual(expectedName, requirement.Name);
Assert.AreEqual(expectedDescription, requirement.Description);
Assert.AreEqual(expectedType, requirement.OfType);
Assert.IsNull(requirement.CollectionInfo);
Assert.IsFalse(requirement.DependsOn.Any());
Assert.IsFalse(requirement.ExclusiveWith.Any());
Assert.AreEqual(typeof(ArgumentNullException), requirement.Validate(null).GetType());
Assert.AreEqual(typeof(ArgumentException), requirement.Validate(badInput).GetType());
Assert.IsNull(requirement.Validate(goodInput));
}
public void Configuration_Ctor_DependsOnChains_Succeeds()
{
IConfigurationRequirement parent = TestUtil.CreateConfigurationRequirement(baseName: "Parent");
IConfigurationRequirement child = TestUtil.CreateConfigurationRequirement(
baseName: "Child",
dependsOn: new IConfigurationRequirement[] { parent });
Dictionary <IConfigurationRequirement, object> supplied =
new Dictionary <IConfigurationRequirement, object>()
{
[parent] = TestUtil.GetDefaultValidObjectForRequirement(parent),
[child] = TestUtil.GetDefaultValidObjectForRequirement(child)
};
MockRequirementSource configurable = new MockRequirementSource(new IConfigurationRequirement[] { parent, child });
Configuration configuration = new Configuration(configurable, supplied);
Assert.IsNotNull(configuration);
CollectionAssert.AreEquivalent(
supplied.Select(x => new Mapping(x.Key, x.Value)).ToArray(),
configuration.ToArray());
}
