public void FinalizeOrder()
    {
        var called = string.Empty;

        IEnumerator get()
        {
            yield return(null);
        }

        var routines = new List <Finalizable>();
        var routineA = new Finalizable {
            wrapped = get()
        };
        var routineB = new Finalizable {
            wrapped = get()
        };
        var stacking = new DurationStacking();

        stacking.Add(routineA, routines, a => a.OnFinalize += () => called += "wr");
        stacking.Add(routineB, routines, a => a.OnFinalize += () => called += "wr");
        routineA.OnFinalize += () => called += "a";
        routineB.OnFinalize += () => called += "b";

        var concat = routines[0];

        concat.MoveNext();
        concat.MoveNext();
        concat.MoveNext();

        Assert.AreEqual("abwr", called);
    }
    public void ConcatSecond()
    {
        var called = string.Empty;

        IEnumerator get(string v)
        {
            called += v;
            yield return(null);
        }

        var routines = new List <Finalizable>();
        var routineA = new Finalizable {
            wrapped = get("f")
        };
        var routineB = new Finalizable {
            wrapped = get("s")
        };
        var stacking = new DurationStacking();

        stacking.Add(routineA, routines, _ => { });
        stacking.Add(routineB, routines, _ => { });

        var concat = routines[0];

        concat.MoveNext();
        concat.MoveNext();

        Assert.AreEqual("fs", called);
    }
Ejemplo n.º 3
0
 public void Add(Finalizable effectRoutine, List <Finalizable> routines, Action <Finalizable> onAdd)
 {
     (Action <Finalizable> apply, Finalizable wrapper) = routines.Count switch {
         0 => (routines.Add + onAdd, new Finalizable {
             wrapped = effectRoutine
         }),
         _ => (DurationStacking.Concat(effectRoutine), routines.First()),
     };
     apply(wrapper);
 }
    public void DontAddSecond()
    {
        var routines = new List <Finalizable>();
        var routine  = new Finalizable();
        var stacking = new DurationStacking();

        stacking.Add(routine, routines, _ => { });
        stacking.Add(routine, routines, _ => { });

        Assert.AreEqual(1, routines.Count);
    }
    public void AddNewOnAdd()
    {
        var called   = default(Finalizable);
        var routines = new List <Finalizable>();
        var routine  = new Finalizable();
        var stacking = new DurationStacking();

        stacking.Add(routine, routines, a => called = a);

        Assert.AreSame(routines[0], called);
    }
    public void AddNew()
    {
        var routines = new List <Finalizable>();
        var routine  = new Finalizable();
        var stacking = new DurationStacking();

        stacking.Add(routine, routines, _ => { });

        CollectionAssert.AreEqual(
            new Finalizable[] { routine },
            routines.Select(f => f.wrapped)
            );
    }