public void GetByCardTypeAndMaximumDamage_ShouldWorkCorrectly_AfterRemove()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(2, CardType.SPELL, "valq", 14.8, 53);
        Battlecard        cd2      = new Battlecard(1, CardType.SPELL, "valq", 14.8, 5);
        Battlecard        cd3      = new Battlecard(4, CardType.SPELL, "valq", 15.6, 6);
        Battlecard        cd4      = new Battlecard(3, CardType.SPELL, "valq", 15.6, 12);
        Battlecard        cd5      = new Battlecard(8, CardType.RANGED, "valq", 17.8, 613);
        List <Battlecard> expected = new List <Battlecard>()
        {
            cd2
        };

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        RA.RemoveById(cd1.Id);
        //Assert
        List <Battlecard> actual = RA
                                   .GetByCardTypeAndMaximumDamage(CardType.SPELL, 15.0)
                                   .ToList();

        CollectionAssert.AreEqual(expected, actual);
    }
Exemple #2
0
    public void FindFirstLeastSwag_ShouldWorkCorrectly()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(5, CardType.SPELL, "joro", 6, 1);
        Battlecard        cd2      = new Battlecard(6, CardType.MELEE, "joro", 7, 5.5);
        Battlecard        cd3      = new Battlecard(7, CardType.SPELL, "joro", 11, 5.5);
        Battlecard        cd4      = new Battlecard(12, CardType.BUILDING, "joro", 12, 15.6);
        Battlecard        cd5      = new Battlecard(15, CardType.BUILDING, "moro", 13, 7.8);
        List <Battlecard> expected = new List <Battlecard>()
        {
            cd1, cd2, cd3, cd5
        };

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        List <Battlecard> actual = RA
                                   .FindFirstLeastSwag(4)
                                   .ToList();

        //Assert
        CollectionAssert.AreEqual(expected, actual);
    }
    public void GetByTypeAndDamageRangeOrderedByDamageThenById_ShouldWorkCorrectly_On_CorrectRange()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(5, CardType.SPELL, "joro", 1, 5);
        Battlecard        cd2      = new Battlecard(6, CardType.SPELL, "joro", 5.5, 6);
        Battlecard        cd3      = new Battlecard(7, CardType.SPELL, "joro", 5.5, 7);
        Battlecard        cd4      = new Battlecard(12, CardType.SPELL, "joro", 15.6, 10);
        Battlecard        cd5      = new Battlecard(15, CardType.RANGED, "joro", 7.8, 6);
        List <Battlecard> expected = new List <Battlecard>()
        {
            cd4, cd2, cd3, cd1
        };

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        //Assert
        List <Battlecard> actual = RA.GetByTypeAndDamageRangeOrderedByDamageThenById(CardType.SPELL, 0, 20).ToList();

        CollectionAssert.AreEqual(expected, actual);
    }
    public void GetByTypeAndDamageRange_ShouldReturnCorrectRange_CorrectlyOrdered()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(2, CardType.SPELL, "joro", 1, 5);
        Battlecard        cd2      = new Battlecard(1, CardType.SPELL, "joro", 1, 100);
        Battlecard        cd3      = new Battlecard(4, CardType.SPELL, "joro", 15.6, 53);
        Battlecard        cd4      = new Battlecard(3, CardType.SPELL, "joro", 15.6, 100);
        Battlecard        cd5      = new Battlecard(8, CardType.SPELL, "joro", 17.8, 102);
        List <Battlecard> expected = new List <Battlecard>()
        {
            cd5, cd4, cd3, cd2, cd1
        };

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        //Assert
        List <Battlecard> actual = RA.GetByTypeAndDamageRangeOrderedByDamageThenById(CardType.SPELL, 0, 20).ToList();

        CollectionAssert.AreEqual(expected, actual);
    }
