コード例 #1
0
        public void AddActionWithExistingAction()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            ScheduleElementId id = null;
            var scheduleBuilder  = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddExecutingAction(It.IsAny <ScheduleElementId>()))
                .Callback <ScheduleElementId>(s => id = s)
                .Returns <ScheduleElementId>(s => new ExecutingActionVertex(0, s));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var firstRegistration  = new ScheduleActionRegistrationId(typeof(string), 0, "a");
            var secondRegistration = new ScheduleActionRegistrationId(typeof(string), 0, "a");
            var firstVertex        = builder.AddExecutingAction(firstRegistration);

            var first = id;

            id = null;
            var secondVertex = builder.AddExecutingAction(secondRegistration);

            Assert.IsNotNull(firstVertex);
            Assert.IsNotNull(secondVertex);
            Assert.AreEqual(first, id);
        }
コード例 #2
0
        public void AddActionWithExistingAction()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            ScheduleElementId id = null;
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddExecutingAction(It.IsAny<ScheduleElementId>()))
                    .Callback<ScheduleElementId>(s => id = s)
                    .Returns<ScheduleElementId>(s => new ExecutingActionVertex(0, s));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var firstRegistration = new ScheduleActionRegistrationId(typeof(string), 0, "a");
            var secondRegistration = new ScheduleActionRegistrationId(typeof(string), 0, "a");
            var firstVertex = builder.AddExecutingAction(firstRegistration);

            var first = id;
            id = null;
            var secondVertex = builder.AddExecutingAction(secondRegistration);
            Assert.IsNotNull(firstVertex);
            Assert.IsNotNull(secondVertex);
            Assert.AreEqual(first, id);
        }
コード例 #3
0
        public void LinkToWithExistingCondition()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            ScheduleElementId id = null;
            var scheduleBuilder  = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(
                    s => s.LinkTo(
                        It.IsAny <IScheduleVertex>(),
                        It.IsAny <IScheduleVertex>(),
                        It.IsAny <ScheduleElementId>()))
                .Callback <IScheduleVertex, IScheduleVertex, ScheduleElementId>(
                    (s, e, c) => id = c);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var condition = new ScheduleConditionRegistrationId(typeof(string), 0, "a");

            builder.LinkTo(new MarkHistoryVertex(0), new InsertVertex(1), condition);

            Assert.IsNotNull(id);

            var firstId = id;

            builder.LinkTo(new MarkHistoryVertex(2), new InsertVertex(3), condition);

            Assert.IsNotNull(id);
            Assert.AreSame(firstId, id);
        }
コード例 #4
0
        public void Register()
        {
            var graph = new BidirectionalGraph <IScheduleVertex, ScheduleEdge>();

            var start = new StartVertex(1);

            graph.AddVertex(start);

            var end = new EndVertex(2);

            graph.AddVertex(end);
            graph.AddEdge(new ScheduleEdge(start, end));

            var schedule        = new Schedule(graph, start, end);
            var scheduleBuilder = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.Build())
                .Returns(schedule);
                scheduleBuilder.Setup(s => s.AddExecutingAction(It.IsAny <ScheduleElementId>()))
                .Returns <ScheduleElementId>(s => new ExecutingActionVertex(0, s));
            }

            var actionId    = new ScheduleActionRegistrationId(typeof(string), 0, "a");
            var conditionId = new ScheduleConditionRegistrationId(typeof(string), 0, "a");
            var owner       = new Mock <IOwnScheduleDefinitions>();
            {
                owner.Setup(
                    o => o.StoreSchedule(
                        It.IsAny <ISchedule>(),
                        It.IsAny <Dictionary <ScheduleActionRegistrationId, ScheduleElementId> >(),
                        It.IsAny <Dictionary <ScheduleConditionRegistrationId, ScheduleElementId> >()))
                .Callback <ISchedule, Dictionary <ScheduleActionRegistrationId, ScheduleElementId>, Dictionary <ScheduleConditionRegistrationId, ScheduleElementId> >(
                    (s, a, c) =>
                {
                    Assert.That(a.Keys, Is.EquivalentTo(new List <ScheduleActionRegistrationId> {
                        actionId
                    }));
                    Assert.That(c.Keys, Is.EquivalentTo(new List <ScheduleConditionRegistrationId> {
                        conditionId
                    }));
                });
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex  = builder.AddExecutingAction(actionId);

            builder.LinkToEnd(vertex, conditionId);
            builder.Register();
        }
