public void QualityShouldDecreaseDoubleWhenSellByDatePast(int daysPast, int expectedResult)
        {
            FreshItem freshItem = new FreshItem("", 1, 50);

            freshItem.DaysPast(daysPast);
            Assert.AreEqual(expectedResult, freshItem.GetQuality());
        }
        public void QualityShouldDecreaseByOneperDay()
        {
            FreshItem freshItem = new FreshItem("", 10, 50);

            freshItem.DaysPast(2);
            Assert.AreEqual(46, freshItem.GetQuality());
        }
        public void QualityShouldBeNotGoBelowMinQuality()
        {
            FreshItem freshItem = new FreshItem("", 5, 5);

            freshItem.DaysPast(9);
            Assert.AreEqual(0, freshItem.GetQuality());
        }
        public void QualityShouldBeAtMaxQualityIfResultIsGreaterThanMaxQuality()
        {
            FreshItem freshItem = new FreshItem("", -1, 60);

            freshItem.DaysPast(1);
            Assert.AreEqual(50, freshItem.GetQuality());
        }
        public void QualityShouldNotGoBelowZero()
        {
            FreshItem freshItem = new FreshItem("", 10, 5);

            freshItem.DaysPast(6);
            Assert.AreEqual(0, freshItem.GetQuality());
        }
        public void SellInShouldDecreaseByOneperDay()
        {
            FreshItem freshItem = new FreshItem("", 10, 50);

            freshItem.DaysPast(2);
            Assert.AreEqual(8, freshItem.GetSellIn());
        }
        public void TestInputFromTechTest2()
        {
            FreshItem freshItem = new FreshItem("", -1, 5);

            freshItem.DaysPast(1);
            Assert.AreEqual(1, freshItem.GetQuality());
            Assert.AreEqual(-2, freshItem.GetSellIn());
        }
        public void UpdateQuality_Negative_ReturnsZero()
        {
            Item item = new FreshItem();

            item.Quality = 0;
            item.UpdateQuality();
            Assert.AreEqual(0, item.Quality);
        }
        public void UpdateSellIn_Fresh_ReduceBy1()
        {
            Item item = new FreshItem();

            item.SellIn = 1;
            item.UpdateSellIn();
            Assert.AreEqual(0, item.SellIn);
        }
Esempio n. 10
0
        public void UpdateName_Fresh_SameValue()
        {
            Item item = new FreshItem {
                Name = "a"
            };

            item.UpdateName();
            Assert.AreEqual("a", item.Name);
        }
Esempio n. 11
0
        public void UpdateQuality_FreshInDate_ReduceBy2()
        {
            Item item = new FreshItem();

            item.SellIn  = 0;
            item.Quality = 2;
            item.UpdateQuality();
            Assert.AreEqual(0, item.Quality);
        }
Esempio n. 12
0
        public void UpdateQuality_FreshNotInDate_ReduceBy4()
        {
            Item item = new FreshItem();

            item.SellIn  = -1;
            item.Quality = 4;
            item.UpdateQuality();
            Assert.AreEqual(0, item.Quality);
        }
Esempio n. 13
0
        public void QualityShouldNeverBeOver50(int quality)
        {
            // Arrange

            InventoryItem systemUnderTest = new FreshItem(1, quality);

            // Act

            systemUnderTest.MatureOvernight();

            // Assert

            systemUnderTest.Quality.ShouldBe(50);
        }
Esempio n. 14
0
        public void SellInShouldNotChangeAtMinValue()
        {
            // Arrange

            InventoryItem systemUnderTest = new FreshItem(int.MinValue, 1);

            // Act

            systemUnderTest.MatureOvernight();

            // Assert

            systemUnderTest.SellIn.ShouldBe(int.MinValue);
        }
Esempio n. 15
0
        public void ShouldDecreaseQualityBy2BeforeSellby(int sellIn, int quality)
        {
            // Arrange

            InventoryItem systemUnderTest = new FreshItem(sellIn, quality);

            // Act

            systemUnderTest.MatureOvernight();

            // Assert

            systemUnderTest.SellIn.ShouldBe(sellIn - 1);
            systemUnderTest.Quality.ShouldBe(quality - 2);
        }
