public void Constructor5_ValueAsIdArgument_ShouldSetICompositionErrorIdProperty()
{
var expectations = Expectations.GetEnumValues <CompositionErrorId>();
Assert.All(expectations, e =>
{
var error = new CompositionError(e, "Description", ElementFactory.Create(), new Exception());
Assert.Equal(e, error.Id);
});
}
public void Constructor2_ShouldSetRequiredCreationPolicyToAny()
{
var expectations = Expectations.GetEnumValues <CreationPolicy>();
foreach (var e in expectations)
{
var definition = new ContractBasedImportDefinition("ContractName", (string)null, Enumerable.Empty <KeyValuePair <string, Type> >(), ImportCardinality.ExactlyOne, false, false, e);
Assert.Equal(e, definition.RequiredCreationPolicy);
}
}
public void Constructor2_ValueAsCardinalityArgument_ShouldSetCardinalityProperty()
{
var expectations = Expectations.GetEnumValues <ImportCardinality>();
foreach (var e in expectations)
{
var definition = new ContractBasedImportDefinition("ContractName", (string)null, Enumerable.Empty <KeyValuePair <string, Type> >(), e, false, false, CreationPolicy.Any);
Assert.Equal(e, definition.Cardinality);
}
}
public void Constructor_ShouldSetCreationPolicyToGivenValue()
{
var expectations = Expectations.GetEnumValues <CreationPolicy>();
foreach (var e in expectations)
{
var attribute = new PartCreationPolicyAttribute(e);
Assert.AreEqual(e, attribute.CreationPolicy);
}
}
public void Constructor2_ValueAsCardinalityArgument_ShouldSetCardinalityProperty()
{
var expectations = Expectations.GetEnumValues <ImportCardinality>();
foreach (var e in expectations)
{
var definition = new ImportDefinition(d => true, "", e, false, false);
Assert.Equal(e, definition.Cardinality);
}
}
public void Constructor9_ValueAsIdArgument_ShouldSetICompositionErrorIdProperty()
{
var expectations = Expectations.GetEnumValues <CompositionErrorId>();
foreach (var e in expectations)
{
var exception = (ICompositionError) new ComposablePartException(e, "Message", ElementFactory.Create(), new Exception());
Assert.AreEqual(e, exception.Id);
}
}
public void Constructor5_ValueAsIdArgument_ShouldSetICompositionErrorIdProperty()
{
var expectations = Expectations.GetEnumValues <CompositionErrorId>();
foreach (var e in expectations)
{
var error = new CompositionError(e, "Description", ElementFactory.Create(), new Exception());
Assert.AreEqual(e, ((ICompositionError)error).Id);
}
}
private CompositionResult <T> CreateCompositionResult <T>(int count)
{
var expectations = Expectations.GetEnumValues <CompositionErrorId>();
List <CompositionError> errors = new List <CompositionError>();
foreach (var e in expectations.Take(count))
{
errors.Add(ErrorFactory.Create(e));
}
return(CreateCompositionResult <T>(errors));
}
public void Id_CanBeSerialized()
{
var expectations = Expectations.GetEnumValues <CompositionErrorId>();
foreach (var e in expectations)
{
var exception = (ICompositionError)CreateComposablePartException(e);
var result = (ICompositionError)SerializationTestServices.RoundTrip(exception);
Assert.AreEqual(exception.Id, result.Id);
}
}
public void ICompositionErrorId_CanBeSerialized()
{
var expectations = Expectations.GetEnumValues <CompositionErrorId>();
foreach (var e in expectations)
{
var error = CreateCompositionError(e);
var result = SerializationTestServices.RoundTrip(error);
Assert.AreEqual(error.Id, result.Id);
}
}
public void Value_TwoSameValuesAsErrorsArgument_ShouldThrowComposition()
{
var errorIds = Expectations.GetEnumValues <CompositionErrorId>();
foreach (var errorId in errorIds)
{
var result = CreateCompositionResult <string>(errorId, errorId);
CompositionAssert.ThrowsErrors((ErrorId)errorId, (ErrorId)errorId, () =>
{
var value = result.Value;
});
}
}
public void ThrowOnErrors_SingleValueAsErrorsArgument_ShouldThrowComposition()
{
var errorIds = Expectations.GetEnumValues <CompositionErrorId>();
foreach (var errorId in errorIds)
{
var result = CreateCompositionResult(errorId);
CompositionAssert.ThrowsError((ErrorId)errorId, () =>
{
result.ThrowOnErrors();
});
}
}
public void MergeError_ValueAsErrorArgumentWhenMergedWithResultWithErrors_ShouldReturnResultWithCombinedErrors()
{
var result = CreateCompositionResult(2);
var expectations = Expectations.GetEnumValues <CompositionErrorId>();
foreach (var e in expectations)
{
var error = ErrorFactory.Create(e);
var mergedResult = result.MergeError(error);
var mergedErrors = result.Errors.Concat(new CompositionError[] { error });
EqualityExtensions.CheckEquals(mergedErrors, mergedResult.Errors);
Assert.False(mergedResult.Succeeded);
}
}
public void MergeError_ValueAsErrorArgumentWhenMergedWithResultWithEmptyErrors_ShouldReturnResultWithCombinedErrors()
{
var result = CreateCompositionResult(Enumerable.Empty <CompositionError>());
var expectations = Expectations.GetEnumValues <CompositionErrorId>();
foreach (var e in expectations)
{
var error = ErrorFactory.Create(e);
var mergedResult = result.MergeError(error);
var mergedErrors = result.Errors.Concat(new CompositionError[] { error });
EnumerableAssert.AreSequenceSame(mergedErrors, mergedResult.Errors);
Assert.IsFalse(mergedResult.Succeeded);
}
}
public void Value_TwoDifferentValuesAsErrorsArgument_ShouldThrowComposition()
{
var errorIds1 = Expectations.GetEnumValues <CompositionErrorId>();
var errorIds2 = Expectations.GetEnumValues <CompositionErrorId>();
for (int i = 0; i < errorIds1.Count(); i++)
{
var errorId1 = errorIds1.ElementAt(i);
var errorId2 = errorIds1.ElementAt(errorIds2.Count() - 1 - i);
var result = CreateCompositionResult <string>(errorId1, errorId2);
CompositionAssert.ThrowsErrors((ErrorId)errorId1, (ErrorId)errorId2, () =>
{
var value = result.Value;
});
}
}