From 1f8bcf777ba8958a0a77d390f6709db83e2e6e5e Mon Sep 17 00:00:00 2001 From: Gasan Guseinov <465806+gusega@users.noreply.github.com> Date: Sun, 18 Apr 2021 14:18:16 +0200 Subject: [PATCH] updated kata --- Java/build.gradle | 2 + .../main/java/com/gildedrose/GildedRose.java | 68 ++------- .../com/gildedrose/QualityItemHandler.java | 28 ++++ .../itemprocessors/AgedBrieProcessor.java | 12 ++ .../BackstagePassProcessor.java | 28 ++++ .../itemprocessors/ConjuredItemProcessor.java | 15 ++ .../itemprocessors/NormalItemProcessor.java | 8 + .../itemprocessors/ProcessorFactory.java | 37 +++++ .../itemprocessors/QualityItemProcessor.java | 86 +++++++++++ .../itemprocessors/SulfurasProcessor.java | 11 ++ .../com/gildedrose/itemsorts/AgedBrie.java | 10 ++ .../gildedrose/itemsorts/BackstagePass.java | 9 ++ .../gildedrose/itemsorts/ConjuredItem.java | 9 ++ .../com/gildedrose/itemsorts/NormalItem.java | 9 ++ .../com/gildedrose/itemsorts/QualityItem.java | 65 ++++++++ .../com/gildedrose/itemsorts/Sulfuras.java | 9 ++ .../ProcessingRequestFromQualityItem.java | 10 ++ .../AgedBrieFromProcessingResponse.java | 11 ++ .../BackstagePassFromProcessingResponse.java | 11 ++ .../ConjuredItemFromProcessingResponse.java | 11 ++ .../NormalItemFromProcessingResponse.java | 12 ++ .../QualityItemFromProcessingResponse.java | 8 + ...lityItemFromProcessingResponseFactory.java | 44 ++++++ .../SulfurasFromProcessingResponse.java | 11 ++ .../java/com/gildedrose/GildedRoseTest.java | 83 +++++++++- .../gildedrose/QualityItemHandlerTest.java | 55 +++++++ .../java/com/gildedrose/TexttestFixture.java | 72 +++++++-- .../itemprocessors/AgedBrieProcessorTest.java | 15 ++ .../BackstagePassProcessorTest.java | 38 +++++ .../ConjuredItemProcessorTest.java | 17 +++ .../itemprocessors/ProcessorFactoryTest.java | 39 +++++ .../QualityItemProcessorTest.java | 142 ++++++++++++++++++ .../itemprocessors/SulfurasProcessorTest.java | 19 +++ .../ProcessingRequestFromQualityItemTest.java | 19 +++ .../AgedBrieFromProcessingResponseTest.java | 21 +++ ...ckstagePassFromProcessingResponseTest.java | 21 +++ ...onjuredItemFromProcessingResponseTest.java | 21 +++ .../NormalItemFromProcessingResponseTest.java | 21 +++ ...ItemFromProcessingResponseFactoryTest.java | 40 +++++ .../SulfurasFromProcessingResponseTest.java | 21 +++ texttests/ThirtyDays/stdout.gr | 8 +- texttests/config.gr | 5 +- 42 files changed, 1107 insertions(+), 74 deletions(-) create mode 100644 Java/src/main/java/com/gildedrose/QualityItemHandler.java create mode 100644 Java/src/main/java/com/gildedrose/itemprocessors/AgedBrieProcessor.java create mode 100644 Java/src/main/java/com/gildedrose/itemprocessors/BackstagePassProcessor.java create mode 100644 Java/src/main/java/com/gildedrose/itemprocessors/ConjuredItemProcessor.java create mode 100644 Java/src/main/java/com/gildedrose/itemprocessors/NormalItemProcessor.java create mode 100644 Java/src/main/java/com/gildedrose/itemprocessors/ProcessorFactory.java create mode 100644 Java/src/main/java/com/gildedrose/itemprocessors/QualityItemProcessor.java create mode 100644 Java/src/main/java/com/gildedrose/itemprocessors/SulfurasProcessor.java create mode 100644 Java/src/main/java/com/gildedrose/itemsorts/AgedBrie.java create mode 100644 Java/src/main/java/com/gildedrose/itemsorts/BackstagePass.java create mode 100644 Java/src/main/java/com/gildedrose/itemsorts/ConjuredItem.java create mode 100644 Java/src/main/java/com/gildedrose/itemsorts/NormalItem.java create mode 100644 Java/src/main/java/com/gildedrose/itemsorts/QualityItem.java create mode 100644 Java/src/main/java/com/gildedrose/itemsorts/Sulfuras.java create mode 100644 Java/src/main/java/com/gildedrose/itemtorequest/ProcessingRequestFromQualityItem.java create mode 100644 Java/src/main/java/com/gildedrose/responsetoitem/AgedBrieFromProcessingResponse.java create mode 100644 Java/src/main/java/com/gildedrose/responsetoitem/BackstagePassFromProcessingResponse.java create mode 100644 Java/src/main/java/com/gildedrose/responsetoitem/ConjuredItemFromProcessingResponse.java create mode 100644 Java/src/main/java/com/gildedrose/responsetoitem/NormalItemFromProcessingResponse.java create mode 100644 Java/src/main/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponse.java create mode 100644 Java/src/main/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponseFactory.java create mode 100644 Java/src/main/java/com/gildedrose/responsetoitem/SulfurasFromProcessingResponse.java create mode 100644 Java/src/test/java/com/gildedrose/QualityItemHandlerTest.java create mode 100644 Java/src/test/java/com/gildedrose/itemprocessors/AgedBrieProcessorTest.java create mode 100644 Java/src/test/java/com/gildedrose/itemprocessors/BackstagePassProcessorTest.java create mode 100644 Java/src/test/java/com/gildedrose/itemprocessors/ConjuredItemProcessorTest.java create mode 100644 Java/src/test/java/com/gildedrose/itemprocessors/ProcessorFactoryTest.java create mode 100644 Java/src/test/java/com/gildedrose/itemprocessors/QualityItemProcessorTest.java create mode 100644 Java/src/test/java/com/gildedrose/itemprocessors/SulfurasProcessorTest.java create mode 100644 Java/src/test/java/com/gildedrose/itemtorequest/ProcessingRequestFromQualityItemTest.java create mode 100644 Java/src/test/java/com/gildedrose/responsetoitem/AgedBrieFromProcessingResponseTest.java create mode 100644 Java/src/test/java/com/gildedrose/responsetoitem/BackstagePassFromProcessingResponseTest.java create mode 100644 Java/src/test/java/com/gildedrose/responsetoitem/ConjuredItemFromProcessingResponseTest.java create mode 100644 Java/src/test/java/com/gildedrose/responsetoitem/NormalItemFromProcessingResponseTest.java create mode 100644 Java/src/test/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponseFactoryTest.java create mode 100644 Java/src/test/java/com/gildedrose/responsetoitem/SulfurasFromProcessingResponseTest.java diff --git a/Java/build.gradle b/Java/build.gradle index f3773536..ed21f353 100644 --- a/Java/build.gradle +++ b/Java/build.gradle @@ -1,5 +1,6 @@ plugins { id 'java' + id "io.freefair.lombok" version "6.0.0-m2" } repositories { @@ -11,6 +12,7 @@ dependencies { testImplementation 'org.junit.jupiter:junit-jupiter-params:5.6.2' testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.6.2' testImplementation 'com.approvaltests:approvaltests:5.0.0' + implementation 'org.mockito:mockito-core:3.9.0' } group = 'com.gildedrose' diff --git a/Java/src/main/java/com/gildedrose/GildedRose.java b/Java/src/main/java/com/gildedrose/GildedRose.java index e6feb751..988c3adb 100644 --- a/Java/src/main/java/com/gildedrose/GildedRose.java +++ b/Java/src/main/java/com/gildedrose/GildedRose.java @@ -1,62 +1,24 @@ package com.gildedrose; -class GildedRose { - Item[] items; +import com.gildedrose.itemsorts.QualityItem; - public GildedRose(Item[] items) { +import java.util.ArrayList; +import java.util.List; + +public class GildedRose { + private final List items; + private final QualityItemHandler qualityItemHandler; + + public GildedRose(List items, QualityItemHandler qualityItemHandler) { this.items = items; + this.qualityItemHandler = qualityItemHandler; + } + + public List getItems() { + return new ArrayList<>(items); } public void updateQuality() { - for (int i = 0; i < items.length; i++) { - if (!items[i].name.equals("Aged Brie") - && !items[i].name.equals("Backstage passes to a TAFKAL80ETC concert")) { - if (items[i].quality > 0) { - if (!items[i].name.equals("Sulfuras, Hand of Ragnaros")) { - items[i].quality = items[i].quality - 1; - } - } - } else { - if (items[i].quality < 50) { - items[i].quality = items[i].quality + 1; - - if (items[i].name.equals("Backstage passes to a TAFKAL80ETC concert")) { - if (items[i].sellIn < 11) { - if (items[i].quality < 50) { - items[i].quality = items[i].quality + 1; - } - } - - if (items[i].sellIn < 6) { - if (items[i].quality < 50) { - items[i].quality = items[i].quality + 1; - } - } - } - } - } - - if (!items[i].name.equals("Sulfuras, Hand of Ragnaros")) { - items[i].sellIn = items[i].sellIn - 1; - } - - if (items[i].sellIn < 0) { - if (!items[i].name.equals("Aged Brie")) { - if (!items[i].name.equals("Backstage passes to a TAFKAL80ETC concert")) { - if (items[i].quality > 0) { - if (!items[i].name.equals("Sulfuras, Hand of Ragnaros")) { - items[i].quality = items[i].quality - 1; - } - } - } else { - items[i].quality = items[i].quality - items[i].quality; - } - } else { - if (items[i].quality < 50) { - items[i].quality = items[i].quality + 1; - } - } - } - } + items.replaceAll(qualityItemHandler::processOneItem); } } \ No newline at end of file diff --git a/Java/src/main/java/com/gildedrose/QualityItemHandler.java b/Java/src/main/java/com/gildedrose/QualityItemHandler.java new file mode 100644 index 00000000..527af622 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/QualityItemHandler.java @@ -0,0 +1,28 @@ +package com.gildedrose; + + +import com.gildedrose.itemprocessors.ProcessorFactory; +import com.gildedrose.itemsorts.QualityItem; +import com.gildedrose.itemtorequest.ProcessingRequestFromQualityItem; +import com.gildedrose.responsetoitem.QualityItemFromProcessingResponseFactory; + +public class QualityItemHandler { + private final ProcessorFactory processorFactory; + private final ProcessingRequestFromQualityItem processingRequestFromQualityItem; + private final QualityItemFromProcessingResponseFactory qualityItemFromProcessingResponseFactory; + + QualityItemHandler(ProcessorFactory processorFactory, ProcessingRequestFromQualityItem processingRequestFromQualityItem, + QualityItemFromProcessingResponseFactory qualityItemFromProcessingResponseFactory) { + this.processorFactory = processorFactory; + this.processingRequestFromQualityItem = processingRequestFromQualityItem; + this.qualityItemFromProcessingResponseFactory = qualityItemFromProcessingResponseFactory; + } + + QualityItem processOneItem(QualityItem qualityItem) { + return qualityItemFromProcessingResponseFactory.get(qualityItem).toQualityItem( + qualityItem, + processorFactory.get(qualityItem). + processItem(processingRequestFromQualityItem.get(qualityItem)) + ); + } +} diff --git a/Java/src/main/java/com/gildedrose/itemprocessors/AgedBrieProcessor.java b/Java/src/main/java/com/gildedrose/itemprocessors/AgedBrieProcessor.java new file mode 100644 index 00000000..12295747 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemprocessors/AgedBrieProcessor.java @@ -0,0 +1,12 @@ +package com.gildedrose.itemprocessors; + +import com.gildedrose.itemprocessors.QualityItemProcessor.QualityItemProcessorSkeleton; + +import com.gildedrose.itemsorts.AgedBrie; + +public class AgedBrieProcessor extends QualityItemProcessorSkeleton implements QualityItemProcessor { + @Override + int qualityFunction(int oldQuality, int qualityChange) { + return oldQuality + qualityChange; + } +} diff --git a/Java/src/main/java/com/gildedrose/itemprocessors/BackstagePassProcessor.java b/Java/src/main/java/com/gildedrose/itemprocessors/BackstagePassProcessor.java new file mode 100644 index 00000000..d1de40f7 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemprocessors/BackstagePassProcessor.java @@ -0,0 +1,28 @@ +package com.gildedrose.itemprocessors; + +import com.gildedrose.itemprocessors.QualityItemProcessor.QualityItemProcessorSkeleton; +import com.gildedrose.itemsorts.BackstagePass; + +public class BackstagePassProcessor extends QualityItemProcessorSkeleton implements QualityItemProcessor{ + + public static final int FIVE_DAYS_BEFORE_CONCERT = 5; + public static final int TEN_DAYS_BEFORE_CONCERT = 10; + + @Override + int qualityFunction(int oldQuality, int qualityChange) { + return oldQuality + qualityChange; + } + + @Override + int calculateQualityChange(int sellIn, int oldQuality) { + if (sellIn < 0) { + return -oldQuality; + } else if (sellIn < FIVE_DAYS_BEFORE_CONCERT) { + return 3; + } else if (sellIn < TEN_DAYS_BEFORE_CONCERT) { + return 2; + } else { + return 1; + } + } +} diff --git a/Java/src/main/java/com/gildedrose/itemprocessors/ConjuredItemProcessor.java b/Java/src/main/java/com/gildedrose/itemprocessors/ConjuredItemProcessor.java new file mode 100644 index 00000000..d61f734c --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemprocessors/ConjuredItemProcessor.java @@ -0,0 +1,15 @@ +package com.gildedrose.itemprocessors; + +import com.gildedrose.itemprocessors.QualityItemProcessor.QualityItemProcessorSkeleton; +import com.gildedrose.itemsorts.ConjuredItem; + + +public class ConjuredItemProcessor extends QualityItemProcessorSkeleton implements QualityItemProcessor { + + public static final int CONJURED_ITEM_QUALITY_CHANGE_MULTIPLIER = 2; + + @Override + int applyQualityChangeMultiplier(int qualityChange) { + return CONJURED_ITEM_QUALITY_CHANGE_MULTIPLIER * qualityChange; + } +} diff --git a/Java/src/main/java/com/gildedrose/itemprocessors/NormalItemProcessor.java b/Java/src/main/java/com/gildedrose/itemprocessors/NormalItemProcessor.java new file mode 100644 index 00000000..dadc8e71 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemprocessors/NormalItemProcessor.java @@ -0,0 +1,8 @@ +package com.gildedrose.itemprocessors; + +import com.gildedrose.itemprocessors.QualityItemProcessor.QualityItemProcessorSkeleton; +import com.gildedrose.itemsorts.NormalItem; + + +public class NormalItemProcessor extends QualityItemProcessorSkeleton implements QualityItemProcessor { +} diff --git a/Java/src/main/java/com/gildedrose/itemprocessors/ProcessorFactory.java b/Java/src/main/java/com/gildedrose/itemprocessors/ProcessorFactory.java new file mode 100644 index 00000000..9768c06a --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemprocessors/ProcessorFactory.java @@ -0,0 +1,37 @@ +package com.gildedrose.itemprocessors; + +import com.gildedrose.itemsorts.QualityItem; +import lombok.AllArgsConstructor; +import lombok.Getter; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +public class ProcessorFactory { + static final String EXCEPTION_MESSAGE_TEMPLATE = "Item processor for the item of type %s is not found. Make sure that the factory" + + "is configured correctly"; + private final Map, QualityItemProcessor> qualityItemsProcessors = new HashMap<>(); + + + public ProcessorFactory(List> qualityItemProcessors) { + qualityItemProcessors.forEach(processorFactoryItem -> qualityItemsProcessors.put(processorFactoryItem.getItemType(),processorFactoryItem.getItemProcessor())); + } + + @Getter + @AllArgsConstructor + public static class ProcessorFactoryItem { + private final Class itemType; + private final QualityItemProcessor itemProcessor; + } + + public QualityItemProcessor get(QualityItem qualityItem) { + Class aClass = qualityItem.getClass(); + QualityItemProcessor qualityItemProcessor = Optional.ofNullable(qualityItemsProcessors.get(aClass)).orElseThrow( + () -> new IllegalArgumentException(String.format(EXCEPTION_MESSAGE_TEMPLATE, aClass))); + @SuppressWarnings("unchecked") // unnecessary + QualityItemProcessor qualityItemProcessorCasted = (QualityItemProcessor) qualityItemProcessor; + return qualityItemProcessorCasted; + } +} diff --git a/Java/src/main/java/com/gildedrose/itemprocessors/QualityItemProcessor.java b/Java/src/main/java/com/gildedrose/itemprocessors/QualityItemProcessor.java new file mode 100644 index 00000000..4a4c7745 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemprocessors/QualityItemProcessor.java @@ -0,0 +1,86 @@ +package com.gildedrose.itemprocessors; + +import com.gildedrose.itemsorts.QualityItem; +import lombok.AllArgsConstructor; +import lombok.EqualsAndHashCode; +import lombok.Getter; + + +public interface QualityItemProcessor { + ProcessingResponse processItem(ProcessingRequest processingRequest); + + + @EqualsAndHashCode + @Getter + @AllArgsConstructor + class ProcessingResponse { + private final int sellIn; + private final int quality; + } + + @EqualsAndHashCode + @Getter + @AllArgsConstructor + class ProcessingRequest { + private final int sellIn; + private final int quality; + } + + + /** + * A skeleton intended for subclassing + * + * @param - type of the item + */ + abstract class QualityItemProcessorSkeleton implements QualityItemProcessor { + static final int QUALITY_CHANGE_AFTER_SELL_DATE = 2; + static final int QUALITY_CHANGE_BEFORE_SELL_DATE = 1; + static final int MAX_QUALITY = 50; + static final int MIN_QUALITY = 0; + public static final int DEFAULT_QUALITY_CHANGE_MULTIPLIER = 1; + + + @Override + public ProcessingResponse processItem(ProcessingRequest processingRequest) { + int newSellIn = calculateNewSellIn(processingRequest.getSellIn()); + int newQuality = calculateNewQuality(newSellIn, processingRequest.getQuality()); + return new ProcessingResponse<>(newSellIn, newQuality); + } + + int calculateNewSellIn(int oldSellIn) { + return oldSellIn - 1; + } + + int calculateNewQuality(int newSellIn, int oldQuality) { + return qualityLimitsCheck(qualityFunction(oldQuality, applyQualityChangeMultiplier(calculateQualityChange(newSellIn, oldQuality)))); + } + + int qualityFunction(int oldQuality, int qualityChange) { + return oldQuality - qualityChange; + } + + int applyQualityChangeMultiplier(int qualityChange) { + return DEFAULT_QUALITY_CHANGE_MULTIPLIER * qualityChange; + } + + int calculateQualityChange(int sellIn, int oldQuality) { + if (sellIn < 0) { + return QUALITY_CHANGE_AFTER_SELL_DATE; + } else { + return QUALITY_CHANGE_BEFORE_SELL_DATE; + } + } + + + int qualityLimitsCheck(int quality) { + if (quality > MAX_QUALITY) { + return MAX_QUALITY; + } else if (quality < MIN_QUALITY) { + return MIN_QUALITY; + } else { + return quality; + } + } + } + +} diff --git a/Java/src/main/java/com/gildedrose/itemprocessors/SulfurasProcessor.java b/Java/src/main/java/com/gildedrose/itemprocessors/SulfurasProcessor.java new file mode 100644 index 00000000..345fc528 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemprocessors/SulfurasProcessor.java @@ -0,0 +1,11 @@ +package com.gildedrose.itemprocessors; + + +import com.gildedrose.itemsorts.Sulfuras; + +public class SulfurasProcessor implements QualityItemProcessor { + @Override + public ProcessingResponse processItem(ProcessingRequest processingRequest) { + return new ProcessingResponse<>(processingRequest.getSellIn(), processingRequest.getQuality()); + } +} diff --git a/Java/src/main/java/com/gildedrose/itemsorts/AgedBrie.java b/Java/src/main/java/com/gildedrose/itemsorts/AgedBrie.java new file mode 100644 index 00000000..80c5192b --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemsorts/AgedBrie.java @@ -0,0 +1,10 @@ +package com.gildedrose.itemsorts; + +import com.gildedrose.itemsorts.QualityItem.QualityItemSkeleton; + + +public class AgedBrie extends QualityItemSkeleton { + public AgedBrie(String name, int sellIn, int quality) { + super(name, sellIn, quality); + } +} diff --git a/Java/src/main/java/com/gildedrose/itemsorts/BackstagePass.java b/Java/src/main/java/com/gildedrose/itemsorts/BackstagePass.java new file mode 100644 index 00000000..e7aa1491 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemsorts/BackstagePass.java @@ -0,0 +1,9 @@ +package com.gildedrose.itemsorts; + +import com.gildedrose.itemsorts.QualityItem.QualityItemSkeleton; + +public class BackstagePass extends QualityItemSkeleton { + public BackstagePass(String name, int sellIn, int quality) { + super(name, sellIn, quality); + } +} diff --git a/Java/src/main/java/com/gildedrose/itemsorts/ConjuredItem.java b/Java/src/main/java/com/gildedrose/itemsorts/ConjuredItem.java new file mode 100644 index 00000000..655574f6 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemsorts/ConjuredItem.java @@ -0,0 +1,9 @@ +package com.gildedrose.itemsorts; + +import com.gildedrose.itemsorts.QualityItem.QualityItemSkeleton; + +public class ConjuredItem extends QualityItemSkeleton implements QualityItem { + public ConjuredItem(String name, int sellIn, int quality) { + super(name, sellIn, quality); + } +} diff --git a/Java/src/main/java/com/gildedrose/itemsorts/NormalItem.java b/Java/src/main/java/com/gildedrose/itemsorts/NormalItem.java new file mode 100644 index 00000000..f5f4da5a --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemsorts/NormalItem.java @@ -0,0 +1,9 @@ +package com.gildedrose.itemsorts; + +import com.gildedrose.itemsorts.QualityItem.QualityItemSkeleton; + +public class NormalItem extends QualityItemSkeleton implements QualityItem { + public NormalItem(String name, int sellIn, int quality) { + super(name, sellIn, quality); + } +} diff --git a/Java/src/main/java/com/gildedrose/itemsorts/QualityItem.java b/Java/src/main/java/com/gildedrose/itemsorts/QualityItem.java new file mode 100644 index 00000000..4a05942d --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemsorts/QualityItem.java @@ -0,0 +1,65 @@ +package com.gildedrose.itemsorts; + +import com.gildedrose.Item; +import lombok.AllArgsConstructor; +import lombok.Getter; + +public interface QualityItem { + String getName(); + + int getSellIn(); + + int getQuality(); + + /** + * Skeleton class intended for subclassing + */ + abstract class QualityItemSkeleton implements QualityItem { + private final Item item; + + public QualityItemSkeleton(String name, int sellIn, int quality) { + this.item = new Item(name, sellIn, quality); + } + + @Override + public String getName() { + return item.name; + } + + @Override + public String toString() { + return item.toString(); + } + + @Override + public int getQuality() { + return item.quality; + } + + @Override + public int getSellIn() { + return item.sellIn; + } + + @Override + public boolean equals(Object other) { + if (!(other instanceof QualityItem) || other.getClass() != this.getClass()) { + return false; + } + QualityItem qualityItem = (QualityItem) other; + return (this.getName().equals(qualityItem.getName())) && + (this.getQuality() == qualityItem.getQuality()) && + (this.getSellIn() == qualityItem.getSellIn()); + } + + + @Override + public int hashCode() { + int result = getName() == null ? 0 : getName().hashCode(); + result += 31 * result + getQuality(); + result += 31 * result + getSellIn(); + result += 31 * result + this.getClass().getName().hashCode(); + return result; + } + } +} diff --git a/Java/src/main/java/com/gildedrose/itemsorts/Sulfuras.java b/Java/src/main/java/com/gildedrose/itemsorts/Sulfuras.java new file mode 100644 index 00000000..71d4c8ae --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemsorts/Sulfuras.java @@ -0,0 +1,9 @@ +package com.gildedrose.itemsorts; + +import com.gildedrose.itemsorts.QualityItem.QualityItemSkeleton; + +public class Sulfuras extends QualityItemSkeleton implements QualityItem { + public Sulfuras(String name, int sellIn, int quality) { + super(name, sellIn, quality); + } +} diff --git a/Java/src/main/java/com/gildedrose/itemtorequest/ProcessingRequestFromQualityItem.java b/Java/src/main/java/com/gildedrose/itemtorequest/ProcessingRequestFromQualityItem.java new file mode 100644 index 00000000..bab65808 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/itemtorequest/ProcessingRequestFromQualityItem.java @@ -0,0 +1,10 @@ +package com.gildedrose.itemtorequest; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingRequest; +import com.gildedrose.itemsorts.QualityItem; + +public class ProcessingRequestFromQualityItem { + public ProcessingRequest get(T qualityItem) { + return new ProcessingRequest<>(qualityItem.getSellIn(), qualityItem.getQuality()); + } +} diff --git a/Java/src/main/java/com/gildedrose/responsetoitem/AgedBrieFromProcessingResponse.java b/Java/src/main/java/com/gildedrose/responsetoitem/AgedBrieFromProcessingResponse.java new file mode 100644 index 00000000..c030b458 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/responsetoitem/AgedBrieFromProcessingResponse.java @@ -0,0 +1,11 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.AgedBrie; + +public class AgedBrieFromProcessingResponse implements QualityItemFromProcessingResponse { + @Override + public AgedBrie toQualityItem(AgedBrie qualityItemOld, ProcessingResponse processingResponse) { + return new AgedBrie(qualityItemOld.getName(), processingResponse.getSellIn(), processingResponse.getQuality()); + } +} diff --git a/Java/src/main/java/com/gildedrose/responsetoitem/BackstagePassFromProcessingResponse.java b/Java/src/main/java/com/gildedrose/responsetoitem/BackstagePassFromProcessingResponse.java new file mode 100644 index 00000000..06c976c0 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/responsetoitem/BackstagePassFromProcessingResponse.java @@ -0,0 +1,11 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.BackstagePass; + +public class BackstagePassFromProcessingResponse implements QualityItemFromProcessingResponse { + @Override + public BackstagePass toQualityItem(BackstagePass qualityItemOld, ProcessingResponse processingResponse) { + return new BackstagePass(qualityItemOld.getName(), processingResponse.getSellIn(), processingResponse.getQuality()); + } +} diff --git a/Java/src/main/java/com/gildedrose/responsetoitem/ConjuredItemFromProcessingResponse.java b/Java/src/main/java/com/gildedrose/responsetoitem/ConjuredItemFromProcessingResponse.java new file mode 100644 index 00000000..3f2b4192 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/responsetoitem/ConjuredItemFromProcessingResponse.java @@ -0,0 +1,11 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.ConjuredItem; + +public class ConjuredItemFromProcessingResponse implements QualityItemFromProcessingResponse { + @Override + public ConjuredItem toQualityItem(ConjuredItem qualityItemOld, ProcessingResponse processingResponse) { + return new ConjuredItem(qualityItemOld.getName(), processingResponse.getSellIn(), processingResponse.getQuality()); + } +} diff --git a/Java/src/main/java/com/gildedrose/responsetoitem/NormalItemFromProcessingResponse.java b/Java/src/main/java/com/gildedrose/responsetoitem/NormalItemFromProcessingResponse.java new file mode 100644 index 00000000..ea250bba --- /dev/null +++ b/Java/src/main/java/com/gildedrose/responsetoitem/NormalItemFromProcessingResponse.java @@ -0,0 +1,12 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.NormalItem; + + +public class NormalItemFromProcessingResponse implements QualityItemFromProcessingResponse { + @Override + public NormalItem toQualityItem(NormalItem qualityItemOld, ProcessingResponse processingResponse) { + return new NormalItem(qualityItemOld.getName(), processingResponse.getSellIn(), processingResponse.getQuality()); + } +} diff --git a/Java/src/main/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponse.java b/Java/src/main/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponse.java new file mode 100644 index 00000000..4ef35ef7 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponse.java @@ -0,0 +1,8 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.QualityItem; + +public interface QualityItemFromProcessingResponse { + T toQualityItem(T qualityItemOld, ProcessingResponse processingResponse); +} diff --git a/Java/src/main/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponseFactory.java b/Java/src/main/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponseFactory.java new file mode 100644 index 00000000..1f93275e --- /dev/null +++ b/Java/src/main/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponseFactory.java @@ -0,0 +1,44 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemsorts.QualityItem; +import lombok.AllArgsConstructor; +import lombok.Getter; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +public class QualityItemFromProcessingResponseFactory { + static final String EXCEPTION_MESSAGE_TEMPLATE = "QualityItemFromProcessingResponse for the item of type %s is not found. Make sure that the factory" + + "is configured correctly"; + + Map, QualityItemFromProcessingResponse> qualityItemFromProcessingResponseMap = new HashMap<>(); + + public QualityItemFromProcessingResponse get(T qualityItem) { + Class aClass = qualityItem.getClass(); + QualityItemFromProcessingResponse qualityItemProcessor = Optional.ofNullable(qualityItemFromProcessingResponseMap.get(aClass)) + .orElseThrow( + () -> new IllegalArgumentException(String.format(EXCEPTION_MESSAGE_TEMPLATE, aClass))); + @SuppressWarnings("unchecked") + QualityItemFromProcessingResponse qualityItemFromProcessingResponse = + (QualityItemFromProcessingResponse) qualityItemProcessor; + return qualityItemFromProcessingResponse; + } + + + @Getter + @AllArgsConstructor + public static class QualityItemFromProcessingResponseFactoryItem { + private final Class itemType; + private final QualityItemFromProcessingResponse itemProcessor; + } + + public QualityItemFromProcessingResponseFactory(List> qualityItemFromProcessingResponseFactoryItems) { + qualityItemFromProcessingResponseFactoryItems.forEach(qualityItemFromProcessingResponseFactoryItem -> + qualityItemFromProcessingResponseMap.put( + qualityItemFromProcessingResponseFactoryItem.getItemType(), + qualityItemFromProcessingResponseFactoryItem.getItemProcessor()) + ); + } +} diff --git a/Java/src/main/java/com/gildedrose/responsetoitem/SulfurasFromProcessingResponse.java b/Java/src/main/java/com/gildedrose/responsetoitem/SulfurasFromProcessingResponse.java new file mode 100644 index 00000000..12cc5490 --- /dev/null +++ b/Java/src/main/java/com/gildedrose/responsetoitem/SulfurasFromProcessingResponse.java @@ -0,0 +1,11 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.Sulfuras; + +public class SulfurasFromProcessingResponse implements QualityItemFromProcessingResponse { + @Override + public Sulfuras toQualityItem(Sulfuras qualityItemOld, ProcessingResponse processingResponse) { + return new Sulfuras(qualityItemOld.getName(), processingResponse.getSellIn(), processingResponse.getQuality()); + } +} diff --git a/Java/src/test/java/com/gildedrose/GildedRoseTest.java b/Java/src/test/java/com/gildedrose/GildedRoseTest.java index 8ae29eec..6942ddf8 100644 --- a/Java/src/test/java/com/gildedrose/GildedRoseTest.java +++ b/Java/src/test/java/com/gildedrose/GildedRoseTest.java @@ -1,17 +1,94 @@ package com.gildedrose; +import com.gildedrose.itemprocessors.AgedBrieProcessor; +import com.gildedrose.itemprocessors.BackstagePassProcessor; +import com.gildedrose.itemprocessors.ConjuredItemProcessor; +import com.gildedrose.itemprocessors.NormalItemProcessor; +import com.gildedrose.itemprocessors.ProcessorFactory; +import com.gildedrose.itemprocessors.ProcessorFactory.ProcessorFactoryItem; +import com.gildedrose.itemprocessors.SulfurasProcessor; +import com.gildedrose.itemsorts.AgedBrie; +import com.gildedrose.itemsorts.BackstagePass; +import com.gildedrose.itemsorts.ConjuredItem; +import com.gildedrose.itemsorts.NormalItem; +import com.gildedrose.itemsorts.QualityItem; +import com.gildedrose.itemsorts.Sulfuras; +import com.gildedrose.itemtorequest.ProcessingRequestFromQualityItem; +import com.gildedrose.responsetoitem.AgedBrieFromProcessingResponse; +import com.gildedrose.responsetoitem.BackstagePassFromProcessingResponse; +import com.gildedrose.responsetoitem.ConjuredItemFromProcessingResponse; +import com.gildedrose.responsetoitem.NormalItemFromProcessingResponse; +import com.gildedrose.responsetoitem.QualityItemFromProcessingResponseFactory; +import com.gildedrose.responsetoitem.QualityItemFromProcessingResponseFactory.QualityItemFromProcessingResponseFactoryItem; +import com.gildedrose.responsetoitem.SulfurasFromProcessingResponse; import org.junit.jupiter.api.Test; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; class GildedRoseTest { @Test void foo() { - Item[] items = new Item[] { new Item("foo", 0, 0) }; - GildedRose app = new GildedRose(items); + List items = new ArrayList<>(); + items.add(new NormalItem("foo", 0, 0)); + + List> processorFactoryItems = Arrays.asList( + new ProcessorFactoryItem<>(NormalItem.class, new NormalItemProcessor()), + new ProcessorFactoryItem<>(AgedBrie.class, new AgedBrieProcessor()), + new ProcessorFactoryItem<>(Sulfuras.class, new SulfurasProcessor()), + new ProcessorFactoryItem<>(BackstagePass.class, new BackstagePassProcessor()), + new ProcessorFactoryItem<>(ConjuredItem.class, new ConjuredItemProcessor())); + ProcessorFactory processorFactory = new ProcessorFactory(processorFactoryItems); + + List> qualityItemFromProcessingResponseFactoryItems = Arrays.asList( + new QualityItemFromProcessingResponseFactoryItem<>(NormalItem.class, new NormalItemFromProcessingResponse()), + new QualityItemFromProcessingResponseFactoryItem<>(AgedBrie.class, new AgedBrieFromProcessingResponse()), + new QualityItemFromProcessingResponseFactoryItem<>(Sulfuras.class, new SulfurasFromProcessingResponse()), + new QualityItemFromProcessingResponseFactoryItem<>(BackstagePass.class, new BackstagePassFromProcessingResponse()), + new QualityItemFromProcessingResponseFactoryItem<>(ConjuredItem.class, new ConjuredItemFromProcessingResponse())); + QualityItemFromProcessingResponseFactory qualityItemFromProcessingResponseFactory = + new QualityItemFromProcessingResponseFactory(qualityItemFromProcessingResponseFactoryItems); + + ProcessingRequestFromQualityItem processingRequestFromQualityItem = new ProcessingRequestFromQualityItem(); + + QualityItemHandler qualityItemHandler = new QualityItemHandler(processorFactory, processingRequestFromQualityItem, + qualityItemFromProcessingResponseFactory); + + GildedRose app = new GildedRose(items, qualityItemHandler); app.updateQuality(); - assertEquals("fixme", app.items[0].name); + assertEquals("foo", app.getItems().get(0).getName()); } + /** + * Check that {@link GildedRose#updateQuality()} will call {@link QualityItemHandler#processOneItem(QualityItem)} + * for every element in the GildedRose + */ + @Test + void updateQualityTest() { + List calledForItems = new ArrayList<>(); + List inputItems = new ArrayList<>(); + NormalItem expectedItem1 = new NormalItem("name1", 1, 2); + NormalItem expectedItem2 = new NormalItem("name2", 1, 2); + inputItems.add(expectedItem1); + inputItems.add(expectedItem2); + + QualityItemHandler qualityItemHandler = new QualityItemHandler(null, null, null) { + @Override + QualityItem processOneItem(QualityItem qualityItem) { + calledForItems.add(qualityItem); + return qualityItem; + } + }; + GildedRose gildedRose = new GildedRose(inputItems, qualityItemHandler); + + gildedRose.updateQuality(); + assertTrue(calledForItems.containsAll(inputItems)); + calledForItems.removeAll(inputItems); + assertTrue(calledForItems.isEmpty()); + } } diff --git a/Java/src/test/java/com/gildedrose/QualityItemHandlerTest.java b/Java/src/test/java/com/gildedrose/QualityItemHandlerTest.java new file mode 100644 index 00000000..526f5a3e --- /dev/null +++ b/Java/src/test/java/com/gildedrose/QualityItemHandlerTest.java @@ -0,0 +1,55 @@ +package com.gildedrose; + +import com.gildedrose.responsetoitem.QualityItemFromProcessingResponse; +import com.gildedrose.responsetoitem.QualityItemFromProcessingResponseFactory; +import com.gildedrose.itemprocessors.ProcessorFactory; +import com.gildedrose.itemprocessors.QualityItemProcessor; +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingRequest; +import com.gildedrose.itemtorequest.ProcessingRequestFromQualityItem; +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.NormalItem; +import com.gildedrose.itemsorts.QualityItem; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class QualityItemHandlerTest { + + /** + * Tests the chain of calls in the {@link QualityItemHandler#processOneItem(QualityItem)} method. + */ + @Test + void updateQualityForOneItemTest() { + ProcessorFactory processorFactoryMock = Mockito.mock(ProcessorFactory.class); + ProcessingRequestFromQualityItem processingRequestFromQualityItemMock = Mockito.mock(ProcessingRequestFromQualityItem.class); + QualityItemFromProcessingResponseFactory qualityItemFromProcessingResponseFactoryMock = Mockito.mock(QualityItemFromProcessingResponseFactory.class); + + + QualityItemHandler qualityItemHandler = new QualityItemHandler(processorFactoryMock, processingRequestFromQualityItemMock, qualityItemFromProcessingResponseFactoryMock); + QualityItem qualityItem = new NormalItem("name", 1, 1); + QualityItem qualityItemResult = new NormalItem("result", 1, 1); + + ProcessingRequest expectedProcessingRequest = new ProcessingRequest<>(1, 2); + Mockito.when(processingRequestFromQualityItemMock.get(qualityItem)).thenReturn(expectedProcessingRequest); + + @SuppressWarnings("unchecked") + QualityItemProcessor itemProcessorMock = (QualityItemProcessor) Mockito.mock(QualityItemProcessor.class); + Mockito.when(processorFactoryMock.get(qualityItem)).thenReturn(itemProcessorMock); + + + ProcessingResponse expectedProcessingResponse = new ProcessingResponse<>(1, 2); + Mockito.when(itemProcessorMock.processItem(expectedProcessingRequest)).thenReturn(expectedProcessingResponse); + + + @SuppressWarnings("unchecked") + QualityItemFromProcessingResponse qualityItemQualityItemFromProcessingResponse = + (QualityItemFromProcessingResponse) Mockito.mock(QualityItemFromProcessingResponse.class); + Mockito.when(qualityItemFromProcessingResponseFactoryMock.get(qualityItem)).thenReturn(qualityItemQualityItemFromProcessingResponse); + + Mockito.when(qualityItemQualityItemFromProcessingResponse.toQualityItem(qualityItem, expectedProcessingResponse)) + .thenReturn(qualityItemResult); + + assertEquals(qualityItemResult, qualityItemHandler.processOneItem(qualityItem)); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/TexttestFixture.java b/Java/src/test/java/com/gildedrose/TexttestFixture.java index d059c88f..6ca1d5ec 100644 --- a/Java/src/test/java/com/gildedrose/TexttestFixture.java +++ b/Java/src/test/java/com/gildedrose/TexttestFixture.java @@ -1,22 +1,70 @@ package com.gildedrose; +import com.gildedrose.responsetoitem.AgedBrieFromProcessingResponse; +import com.gildedrose.responsetoitem.BackstagePassFromProcessingResponse; +import com.gildedrose.responsetoitem.ConjuredItemFromProcessingResponse; +import com.gildedrose.responsetoitem.NormalItemFromProcessingResponse; +import com.gildedrose.responsetoitem.QualityItemFromProcessingResponseFactory; +import com.gildedrose.responsetoitem.QualityItemFromProcessingResponseFactory.QualityItemFromProcessingResponseFactoryItem; +import com.gildedrose.responsetoitem.SulfurasFromProcessingResponse; +import com.gildedrose.itemprocessors.AgedBrieProcessor; +import com.gildedrose.itemprocessors.BackstagePassProcessor; +import com.gildedrose.itemprocessors.ConjuredItemProcessor; +import com.gildedrose.itemprocessors.NormalItemProcessor; +import com.gildedrose.itemprocessors.ProcessorFactory; +import com.gildedrose.itemprocessors.ProcessorFactory.ProcessorFactoryItem; +import com.gildedrose.itemtorequest.ProcessingRequestFromQualityItem; +import com.gildedrose.itemprocessors.SulfurasProcessor; +import com.gildedrose.itemsorts.AgedBrie; +import com.gildedrose.itemsorts.BackstagePass; +import com.gildedrose.itemsorts.ConjuredItem; +import com.gildedrose.itemsorts.NormalItem; +import com.gildedrose.itemsorts.QualityItem; +import com.gildedrose.itemsorts.Sulfuras; + +import java.util.Arrays; +import java.util.List; + public class TexttestFixture { public static void main(String[] args) { System.out.println("OMGHAI!"); - Item[] items = new Item[] { - new Item("+5 Dexterity Vest", 10, 20), // - new Item("Aged Brie", 2, 0), // - new Item("Elixir of the Mongoose", 5, 7), // - new Item("Sulfuras, Hand of Ragnaros", 0, 80), // - new Item("Sulfuras, Hand of Ragnaros", -1, 80), - new Item("Backstage passes to a TAFKAL80ETC concert", 15, 20), - new Item("Backstage passes to a TAFKAL80ETC concert", 10, 49), - new Item("Backstage passes to a TAFKAL80ETC concert", 5, 49), + List items = Arrays.asList( + new NormalItem("+5 Dexterity Vest", 10, 20), // + new AgedBrie("Aged Brie", 2, 0), // + new NormalItem("Elixir of the Mongoose", 5, 7), // + new Sulfuras("Sulfuras, Hand of Ragnaros", 0, 80), // + new Sulfuras("Sulfuras, Hand of Ragnaros", -1, 80), + new BackstagePass("Backstage passes to a TAFKAL80ETC concert", 15, 20), + new BackstagePass("Backstage passes to a TAFKAL80ETC concert", 10, 49), + new BackstagePass("Backstage passes to a TAFKAL80ETC concert", 5, 49), // this conjured item does not work properly yet - new Item("Conjured Mana Cake", 3, 6) }; + new ConjuredItem("Conjured Mana Cake", 3, 6) + ); - GildedRose app = new GildedRose(items); + List> processorFactoryItems = Arrays.asList( + new ProcessorFactoryItem<>(NormalItem.class, new NormalItemProcessor()), + new ProcessorFactoryItem<>(AgedBrie.class, new AgedBrieProcessor()), + new ProcessorFactoryItem<>(Sulfuras.class, new SulfurasProcessor()), + new ProcessorFactoryItem<>(BackstagePass.class, new BackstagePassProcessor()), + new ProcessorFactoryItem<>(ConjuredItem.class, new ConjuredItemProcessor())); + ProcessorFactory processorFactory = new ProcessorFactory(processorFactoryItems); + + List> qualityItemFromProcessingResponseFactoryItems = Arrays.asList( + new QualityItemFromProcessingResponseFactoryItem<>(NormalItem.class, new NormalItemFromProcessingResponse()), + new QualityItemFromProcessingResponseFactoryItem<>(AgedBrie.class, new AgedBrieFromProcessingResponse()), + new QualityItemFromProcessingResponseFactoryItem<>(Sulfuras.class, new SulfurasFromProcessingResponse()), + new QualityItemFromProcessingResponseFactoryItem<>(BackstagePass.class, new BackstagePassFromProcessingResponse()), + new QualityItemFromProcessingResponseFactoryItem<>(ConjuredItem.class, new ConjuredItemFromProcessingResponse())); + QualityItemFromProcessingResponseFactory qualityItemFromProcessingResponseFactory = + new QualityItemFromProcessingResponseFactory(qualityItemFromProcessingResponseFactoryItems); + + ProcessingRequestFromQualityItem processingRequestFromQualityItem = new ProcessingRequestFromQualityItem(); + + QualityItemHandler qualityItemHandler = new QualityItemHandler(processorFactory, processingRequestFromQualityItem, + qualityItemFromProcessingResponseFactory); + + GildedRose app = new GildedRose(items, qualityItemHandler); int days = 2; if (args.length > 0) { @@ -26,7 +74,7 @@ public class TexttestFixture { for (int i = 0; i < days; i++) { System.out.println("-------- day " + i + " --------"); System.out.println("name, sellIn, quality"); - for (Item item : items) { + for (QualityItem item : items) { System.out.println(item); } System.out.println(); diff --git a/Java/src/test/java/com/gildedrose/itemprocessors/AgedBrieProcessorTest.java b/Java/src/test/java/com/gildedrose/itemprocessors/AgedBrieProcessorTest.java new file mode 100644 index 00000000..db7240dc --- /dev/null +++ b/Java/src/test/java/com/gildedrose/itemprocessors/AgedBrieProcessorTest.java @@ -0,0 +1,15 @@ +package com.gildedrose.itemprocessors; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class AgedBrieProcessorTest { + @Test + public void test(){ + AgedBrieProcessor agedBrieProcessor = new AgedBrieProcessor(); + int oldQuality = 3; + int qualityChange = 4; + assertEquals(oldQuality + qualityChange, agedBrieProcessor.qualityFunction(oldQuality, qualityChange)); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/itemprocessors/BackstagePassProcessorTest.java b/Java/src/test/java/com/gildedrose/itemprocessors/BackstagePassProcessorTest.java new file mode 100644 index 00000000..59dc7833 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/itemprocessors/BackstagePassProcessorTest.java @@ -0,0 +1,38 @@ +package com.gildedrose.itemprocessors; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.stream.Stream; + +import static com.gildedrose.itemprocessors.BackstagePassProcessor.FIVE_DAYS_BEFORE_CONCERT; +import static com.gildedrose.itemprocessors.BackstagePassProcessor.TEN_DAYS_BEFORE_CONCERT; +import static org.junit.jupiter.api.Assertions.assertEquals; + +class BackstagePassProcessorTest { + @Test + public void test() { + BackstagePassProcessor backstagePassProcessor = new BackstagePassProcessor(); + int oldQuality = 33; + int newQuality = 88; + assertEquals(oldQuality + newQuality, backstagePassProcessor.qualityFunction(oldQuality, newQuality)); + } + + @SuppressWarnings("unused") + public static Stream calculateQualityChangeValues() { + return Stream.of( + Arguments.of(-1, 77, -77) , + Arguments.of(FIVE_DAYS_BEFORE_CONCERT - 1, 77, 3), + Arguments.of(TEN_DAYS_BEFORE_CONCERT - 1, 77, 2), + Arguments.of(TEN_DAYS_BEFORE_CONCERT, 77, 1) + ); + } + @MethodSource("calculateQualityChangeValues") + @ParameterizedTest + public void calculateQualityChangeTest(int sellIn, int oldQuality, int expectedQualityChange) { + BackstagePassProcessor backstagePassProcessor = new BackstagePassProcessor(); + assertEquals(expectedQualityChange, backstagePassProcessor.calculateQualityChange(sellIn, oldQuality)); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/itemprocessors/ConjuredItemProcessorTest.java b/Java/src/test/java/com/gildedrose/itemprocessors/ConjuredItemProcessorTest.java new file mode 100644 index 00000000..eb9968b8 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/itemprocessors/ConjuredItemProcessorTest.java @@ -0,0 +1,17 @@ +package com.gildedrose.itemprocessors; + +import org.junit.jupiter.api.Test; + +import static com.gildedrose.itemprocessors.ConjuredItemProcessor.CONJURED_ITEM_QUALITY_CHANGE_MULTIPLIER; +import static org.junit.jupiter.api.Assertions.assertEquals; + +class ConjuredItemProcessorTest { + + @Test + void calculateQualityChange() { + ConjuredItemProcessor conjuredItemProcessor = new ConjuredItemProcessor(); + int qualityChange = 77; + assertEquals(qualityChange * CONJURED_ITEM_QUALITY_CHANGE_MULTIPLIER, + conjuredItemProcessor.applyQualityChangeMultiplier(qualityChange)); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/itemprocessors/ProcessorFactoryTest.java b/Java/src/test/java/com/gildedrose/itemprocessors/ProcessorFactoryTest.java new file mode 100644 index 00000000..cf0e92fe --- /dev/null +++ b/Java/src/test/java/com/gildedrose/itemprocessors/ProcessorFactoryTest.java @@ -0,0 +1,39 @@ +package com.gildedrose.itemprocessors; + +import com.gildedrose.itemprocessors.ProcessorFactory.ProcessorFactoryItem; +import com.gildedrose.itemsorts.NormalItem; +import com.gildedrose.itemsorts.QualityItem; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + + +import java.util.Collections; + +import static com.gildedrose.itemprocessors.ProcessorFactory.EXCEPTION_MESSAGE_TEMPLATE; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class ProcessorFactoryTest { + + @Test + public void testFactoryCannotHandleItem() { + ProcessorFactory processorFactory = new ProcessorFactory(Collections.emptyList()); + QualityItem itemThatCannotBeProcessed = Mockito.mock(QualityItem.class); + boolean exceptionWasThrown = false; + try { + processorFactory.get(itemThatCannotBeProcessed); + } catch (IllegalArgumentException e) { + exceptionWasThrown = true; + assertEquals(String.format(EXCEPTION_MESSAGE_TEMPLATE, itemThatCannotBeProcessed.getClass()), e.getMessage()); + } + assertTrue(exceptionWasThrown); + } + + @Test + public void testFactoryCanHandleItem() { + QualityItemProcessor normalItemProcessor = new NormalItemProcessor(); + NormalItem normalItem = new NormalItem("name", 1, 2); + ProcessorFactory processorFactory = new ProcessorFactory(Collections.singletonList(new ProcessorFactoryItem<>(NormalItem.class, normalItemProcessor))); + assertEquals(normalItemProcessor, processorFactory.get(normalItem)); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/itemprocessors/QualityItemProcessorTest.java b/Java/src/test/java/com/gildedrose/itemprocessors/QualityItemProcessorTest.java new file mode 100644 index 00000000..4c4fd37d --- /dev/null +++ b/Java/src/test/java/com/gildedrose/itemprocessors/QualityItemProcessorTest.java @@ -0,0 +1,142 @@ +package com.gildedrose.itemprocessors; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingRequest; +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemprocessors.QualityItemProcessor.QualityItemProcessorSkeleton; +import com.gildedrose.itemsorts.NormalItem; +import com.gildedrose.itemsorts.QualityItem; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.stream.Stream; + +import static com.gildedrose.itemprocessors.QualityItemProcessor.QualityItemProcessorSkeleton.MAX_QUALITY; +import static com.gildedrose.itemprocessors.QualityItemProcessor.QualityItemProcessorSkeleton.MIN_QUALITY; +import static com.gildedrose.itemprocessors.QualityItemProcessor.QualityItemProcessorSkeleton.QUALITY_CHANGE_AFTER_SELL_DATE; +import static com.gildedrose.itemprocessors.QualityItemProcessor.QualityItemProcessorSkeleton.QUALITY_CHANGE_BEFORE_SELL_DATE; +import static org.junit.jupiter.api.Assertions.assertEquals; + +class QualityItemProcessorTest { + + + @Test + public void testCalculateItem() { + final int oldQualityExpected = 3; + final int oldSellInExpected = 27; + final int newSellInExpected = 509; + final int newQualityExpected = 99; + NormalItem testItem = new NormalItem("test item", oldSellInExpected, oldQualityExpected); + + ProcessingRequest qualityItemProcessingRequest = new ProcessingRequest<>(testItem.getSellIn(), testItem.getQuality()); + ProcessingResponse qualityItemProcessingResponse = new ProcessingResponse<>(newSellInExpected, newQualityExpected); + + QualityItemProcessorSkeleton qualityItemProcessorSkeleton = new QualityItemProcessorSkeleton() { + @Override + int calculateNewSellIn(int oldSellIn) { + assertEquals(oldSellInExpected, oldSellIn); + return newSellInExpected; + } + + @Override + int calculateNewQuality(int newSellIn, int oldQuality) { + assertEquals(oldQualityExpected, oldQuality); + assertEquals(newSellInExpected, newSellIn); + return newQualityExpected; + } + }; + assertEquals(qualityItemProcessingResponse, qualityItemProcessorSkeleton.processItem(qualityItemProcessingRequest)); + } + + @Test + public void calculateNewSellInTest() { + QualityItemProcessorSkeleton qualityItemProcessorSkeleton = new QualityItemProcessorSkeleton() { + }; + int oldSellIn = 1; + assertEquals(0, qualityItemProcessorSkeleton.calculateNewSellIn(oldSellIn)); + } + + @Test + public void calculateNewQuality() { + int oldQualityExpected = 3; + int newSellInExpected = 4; + int qualityChangeExpected = 77; + int resultOfQualityFunctionExpected = 300; + int qualityLimitsCheckExpected = 777; + int qualityChangeAfterQualityChangeMultiplierWasApplied = 389; + QualityItemProcessorSkeleton qualityItemProcessorSkeleton = new QualityItemProcessorSkeleton() { + @Override + int calculateQualityChange(int sellIn, int oldQuality) { + assertEquals(oldQualityExpected, oldQuality); + assertEquals(newSellInExpected, sellIn); + return qualityChangeExpected; + } + + @Override + int applyQualityChangeMultiplier(int qualityChange) { + assertEquals(qualityChangeExpected, qualityChange); + return qualityChangeAfterQualityChangeMultiplierWasApplied; + } + + @Override + int qualityFunction(int oldQuality, int qualityChange) { + assertEquals(oldQualityExpected, oldQuality); + assertEquals(qualityChangeAfterQualityChangeMultiplierWasApplied, qualityChange); + return resultOfQualityFunctionExpected; + } + + + @Override + int qualityLimitsCheck(int quality) { + assertEquals(resultOfQualityFunctionExpected, quality); + return qualityLimitsCheckExpected; + } + }; + + assertEquals(qualityLimitsCheckExpected, qualityItemProcessorSkeleton.calculateNewQuality(newSellInExpected, oldQualityExpected)); + } + + @SuppressWarnings("unused") + public static Stream qualityChangeTestValues() { + return Stream.of( + Arguments.of(-1, QUALITY_CHANGE_AFTER_SELL_DATE), + Arguments.of(0, QUALITY_CHANGE_BEFORE_SELL_DATE) + ); + } + + @MethodSource("qualityChangeTestValues") + @ParameterizedTest + public void calculateQualityChangeTest(int sellIn, int expectedChange) { + int oldQuality = 333; + QualityItemProcessorSkeleton qualityItemProcessorSkeleton = new QualityItemProcessorSkeleton() {}; + assertEquals(expectedChange, qualityItemProcessorSkeleton.calculateQualityChange(sellIn, oldQuality)); + } + + @Test + void testQualityFunctionTest() { + int oldQuality = 333; + int qualityChange = 77; + QualityItemProcessorSkeleton qualityItemProcessorSkeleton = new QualityItemProcessorSkeleton() {}; + assertEquals(oldQuality - qualityChange, qualityItemProcessorSkeleton.qualityFunction(oldQuality, qualityChange)); + } + + @SuppressWarnings("unused") + public static Stream qualityLimitCheckValues() { + int between_max_and_min = (MAX_QUALITY + MIN_QUALITY) / 2; + return Stream.of( + Arguments.of(MAX_QUALITY + 1, MAX_QUALITY), + Arguments.of(MIN_QUALITY - 1, MIN_QUALITY), + Arguments.of(between_max_and_min, between_max_and_min) + ); + } + + @MethodSource("qualityLimitCheckValues") + @ParameterizedTest + void qualityLimitsCheckTest(int quality, int resultingQuality) { + QualityItemProcessorSkeleton qualityItemProcessorSkeleton = new QualityItemProcessorSkeleton() {}; + assertEquals(resultingQuality, qualityItemProcessorSkeleton.qualityLimitsCheck(quality)); + } + + +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/itemprocessors/SulfurasProcessorTest.java b/Java/src/test/java/com/gildedrose/itemprocessors/SulfurasProcessorTest.java new file mode 100644 index 00000000..821c0e29 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/itemprocessors/SulfurasProcessorTest.java @@ -0,0 +1,19 @@ +package com.gildedrose.itemprocessors; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingRequest; +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.Sulfuras; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class SulfurasProcessorTest { + @Test + void processItem() { + SulfurasProcessor sulfurasProcessor = new SulfurasProcessor(); + ProcessingRequest sulfurasProcessingRequest = new ProcessingRequest<>(3, 4); + ProcessingResponse sulfurasProcessingResponse = sulfurasProcessor.processItem(sulfurasProcessingRequest); + assertEquals(sulfurasProcessingRequest.getSellIn(), sulfurasProcessingResponse.getSellIn()); + assertEquals(sulfurasProcessingRequest.getQuality(), sulfurasProcessingResponse.getQuality()); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/itemtorequest/ProcessingRequestFromQualityItemTest.java b/Java/src/test/java/com/gildedrose/itemtorequest/ProcessingRequestFromQualityItemTest.java new file mode 100644 index 00000000..90e2c8c7 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/itemtorequest/ProcessingRequestFromQualityItemTest.java @@ -0,0 +1,19 @@ +package com.gildedrose.itemtorequest; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingRequest; +import com.gildedrose.itemsorts.NormalItem; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class ProcessingRequestFromQualityItemTest { + @Test + void get() { + ProcessingRequestFromQualityItem processingRequestFromQualityItem = new ProcessingRequestFromQualityItem(); + int sellIn = 99; + int quality = 938; + NormalItem normalItem = new NormalItem("name", sellIn, quality); + ProcessingRequest expectedProcessingRequest = new ProcessingRequest<>(sellIn, quality); + assertEquals(expectedProcessingRequest, processingRequestFromQualityItem.get(normalItem)); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/responsetoitem/AgedBrieFromProcessingResponseTest.java b/Java/src/test/java/com/gildedrose/responsetoitem/AgedBrieFromProcessingResponseTest.java new file mode 100644 index 00000000..12335567 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/responsetoitem/AgedBrieFromProcessingResponseTest.java @@ -0,0 +1,21 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.AgedBrie; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class AgedBrieFromProcessingResponseTest { + + @Test + void toQualityItem() { + AgedBrieFromProcessingResponse agedBrieFromProcessingResponse = new AgedBrieFromProcessingResponse(); + AgedBrie oldItem = new AgedBrie("name", 1, 2); + ProcessingResponse processingResponse = new ProcessingResponse<>(7, 8); + AgedBrie newItem = agedBrieFromProcessingResponse.toQualityItem(oldItem, processingResponse); + assertEquals(oldItem.getName(), newItem.getName()); + assertEquals(processingResponse.getSellIn(), newItem.getSellIn()); + assertEquals(processingResponse.getQuality(), newItem.getQuality()); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/responsetoitem/BackstagePassFromProcessingResponseTest.java b/Java/src/test/java/com/gildedrose/responsetoitem/BackstagePassFromProcessingResponseTest.java new file mode 100644 index 00000000..8d82b1dd --- /dev/null +++ b/Java/src/test/java/com/gildedrose/responsetoitem/BackstagePassFromProcessingResponseTest.java @@ -0,0 +1,21 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.BackstagePass; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class BackstagePassFromProcessingResponseTest { + + @Test + void toQualityItem() { + BackstagePassFromProcessingResponse qualityItemFromProcessingResponse = new BackstagePassFromProcessingResponse(); + BackstagePass oldItem = new BackstagePass("name", 1, 2); + ProcessingResponse processingResponse = new ProcessingResponse<>(7, 8); + BackstagePass newItem = qualityItemFromProcessingResponse.toQualityItem(oldItem, processingResponse); + assertEquals(oldItem.getName(), newItem.getName()); + assertEquals(processingResponse.getSellIn(), newItem.getSellIn()); + assertEquals(processingResponse.getQuality(), newItem.getQuality()); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/responsetoitem/ConjuredItemFromProcessingResponseTest.java b/Java/src/test/java/com/gildedrose/responsetoitem/ConjuredItemFromProcessingResponseTest.java new file mode 100644 index 00000000..3c8a79c6 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/responsetoitem/ConjuredItemFromProcessingResponseTest.java @@ -0,0 +1,21 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.ConjuredItem; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class ConjuredItemFromProcessingResponseTest { + + @Test + void toQualityItem() { + ConjuredItemFromProcessingResponse qualityItemFromProcessingResponse = new ConjuredItemFromProcessingResponse(); + ConjuredItem oldItem = new ConjuredItem("name", 1, 2); + ProcessingResponse processingResponse = new ProcessingResponse<>(7, 8); + ConjuredItem newItem = qualityItemFromProcessingResponse.toQualityItem(oldItem, processingResponse); + assertEquals(oldItem.getName(), newItem.getName()); + assertEquals(processingResponse.getSellIn(), newItem.getSellIn()); + assertEquals(processingResponse.getQuality(), newItem.getQuality()); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/responsetoitem/NormalItemFromProcessingResponseTest.java b/Java/src/test/java/com/gildedrose/responsetoitem/NormalItemFromProcessingResponseTest.java new file mode 100644 index 00000000..a2aa271e --- /dev/null +++ b/Java/src/test/java/com/gildedrose/responsetoitem/NormalItemFromProcessingResponseTest.java @@ -0,0 +1,21 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.NormalItem; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class NormalItemFromProcessingResponseTest { + + @Test + void toQualityItem() { + NormalItemFromProcessingResponse qualityItemFromProcessingResponse = new NormalItemFromProcessingResponse(); + NormalItem oldItem = new NormalItem("name", 1, 2); + ProcessingResponse processingResponse = new ProcessingResponse<>(7, 8); + NormalItem newItem = qualityItemFromProcessingResponse.toQualityItem(oldItem, processingResponse); + assertEquals(oldItem.getName(), newItem.getName()); + assertEquals(processingResponse.getSellIn(), newItem.getSellIn()); + assertEquals(processingResponse.getQuality(), newItem.getQuality()); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponseFactoryTest.java b/Java/src/test/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponseFactoryTest.java new file mode 100644 index 00000000..b9ef3a25 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/responsetoitem/QualityItemFromProcessingResponseFactoryTest.java @@ -0,0 +1,40 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.responsetoitem.QualityItemFromProcessingResponseFactory.QualityItemFromProcessingResponseFactoryItem; +import com.gildedrose.itemsorts.NormalItem; +import com.gildedrose.itemsorts.QualityItem; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; + +import java.util.Collections; + +import static com.gildedrose.responsetoitem.QualityItemFromProcessingResponseFactory.EXCEPTION_MESSAGE_TEMPLATE; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class QualityItemFromProcessingResponseFactoryTest { + @Test + public void testFactoryCannotHandleAnItem() { + QualityItemFromProcessingResponseFactory factory = new QualityItemFromProcessingResponseFactory(Collections.emptyList()); + QualityItem itemThatCannotBeProcessed = Mockito.mock(QualityItem.class); + boolean exceptionWasThrown = false; + try { + factory.get(itemThatCannotBeProcessed); + } catch (IllegalArgumentException e) { + exceptionWasThrown = true; + assertEquals(String.format(EXCEPTION_MESSAGE_TEMPLATE, itemThatCannotBeProcessed.getClass()), e.getMessage()); + } + assertTrue(exceptionWasThrown); + } + + @Test + public void testFactoryCanHandleAnItem() { + QualityItemFromProcessingResponse normalItemProcessor = new NormalItemFromProcessingResponse(); + NormalItem normalItem = new NormalItem("name", 1, 2); + QualityItemFromProcessingResponseFactory qualityItemFromProcessingResponseFactory = + new QualityItemFromProcessingResponseFactory(Collections.singletonList( + new QualityItemFromProcessingResponseFactoryItem<>(NormalItem.class, normalItemProcessor) + )); + assertEquals(normalItemProcessor, qualityItemFromProcessingResponseFactory.get(normalItem)); + } +} \ No newline at end of file diff --git a/Java/src/test/java/com/gildedrose/responsetoitem/SulfurasFromProcessingResponseTest.java b/Java/src/test/java/com/gildedrose/responsetoitem/SulfurasFromProcessingResponseTest.java new file mode 100644 index 00000000..de1d2488 --- /dev/null +++ b/Java/src/test/java/com/gildedrose/responsetoitem/SulfurasFromProcessingResponseTest.java @@ -0,0 +1,21 @@ +package com.gildedrose.responsetoitem; + +import com.gildedrose.itemprocessors.QualityItemProcessor.ProcessingResponse; +import com.gildedrose.itemsorts.Sulfuras; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +class SulfurasFromProcessingResponseTest { + + @Test + void toQualityItem() { + SulfurasFromProcessingResponse qualityItemFromProcessingResponse = new SulfurasFromProcessingResponse(); + Sulfuras oldItem = new Sulfuras("name", 1, 2); + ProcessingResponse processingResponse = new ProcessingResponse<>(7, 8); + Sulfuras newItem = qualityItemFromProcessingResponse.toQualityItem(oldItem, processingResponse); + assertEquals(oldItem.getName(), newItem.getName()); + assertEquals(processingResponse.getSellIn(), newItem.getSellIn()); + assertEquals(processingResponse.getQuality(), newItem.getQuality()); + } +} \ No newline at end of file diff --git a/texttests/ThirtyDays/stdout.gr b/texttests/ThirtyDays/stdout.gr index a04e48ac..4e7237ff 100644 --- a/texttests/ThirtyDays/stdout.gr +++ b/texttests/ThirtyDays/stdout.gr @@ -21,7 +21,7 @@ Sulfuras, Hand of Ragnaros, -1, 80 Backstage passes to a TAFKAL80ETC concert, 14, 21 Backstage passes to a TAFKAL80ETC concert, 9, 50 Backstage passes to a TAFKAL80ETC concert, 4, 50 -Conjured Mana Cake, 2, 5 +Conjured Mana Cake, 2, 4 -------- day 2 -------- name, sellIn, quality @@ -33,7 +33,7 @@ Sulfuras, Hand of Ragnaros, -1, 80 Backstage passes to a TAFKAL80ETC concert, 13, 22 Backstage passes to a TAFKAL80ETC concert, 8, 50 Backstage passes to a TAFKAL80ETC concert, 3, 50 -Conjured Mana Cake, 1, 4 +Conjured Mana Cake, 1, 2 -------- day 3 -------- name, sellIn, quality @@ -45,7 +45,7 @@ Sulfuras, Hand of Ragnaros, -1, 80 Backstage passes to a TAFKAL80ETC concert, 12, 23 Backstage passes to a TAFKAL80ETC concert, 7, 50 Backstage passes to a TAFKAL80ETC concert, 2, 50 -Conjured Mana Cake, 0, 3 +Conjured Mana Cake, 0, 0 -------- day 4 -------- name, sellIn, quality @@ -57,7 +57,7 @@ Sulfuras, Hand of Ragnaros, -1, 80 Backstage passes to a TAFKAL80ETC concert, 11, 24 Backstage passes to a TAFKAL80ETC concert, 6, 50 Backstage passes to a TAFKAL80ETC concert, 1, 50 -Conjured Mana Cake, -1, 1 +Conjured Mana Cake, -1, 0 -------- day 5 -------- name, sellIn, quality diff --git a/texttests/config.gr b/texttests/config.gr index 7183e174..6d31c3cb 100755 --- a/texttests/config.gr +++ b/texttests/config.gr @@ -1,4 +1,5 @@ full_name:Gilded Rose Refactoring Kata +home_operating_system:posix # set your preferred editor and diff tool. view_program:subl @@ -12,8 +13,8 @@ diff_program:meld #executable:${TEXTTEST_HOME}/cpp/cmake-build-debug/test/cpp_texttest/GildedRoseTextTests # Settings for the Java version -#executable:com.gildedrose.TexttestFixture -#interpreter:java +executable:com.gildedrose.TexttestFixture +interpreter:java # note you'll also need to update the file environment.gr with your classpath if you keep your classfiles somewhere unusual # Settings for the Ruby version