public void should_return_children_merged_actions()
{
// --arrange
var buildStep1 = new LastUnitSequenceMatcher(Match.Type <int>(null));
buildStep1.AddBuildAction(BuildStage.Cache, CreateByReflectionBuildAction.Instance);
var singletonAction = new SingletonBuildAction();
var buildStep2 = new AnyUnitSequenceMatcher();
buildStep2.AddBuildAction(BuildStage.Cache, singletonAction);
var target = new WildcardUnitSequenceMatcher(Match.Type <string>(null));
target.AddOrGetUnitSequenceMatcher(buildStep1);
target.AddOrGetUnitSequenceMatcher(buildStep2);
// --act
var actual = target.GetBuildActions(new[] { Unit.OfType <string>(), Unit.OfType <int>() }.GetTail(0), 0);
// --assert
actual.Should().NotBeNull();
// ReSharper disable once PossibleNullReferenceException
actual[BuildStage.Cache]
.Should()
.HaveCount(2)
.And
.Subject.Select(_ => _.Entity)
.Should()
.BeEquivalentTo(CreateByReflectionBuildAction.Instance, singletonAction);
}
public Tuner CreatedByReflection()
{
var childMatcher = new WildcardUnitSequenceMatcher(Match.OpenGenericType(OpenGenericType, Token), UnitSequenceMatchingWeight.WildcardMatchingUnit - 1);
UnitSequenceMatcher
.AddOrGetUnitSequenceMatcher(childMatcher)
.AddBuildAction(BuildStage.Create, CreateByReflectionBuildAction.Instance);
return(new Tuner(childMatcher));
}
/// <summary>
/// Used to make a build plan for <paramref name="unitInfo"/>
/// How it should be treated is specified by subsequence calls using returned object.
/// </summary>
public static TreatingTuner Treat([NotNull] this BuildPlansCollection buildPlans, [NotNull] UnitInfo unitInfo)
{
if (buildPlans == null)
{
throw new ArgumentNullException(nameof(buildPlans));
}
var unitSequenceMatcher = new WildcardUnitSequenceMatcher(new UnitInfoMatcher(unitInfo));
return(new TreatingTuner(buildPlans.AddOrGetUnitSequenceMatcher(unitSequenceMatcher)));
}
/// <summary>
/// Used to make a build plan for a unit only if it is building in a context of building <paramref name="type" /> with token <paramref name="token" />
/// </summary>
public SequenceTuner Building([NotNull] Type type, object token = null)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
var unitSequenceMatcher = new WildcardUnitSequenceMatcher(Match.Type(type, token));
return(new SequenceTuner(UnitSequenceMatcher.AddOrGetUnitSequenceMatcher(unitSequenceMatcher)));
}
/// <summary>
/// Used to make a build plan for Unit of type <typeparamref name="T" />.
/// How <typeparamref name="T" /> should be treated is specified by subsequence calls using returned object.
/// </summary>
public static TreatingTuner <T> Treat <T>([NotNull] this BuildPlansCollection buildPlans, object token = null)
{
if (buildPlans == null)
{
throw new ArgumentNullException(nameof(buildPlans));
}
var unitSequenceMatcher = new WildcardUnitSequenceMatcher(Match.Type <T>(token));
return(new TreatingTuner <T>(buildPlans.AddOrGetUnitSequenceMatcher(unitSequenceMatcher)));
}
/// <summary>
/// Used to make a build plan for a unit only if it is building in a context of building <paramref name="type" />.
/// </summary>
public static SequenceTuner Building([NotNull] this BuildPlansCollection buildPlans, Type type, object token = null)
{
if (buildPlans == null)
{
throw new ArgumentNullException(nameof(buildPlans));
}
var unitSequenceMatcher = new WildcardUnitSequenceMatcher(Match.Type(type, token));
return(new SequenceTuner(buildPlans.AddOrGetUnitSequenceMatcher(unitSequenceMatcher)));
}
private static TreatingTuner Treat(BuildPlansCollection buildPlans, UnitInfo unitInfo)
{
if (buildPlans == null)
{
throw new ArgumentNullException(nameof(buildPlans));
}
var unitMatcher = new MockUnitMatcher(new UnitInfoMatcher(unitInfo));
var unitSequenceMatcher = new WildcardUnitSequenceMatcher(unitMatcher);
return(new TreatingTuner(buildPlans.AddOrGetUnitSequenceMatcher(unitSequenceMatcher)));
}
/// <summary>
/// Used to make a build plan for all inheritors of <typeparamref name="T" />.
/// How <typeparamref name="T" /> should be treated is specified by subsequence calls using returned object.
/// </summary>
public static TreatingTuner <T> TreatInheritorsOf <T>([NotNull] this BuildPlansCollection buildPlans, object token = null)
{
if (buildPlans == null)
{
throw new ArgumentNullException(nameof(buildPlans));
}
var unitSequenceMatcher = new WildcardUnitSequenceMatcher(
new BaseTypeMatcher(new UnitInfo(typeof(T), token)),
UnitSequenceMatchingWeight.WildcardMatchingBaseTypeUnit);
return(new TreatingTuner <T>(buildPlans.AddOrGetUnitSequenceMatcher(unitSequenceMatcher)));
}
/// <summary>
/// Used to make a build plan for whole class of open generic types.
/// How <paramref name="openGenericType" /> should be treated is specified by subsequence calls using returned object.
/// </summary>
public static TreatingOpenGenericTuner TreatOpenGeneric([NotNull] this BuildPlansCollection buildPlans, Type openGenericType, object token = null)
{
if (buildPlans == null)
{
throw new ArgumentNullException(nameof(buildPlans));
}
var unitSequenceMatcher = new WildcardUnitSequenceMatcher(
Match.OpenGenericType(openGenericType, token),
UnitSequenceMatchingWeight.WildcardMatchingOpenGenericUnit);
return(new TreatingOpenGenericTuner(buildPlans.AddOrGetUnitSequenceMatcher(unitSequenceMatcher)));
}
/// <summary>
/// Used to override a build plan for <paramref name="type"/>
/// How it should be treated is specified by subsequence calls using returned object.
/// </summary>
public static TreatingTuner Override([NotNull] this BuildPlansCollection buildPlans, [NotNull] Type type, object token = null)
{
if (buildPlans == null)
{
throw new ArgumentNullException(nameof(buildPlans));
}
var newSequenceMatcher = new WildcardUnitSequenceMatcher(Match.Type(type, token));
var oldSequenceMatcher = buildPlans.Children.Single(_ => _.Equals(newSequenceMatcher));
buildPlans.Children.Remove(oldSequenceMatcher);
return(new TreatingTuner(buildPlans.AddOrGetUnitSequenceMatcher(newSequenceMatcher)));
}
public void should_match_build_sequence_weak()
{
var expected = new SingletonBuildAction();
// --arrange
var target = new WildcardUnitSequenceMatcher(Match.Type <IDisposable>(null))
.AddOrGetUnitSequenceMatcher(new WildcardUnitSequenceMatcher(Match.Type <MemoryStream>(null)))
.AddBuildAction(BuildStage.Cache, expected);
// --act
var actual = target
.GetBuildActions(new[] { Unit.OfType <IDisposable>(), Unit.OfType <string>(), Unit.OfType <MemoryStream>() }.GetTail(0), 0)
.GetTopmostAction(BuildStage.Cache);
// --assert
actual.Should().BeSameAs(expected);
}
/// <summary>
/// Used to make a build plan for <typeparamref name="T" />.
/// How <typeparamref name="T" /> should be treated is specified by subsequence calls using returned object
/// </summary>
public TreatingTuner <T> Treat <T>(object token = null)
{
var unitSequenceMatcher = new WildcardUnitSequenceMatcher(Match.Type <T>(token));
return(new TreatingTuner <T>(UnitSequenceMatcher.AddOrGetUnitSequenceMatcher(unitSequenceMatcher)));
}
/// <summary>
/// Used to make a build plan for Unit of type <paramref name="type"/>.
/// How it should be treated is specified by subsequence calls using returned object.
/// </summary>
public TreatingTuner Treat([NotNull] Type type, object token = null)
{
var unitSequenceMatcher = new WildcardUnitSequenceMatcher(Match.Type(type, token));
return(new TreatingTuner(UnitSequenceMatcher.AddOrGetUnitSequenceMatcher(unitSequenceMatcher)));
}