Exemple #5
0
    public void GetAllByNameAndSwag_ShouldWorkCorrectly_AfterRemove()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(2, CardType.SPELL, "pesho", 5, 14.8);
        Battlecard        cd2      = new Battlecard(1, CardType.SPELL, "pesho", 5, 14.9);
        Battlecard        cd3      = new Battlecard(4, CardType.SPELL, "maru", 5, 15.6);
        Battlecard        cd4      = new Battlecard(3, CardType.SPELL, "pesho", 5, 15.6);
        Battlecard        cd5      = new Battlecard(8, CardType.RANGED, "pesho", 5, 17.8);
        List <Battlecard> expected = new List <Battlecard>()
        {
            cd2, cd3
        };

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        RA.RemoveById(8);
        RA.RemoveById(3);
        //Assert
        List <Battlecard> actual = RA.GetAllByNameAndSwag().ToList();

        CollectionAssert.AreEqual(expected, actual);
    }
        public void GetByCardType_ShouldReturnCorrectResultAfterRemove()
        {
            //Arrange
            IArena            RA       = new RoyaleArena();
            BattleCard        cd1      = new BattleCard(2, CardType.SPELL, "valq", 2, 14.8);
            BattleCard        cd2      = new BattleCard(1, CardType.SPELL, "valq", 2, 14.8);
            BattleCard        cd3      = new BattleCard(4, CardType.SPELL, "valq", 4, 15.6);
            BattleCard        cd4      = new BattleCard(3, CardType.SPELL, "valq", 3, 15.6);
            BattleCard        cd5      = new BattleCard(8, CardType.RANGED, "valq", 8, 17.8);
            List <BattleCard> expected = new List <BattleCard>()
            {
                cd3, cd2, cd1
            };

            //Act
            RA.Add(cd1);
            RA.Add(cd3);
            RA.Add(cd2);
            RA.Add(cd4);
            RA.Add(cd5);
            RA.RemoveById(8);
            RA.RemoveById(3);

            //Assert
            IEnumerable <BattleCard> battlecards = RA.GetByCardType(CardType.SPELL);
            List <BattleCard>        actual      = new List <BattleCard>();

            foreach (var item in battlecards)
            {
                actual.Add(item);
            }
            CollectionAssert.AreEquivalent(expected, actual);
        }
    public void FindFirstLeastSwag_ShoudlThrowAfterRemove()
    {
        //Arrange
        IArena     RA  = new RoyaleArena();
        Battlecard cd1 = new Battlecard(5, CardType.SPELL, "joro", 5, 1);
        Battlecard cd2 = new Battlecard(6, CardType.SPELL, "joro", 6, 5.5);
        Battlecard cd3 = new Battlecard(7, CardType.SPELL, "joro", 7, 5.5);
        Battlecard cd4 = new Battlecard(12, CardType.SPELL, "joro", 8, 15.6);
        Battlecard cd5 = new Battlecard(15, CardType.RANGED, "joro", 12, 7.8);

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        RA.RemoveById(5);
        RA.RemoveById(7);
        RA.RemoveById(6);
        RA.RemoveById(12);
        RA.RemoveById(15);
        //Assert
        Assert.Throws <InvalidOperationException>(() =>
        {
            RA.FindFirstLeastSwag(1);
        });
    }
        public void GetByName_ShouldWorkCorrectly()
        {
            //Arrange
            IArena            RA       = new RoyaleArena();
            BattleCard        cd1      = new BattleCard(2, CardType.SPELL, "joro", 5, 1);
            BattleCard        cd2      = new BattleCard(1, CardType.SPELL, "joro", 6, 1);
            BattleCard        cd3      = new BattleCard(4, CardType.SPELL, "joro", 7, 15.6);
            BattleCard        cd4      = new BattleCard(3, CardType.SPELL, "joro", 8, 15.6);
            BattleCard        cd5      = new BattleCard(8, CardType.RANGED, "joro", 11, 17.8);
            List <BattleCard> expected = new List <BattleCard>()
            {
                cd5, cd4, cd3, cd2, cd1
            };

            //Act
            RA.Add(cd1);
            RA.Add(cd3);
            RA.Add(cd2);
            RA.Add(cd4);
            RA.Add(cd5);

            //Assert
            IEnumerable <BattleCard> joro   = RA.GetByNameOrderedBySwagDescending("joro");
            List <BattleCard>        actual = new List <BattleCard>();

            foreach (var item in joro)
            {
                actual.Add(item);
            }
            CollectionAssert.AreEquivalent(expected, actual);
        }
        public void GetByCardTypeAndMaximumDamage_ShouldWorkCorrectly_OnExistingSender()
        {
            //Arrange
            IArena            RA       = new RoyaleArena();
            BattleCard        cd1      = new BattleCard(2, CardType.SPELL, "joro", 1, 5);
            BattleCard        cd2      = new BattleCard(1, CardType.SPELL, "valq", 14.8, 6);
            BattleCard        cd3      = new BattleCard(3, CardType.SPELL, "valq", 15.6, 12);
            BattleCard        cd4      = new BattleCard(4, CardType.SPELL, "valq", 15.6, 61);
            BattleCard        cd5      = new BattleCard(8, CardType.SPELL, "valq", 17.8, 13);
            List <BattleCard> expected = new List <BattleCard>()
            {
                cd3, cd4, cd2, cd1
            };

            //Act
            RA.Add(cd1);
            RA.Add(cd3);
            RA.Add(cd2);
            RA.Add(cd4);
            RA.Add(cd5);

            //Assert
            IEnumerable <BattleCard> battlecards = RA.GetByCardTypeAndMaximumDamage(CardType.SPELL, 15.6);
            List <BattleCard>        actual      = new List <BattleCard>();

            foreach (var item in battlecards)
            {
                actual.Add(item);
            }
            CollectionAssert.AreEqual(expected, actual);
        }
        public void FindFirstLeastSwag_ShouldWorkCorrectly()
        {
            //Arrange
            IArena            RA       = new RoyaleArena();
            BattleCard        cd1      = new BattleCard(5, CardType.SPELL, "joro", 6.0, 1.0);
            BattleCard        cd2      = new BattleCard(6, CardType.MELEE, "joro", 7.0, 5.5);
            BattleCard        cd3      = new BattleCard(7, CardType.SPELL, "joro", 11.0, 5.5);
            BattleCard        cd4      = new BattleCard(12, CardType.BUILDING, "joro", 12.0, 15.6);
            BattleCard        cd5      = new BattleCard(15, CardType.BUILDING, "moro", 13.0, 7.8);
            List <BattleCard> expected = new List <BattleCard>()
            {
                cd1, cd2, cd3, cd5
            };

            //Act
            RA.Add(cd1);
            RA.Add(cd3);
            RA.Add(cd2);
            RA.Add(cd4);
            RA.Add(cd5);
            IEnumerable <BattleCard> battlecards = RA.FindFirstLeastSwag(4);

            List <BattleCard> actual = new List <BattleCard>();

            foreach (var b in battlecards)
            {
                actual.Add(b);
            }

            //Assert
            CollectionAssert.AreEqual(expected, actual);
        }
        public void GetInSwagRange_ShouldReturn_CorrectBattlecards()
        {
            //Arrange
            IArena            RA       = new RoyaleArena();
            BattleCard        cd1      = new BattleCard(5, CardType.SPELL, "dragon", 8, 1);
            BattleCard        cd2      = new BattleCard(6, CardType.SPELL, "raa", 7, 2);
            BattleCard        cd3      = new BattleCard(7, CardType.SPELL, "maga", 6, 5.5);
            BattleCard        cd4      = new BattleCard(12, CardType.SPELL, "shuba", 5, 15.6);
            BattleCard        cd5      = new BattleCard(15, CardType.SPELL, "tanuki", 5, 7.8);
            List <BattleCard> expected = new List <BattleCard>()
            {
                cd5, cd4
            };

            //Act
            RA.Add(cd1);
            RA.Add(cd3);
            RA.Add(cd2);
            RA.Add(cd4);
            RA.Add(cd5);
            IEnumerable <BattleCard> battlecards = RA.GetAllInSwagRange(7, 16);
            List <BattleCard>        actual      = new List <BattleCard>();

            foreach (var b in battlecards)
            {
                actual.Add(b);
            }

            //Assert
            CollectionAssert.AreEqual(expected, actual);
        }
        public void RA_ShouldReturn_BattlecardsInCorrectOrder_AfterDelete()
        {
            //Arrange
            IArena            RA       = new RoyaleArena();
            BattleCard        cd1      = new BattleCard(5, CardType.SPELL, "joro", 10, 5);
            BattleCard        cd2      = new BattleCard(6, CardType.SPELL, "joro", 11, 5);
            BattleCard        cd3      = new BattleCard(7, CardType.SPELL, "joro", 12, 5);
            List <BattleCard> expected = new List <BattleCard>()
            {
                cd2
            };

            //Act
            RA.Add(cd1);
            RA.Add(cd3);
            RA.Add(cd2);
            RA.RemoveById(5);
            RA.RemoveById(7);
            List <BattleCard> actual = new List <BattleCard>();

            foreach (BattleCard battlecard in RA)
            {
                actual.Add(battlecard);
            }

            //Assert
            CollectionAssert.AreEqual(expected, actual);
        }