Esempio n. 16
0
        public void ShouldDecreaseQualityAtDoubleSpeedAtNegative(int positiveSellIn)
        {
            // Arrange

            InventoryItem systemUnderTestPositive = new FreshItem(positiveSellIn, 10);
            InventoryItem systemUnderTestNegative = new FreshItem(-positiveSellIn, 10);

            // Act

            systemUnderTestPositive.MatureOvernight();
            systemUnderTestNegative.MatureOvernight();

            // Assert

            int PositiveDecrease = 10 - systemUnderTestPositive.Quality;
            int NegativeDecrease = 10 - systemUnderTestNegative.Quality;

            NegativeDecrease.ShouldBe(PositiveDecrease * 2);
        }
Esempio n. 17
0
        private List <FreshItem> RecreateInventory(List <Item> items)
        {
            var sortedItems = new List <FreshItem>();

            FreshItem currentItem = null;

            var previousAmount = 0;
            var previousItemId = -1;
            var previousSkinId = (ulong)0;

            foreach (var item in OrderItems(items))
            {
                if (item.maxCondition.CompareTo(0) != 0 ||
                    item.contents != null)
                {
                    continue;
                }

                // Add current item to item list if
                //  item id changes
                //  skin id changes
                if (currentItem == null ||
                    previousItemId != item.info.itemid ||
                    previousSkinId != item.skin)
                {
                    if (currentItem != null)
                    {
                        sortedItems.Add(currentItem);
                    }

                    currentItem = new FreshItem(item);
                    currentItem.UniqueItemIds.Add(item.uid);

                    previousAmount = 0;
                }

                var currentAmount     = previousAmount;
                var currentAmountLeft = item.amount;

                if (!currentItem.UniqueItemIds.Contains(item.uid))
                {
                    currentItem.UniqueItemIds.Add(item.uid);
                }

                do
                {
                    // Add current item to item list if
                    //  max stack has been reached
                    if (currentAmount == item.MaxStackable())
                    {
                        sortedItems.Add(currentItem);

                        currentItem = new FreshItem(item);
                        currentItem.UniqueItemIds.Add(item.uid);
                        currentAmount = 0;
                    }

                    var amount = currentAmountLeft;
                    if (amount + currentAmount > item.MaxStackable()) // If overflow.
                    {
                        amount = item.MaxStackable() - currentAmount;
                    }

                    currentAmount      += amount;
                    currentAmountLeft  -= amount;
                    currentItem.Amount += amount;
                } while (currentAmountLeft > 0);

                previousAmount = currentAmount;
                previousItemId = currentItem.ItemId;
                previousSkinId = currentItem.ItemSkinId;
            }

            if (currentItem != null)
            {
                sortedItems.Add(currentItem);
            }

            return(sortedItems);
        }
Esempio n. 18
0
        private static List <Item> GetItemsFromFile(string fileName)
        {
            List <Item> items = new List <Item>();

            string[] fileLines = File.ReadAllLines(fileName);
            foreach (string line in fileLines)
            {
                string[] temp     = line.Split(' ');
                string   itemName = "";
                int      sellIn;
                int      quality;

                if (temp.Length > 3)
                {
                    itemName = GetItemName(temp[0], temp[1]);
                    sellIn   = int.Parse(temp[2]);
                    quality  = int.Parse(temp[3]);
                }
                else
                {
                    itemName = GetItemName(temp[0]);
                    sellIn   = int.Parse(temp[1]);
                    quality  = int.Parse(temp[2]);
                }
                switch (itemName)
                {
                case "Fresh Item":
                    Item freshItem = new FreshItem {
                        Name = itemName, SellIn = sellIn, Quality = quality
                    };
                    items.Add(freshItem);
                    break;

                case "Frozen Item":
                    Item frozenItem = new FrozenItem {
                        Name = itemName, SellIn = sellIn, Quality = quality
                    };
                    items.Add(frozenItem);
                    break;

                case "Christmas Crackers":
                    Item christmasCrackers = new ChristmasCrackers {
                        Name = itemName, SellIn = sellIn, Quality = quality
                    };
                    items.Add(christmasCrackers);
                    break;

                case "Soap":
                    Item soap = new Soap {
                        Name = itemName, SellIn = sellIn, Quality = quality
                    };
                    items.Add(soap);
                    break;

                case "Aged Brie":
                    Item agedBrie = new AgedBrie {
                        Name = itemName, SellIn = sellIn, Quality = quality
                    };
                    items.Add(agedBrie);
                    break;

                case "INVALID ITEM":
                    Item invalidItem = new InvalidItem {
                        Name = itemName, SellIn = sellIn, Quality = quality
                    };
                    items.Add(invalidItem);
                    break;
                }
            }
            return(items);
        }