コード例 #5
0
        public void AddInsertPointWithCount()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            var scheduleBuilder = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddInsertPoint(It.IsAny <int>()))
                .Returns <int>(i => new InsertVertex(0, i));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex  = builder.AddInsertPoint(10);

            Assert.AreEqual(10, vertex.RemainingInserts);
        }
コード例 #6
0
        public void AddInsertPoint()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            var insertVertex    = new InsertVertex(0);
            var scheduleBuilder = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddInsertPoint())
                .Returns(insertVertex);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex  = builder.AddInsertPoint();

            Assert.AreSame(insertVertex, vertex);
        }
コード例 #7
0
        public void AddHistoryMarkingPoint()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            MarkHistoryVertex startVertex = new MarkHistoryVertex(0);
            var scheduleBuilder           = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddHistoryMarkingPoint())
                .Returns(startVertex);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex  = builder.AddHistoryMarkingPoint();

            Assert.AreSame(startVertex, vertex);
        }
コード例 #8
0
        public void LinkToEndWithoutCondition()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            var scheduleBuilder = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(
                    s => s.LinkToEnd(
                        It.IsAny <IScheduleVertex>(),
                        It.IsAny <ScheduleElementId>()))
                .Callback <IScheduleVertex, ScheduleElementId>(
                    (s, c) => Assert.IsNull(c));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            builder.LinkToEnd(new MarkHistoryVertex(0));
        }
コード例 #9
0
        public void AddAction()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            ScheduleElementId id = null;
            var scheduleBuilder  = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddExecutingAction(It.IsAny <ScheduleElementId>()))
                .Callback <ScheduleElementId>(s => id = s)
                .Returns <ScheduleElementId>(s => new ExecutingActionVertex(0, s));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var registrationId = new ScheduleActionRegistrationId(typeof(string), 0, "a");
            var vertex         = builder.AddExecutingAction(registrationId);

            Assert.IsNotNull(vertex);
            Assert.IsNotNull(id);
        }
コード例 #10
0
        public void AddAction()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            ScheduleElementId id = null;
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddExecutingAction(It.IsAny<ScheduleElementId>()))
                    .Callback<ScheduleElementId>(s => id = s)
                    .Returns<ScheduleElementId>(s => new ExecutingActionVertex(0, s));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var registrationId = new ScheduleActionRegistrationId(typeof(string), 0, "a");
            var vertex = builder.AddExecutingAction(registrationId);

            Assert.IsNotNull(vertex);
            Assert.IsNotNull(id);
        }
コード例 #11
0
        public void AddSubSchedule()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            var        schedule        = new ScheduleId();
            ScheduleId storedId        = null;
            var        scheduleVertex  = new SubScheduleVertex(0, schedule);
            var        scheduleBuilder = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddSubSchedule(It.IsAny <ScheduleId>()))
                .Callback <ScheduleId>(s => storedId = s)
                .Returns(scheduleVertex);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex  = builder.AddSubSchedule(schedule);

            Assert.AreSame(scheduleVertex, vertex);
            Assert.AreSame(schedule, storedId);
        }
コード例 #12
0
        public void AddSynchronizationStartPoint()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            IEnumerable <IScheduleVariable> variables = null;
            var scheduleBuilder = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddSynchronizationStart(It.IsAny <IEnumerable <IScheduleVariable> >()))
                .Callback <IEnumerable <IScheduleVariable> >(s => variables = s)
                .Returns <IEnumerable <IScheduleVariable> >(s => new SynchronizationStartVertex(0, s));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var synchronizationVariables = new List <IScheduleVariable> {
                new Mock <IScheduleVariable>().Object
            };
            var vertex = builder.AddSynchronizationStart(synchronizationVariables);

            Assert.IsNotNull(vertex);
            Assert.That(variables, Is.EquivalentTo(synchronizationVariables));
        }