Exemple #13
0
    public void RemoveById_ShoudlWorkFast()
    {
        IArena            ar   = new RoyaleArena();
        List <Battlecard> cds  = new List <Battlecard>();
        Random            rand = new Random();

        for (int i = 0; i < 40_000; i++)
        {
            int        amount = rand.Next(0, 60000);
            Battlecard cd     = new Battlecard(i, CardType.SPELL,
                                               i.ToString(), i, amount);
            ar.Add(cd);
            cds.Add(cd);
        }

        int count = ar.Count;

        Assert.AreEqual(40000, count);

        Stopwatch watch = new Stopwatch();

        watch.Start();

        foreach (Battlecard cd in cds)
        {
            ar.RemoveById(cd.Id);
        }

        watch.Stop();
        long l1 = watch.ElapsedMilliseconds;

        Assert.Less(l1, 300);
    }
Exemple #14
0
    public void GetByName_ShouldWorkCorrectly()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(2, CardType.SPELL, "joro", 5, 1);
        Battlecard        cd2      = new Battlecard(1, CardType.SPELL, "joro", 6, 1);
        Battlecard        cd3      = new Battlecard(4, CardType.SPELL, "joro", 7, 15.6);
        Battlecard        cd4      = new Battlecard(3, CardType.SPELL, "joro", 8, 15.6);
        Battlecard        cd5      = new Battlecard(8, CardType.RANGED, "joro", 11, 17.8);
        List <Battlecard> expected = new List <Battlecard>()
        {
            cd5, cd4, cd3, cd2, cd1
        };

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        //Assert
        List <Battlecard> actual = RA.GetByNameOrderedBySwagDescending("joro").ToList();

        CollectionAssert.AreEqual(expected, actual);
    }
    public void GetAllInSwagRange()
    {
        IArena            ar   = new RoyaleArena();
        List <Battlecard> cds  = new List <Battlecard>();
        Random            rand = new Random();

        for (int i = 0; i < 100000; i++)
        {
            Battlecard cd = new Battlecard(i, CardType.SPELL,
                                           "player", 550, i);
            ar.Add(cd);
            cds.Add(cd);
        }
        cds = cds.OrderBy(x => x.Swag).ThenBy(x => x.Id).ToList();
        int count = ar.Count;

        Assert.AreEqual(100000, count);
        Stopwatch watch = new Stopwatch();

        watch.Start();

        for (int i = 0; i < 100; i++)
        {
            IEnumerable <Battlecard> all = ar.GetAllInSwagRange(200, 600);
        }
        watch.Stop();
        long l1 = watch.ElapsedMilliseconds;

        Assert.Less(l1, 150);
    }
    public void GetAllByNameAndSwag_ShouldWorkCorrectly_OnExistingName()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(2, CardType.SPELL, "valq", 5, 14.8);
        Battlecard        cd2      = new Battlecard(1, CardType.SPELL, "moro", 5, 14.8);
        Battlecard        cd3      = new Battlecard(4, CardType.SPELL, "boro", 5, 15.6);
        Battlecard        cd4      = new Battlecard(3, CardType.SPELL, "toro", 5, 15.6);
        Battlecard        cd5      = new Battlecard(8, CardType.RANGED, "toro", 6, 17.8);
        List <Battlecard> expected = new List <Battlecard>()
        {
            cd1, cd2, cd3, cd5
        };

        //Act
        RA.Add(cd1);
        RA.Add(cd2);
        RA.Add(cd3);
        RA.Add(cd4);
        RA.Add(cd5);
        //Assert
        List <Battlecard> actual = RA.GetAllByNameAndSwag().ToList();

        CollectionAssert.AreEqual(expected, actual);
    }
    public void Add_100000_Battlecards_Should_WorkFast()
    {
        IArena    ar    = new RoyaleArena();
        Stopwatch sw    = new Stopwatch();
        int       count = 80_000;

        CardType[] statuses = new CardType[]
        {
            CardType.MELEE,
            CardType.RANGED,
            CardType.SPELL,
            CardType.BUILDING
        };
        Random rand = new Random();

        sw.Start();
        for (int i = 0; i < count; i++)
        {
            //int status = rand.Next(0, 4);
            ar.Add(new Battlecard(i, CardType.SPELL,
                                  i.ToString(), i, i));
        }

        sw.Stop();
        Assert.AreEqual(count, ar.Count);
        Assert.Less(sw.ElapsedMilliseconds, 400);
    }
