public IEnumerator OutOfGameTime_DoesNotUpdateOnSave(
[ValueSource(nameof(RealSeconds))] double secondsOutOfGame
)
{
FortuneFountainSaveData fortuneFountainSaveData =
FortuneFountainSaveData.NewSaveFile(nameof(OutOfGameTime_DoesNotUpdateOnSave));
var outOfGameSpan = TimeSpan.FromSeconds(secondsOutOfGame);
//Set the OutOfGameTimeSinceLastThrow (using reflection since the setter is private)
fortuneFountainSaveData.GetType().GetProperty(nameof(FortuneFountainSaveData.OutOfGameTimeSinceLastThrow))
?.SetValue(fortuneFountainSaveData, outOfGameSpan);
Assert.That(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow, Is.EqualTo(outOfGameSpan));
const int repetitions = 5;
for (int rep = 0; rep < repetitions; rep++)
{
yield return(new WaitForSecondsRealtime(0.01f));
fortuneFountainSaveData.Save(false);
Assert.That(fortuneFountainSaveData.OutOfGameTimeSinceLastThrow, Is.EqualTo(outOfGameSpan),
$"[{nameof(rep)}: {rep}] The {nameof(FortuneFountainSaveData.OutOfGameTimeSinceLastThrow)} should not have changed when we {nameof(FortuneFountainSaveData.Save)}-ed!");
}
}
public void TestSerializeThrowables()
{
const string nickName = nameof(TestSerializeThrowables);
FortuneFountainSaveData fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nickName);
for (int i = 0; i < ValuableDatabase.ValuableTypes.Length; i++)
{
// copying `i` into `index` inside the loop 'cus otherwise lambdas can get messed up
var index = i;
var karmaValue = Random.Range(1, 25);
var valuableType = ValuableDatabase.ValuableTypes[index];
Log($"Grabbing a {valuableType} with a value of {karmaValue}");
fortuneFountainSaveData.Hand.AddToHand(new ThrowableValuable(valuableType, karmaValue));
fortuneFountainSaveData.Save(useReSaveDelay: false);
Log($"before loading throwables:", fortuneFountainSaveData.Hand.Throwables.JoinLines());
//load the save data we created
FortuneFountainSaveData loadedSaveData = FortuneFountainSaveData.Load(nickName);
Log($"original SaveData:", fortuneFountainSaveData);
Log($"loaded SaveData:", loadedSaveData);
AssertAll.Of(
() => Assert.That(loadedSaveData.ToJson(), Contains.Substring($"\"{nameof(Hand._throwables)}\":")),
() => Assert.That(loadedSaveData.Hand.Throwables.Count, Is.EqualTo(index + 1)),
() => Assert.That(loadedSaveData.Hand.Throwables[index] as ThrowableValuable,
Has.Property(nameof(ThrowableValuable.ValuableType)).EqualTo(valuableType)),
() => Assert.That(loadedSaveData.Hand.Throwables[index] as ThrowableValuable,
Has.Property(nameof(ThrowableValuable.PresentValue)).EqualTo(karmaValue))
);
}
}
public void ReductionWorks(int iterations, double maxIncrementsPerIteration)
{
var incrementer = new Incrementer();
for (int i = 0; i < iterations; i++)
{
incrementer.AddIncrements(Brandom.Gen.NextDouble() * maxIncrementsPerIteration);
}
var exactBeforeReduction = incrementer.ExactIncrements;
var fullBeforeReduction = incrementer.FullIncrements;
var partialBeforeReduction = incrementer.PartialIncrements;
Assert.That(exactBeforeReduction - fullBeforeReduction, Is.EqualTo(partialBeforeReduction),
$"Before {nameof(incrementer.Reduce)}: {nameof(incrementer.ExactIncrements)} - {nameof(incrementer.FullIncrements)} == {nameof(incrementer.PartialIncrements)}");
var reductionAmount = incrementer.Reduce();
AssertAll.Of(
$"After calling {nameof(incrementer.Reduce)}",
() => Assert.That(reductionAmount, Is.EqualTo(fullBeforeReduction),
$"{nameof(incrementer.Reduce)} should have returned the previous {nameof(incrementer.FullIncrements)}"),
() => Assert.That(incrementer.ExactIncrements, Is.EqualTo(partialBeforeReduction),
$"{nameof(incrementer.ExactIncrements)} should equal the previous {nameof(incrementer.PartialIncrements)}"),
() => Assert.That(incrementer.ExactIncrements, Is.Positive.And.LessThan(1),
$"1 > {nameof(incrementer.ExactIncrements)} >= 0")
);
}
public void EmptyFallbackSerializesEmpty()
{
var fallback = new Fallback <int>();
var json = JsonConvert.SerializeObject(fallback);
Console.WriteLine(json);
Assert.That(json, Is.EqualTo(@"{""FallbackValue"":0,""ExplicitValue"":[]}"));
}
public void DefaultEqualsEmpty()
{
Optional <int> a = default;
Console.WriteLine(a);
AssertAll.Of(
a,
Has.Property(nameof(a.HasValue)).EqualTo(false),
Is.EqualTo(new Optional <int>())
);
}
public void ComputeElapsedIncrements(double periodInSeconds, double elapsedTimeInSeconds,
double expectedIntervalAmount)
{
var incrementer = new Incrementer()
{
Period = TimeSpan.FromSeconds(periodInSeconds)
};
var elapsedTime = TimeSpan.FromSeconds(elapsedTimeInSeconds);
Assert.That(incrementer.ComputeElapsedIncrements(elapsedTime), Is.EqualTo(expectedIntervalAmount));
}
public void EmptyEqualsEmpty()
{
var a = new Optional <int>();
var b = new Optional <int>();
Asserter.Against(a)
.And(Is.EqualTo(b), "a IsEqualTo b")
.And(Is.EqualTo(new Optional <int>()))
.And(Is.EqualTo(default(Optional <int>)))
.And(it => it == b, Is.True, "a == b")
.And(it => it.Equals(b), Is.True, "a.Equals(b)")
.Invoke();
}
public void TestInGameTimeSinceLastThrowWithoutSaving(
[ValueSource(nameof(Seconds))] double secondsInGame
)
{
FortuneFountainSaveData fortuneFountainSaveData =
FortuneFountainSaveData.NewSaveFile(nameof(TestInGameTimeSinceLastThrowWithoutSaving));
var inGameTime = TimeSpan.FromSeconds(secondsInGame);
fortuneFountainSaveData.Hand.LastThrowTime = FrameTime.Now - inGameTime;
Assert.That(fortuneFountainSaveData.InGameTimeSinceLastThrow,
Is.InRange(inGameTime.Multiply(0.999), inGameTime.Multiply(1.001)));
}
public void OptionalEqualsUnboxed_String()
{
const string str = "yolo";
var a = new Optional <string>(str);
AssertAll.Of(
() => Assert.That(a.Equals(str), "a.Equals(str)"),
() => Assert.That(a, Is.EqualTo(str)),
() => Assert.That(a == str, "a == str"),
() => Assert.That(str == a, "str == a"),
() => Assert.That(str, Is.EqualTo(a)),
() => Assert.That(a.Equals(str), "a.Equals(str)")
);
}
public void FromList(int numberOfChoices, int numberOfPicks)
{
var ls = Enumerable.Range(0, numberOfChoices).ToList();
var v2 = new FromList <int>(ls);
var picks = numberOfPicks.Repeat <int>(() => v2).ToList();
Assert.That(picks, Is.SupersetOf(ls));
var groups = picks.Group();
var expectedHitsPerChoice = (double)numberOfPicks / numberOfChoices;
Assert.That(groups, Has.All.Values().Approximately(expectedHitsPerChoice, expectedHitsPerChoice / 2));
}
public void TestFirstValuableEnabledOnNewSave()
{
const string nickName = nameof(TestFirstValuableEnabledOnNewSave);
var fortuneFountainSaveData = FortuneFountainSaveData.NewSaveFile(nickName);
const ValuableType expectedFirstValuableType = 0;
Assert.That(fortuneFountainSaveData.PlayerValuables,
Has.Some.Property(nameof(PlayerValuable.ValuableType)).EqualTo(expectedFirstValuableType),
$"The new save file didn't contain PlayerValuable type 0 ({expectedFirstValuableType})!");
Assert.That(fortuneFountainSaveData.PlayerValuables.Count, Is.EqualTo(1),
"The save file contained extra player valuables!");
}
public void TestGenerateInterval(
[ValueSource(nameof(rates))] double rateInItemsPerSecond
)
{
var saveData = new FortuneFountainSaveData(nameof(TestGenerateInterval));
var pv = new PlayerValuable(saveData, ValuableType.Coin)
{
Rate = rateInItemsPerSecond
};
Assert.That(TimeSpan.FromSeconds(1).Divide(pv.GenerateInterval),
Is.InRange(Math.Floor(rateInItemsPerSecond), rateInItemsPerSecond * 1.00001));
Assert.That(pv.GenerateInterval,
Is.EqualTo(TimeSpan.FromTicks((long)(TimeSpan.TicksPerSecond / rateInItemsPerSecond))));
}
public Asserter <AggregateExecutionComparison.TimeComparison> AssertComparison(
AggregateExecutionComparison.TimeComparison results,
int expectedComparison
)
{
Constraint ratioConstraint = expectedComparison switch {
-1 => Is.Positive.And.LessThan(1),
0 => Is.EqualTo(1),
1 => Is.Positive.And.GreaterThan(1),
_ => throw new ArgumentOutOfRangeException(nameof(expectedComparison))
};
return(Asserter.Against(results)
.And(it => it.First.CompareTo(it.Second), Is.EqualTo(expectedComparison))
.And(it => it.Difference.Sign(), Is.EqualTo(expectedComparison))
.And(it => it.Ratio, ratioConstraint));
}
public void TestGenerateIsLimitedByRate()
{
const string nickName = nameof(TestGenerateIsLimitedByRate);
GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nickName);
var generateCounter = 0;
PlayerValuable.GeneratePlayerValuableEvent += (valuable, amount) => generateCounter++;
LogUtils.Log(GameManager.SaveData.PlayerValuables[0]);
LogUtils.Log(JsonConvert.SerializeObject(GameManager.SaveData.PlayerValuables[0]));
for (var i = 0; i < 10; i++)
{
GameManager.SaveData.PlayerValuables.CheckGenerate();
Assert.That(generateCounter, Is.EqualTo(0), $"Error on {i + 1}th generation!");
}
}
public void ApproximationConstraint(
[ValueSource(typeof(PrimitiveUtils), nameof(PrimitiveUtils.NumericTypes))]
Type actualType,
[ValueSource(typeof(PrimitiveUtils), nameof(PrimitiveUtils.NumericTypes))]
Type expectedType,
[ValueSource(typeof(PrimitiveUtils), nameof(PrimitiveUtils.NumericTypes))]
Type thresholdType,
[Values] Clusivity clusivity
)
{
var exp = new ApproximationExpectation(actualType, expectedType, thresholdType);
Console.WriteLine(exp);
AssertAll.Of(
() => Assert.That(exp.Actual, Is.Approximately(exp.Expected_ToPass(clusivity), exp.Threshold, clusivity), $"{nameof(exp.Expected_ToPass)}, {clusivity}"),
() => Assert.That(exp.Actual, Is.Not.Approximately(exp.Expected_ToFail(clusivity), exp.Threshold, clusivity), $"{nameof(exp.Expected_ToFail)}, {clusivity}")
);
}
public void SingleActionTime()
{
Action action = Quick;
//stopwatch version
var stopwatch = Stopwatch.StartNew();
action();
stopwatch.Stop();
Console.WriteLine($"Stopwatch version: {stopwatch.Elapsed:g}");
var exTime = new ExecutionTime(action);
Console.WriteLine($"{nameof(exTime)}: {exTime}");
Asserter.Against(exTime)
.And(Has.Property(nameof(exTime.Duration)).CloseTo(SlowSpan, TimeSpan.FromSeconds(0.01)))
.And(it => it.Execution.Failed, Is.EqualTo(false))
.And(Has.Property(nameof(exTime.Duration)).CloseTo(stopwatch.Elapsed))
.Invoke();
}
public IEnumerator TestPartialUncheckedItemsGeneratedDuringLastSession(
[Values(0.5)] double previousGenIntervals,
[Values(3)] double totalItemsToGenerate
)
{
Assume.That(previousGenIntervals, Is.LessThan(1));
Assume.That(totalItemsToGenerate, Is.GreaterThan(previousGenIntervals));
GameManager.SaveData =
FortuneFountainSaveData.NewSaveFile(nameof(TestPartialUncheckedItemsGeneratedDuringLastSession));
GameManager.SaveData.PlayerValuables = TestData.GetUniformPlayerValuables(GameManager.SaveData);
yield return(TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval,
previousGenIntervals));
GameManager.SaveData.Save(false);
var genCounters = CreateValuableGenerationCounters(GameManager.SaveData.PlayerValuables);
yield return(TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval, 2));
GameManager.SaveData.Reload();
var sleepIntervals = totalItemsToGenerate - previousGenIntervals + 0.5;
LogUtils.Log($"{nameof(sleepIntervals)} = {sleepIntervals}");
yield return(TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval,
sleepIntervals));
var itemsGenerated = GameManager.SaveData.PlayerValuables.CheckGenerate();
Assert.That(itemsGenerated, Has.All.EqualTo(totalItemsToGenerate));
Assert.That(genCounters,
Has.All.Values().EqualTo(new ValuableGenerationCounter()
{
Amount = (int)totalItemsToGenerate, Events = 1
}));
}
public void ReturnBoxed()
{
Assert.That(Boxional(5), Is.TypeOf <Optional <int> >());
}
public void ReturnUnboxed()
{
Assert.That(Unboxional(Optional.Of(5)), Is.TypeOf <int>());
}
public IEnumerator GenerateAllViaCollectionExtension(
[Values(true, false)] bool checkThrowables
)
{
const string nickName = nameof(TestGenerateIsLimitedByRate);
GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nickName);
GameManager.SaveData.PlayerValuables = TestData.GetUniformPlayerValuables(GameManager.SaveData);
Assume.That(GameManager.SaveData.PlayerValuables.Count, Is.GreaterThan(1),
"We need to test more than 1 valuable type!");
Assume.That(GameManager.SaveData.PlayerValuables, Has.All.Property("Rate").EqualTo(1),
"All valuables should have a generation rate of 1!");
//Add counter events for each of the valuables
var generateCounters = CreateValuableGenerationCounters(GameManager.SaveData.PlayerValuables);
//Set the LastGenerateTime for each valuable to be their previous interval (that way, they are ready to generate)
var setTime = FrameTime.Now - GameManager.SaveData.PlayerValuables[0].GenerateInterval;
GameManager.SaveData.Hand.LastThrowTime = setTime;
GameManager.SaveData.PlayerValuables.ForEach(it => it.LastGenerateCheckTime = setTime);
if (checkThrowables)
{
Assert.That(GameManager.SaveData.Hand.Throwables.Count, Is.EqualTo(0));
}
//Generate stuff
GameManager.SaveData.PlayerValuables.CheckGenerate();
Assert.That(generateCounters,
Has.All.Values().EqualTo(new ValuableGenerationCounter()
{
Events = 1, Amount = 1
}));
if (checkThrowables)
{
Assert.That(GameManager.SaveData.Hand.Throwables.Count,
Is.EqualTo(generateCounters.Sum(it => it.Value.Amount)));
}
//sleep so we can expect to generate another item
yield return(TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval));
//Generate stuff
GameManager.SaveData.PlayerValuables.CheckGenerate();
Assert.That(generateCounters,
Has.All.Values().EqualTo(new ValuableGenerationCounter()
{
Events = 2, Amount = 2
}));
if (checkThrowables)
{
Assert.That(GameManager.SaveData.Hand.Throwables.Count,
Is.EqualTo(generateCounters.Sum(it => it.Value.Amount)));
}
//sleep so that we can expect to generate _2_ more items
yield return
(TestUtils.WaitForRealtime(GameManager.SaveData.PlayerValuables[0].GenerateInterval.Multiply(2)));
//Generate stuff
GameManager.SaveData.PlayerValuables.CheckGenerate();
Assert.That(generateCounters,
Has.All.Values().EqualTo(new ValuableGenerationCounter()
{
Events = 3, Amount = 4
}));
if (checkThrowables)
{
Assert.That(GameManager.SaveData.Hand.Throwables,
Has.Property(nameof(Hand.Throwables.Count)).EqualTo(generateCounters.Sum(it => it.Value.Amount)));
}
}
public void GenerateEventsLimitedByMaxGenerateTime(
double generateTimeLimitInSeconds,
double itemsPerSecond,
double extraGenerationSeconds
)
{
//the number of items we expect to generate - which should always be limited by maxGenerationSeconds
var expectedItemsGenerated = generateTimeLimitInSeconds * itemsPerSecond;
Ignore.Unless(
() => Assume.That(generateTimeLimitInSeconds, Is.GreaterThan(0),
$"{nameof(generateTimeLimitInSeconds)} must be greater than 0!"),
() => Assume.That(itemsPerSecond, Is.GreaterThan(0),
$"{nameof(itemsPerSecond)} must be greater than 0!"),
() => Assume.That(extraGenerationSeconds, Is.GreaterThanOrEqualTo(0),
$"{nameof(extraGenerationSeconds)} must be positive!"),
() => Assume.That(expectedItemsGenerated, Is.GreaterThanOrEqualTo(1),
$"{nameof(expectedItemsGenerated)} must be at least 1!")
);
//this test is very quick and runs a LOT of times, so we should disable logging to prevent it from being crazy slow
// LogUtils.locations = LogUtils.Locations.None;
const string nickName = nameof(GenerateEventsLimitedByMaxGenerateTime);
GameManager.SaveData = FortuneFountainSaveData.NewSaveFile(nickName);
//Setting up the player data
GameManager.SaveData.PlayerValuables =
TestData.GetUniformPlayerValuables(GameManager.SaveData, itemsPerSecond);
GameManager.SaveData.Hand.LastThrowTime = FrameTime.Now -
TimeSpan.FromSeconds(generateTimeLimitInSeconds +
extraGenerationSeconds);
GameManager.SaveData.PlayerValuables.ForEach(it =>
it.LastGenerateCheckTime = GameManager.SaveData.Hand.LastThrowTime);
GameManager.SaveData.Hand.GenerateTimeLimit = TimeSpan.FromSeconds(generateTimeLimitInSeconds);
Assert.That(GameManager.SaveData.PlayerValuables[0].GenerateInterval,
Is.LessThanOrEqualTo(GameManager.SaveData.Hand.GenerateTimeLimit),
$"We must have enough time to generate at least one item - i.e. {nameof(PlayerValuable.GenerateInterval)} <= {nameof(Hand.GenerateTimeLimit)}!");
var genCounters = CreateValuableGenerationCounters(GameManager.SaveData.PlayerValuables);
//Generate the items
GameManager.SaveData.PlayerValuables.CheckGenerate();
//Check for the proper number of events & actual items generated
AssertAll.Of(
() => Assert.That(
GroupThrowables(GameManager.SaveData.Hand.Throwables),
Has.All.Values().With.Count.InRange(Math.Floor(expectedItemsGenerated),
Math.Ceiling(expectedItemsGenerated))
),
() => Assert.That(genCounters,
Has.All.Values().With.Property(nameof(ValuableGenerationCounter.Events)).EqualTo(1)),
() => Assert.That(genCounters,
Has.All.Values().With.Property(nameof(ValuableGenerationCounter.Amount))
.InRange(Math.Floor(expectedItemsGenerated), Math.Ceiling(expectedItemsGenerated)))
);
}
public void PassUnboxional()
{
Assert.That(Unboxional <int>(5), Is.TypeOf <int>());
}