public void AddEdge55()
{
try
{
AdjacencyGraph <int, Edge <int> > adjacencyGraph;
bool b;
KeyValuePair <int, int>[] keyValuePairs = new KeyValuePair <int, int> [2];
KeyValuePair <int, int> s0 = new KeyValuePair <int, int>(36014113, 1781006400);
keyValuePairs[0] = s0;
KeyValuePair <int, int> s1 = new KeyValuePair <int, int>(708135361, 708135361);
keyValuePairs[1] = s1;
adjacencyGraph = AdjacencyGraphFactory.Create(false, keyValuePairs);
b = this.AddEdge <int, Edge <int> >(adjacencyGraph, (Edge <int>)null);
Assert.AreEqual <bool>(false, b);
Assert.IsNotNull((object)adjacencyGraph);
Assert.AreEqual <bool>(true, adjacencyGraph.IsDirected);
Assert.AreEqual <bool>(false, adjacencyGraph.AllowParallelEdges);
Assert.AreEqual <int>(-1, adjacencyGraph.EdgeCapacity);
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void AddEdgeThrowsContractException966()
{
try
{
AdjacencyGraph <int, Edge <int> > adjacencyGraph;
bool b;
KeyValuePair <int, int>[] keyValuePairs = new KeyValuePair <int, int> [3];
KeyValuePair <int, int> s0 = new KeyValuePair <int, int>(1048578, 840056837);
keyValuePairs[0] = s0;
KeyValuePair <int, int> s1 = new KeyValuePair <int, int>(273287168, 273287168);
keyValuePairs[1] = s1;
KeyValuePair <int, int> s2 = new KeyValuePair <int, int>(-1, -1);
keyValuePairs[2] = s2;
adjacencyGraph = AdjacencyGraphFactory.Create(false, keyValuePairs);
b = this.AddEdge <int, Edge <int> >(adjacencyGraph, (Edge <int>)null);
throw new AssertFailedException();
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void UpdateValuesThrowsContractException387()
{
try
{
VoterDO voterDO;
voterDO = PexInvariant.CreateInstance <VoterDO>();
PexInvariant.SetField <uint?>((object)voterDO, "primaryKey", default(uint?));
PexInvariant.SetField <EntityRef <PollingStationDO> >
((object)voterDO, "_pollingStation", default(EntityRef <PollingStationDO>));
PexInvariant.SetField <uint?>
((object)voterDO, "<PollingStationId>k__BackingField", default(uint?));
PexInvariant.SetField <string>
((object)voterDO, "<Name>k__BackingField", (string)null);
PexInvariant.SetField <string>
((object)voterDO, "<Address>k__BackingField", (string)null);
PexInvariant.SetField <string>
((object)voterDO, "<City>k__BackingField", (string)null);
PexInvariant.SetField <bool?>
((object)voterDO, "<CardPrinted>k__BackingField", new bool?(true));
PexInvariant.SetField <bool?>
((object)voterDO, "<Voted>k__BackingField", new bool?(true));
PexInvariant.CheckInvariant((object)voterDO);
this.UpdateValues(voterDO, (IDataObject)null);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void Compute02()
{
try
{
if (!PexContract.HasRequiredRuntimeContracts
(typeof(global::ClassWithProtocol), (PexRuntimeContractsFlags)4223))
{
Assert.Inconclusive
("assembly assembly Samples is not instrumented with runtime contracts");
}
global::ClassWithProtocol classWithProtocol;
bool b;
classWithProtocol =
global::ClassWithProtocolFactory.Create((string)null, (string)null, 0);
b = this.Compute(classWithProtocol, "");
throw new AssertFailedException();
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void ConstructorThrowsContractException735()
{
try
{
this.Constructor <int, int>(int.MinValue);
throw new AssertFailedException();
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void intersectThrowsContractException819()
{
try
{
this.intersect((global::NatSet.NatSet)null);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void ConstructorThrowsContractException944()
{
try
{
EdgeEventArgs <int, Edge <int> > edgeEventArgs;
edgeEventArgs = this.Constructor <int, Edge <int> >((Edge <int>)null);
throw new AssertFailedException();
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void insertThrowsContractException322()
{
try
{
this.insert(int.MinValue);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void calThrowsContractException23701()
{
try
{
int i;
i = this.cal(12, 3, 12, 34, 0);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void calTestThrowsContractException761()
{
try
{
int i;
i = this.calTest(2, 2, 2, 0, 0);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void patternIndexThrowsContractException34()
{
try
{
int i;
i = this.patternIndex((string)null, (string)null);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void calThrowsContractException97801()
{
try
{
int i;
i = this.cal(2, 28, 2, 31, 633);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void patternIndexTestThrowsContractException675()
{
try
{
int i;
i = this.patternIndexTest("00", "");
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void AddEdgeThrowsContractException811()
{
try
{
AdjacencyGraph <int, SEdge <int> > adjacencyGraph;
bool b;
adjacencyGraph = new AdjacencyGraph <int, SEdge <int> >(false, 1, 0);
b = this.AddEdge <int, SEdge <int> >(adjacencyGraph, default(SEdge <int>));
throw new AssertFailedException();
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void removeTestThrowsContractException513()
{
try
{
ArrayList arrayList;
arrayList = ArrayListFactory.Create();
this.removeTest(arrayList, int.MinValue);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void addTestThrowsContractException23()
{
try
{
ArrayList arrayList;
arrayList = ArrayListFactory.Create();
this.addTest(arrayList, (object)null, 9);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void ConstructorThrowsContractException904()
{
try
{
VoterDO voterDO;
voterDO = this.Constructor(default(uint?), new uint?(0u), (string)null,
(string)null, (string)null, new bool?(true), new bool?(true));
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void removeTestThrowsContractException837()
{
try
{
ArrayList arrayList;
arrayList = ArrayListFactory.creatEmpty();
this.removeTest(arrayList, 0);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void UpdateValuesThrowsContractException338()
{
try
{
MunicipalityDO municipalityDO;
municipalityDO =
new MunicipalityDO(default(uint?), (string)null, (string)null, (string)null);
this.UpdateValues(municipalityDO, (IDataObject)null);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void ProductionVolumePerBinTestThrowsContractException643()
{
try
{
ERPWarehouseIntegration eRPWarehouseIntegration;
int i;
eRPWarehouseIntegration = ERPWarehouseIntegrationFactory.Create();
i = this.ProductionVolumePerBinTest(eRPWarehouseIntegration, 0, 2);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void insertTestThrowsContractException616()
{
try
{
int[] ints = new int[2];
ints[0] = -2147483551;
ints[1] = 1073741829;
this.insertTest(ints);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void addThrowsContractException999()
{
try
{
ArrayList arrayList;
arrayList = ArrayListFactory.Create0();
object s0 = new object();
this.add(arrayList, s0, int.MinValue);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void AddEdgeThrowsContractException72()
{
try
{
AdjacencyGraph <int, Edge <int> > adjacencyGraph;
bool b;
KeyValuePair <int, int>[] keyValuePairs = new KeyValuePair <int, int> [1];
adjacencyGraph = AdjacencyGraphFactory.Create(false, keyValuePairs);
b = this.AddEdge <int, Edge <int> >(adjacencyGraph, (Edge <int>)null);
throw new AssertFailedException();
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void UpdateValuesThrowsContractException717()
{
try
{
PollingStationDO pollingStationDO;
pollingStationDO = new PollingStationDO
(default(uint?), default(uint?), (string)null, (string)null);
this.UpdateValues(pollingStationDO, (IDataObject)null);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void TrimSuffix02()
{
try
{
if (!PexContract.HasRequiredRuntimeContracts
(typeof(Class1), (PexRuntimeContractsFlags)4223))
{
Assert.Inconclusive
("assembly assembly VBLib is not instrumented with runtime contracts");
}
string s;
s = this.TrimSuffix("", (string)null);
throw new AssertFailedException();
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void Constructor02()
{
try
{
if (!PexContract.HasRequiredRuntimeContracts
(typeof(Chunker), (PexRuntimeContractsFlags)4223))
{
Assert.Inconclusive
("assembly assembly Samples is not instrumented with runtime contracts");
}
Chunker chunker;
chunker = this.Constructor((string)null, 1);
throw new AssertFailedException();
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void UnregisterCurrentVoterThrowsContractException834()
{
try
{
VoterDO voterDO;
Model model;
voterDO = PexInvariant.CreateInstance <VoterDO>();
PexInvariant.SetField <uint?>((object)voterDO, "primaryKey", default(uint?));
PexInvariant.SetField <EntityRef <PollingStationDO> >
((object)voterDO, "_pollingStation", default(EntityRef <PollingStationDO>));
PexInvariant.SetField <uint?>
((object)voterDO, "<PollingStationId>k__BackingField", default(uint?));
PexInvariant.SetField <string>
((object)voterDO, "<Name>k__BackingField", (string)null);
PexInvariant.SetField <string>
((object)voterDO, "<Address>k__BackingField", (string)null);
PexInvariant.SetField <string>
((object)voterDO, "<City>k__BackingField", (string)null);
PexInvariant.SetField <bool?>
((object)voterDO, "<CardPrinted>k__BackingField", new bool?(true));
PexInvariant.SetField <bool?>
((object)voterDO, "<Voted>k__BackingField", new bool?(false));
PexInvariant.CheckInvariant((object)voterDO);
model = new Model();
model.currentVoter = voterDO;
model.AdminPass = (string)null;
this.UnregisterCurrentVoter(model);
throw
new AssertFailedException("expected an exception of type ContractException");
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void AddEdge791()
{
try
{
AdjacencyGraph <int, Edge <int> > adjacencyGraph;
bool b;
KeyValuePair <int, int>[] keyValuePairs = new KeyValuePair <int, int> [2];
adjacencyGraph = AdjacencyGraphFactory.Create(true, keyValuePairs);
b = this.AddEdge <int, Edge <int> >(adjacencyGraph, (Edge <int>)null);
Assert.AreEqual <bool>(true, b);
Assert.IsNotNull((object)adjacencyGraph);
Assert.AreEqual <bool>(true, adjacencyGraph.IsDirected);
Assert.AreEqual <bool>(true, adjacencyGraph.AllowParallelEdges);
Assert.AreEqual <int>(-1, adjacencyGraph.EdgeCapacity);
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
public void AddEdgeThrowsContractException569()
{
try
{
AdjacencyGraph <int, Edge <int> > adjacencyGraph;
bool b;
KeyValuePair <int, int>[] keyValuePairs = new KeyValuePair <int, int> [2];
KeyValuePair <int, int> s0 = new KeyValuePair <int, int>(-2097099498, 50384150);
keyValuePairs[0] = s0;
KeyValuePair <int, int> s1
= new KeyValuePair <int, int>(-2097099498, -2097099498);
keyValuePairs[1] = s1;
adjacencyGraph = AdjacencyGraphFactory.Create(false, keyValuePairs);
b = this.AddEdge <int, Edge <int> >(adjacencyGraph, (Edge <int>)null);
throw new AssertFailedException();
}
catch (Exception ex)
{
if (!PexContract.IsContractException(ex))
{
throw ex;
}
}
}