Exemple #18
0
    public void GetByCardType_ShouldReturnCorrectResultAfterRemove()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(2, CardType.SPELL, "valq", 2, 14.8);
        Battlecard        cd2      = new Battlecard(1, CardType.SPELL, "valq", 2, 14.8);
        Battlecard        cd3      = new Battlecard(4, CardType.SPELL, "valq", 4, 15.6);
        Battlecard        cd4      = new Battlecard(3, CardType.SPELL, "valq", 3, 15.6);
        Battlecard        cd5      = new Battlecard(8, CardType.RANGED, "valq", 8, 17.8);
        List <Battlecard> expected = new List <Battlecard>()
        {
            cd3, cd2, cd1
        };

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        RA.RemoveById(8);
        RA.RemoveById(3);
        //Assert
        List <Battlecard> actual = RA
                                   .GetByCardType(CardType.SPELL)
                                   .ToList();

        CollectionAssert.AreEqual(expected, actual);
    }
Exemple #19
0
    public void GetByCardTypeAndMaximumDamage_ShouldWorkCorrectly()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(2, CardType.SPELL, "valq", 14, 5);
        Battlecard        cd2      = new Battlecard(1, CardType.SPELL, "valq", 14, 5);
        Battlecard        cd3      = new Battlecard(4, CardType.SPELL, "valq", 15, 6);
        Battlecard        cd4      = new Battlecard(3, CardType.SPELL, "valq", 15, 7);
        Battlecard        cd5      = new Battlecard(8, CardType.SPELL, "valq", 18, 8);
        List <Battlecard> expected = new List <Battlecard>()
        {
            cd4, cd3, cd2, cd1
        };

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        //Assert
        List <Battlecard> actual = RA
                                   .GetByCardTypeAndMaximumDamage(CardType.SPELL, 17)
                                   .ToList();

        CollectionAssert.AreEqual(expected, actual);
    }
        public void RA_ShouldBeEnumeratedIn_InsertionOrder()
        {
            //Arrange
            IArena            RA       = new RoyaleArena();
            BattleCard        cd1      = new BattleCard(5, CardType.SPELL, "joro", 5, 5);
            BattleCard        cd2      = new BattleCard(6, CardType.SPELL, "joro", 6, 5);
            BattleCard        cd3      = new BattleCard(7, CardType.SPELL, "joro", 7, 5);
            List <BattleCard> expected = new List <BattleCard>()
            {
                cd1, cd3, cd2
            };

            //Act
            RA.Add(cd1);
            RA.Add(cd3);
            RA.Add(cd2);

            List <BattleCard> actual = new List <BattleCard>();

            foreach (BattleCard battlecard in RA)
            {
                actual.Add(battlecard);
            }

            //Assert
            CollectionAssert.AreEqual(expected, actual);
        }
    public void GetAllInSwagRange_ShouldReturn_EmptyCollectionOnNonExistingRange()
    {
        //Arrange
        IArena            RA       = new RoyaleArena();
        Battlecard        cd1      = new Battlecard(5, CardType.SPELL, "joro", 2, 1);
        Battlecard        cd2      = new Battlecard(6, CardType.SPELL, "joro", 3, 2);
        Battlecard        cd3      = new Battlecard(7, CardType.SPELL, "joro", 4, 5.5);
        Battlecard        cd4      = new Battlecard(12, CardType.SPELL, "joro", 5, 15.6);
        Battlecard        cd5      = new Battlecard(15, CardType.SPELL, "joro", 6, 7.8);
        List <Battlecard> expected = new List <Battlecard>();

        //Act
        RA.Add(cd1);
        RA.Add(cd3);
        RA.Add(cd2);
        RA.Add(cd4);
        RA.Add(cd5);
        List <Battlecard> actual = RA.GetAllInSwagRange(7.7, 7.75).ToList();

        //Assert
        CollectionAssert.AreEqual(expected, actual);
        RA.RemoveById(12);
        RA.RemoveById(15);
        actual = RA.GetAllInSwagRange(7.8, 16).ToList();
        CollectionAssert.AreEqual(expected, actual);
    }
