test: cover fueledStand and brewOnce

tests/testBrewing.cpp

@@ -0,0 +1,159 @@
+#include <vector>
+
+#include "testHarness.h"
+#include "vf/Brewing.h"
+
+using namespace vf;
+
+namespace {
+
+using Ingredient = BrewRecipe::Ingredient;
+
+BrewingStandState fueledStand(const PotionItem& bottle, int blazePowder = 5) {
+    BrewingStandState stand;
+    setBottle(stand, 0, bottle);
+    addFuel(stand, blazePowder);
+    return stand;
+}
+
+// Loads one ingredient and runs the stand until the brew lands. Returns the
+// bottle in the first slot afterwards.
+PotionItem brewOnce(BrewingStandState& stand, Ingredient ingredient) {
+    setIngredient(stand, ingredient, 1);
+    for (int tick = 0; tick < brewDurationTicks; ++tick) tickBrewing(stand);
+    return stand.bottles[0].potion;
+}
+
+// Walks a whole chain of ingredients through a single bottle.
+PotionItem brewChain(const PotionItem& start, const std::vector<Ingredient>& chain) {
+    BrewingStandState stand = fueledStand(start, 10);
+    PotionItem bottle = start;
+    for (Ingredient ingredient : chain) bottle = brewOnce(stand, ingredient);
+    return bottle;
+}
+
+PotionItem potionOf(PotionKind kind) {
+    PotionItem potion;
+    potion.kind = kind;
+    return potion;
+}
+
+int durationOf(PotionKind kind, bool upgraded, bool extended) {
+    PotionItem potion = potionOf(kind);
+    potion.upgraded = upgraded;
+    potion.extended = extended;
+    return potionEffect(potion).durationTicks;
+}
+
+int levelOf(PotionKind kind, bool upgraded, bool extended) {
+    PotionItem potion = potionOf(kind);
+    potion.upgraded = upgraded;
+    potion.extended = extended;
+    return potionEffect(potion).level();
+}
+
+} // namespace
+
+VF_TEST(theStandsPublishedConstantsAreTheOnesTheRestOfTheEngineWasBuiltAgainst) {
+    CHECK_EQ(brewingBottleSlots, 3);
+    CHECK_EQ(brewDurationTicks, 400);
+    CHECK_EQ(brewDurationTicks, 20 * ticksPerSecond);
+    CHECK_EQ(brewsPerBlazePowder, 20);
+    CHECK_EQ(static_cast<int>(PotionKind::Count), 17);
+    CHECK_EQ(static_cast<int>(BrewRecipe::Ingredient::None), 0);
+
+    // A stand with one blaze powder in it runs a literal twenty second brew and
+    // has nineteen brews of fuel left afterwards.
+    BrewingStandState stand;
+    setBottle(stand, 0, PotionItem{});
+    addFuel(stand, 1);
+    setIngredient(stand, Ingredient::NetherWart, 1);
+    CHECK_EQ(stand.fuel, 20);
+
+    int completedOn = 0;
+    for (int tick = 1; tick <= 500; ++tick) {
+        if (tickBrewing(stand) && completedOn == 0) completedOn = tick;
+    }
+    CHECK_EQ(completedOn, 400);
+    CHECK_EQ(stand.fuel, 19);
+}
+
+VF_TEST(recipeTableHasNoDuplicateInputAndIngredientPairs) {
+    const std::vector<BrewRecipe>& recipes = brewRecipes();
+    CHECK(recipes.size() >= 19);
+
+    int collisions = 0;
+    int selfLoops = 0;
+    int emptyIngredients = 0;
+    for (std::size_t i = 0; i < recipes.size(); ++i) {
+        if (recipes[i].ingredient == Ingredient::None) ++emptyIngredients;
+        if (recipes[i].input == recipes[i].output) ++selfLoops;
+        for (std::size_t j = i + 1; j < recipes.size(); ++j) {
+            if (recipes[i].input == recipes[j].input &&
+                recipes[i].ingredient == recipes[j].ingredient) {
+                ++collisions;
+            }
+        }
+    }
+    CHECK_EQ(collisions, 0);
+    CHECK_EQ(selfLoops, 0);
+    CHECK_EQ(emptyIngredients, 0);
+}
+
+VF_TEST(netherWartTurnsWaterIntoAwkwardAndAwkwardOpensEveryBasePotion) {
+    bool changed = false;
+    CHECK_EQ(brewResult(PotionItem{}, Ingredient::NetherWart, changed).kind, PotionKind::Awkward);
+    CHECK(changed);
+
+    const struct { Ingredient ingredient; PotionKind expected; } branches[] = {
+        {Ingredient::Sugar, PotionKind::Swiftness},
+        {Ingredient::GlisteringMelon, PotionKind::Healing},
+        {Ingredient::SpiderEye, PotionKind::Poison},
+        {Ingredient::BlazePowder, PotionKind::Strength},
+        {Ingredient::MagmaCream, PotionKind::FireResistance},
+        {Ingredient::PufferFish, PotionKind::WaterBreathing},
+        {Ingredient::GoldenCarrot, PotionKind::NightVision},
+        {Ingredient::GhastTear, PotionKind::Regeneration},
+        {Ingredient::RabbitFoot, PotionKind::Leaping},
+    };
+    for (const auto& branch : branches) {
+        bool branched = false;
+        PotionItem brewed = brewResult(potionOf(PotionKind::Awkward), branch.ingredient, branched);
+        CHECK(branched);
+        CHECK_EQ(brewed.kind, branch.expected);
+    }
+}
+
+VF_TEST(aStandTurnsWaterIntoAwkwardOnTheFourHundredthTickAndNotOneTickEarlier) {
+    BrewingStandState stand = fueledStand(PotionItem{}, 1);
+    CHECK_EQ(stand.fuel, brewsPerBlazePowder);
+    CHECK(setIngredient(stand, Ingredient::NetherWart, 1));
+
+    bool completedEarly = false;
+    for (int tick = 1; tick < brewDurationTicks; ++tick) {
+        if (tickBrewing(stand)) completedEarly = true;
+    }
+    CHECK(!completedEarly);
+    CHECK(stand.brewing);
+    CHECK_EQ(stand.progressTicks, brewDurationTicks - 1);
+    CHECK_EQ(stand.bottles[0].potion.kind, PotionKind::Water);
+
+    CHECK(tickBrewing(stand));
+    CHECK_EQ(stand.bottles[0].potion.kind, PotionKind::Awkward);
+    CHECK_EQ(stand.progressTicks, 0);
+    CHECK(!stand.brewing);
+    CHECK_EQ(stand.fuel, brewsPerBlazePowder - 1);
+    CHECK_EQ(stand.ingredientCount, 0);
+    CHECK_EQ(stand.ingredient, Ingredient::None);
+}
+
+VF_TEST(theFullWaterToUpgradedSplashStrengthCycleRunsOnOneStand) {
+    BrewingStandState stand = fueledStand(PotionItem{}, 1);
+
+    CHECK_EQ(brewOnce(stand, Ingredient::NetherWart).kind, PotionKind::Awkward);
+    CHECK_EQ(brewOnce(stand, Ingredient::BlazePowder).kind, PotionKind::Strength);
+
+    PotionItem upgraded = brewOnce(stand, Ingredient::Glowstone);
+    CHECK(upgraded.upgraded);
+    CHECK(!upgraded.extended);
+