コード例 #13
0
        public void LinkToEndWithCondition()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            ScheduleElementId id = null;
            var scheduleBuilder  = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(
                    s => s.LinkToEnd(
                        It.IsAny <IScheduleVertex>(),
                        It.IsAny <ScheduleElementId>()))
                .Callback <IScheduleVertex, ScheduleElementId>(
                    (s, c) => id = c);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var condition = new ScheduleConditionRegistrationId(typeof(string), 0, "a");

            builder.LinkToEnd(new InsertVertex(1), condition);

            Assert.IsNotNull(id);
        }
コード例 #14
0
        public void AddSynchronizationEndPoint()
        {
            var owner = new Mock <IOwnScheduleDefinitions>();

            SynchronizationStartVertex startVertex = null;
            var scheduleBuilder = new Mock <IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddSynchronizationEnd(It.IsAny <SynchronizationStartVertex>()))
                .Callback <SynchronizationStartVertex>(s => startVertex = s)
                .Returns <SynchronizationStartVertex>(s => new SynchronizationEndVertex(0));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var inputVertex = new SynchronizationStartVertex(
                0,
                new List <IScheduleVariable> {
                new Mock <IScheduleVariable>().Object
            });
            var vertex = builder.AddSynchronizationEnd(inputVertex);

            Assert.IsNotNull(vertex);
            Assert.AreSame(inputVertex, startVertex);
        }
コード例 #15
0
        public void AddInsertPoint()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            var insertVertex = new InsertVertex(0);
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddInsertPoint())
                    .Returns(insertVertex);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex = builder.AddInsertPoint();

            Assert.AreSame(insertVertex, vertex);
        }
コード例 #16
0
        public void AddSynchronizationEndPoint()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            SynchronizationStartVertex startVertex = null;
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddSynchronizationEnd(It.IsAny<SynchronizationStartVertex>()))
                    .Callback<SynchronizationStartVertex>(s => startVertex = s)
                    .Returns<SynchronizationStartVertex>(s => new SynchronizationEndVertex(0));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var inputVertex = new SynchronizationStartVertex(
                0,
                new List<IScheduleVariable> { new Mock<IScheduleVariable>().Object });
            var vertex = builder.AddSynchronizationEnd(inputVertex);

            Assert.IsNotNull(vertex);
            Assert.AreSame(inputVertex, startVertex);
        }
コード例 #17
0
        public void AddSubSchedule()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            var schedule = new ScheduleId();
            ScheduleId storedId = null;
            var scheduleVertex = new SubScheduleVertex(0, schedule);
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddSubSchedule(It.IsAny<ScheduleId>()))
                    .Callback<ScheduleId>(s => storedId = s)
                    .Returns(scheduleVertex);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex = builder.AddSubSchedule(schedule);

            Assert.AreSame(scheduleVertex, vertex);
            Assert.AreSame(schedule, storedId);
        }
コード例 #18
0
        public void LinkToEndWithCondition()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            ScheduleElementId id = null;
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(
                        s => s.LinkToEnd(
                            It.IsAny<IScheduleVertex>(),
                            It.IsAny<ScheduleElementId>()))
                    .Callback<IScheduleVertex, ScheduleElementId>(
                        (s, c) => id = c);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var condition = new ScheduleConditionRegistrationId(typeof(string), 0, "a");
            builder.LinkToEnd(new InsertVertex(1), condition);

            Assert.IsNotNull(id);
        }
コード例 #19
0
        public void AddSynchronizationStartPoint()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            IEnumerable<IScheduleVariable> variables = null;
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddSynchronizationStart(It.IsAny<IEnumerable<IScheduleVariable>>()))
                    .Callback<IEnumerable<IScheduleVariable>>(s => variables = s)
                    .Returns<IEnumerable<IScheduleVariable>>(s => new SynchronizationStartVertex(0, s));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var synchronizationVariables = new List<IScheduleVariable> { new Mock<IScheduleVariable>().Object };
            var vertex = builder.AddSynchronizationStart(synchronizationVariables);

            Assert.IsNotNull(vertex);
            Assert.That(variables, Is.EquivalentTo(synchronizationVariables));
        }