Exemple #22
0
    public void GetById_On_Empty_RoyaleArena_ShouldThrow()
    {
        //Arrange
        IArena RA = new RoyaleArena();

        //Act
        //Assert
        Assert.Throws <InvalidOperationException>(() => RA.GetById(5));
    }
    public void Count_Should_Be_0_On_EmptyCollection()
    {
        //Arrange
        IArena RA = new RoyaleArena();

        //Act
        //Assert
        Assert.AreEqual(0, RA.Count);
    }
    public void GetAllInSwagRange_ShouldReturnEmptyEnumeration_On_EmptyRA()
    {
        //Arrange
        IArena RA = new RoyaleArena();
        //Act
        List <Battlecard> actual = RA.GetAllInSwagRange(7.7, 7.75).ToList();

        //Assert
        CollectionAssert.AreEqual(new List <Battlecard>(), actual);
    }
Exemple #25
0
    public void Contains_OnEmptyRoyaleArena_ShouldReturnFalse()
    {
        //Arrange
        IArena RA = new RoyaleArena();

        //Act
        //Assert
        Assert.IsFalse(RA.Contains(new Battlecard(5, CardType.BUILDING, "kocho", 5, 6.2)));
        Assert.IsFalse(RA.Contains(new Battlecard(3, CardType.RANGED, "a", 6, 0.5)));
    }
