public void Pn2Fsm_CheckOnly_SameAfterApplyAllChanges(ChangePropagationMode changePropagation)
{
var fsm = this.fsm;
var pn = this.pn;
FillStateMachine();
FillPetriNet();
fsm2pn.Initialize();
var context = fsm2pn.Synchronize(fsm2pn.SynchronizationRule <FSM2PN.AutomataToNet>(), ref fsm, ref pn, SynchronizationDirection.CheckOnly, changePropagation);
var s1 = AssertOriginalFsm(fsm, context);
AssertOriginalPetriNet(pn, context, null);
foreach (var inconsistency in context.Inconsistencies.ToArray())
{
Assert.IsTrue(inconsistency.CanResolveLeft);
inconsistency.ResolveLeft();
}
AssertPetriNetLikeFsm(fsm, context);
if (changePropagation == ChangePropagationMode.TwoWay)
{
Assert.AreEqual(0, context.Inconsistencies.Count);
}
}
public SynchronizationContext(Synchronization synchronization, SynchronizationDirection direction, ChangePropagationMode changePropagation)
: base(synchronization)
{
Direction = direction;
ChangePropagation = changePropagation;
Inconsistencies = new ObservableSet <IInconsistency>();
}
public static Model Transform(Model pcmModel, ChangePropagationMode changePropagation)
{
var result = new Model();
var inputContainer = new PcmToMM06.InputModelContainer(pcmModel);
var outputContainer = new PcmToMM06.OutputModelContainer(result);
var transformation = new PcmToMM06.PCMto06(inputContainer, outputContainer);
transformation.Synchronize(transformation.SynchronizationRule <PcmToMM06.PCMto06.Model2ModelMainRule>(), ref inputContainer, ref outputContainer, NMF.Synchronizations.SynchronizationDirection.LeftToRight, changePropagation);
return(result);
}
private void TestFsm2Pn(SynchronizationDirection direction, ChangePropagationMode changePropagartion, bool initializeFsm, bool initializePn)
{
Assert.IsTrue(initializeFsm | initializePn);
var fsm = this.fsm;
var pn = this.pn;
if (initializeFsm)
{
FillStateMachine();
}
if (initializePn)
{
FillPetriNet();
}
fsm2pn.Initialize();
var context = fsm2pn.Synchronize(fsm2pn.SynchronizationRule <FSM2PN.AutomataToNet>(), ref fsm, ref pn, direction, changePropagartion);
var isLeftToRight = direction == SynchronizationDirection.LeftToRight || direction == SynchronizationDirection.LeftToRightForced || direction == SynchronizationDirection.LeftWins;
var isForced = direction == SynchronizationDirection.LeftToRightForced || direction == SynchronizationDirection.RightToLeftForced;
var isJoined = direction == SynchronizationDirection.LeftWins || direction == SynchronizationDirection.RightWins;
Fsm.State s1;
Pn.Place p1;
if (initializeFsm && initializePn)
{
if (isForced)
{
if (isLeftToRight)
{
s1 = AssertOriginalFsm(fsm, context);
}
else
{
s1 = AssertPetriNetLikeFsm(fsm, context);
}
}
else if (isJoined || !isLeftToRight)
{
s1 = AssertJoinedFsm(fsm, context);
}
else
{
s1 = AssertOriginalFsm(fsm, context);
}
}
else if (!initializeFsm)
{
if (!isLeftToRight || isJoined)
{
s1 = AssertPetriNetLikeFsm(fsm, context);
}
else
{
s1 = AssertEmptyFsm(fsm);
}
}
else if (!initializePn)
{
if (isForced && !isLeftToRight)
{
s1 = AssertEmptyFsm(fsm);
}
else
{
s1 = AssertOriginalFsm(fsm, context);
}
}
else
{
s1 = null;
Assert.Fail();
}
if (initializeFsm && initializePn)
{
if (isForced)
{
if (!isLeftToRight)
{
p1 = AssertOriginalPetriNet(pn, context, s1);
}
else
{
p1 = AssertFsmLikePetriNet(pn, context, s1);
}
}
else if (isJoined || isLeftToRight)
{
p1 = AssertJoinedPetriNet(pn, context, s1);
}
else
{
p1 = AssertOriginalPetriNet(pn, context, s1);
}
}
else if (!initializePn)
{
if (isLeftToRight || isJoined)
{
p1 = AssertFsmLikePetriNet(pn, context, s1);
}
else
{
p1 = AssertEmptyPetriNet(pn);
}
}
else if (!initializeFsm)
{
if (isForced && isLeftToRight)
{
p1 = AssertEmptyPetriNet(pn);
}
else
{
p1 = AssertOriginalPetriNet(pn, context, s1);
}
}
else
{
p1 = null;
Assert.Fail();
}
if (changePropagartion == ChangePropagationMode.TwoWay ||
(changePropagartion == ChangePropagationMode.OneWay && isLeftToRight))
{
AssertOneWayUpdatesFsmToPetriNet(s1, p1);
}
if (changePropagartion == ChangePropagationMode.TwoWay ||
(changePropagartion == ChangePropagationMode.OneWay && !isLeftToRight))
{
AssertOneWayUpdatesPetriNetToFsm(p1, s1);
}
}
public ISynchronizationContext Synchronize <TLeft, TRight>(SynchronizationRule <TLeft, TRight> startRule, ref TLeft left, ref TRight right, SynchronizationDirection direction, ChangePropagationMode changePropagation)
where TLeft : class
where TRight : class
{
if (startRule == null)
{
throw new ArgumentNullException("startRule");
}
Initialize();
var context = new SynchronizationContext(this, direction, changePropagation);
switch (direction)
{
case SynchronizationDirection.LeftToRight:
case SynchronizationDirection.LeftToRightForced:
case SynchronizationDirection.LeftWins:
var c1 = TransformationRunner.Transform(new object[] { left }, right != null ? new Axiom(right) : null, startRule.LeftToRight, context);
right = c1.Output as TRight;
break;
case SynchronizationDirection.RightToLeft:
case SynchronizationDirection.RightToLeftForced:
case SynchronizationDirection.RightWins:
var c2 = TransformationRunner.Transform(new object[] { right }, left != null ? new Axiom(left) : null, startRule.RightToLeft, context);
left = c2.Output as TLeft;
break;
case SynchronizationDirection.CheckOnly:
if (left == null)
{
throw new ArgumentException("Passed model must not be null when running in check-only mode", nameof(left));
}
if (right == null)
{
throw new ArgumentException("Passed model must not be null when running in check-only mode", nameof(right));
}
TransformationRunner.Transform(new object[] { left }, new Axiom(right), startRule.LeftToRight, context);
break;
default:
throw new ArgumentOutOfRangeException("direction");
}
return(context);
}
public ISynchronizationContext Synchronize <TLeft, TRight>(ref TLeft left, ref TRight right, SynchronizationDirection direction, ChangePropagationMode changePropagation)
where TLeft : class
where TRight : class
{
return(Synchronize <TLeft, TRight>(GetSynchronizationRuleForSignature(typeof(TLeft), typeof(TRight)) as SynchronizationRule <TLeft, TRight>, ref left, ref right, direction, changePropagation));
}
public ISynchronizationContext SynchronizeMany <TLeft, TRight>(SynchronizationRule <TLeft, TRight> startRule, ICollection <TLeft> lefts, ICollection <TRight> rights, SynchronizationDirection direction, ChangePropagationMode changePropagation)
where TLeft : class
where TRight : class
{
if (startRule == null)
{
throw new ArgumentNullException("startRule");
}
var context = new SynchronizationContext(this, direction, changePropagation);
switch (direction)
{
case SynchronizationDirection.LeftToRight:
var c1 = TransformationRunner.TransformMany(lefts.Select(l => new object[] { l }), rights, startRule.LeftToRight, context);
rights.Clear();
rights.AddRange(c1.Select(c => c.Output as TRight));
break;
case SynchronizationDirection.RightToLeft:
var c2 = TransformationRunner.TransformMany(rights.Select(r => new object[] { r }), lefts, startRule.RightToLeft, context);
lefts.Clear();
lefts.AddRange(c2.Select(c => c.Output as TLeft));
break;
default:
throw new ArgumentOutOfRangeException("direction");
}
return(context);
}
public SynchronizationContext(Synchronization synchronization, SynchronizationDirection direction, ChangePropagationMode changePropagation)
: base(synchronization)
{
this.direction = direction;
this.changePropagation = changePropagation;
}
public SynchronizationContext(Synchronization synchronization, SynchronizationDirection direction, ChangePropagationMode changePropagation)
: base(synchronization)
{
this.direction = direction;
this.changePropagation = changePropagation;
}
public ISynchronizationContext Synchronize <TLeft, TRight>(SynchronizationRule <TLeft, TRight> startRule, ref TLeft left, ref TRight right, SynchronizationDirection direction, ChangePropagationMode changePropagation)
where TLeft : class
where TRight : class
{
if (startRule == null)
{
throw new ArgumentNullException("startRule");
}
Initialize();
var context = new SynchronizationContext(this, direction, changePropagation);
switch (direction)
{
case SynchronizationDirection.LeftToRight:
case SynchronizationDirection.LeftToRightForced:
case SynchronizationDirection.LeftWins:
var c1 = TransformationRunner.Transform(new object[] { left }, new object[] { right }, startRule.LeftToRight, context);
right = c1.Output as TRight;
break;
case SynchronizationDirection.RightToLeft:
case SynchronizationDirection.RightToLeftForced:
case SynchronizationDirection.RightWins:
var c2 = TransformationRunner.Transform(new object[] { right }, new object[] { left }, startRule.RightToLeft, context);
left = c2.Output as TLeft;
break;
default:
throw new ArgumentOutOfRangeException("direction");
}
return(context);
}
private void TestFsm2Pn(SynchronizationDirection direction, ChangePropagationMode changePropagartion, bool initializeFsm, bool initializePn)
{
Assert.IsTrue(initializeFsm | initializePn);
var fsm = this.fsm;
var pn = this.pn;
if (initializeFsm) FillStateMachine();
if (initializePn) FillPetriNet();
fsm2pn.Initialize();
var context = fsm2pn.Synchronize(fsm2pn.SynchronizationRule<FSM2PN.AutomataToNet>(), ref fsm, ref pn, direction, changePropagartion);
var isLeftToRight = direction == SynchronizationDirection.LeftToRight || direction == SynchronizationDirection.LeftToRightForced || direction == SynchronizationDirection.LeftWins;
var isForced = direction == SynchronizationDirection.LeftToRightForced || direction == SynchronizationDirection.RightToLeftForced;
var isJoined = direction == SynchronizationDirection.LeftWins || direction == SynchronizationDirection.RightWins;
Fsm.State s1;
Pn.Place p1;
if (initializeFsm && initializePn)
{
if (isForced)
{
if (isLeftToRight)
{
s1 = AssertOriginalFsm(fsm, context);
}
else
{
s1 = AssertPetriNetLikeFsm(fsm, context);
}
}
else if (isJoined || !isLeftToRight)
{
s1 = AssertJoinedFsm(fsm, context);
}
else
{
s1 = AssertOriginalFsm(fsm, context);
}
}
else if (!initializeFsm)
{
if (!isLeftToRight || isJoined)
{
s1 = AssertPetriNetLikeFsm(fsm, context);
}
else
{
s1 = AssertEmptyFsm(fsm);
}
}
else if (!initializePn)
{
if (isForced && !isLeftToRight)
{
s1 = AssertEmptyFsm(fsm);
}
else
{
s1 = AssertOriginalFsm(fsm, context);
}
}
else
{
s1 = null;
Assert.Fail();
}
if (initializeFsm && initializePn)
{
if (isForced)
{
if (!isLeftToRight)
{
p1 = AssertOriginalPetriNet(pn, context, s1);
}
else
{
p1 = AssertFsmLikePetriNet(pn, context, s1);
}
}
else if (isJoined || isLeftToRight)
{
p1 = AssertJoinedPetriNet(pn, context, s1);
}
else
{
p1 = AssertOriginalPetriNet(pn, context, s1);
}
}
else if (!initializePn)
{
if (isLeftToRight || isJoined)
{
p1 = AssertFsmLikePetriNet(pn, context, s1);
}
else
{
p1 = AssertEmptyPetriNet(pn);
}
}
else if (!initializeFsm)
{
if (isForced && isLeftToRight)
{
p1 = AssertEmptyPetriNet(pn);
}
else
{
p1 = AssertOriginalPetriNet(pn, context, s1);
}
}
else
{
p1 = null;
Assert.Fail();
}
if (changePropagartion == ChangePropagationMode.TwoWay ||
(changePropagartion == ChangePropagationMode.OneWay && isLeftToRight))
{
AssertOneWayUpdatesFsmToPetriNet(s1, p1);
}
if (changePropagartion == ChangePropagationMode.TwoWay ||
(changePropagartion == ChangePropagationMode.OneWay && !isLeftToRight))
{
AssertOneWayUpdatesPetriNetToFsm(p1, s1);
}
}
