public void ItemsChangedShouldFire(string[] setters)
{
PexAssume.IsNotNull(setters);
PexAssume.AreElementsNotNull(setters);
this.Log().InfoFormat("Setting TestString to [{0}]", String.Join(",", setters));
(new TestScheduler()).With(sched => {
var output_changed = new List <object>();
var output_changing = new List <object>();
var fixture = new ModelTestFixture();
fixture.Changing.Subscribe(output_changing.Add);
fixture.Changed.Subscribe(output_changed.Add);
foreach (var v in setters)
{
fixture.TestString = v;
}
sched.Start();
PexAssert.AreEqual(setters.Uniq().Count(), output_changed.Count);
PexAssert.AreEqual(setters.Uniq().Count(), output_changing.Count);
});
}
public void AddingItemsShouldChangeTheContentHash(string[] toAdd)
{
PexAssume.IsNotNull(toAdd);
PexAssume.AreElementsNotNull(toAdd);
PexAssume.IsTrue(toAdd.Length > 0);
(new TestScheduler()).With(sched => {
var fixture = new SerializedCollection <ModelTestFixture>();
var hashes = new List <Guid>();
int changeCount = 0;
fixture.Changed.Subscribe(_ => {
hashes.Add(fixture.ContentHash);
changeCount++;
});
foreach (var v in toAdd)
{
fixture.Add(new ModelTestFixture()
{
TestString = v
});
sched.Start();
}
PexAssert.AreDistinctValues(hashes.ToArray());
PexAssert.AreEqual(toAdd.Length, fixture.Count);
PexAssert.AreEqual(toAdd.Uniq().Count(), changeCount);
});
}
public void TM([PexAssumeNotNull] String[] L0)
{
PexAssume.AreElementsNotNull(L0);
PexAssume.AreDistinctValues(L0);
PexAssume.IsTrue(L0.Length >= 3);
Test51.L0p = Array.ConvertAll(L0, n => new Student(n));
Test51.L0q = Array.ConvertAll(L0, n => new Student(n));
ATracer.begin1();
new T5V1.M().Main();
ATracer.begin2();
new T5V2.M().Main();
Console.WriteLine(ATracer.trace1);
Console.WriteLine("--------------");
Console.WriteLine(ATracer.trace2);
PexAssert.AreEqual(ATracer.trace1, ATracer.trace2);
//ATrace.Begin();
//PexAssert.AreBehaviorsEqual(() => new T5V1.M().Main(),
// () => new T5V2.M().Main());
//ATrace.End();
}
public static object CreateDisembarkOrder(GameState.UnitIndex idx, HexTiling.HexCoords[] path)
{
PexAssume.IsNotNull(idx);
PexAssume.IsNotNull(path);
PexAssume.AreElementsNotNull(path);
return(EmbarkOrders.DisembarkOrder.NewDisembark(idx, ListModule.OfArray(path)));
}
public static object CreateOrder(bool isBomb, bool isBombard, bool isConquer, bool isDirectAttack, bool isDockAt, bool isLandAt, HexTiling.HexCoords coords, HexTiling.HexCoords[] path)
{
PexAssume.IsNotNull(coords);
PexAssume.IsNotNull(path);
PexAssume.AreElementsNotNull(path);
return
(isBomb ? Orders.Order.NewBomb(coords, ListModule.OfArray(path)) :
isBombard?Orders.Order.NewBombard(coords) :
isConquer?Orders.Order.NewConquer(ListModule.OfArray(path)) :
isDirectAttack?Orders.Order.NewDirectAttack(coords, ListModule.OfArray(path)) :
isDockAt?Orders.Order.NewDockAt(ListModule.OfArray(path)) :
isLandAt?Orders.Order.NewLandAt(ListModule.OfArray(path)) :
Orders.Order.NewUnload(ListModule.OfArray(path), coords));
}
public static object CreateUnitTypes(int t, bool isDocked, int fuel, Units.BomberTransport bt,
Units.CarriedAircraft[] aircrafts, Units.TransportedUnit[] tu)
{
switch (t)
{
case 0: return(Units.UnitTypes.Infantry);
case 1: return(Units.UnitTypes.AntiAircraft);
case 2: return(Units.UnitTypes.Artillery);
case 3: return(Units.UnitTypes.Tank);
case 4: return(Units.UnitTypes.NewBattleship(isDocked ? Units.Docked.Docked : Units.Docked.NotDocked));
case 5:
PexAssume.IsNotNull(bt);
return(Units.UnitTypes.NewBomber(isDocked ? Units.Landed.Landed : Units.Landed.Airborne,
Units.Fuel.NewFuel(fuel), bt));
case 6:
PexAssume.IsNotNull(aircrafts);
PexAssume.AreElementsNotNull(aircrafts);
return(Units.UnitTypes.NewCarrier(isDocked ? Units.Docked.Docked : Units.Docked.NotDocked,
aircrafts));
case 7:
return(Units.UnitTypes.NewDestroyer(isDocked ? Units.Docked.Docked : Units.Docked.NotDocked));
case 8:
return(Units.UnitTypes.NewFighter(isDocked ? Units.Landed.Landed : Units.Landed.Airborne,
Units.Fuel.NewFuel(fuel)));
case 9:
return(Units.UnitTypes.NewSubmarine(isDocked ? Units.Docked.Docked : Units.Docked.NotDocked, Units.Stealthy.NotStealthy));
case 10:
return(Units.UnitTypes.NewSubmarine(isDocked ? Units.Docked.Docked : Units.Docked.NotDocked, Units.Stealthy.Stealthy));
default:
PexAssume.IsNotNull(tu);
PexAssume.AreElementsNotNull(tu);
return(Units.UnitTypes.NewTransport(isDocked ? Units.Docked.Docked : Units.Docked.NotDocked, tu));
}
}
public void TM([PexAssumeNotNull] String[] L0)
{
PexAssume.AreElementsNotNull(L0);
PexAssume.AreDistinctValues(L0);
PexAssume.IsTrue(L0.Length > 1);
//String[] L1 = L0.UCopy().USort((a, b) => a.CompareTo(b));
String[] L1 = L0.OrderBy(x => x).ToArray();
//new String[L0.Length];
//L0.UCopyTo(L1);
//Array.Sort(L1);
//PexAssert.AreElementsEqual(L0, L1);
//System.Console.WriteLine(String.Join(",", L0));
//System.Console.WriteLine("".Equals("\0"));
//System.Console.WriteLine("\0".CompareTo("\0\0"));
PexAssert.IsTrue(L0.SequenceEqual(L1));
}
public void Concat <T>(IEnumerable <IEnumerable <T> > source)
{
PexAssume.IsNotNull(source);
PexAssume.AreElementsNotNull(source);
var flattenedEnumerable = source.Concat();
var flattenedEnumerator = flattenedEnumerable.GetEnumerator();
foreach (var enumerable in source)
{
foreach (var value in enumerable)
{
PexAssert.IsTrue(flattenedEnumerator.MoveNext());
PexAssert.AreEqual(flattenedEnumerator.Current, value);
}
}
PexAssert.IsFalse(flattenedEnumerator.MoveNext());
}
public void GuidsShouldBeUniqueForContent(string[] setters)
{
PexAssume.IsNotNull(setters);
PexAssume.AreElementsNotNull(setters);
(new TestScheduler()).With(sched => {
var fixture = new ModelTestFixture();
var output = new Dictionary <string, Guid>();
setters.ToObservable(sched).Subscribe(x => {
fixture.TestString = x;
output[x] = fixture.ContentHash;
});
sched.Start();
PexAssert.AreDistinctValues(output.Values.ToArray());
});
}
public void Dematerialize <T>([PexAssumeNotNull] IEnumerable <Notification <T> > source)
{
PexAssume.AreElementsNotNull(source);
var dispatched = source.Dematerialize();
var enumerable = new StatefulEnumerable <T>(dispatched)
{
ShouldRethrow = false
};
var enumerator = enumerable.GetEnumerator();
var sourceEnumerator = source.GetEnumerator();
while (sourceEnumerator.MoveNext())
{
var notification = sourceEnumerator.Current;
var onNext = notification as Notification <T> .OnNext;
if (onNext != null)
{
PexAssert.IsTrue(enumerator.MoveNext());
PexAssert.AreEqual(EnumerableState.MovedNext, enumerable.CurrentState);
PexAssert.AreEqual(onNext.Value, enumerator.Current);
PexAssert.AreEqual(EnumerableState.GotCurrent, enumerable.CurrentState);
}
else
{
var onError = notification as Notification <T> .OnError;
if (onError != null)
{
PexAssert.IsFalse(enumerator.MoveNext());
PexAssert.AreEqual(EnumerableState.MovingNext | EnumerableState.Threw, enumerable.CurrentState);
PexAssert.AreEqual(onError.Exception, enumerable.Exception);
return;
}
var onCompleted = (Notification <T> .OnCompleted)notification;
PexAssert.IsFalse(enumerator.MoveNext());
PexAssert.AreEqual(EnumerableState.AtEnd, enumerable.CurrentState);
return;
}
}
PexAssert.IsFalse(enumerator.MoveNext());
}