Exemple #26
0
    public void GetByName_ShouldThrow_On_EmptyRA()
    {
        //Arrange
        IArena RA = new RoyaleArena();

        //Act
        //Assert
        Assert.Throws <InvalidOperationException>(() => {
            RA.GetByNameOrderedBySwagDescending("pesho");
        });
    }
Exemple #27
0
    public void GetByTypeAndDamageRangeOrderedByDamageThenById_ShouldThrow_On_EmptyRA()
    {
        //Arrange
        IArena RA = new RoyaleArena();

        //Act
        //Assert
        Assert.Throws <InvalidOperationException>(() => {
            RA.GetByTypeAndDamageRangeOrderedByDamageThenById(CardType.MELEE, 0, 20).ToList();
        });
    }
    public void GetByNameAndSwagRange_ShouldWorkFast()
    {
        IArena ar = new RoyaleArena();
        List <List <Battlecard> > cds    = new List <List <Battlecard> >();
        List <Tuple <int, int> >  ranges = new List <Tuple <int, int> >();
        Random rand = new Random();
        int    id   = 0;

        for (int i = 0; i < 100; i++)
        {
            Tuple <int, int> range = new Tuple <int, int>(rand.Next(100, 400), rand.Next(500, 1000));
            ranges.Add(range);
            List <Battlecard> cd = new List <Battlecard>();
            for (int j = 0; j < 100; j++)
            {
                int amount = rand.Next(range.Item1 + 1, range.Item2 - 1);
                id++;
                Battlecard card = new Battlecard(id, CardType.SPELL,
                                                 i.ToString(), i, amount);
                cd.Add(card);
                ar.Add(card);
            }
            cds.Add(cd.OrderByDescending(x => x.Swag).ThenBy(x => x.Id).ToList());
        }

        int count = ar.Count;

        Assert.AreEqual(10000, count);
        Stopwatch watch = new Stopwatch();

        watch.Start();

        List <IEnumerable <Battlecard> > results = new List <IEnumerable <Battlecard> >();

        for (int i = 0; i < 100; i++)
        {
            Tuple <int, int>         range = ranges[i];
            IEnumerable <Battlecard> all   = ar.GetByNameAndSwagRange(i.ToString(), range.Item1, range.Item2);
            results.Add(all);
        }
        watch.Stop();
        int c = 0;

        for (int i = 0; i < 100; i++)
        {
            CollectionAssert.AreEqual(cds[i], results[i].ToList());
            c++;
        }

        long l1 = watch.ElapsedMilliseconds;

        Assert.Less(l1, 150);
        Assert.AreEqual(cds.Count, c);
    }
    public void GetByCardTypeAndMaximumDamage_ShouldThrowOnEmpty_RA()
    {
        //Arrange
        IArena RA = new RoyaleArena();

        //Act
        //Assert
        Assert.Throws <InvalidOperationException>(() => {
            RA.GetByCardTypeAndMaximumDamage(CardType.MELEE, 5);
        });
    }
    public void ChangeCardType_On_NonExistingTranasction_ShouldThrow()
    {
        //Arrange
        IArena RA = new RoyaleArena();

        //Act
        //Assert
        Assert.Throws <ArgumentException>(
            () => RA.ChangeCardType(6, CardType.RANGED)
            );
    }