コード例 #20
0
        public void LinkToWithExistingCondition()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            ScheduleElementId id = null;
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(
                        s => s.LinkTo(
                            It.IsAny<IScheduleVertex>(),
                            It.IsAny<IScheduleVertex>(),
                            It.IsAny<ScheduleElementId>()))
                    .Callback<IScheduleVertex, IScheduleVertex, ScheduleElementId>(
                        (s, e, c) => id = c);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var condition = new ScheduleConditionRegistrationId(typeof(string), 0, "a");
            builder.LinkTo(new MarkHistoryVertex(0), new InsertVertex(1), condition);

            Assert.IsNotNull(id);

            var firstId = id;
            builder.LinkTo(new MarkHistoryVertex(2), new InsertVertex(3), condition);

            Assert.IsNotNull(id);
            Assert.AreSame(firstId, id);
        }
コード例 #21
0
        public void LinkToWithoutCondition()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(
                        s => s.LinkTo(
                            It.IsAny<IScheduleVertex>(),
                            It.IsAny<IScheduleVertex>(),
                            It.IsAny<ScheduleElementId>()))
                    .Callback<IScheduleVertex, IScheduleVertex, ScheduleElementId>(
                        (s, e, c) => Assert.IsNull(c));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);

            var start = new MarkHistoryVertex(0);
            var end = new InsertVertex(1);
            builder.LinkTo(start, end);
        }
コード例 #22
0
        public void Register()
        {
            var graph = new BidirectionalGraph<IScheduleVertex, ScheduleEdge>();

            var start = new StartVertex(1);
            graph.AddVertex(start);

            var end = new EndVertex(2);
            graph.AddVertex(end);
            graph.AddEdge(new ScheduleEdge(start, end));

            var schedule = new Schedule(graph, start, end);
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.Build())
                    .Returns(schedule);
                scheduleBuilder.Setup(s => s.AddExecutingAction(It.IsAny<ScheduleElementId>()))
                    .Returns<ScheduleElementId>(s => new ExecutingActionVertex(0, s));
            }

            var actionId = new ScheduleActionRegistrationId(typeof(string), 0, "a");
            var conditionId = new ScheduleConditionRegistrationId(typeof(string), 0, "a");
            var owner = new Mock<IOwnScheduleDefinitions>();
            {
                owner.Setup(
                    o => o.StoreSchedule(
                        It.IsAny<ISchedule>(),
                        It.IsAny<Dictionary<ScheduleActionRegistrationId, ScheduleElementId>>(),
                        It.IsAny<Dictionary<ScheduleConditionRegistrationId, ScheduleElementId>>()))
                    .Callback<ISchedule, Dictionary<ScheduleActionRegistrationId, ScheduleElementId>, Dictionary<ScheduleConditionRegistrationId, ScheduleElementId>>(
                        (s, a, c) =>
                        {
                            Assert.That(a.Keys, Is.EquivalentTo(new List<ScheduleActionRegistrationId> { actionId }));
                            Assert.That(c.Keys, Is.EquivalentTo(new List<ScheduleConditionRegistrationId> { conditionId }));
                        });
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex = builder.AddExecutingAction(actionId);
            builder.LinkToEnd(vertex, conditionId);
            builder.Register();
        }
コード例 #23
0
        public void AddHistoryMarkingPoint()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            MarkHistoryVertex startVertex = new MarkHistoryVertex(0);
            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddHistoryMarkingPoint())
                    .Returns(startVertex);
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex = builder.AddHistoryMarkingPoint();

            Assert.AreSame(startVertex, vertex);
        }
コード例 #24
0
        public void AddInsertPointWithCount()
        {
            var owner = new Mock<IOwnScheduleDefinitions>();

            var scheduleBuilder = new Mock<IBuildFixedSchedules>();
            {
                scheduleBuilder.Setup(s => s.AddInsertPoint(It.IsAny<int>()))
                    .Returns<int>(i => new InsertVertex(0, i));
            }

            var builder = new ScheduleDefinitionBuilder(owner.Object, scheduleBuilder.Object);
            var vertex = builder.AddInsertPoint(10);
            Assert.AreEqual(10, vertex.RemainingInserts);
        }