public void TestNameIsInitialised()
{
var pn = CreatePetriNet.Called("p1");
Assert.IsTrue(!string.IsNullOrWhiteSpace(pn.Name));
Assert.AreEqual("p1", pn.Name);
}
public void TestFullMontySetup()
{
var pnb = CreatePetriNet
.Called("net")
.WithPlaces("p1", "p2", "p3")
.AndTransitions("t1", "t2", "t3")
.With("t1").FedBy("p1", "p2")
.And().With("t2").FedBy("p3").AsInhibitor()
.And().With("t1").Feeding("p2")
.And().With("t2").Feeding("p1")
.And().WhenFiring("t1")
.Run(x => Console.WriteLine("Fired"))
.Run(x => Console.WriteLine("Fired"))
.Run(x => Console.WriteLine("Fired"))
.And().WhenFiring("t2")
.Run(x => Console.WriteLine("Fired"))
.Run(x => Console.WriteLine("Fired"))
.Run(x => Console.WriteLine("Fired"))
.Complete()
;
var pn = pnb.CreateNet <GraphPetriNet>();
Assert.IsNotNull(pn);
var m = pnb.CreateMarking();
}
public void TestBifurcatingTransition() // a bifurcating transition
{
var m = new Marking(3,
new Dictionary <int, int>
{
{ (int)Places.p1, 0 },
{ (int)Places.p2, 0 },
{ (int)Places.p3, 0 }
});
var p = CreatePetriNet.Parse(StdPetriNets.Bifurcation).CreateNet <GraphPetriNet>();
m.Assert(p.Places, new Dictionary <string, int> {
{ "p1", 0 }, { "p2", 0 }, { "p3", 0 }
});
m.Set(p.Places, "p1", 1);
m.Assert(p.Places, new Dictionary <string, int> {
{ "p1", 1 }, { "p2", 0 }, { "p3", 0 }
});
m = p.Fire(m);
m.Assert(p.Places, new Dictionary <string, int> {
{ "p1", 0 }, { "p2", 1 }, { "p3", 1 }
});
}
public void TestNameCannotBeInitdWithJunk1()
{
var pn = CreatePetriNet.Called("");
Assert.IsTrue(!string.IsNullOrWhiteSpace(pn.Name));
Assert.AreEqual("", pn.Name);
}
public void TestMarkingNotation(string spec, string serialisedMarking)
{
CreatePetriNet pnb = CreatePetriNet.Parse(spec);
var m = pnb.CreateMarking();
Assert.AreEqual(serialisedMarking, m.ToString());
}
public PetriNetConnectionBuilder(CreatePetriNet builder,
string transition)
{
Builder = builder;
TransitionName = transition;
_weight = 1;
}
public PetriNetConnectionBuilder(CreatePetriNet builder,
string transition)
{
Builder = builder;
TransitionName = transition;
_weight = 1;
}
public void TestCompareArcLangWithFluentLang()
{
var pnc = CreatePetriNet.Called("p")
.WithPlaces("p1",
"p2",
"p3")
.AndTransitions("t1")
.With("t1").FedBy("p1")
.And().With("t1").Feeding("p2",
"p3")
.Done();
var pn1 = pnc.CreateNet <GraphPetriNet>();
var spec = @" PetriNet net; Graph p1)-[t1; t1]-({p2,p3}; End ";
CreatePetriNet pnc2 = CreatePetriNet.Parse(spec);
var pn2 = pnc2.CreateNet <GraphPetriNet>();
var m = pnc2.CreateMarking();
m[pnc2.PlaceIndex("p1")] = 1;
var m1 = pn1.Fire(m);
var m2 = pn2.Fire(m);
Assert.AreEqual(0, m1[pnc.PlaceIndex("p1")]);
Assert.AreEqual(1, m1[pnc.PlaceIndex("p2")]);
Assert.AreEqual(1, m1[pnc.PlaceIndex("p3")]);
Assert.AreEqual(0, m2[pnc2.PlaceIndex("p1")]);
Assert.AreEqual(1, m2[pnc2.PlaceIndex("p2")]);
Assert.AreEqual(1, m2[pnc2.PlaceIndex("p3")]);
}
private void RunFullTestCase(string spec,
int inArcs,
int outArcs,
int numInhibitors)
{
CreatePetriNet pnb = CreatePetriNet.Parse(spec);
if (inArcs == 0)
{
Assert.That(pnb.InArcs, Is.Null);
}
else
{
Assert.That(pnb.InArcs.SelectMany(x => x.Value).Count(), Is.EqualTo(inArcs));
Assert.That(pnb.InArcs.SelectMany(x => x.Value).Where(x => x.IsInhibitor).Count(), Is.EqualTo(numInhibitors));
}
if (outArcs == 0)
{
Assert.That(pnb.OutArcs, Is.Null);
}
else
{
Assert.That(pnb.OutArcs.SelectMany(x => x.Value).Count(), Is.EqualTo(outArcs));
}
}
public void TestCalltransitionsTwiceOutOfOrder()
{
var pn = CreatePetriNet
.Called("net")
.WithTransitions("p1")
.WithPlaces("p1")
.WithTransitions("p1");
}
public void TestCreatePlaces()
{
var pn = CreatePetriNet.Called("net").WithPlaces("p1", "p2", "p3");
Assert.IsNotNull(pn.Places);
Assert.IsTrue(pn.Places.Count == 3);
Assert.AreEqual(pn.Places[0], "p1");
Assert.AreEqual(pn.Places[1], "p2");
Assert.AreEqual(pn.Places[2], "p3");
}
public void TestMarkingTransitionEnabled()
{
var m = new Marking(2, new Dictionary <int, int> {
{ 0, 0 }, { 1, 0 }
});
var p = CreatePetriNet.Parse(StdPetriNets.OneInOneOut).CreateNet <GraphPetriNet>();
m[0] = 1;
Assert.AreEqual(true, p.IsEnabled(0, m));
}
public void TestCreateGraphWithIllegalMarking3()
{
var pnb = CreatePetriNet.Called("blah")
.WithPlaces("p1", "p2")
.AndTransitions("t1")
.With("t1").FedBy("p1")
.And().With("t1").Feeding("p1")
.And().WithPlace(null).HavingMarking(1)
.And().WithPlace("p2").HavingMarking(2)
.Done();
}
public void TestMarkingAffectsEnablement()
{
var m = new Marking(2, new Dictionary <int, int> {
{ 0, 1 }, { 1, 1 }
});
var p = CreatePetriNet.Parse(StdPetriNets.TwoInOneOut).CreateNet <GraphPetriNet>();
Assert.AreEqual(true, p.IsEnabled(0, m));
m[0] = 0;
Assert.AreEqual(false, p.IsEnabled(0, m));
}
public void TestDoubleSelfTransition()
{
var m = new Marking(1,
new Dictionary <int, int>
{
{ (int)Places.p1, 1 }
});
var p = CreatePetriNet.Parse(StdPetriNets.DoubleSelfTransition).CreateNet <GraphPetriNet>();
Assert.AreEqual(1, m.Get(p.Places, "p1"));
m = p.Fire(m);
Assert.AreEqual(1, m.Get(p.Places, "p1"));
}
public void TestFireCreatesModifiedMarking()
{
var m = new Marking(2,
new Dictionary <int, int> {
{ 0, 1 }, { 1, 0 }
});
var p = CreatePetriNet.Parse(StdPetriNets.OneInOneOut).CreateNet <GraphPetriNet>();
Assert.AreEqual(1, m[0]);
Assert.AreEqual(0, m[1]);
Assert.AreEqual(true, p.IsEnabled(0, m));
m = p.Fire(m);
Assert.AreEqual(0, m[0]);
Assert.AreEqual(1, m[1]);
}
public void TestCreateMarking()
{
var pnb = CreatePetriNet.Called("blah")
.WithPlaces("p1", "p2")
.AndTransitions("t1")
.With("t1").FedBy("p1")
.And().With("t1").Feeding("p1")
.And().WithPlace("p1").HavingMarking(1)
.And().WithPlace("p2").HavingMarking(2)
.Done();
var m = pnb.CreateMarking();
Assert.AreEqual(2, m.Count);
Assert.AreEqual(1, m[pnb.PlaceIndex("p1")]);
Assert.AreEqual(2, m[pnb.PlaceIndex("p2")]);
}
public void TestCreateGraphWithNonDefaultCapacities()
{
var pnb = CreatePetriNet.Called("blah")
.WithPlaces("p1", "p2")
.AndTransitions("t1")
.With("t1").FedBy("p1")
.And().With("t1").Feeding("p1")
.And().WithPlace("p1").HavingCapacity(2)
.And().WithPlace("p2").HavingCapacity(3)
.Done();
var pn = pnb.CreateNet <GraphPetriNet>();
Assert.AreEqual(2, pn.PlaceCapacities.Count);
Assert.AreEqual(2, pn.PlaceCapacities[pnb.PlaceIndex("p1")]);
Assert.AreEqual(3, pn.PlaceCapacities[pnb.PlaceIndex("p2")]);
}
public void TestFireCreatesModifiedMarking2()
{
var m = new Marking(3,
new Dictionary <int, int> {
{ 0, 1 }, { 1, 0 }, { 2, 0 }
});
var p = CreatePetriNet.Parse(StdPetriNets.TwoInOneOut).CreateNet <GraphPetriNet>();
Assert.IsFalse(p.IsEnabled(0, m));
m[1] = 1;
Assert.IsTrue(p.IsEnabled(0, m));
m = p.Fire(m);
Assert.AreEqual(0, m[0]);
Assert.AreEqual(0, m[1]);
Assert.AreEqual(1, m[2]);
}
void PetriNetSpec()
{
Expect(3);
Expect(2);
Builder = CreatePetriNet.Called(t.val);
Expect(15);
ArcSetSpec();
while (la.kind == 2 || la.kind == 12)
{
ArcSetSpec();
}
Expect(16);
while (la.kind == 2)
{
MarkingSpec();
}
}
public void TestMultiEnabledPetriNet()
{
var m = new Marking(4,
new Dictionary <int, int>
{
{ (int)Places.p1, 0 },
{ (int)Places.p2, 0 },
{ (int)Places.p3, 0 },
{ (int)Places.p4, 0 }
});
var p = CreatePetriNet.Parse(StdPetriNets.MultiEnabled).CreateNet <GraphPetriNet>();
m.Assert(p.Places, new Dictionary <string, int>
{
{ "p1", 0 }, { "p2", 0 },
{ "p3", 0 }, { "p4", 0 }
});
m.Set(p.Places, "p1", 1);
m.Assert(p.Places, new Dictionary <string, int>
{
{ "p1", 1 }, { "p2", 0 },
{ "p3", 0 }, { "p4", 0 }
});
m = p.Fire(m);
m.Assert(p.Places, new Dictionary <string, int>
{
{ "p1", 0 }, { "p2", 1 },
{ "p3", 0 }, { "p4", 0 }
});
m = p.Fire(m);
m.Assert(p.Places, new Dictionary <string, int>
{
{ "p1", 0 }, { "p2", 0 },
{ "p3", 1 }, { "p4", 0 }
});
m.Set(p.Places, "p4", 1);
m.Assert(p.Places, new Dictionary <string, int>
{
{ "p1", 0 }, { "p2", 0 },
{ "p3", 1 }, { "p4", 1 }
});
m = p.Fire(m);
m.Assert(p.Places, new Dictionary <string, int>
{
{ "p1", 0 }, { "p2", 1 },
{ "p3", 1 }, { "p4", 0 }
});
m = p.Fire(m);
m.Assert(p.Places, new Dictionary <string, int>
{
{ "p1", 0 }, { "p2", 0 },
{ "p3", 2 }, { "p4", 0 }
});
}
public void TestCreatePetriNetBuilder()
{
var pn = CreatePetriNet.Called("p1");
Assert.IsNotNull(pn);
}
public void TestCreateTransitionsWithBadNames4()
{
var pn = CreatePetriNet
.Called("net")
.WithPlaces("p1", "p2", "p3").WithTransitions("p1", null, "p2");
}
public void TestCompareWithOldConstructionTechnique()
{
var m = new Marking(3,
new Dictionary <int, int>
{
{ (int)Places.p1, 0 },
{ (int)Places.p2, 0 },
{ (int)Places.p3, 0 }
});
var p = new GraphPetriNet("p",
new Dictionary <int, string> {
{ (int)Places.p1, "p1" },
{ (int)Places.p2, "p2" },
{ (int)Places.p3, "p3" }
},
new Dictionary <int, string>
{
{ (int)Transitions.t1, "t1" }
},
new Dictionary <int, List <InArc> >()
{
{ (int)Transitions.t1, new List <InArc>()
{
new InArc((int)Places.p1)
} }
},
new Dictionary <int, List <OutArc> >()
{
{ (int)Transitions.t1, new List <OutArc>()
{
new OutArc((int)Places.p2),
new OutArc((int)Places.p3)
} }
});
var pnc = CreatePetriNet.Called("p")
.WithPlaces("p1",
"p2",
"p3")
.AndTransitions("t1")
.With("t1").FedBy("p1")
.And().With("t1").Feeding("p2",
"p3")
.Done();
var p2 = pnc.CreateNet <GraphPetriNet>();
m[(int)Places.p1] = 1;
var m2 = p.Fire(m);
var m3 = p2.Fire(m);
AssertMarkings(m2, new Dictionary <int, double> {
{ (int)Places.p1, 0 },
{ (int)Places.p2, 1 },
{ (int)Places.p3, 1 }
});
AssertMarkings(m3, new Dictionary <int, double> {
{ (int)Places.p1, 0 },
{ (int)Places.p2, 1 },
{ (int)Places.p3, 1 }
});
}
public void TestNameCannotBeInitdWithJunk2()
{
var pn = CreatePetriNet.Called("\0");
}
public void TestCreateWithBadNames2()
{
var pn = CreatePetriNet.Called("net").WithPlaces(null);
}
public void TestCreateWithBadNames5()
{
var pn = CreatePetriNet.Called("net").WithPlaces("p1", "\0", "p2");
}
