ALGA/Tesztek/11_KupacTesztek.cs

using NUnit.Framework;
using System;
using OE.ALGA.Adatszerkezetek;

namespace OE.ALGA.Tesztek.Adatszerkezetek
{
   [TestFixture(Category = "Adatszerkezetek", TestName = "11 - Kupac Prioritásos Sor Tesztek")]
   public class KupacPrioritasosSorTesztek
   {
       [TestCase]
       public void TulSokElemTeszt()
       {
           PrioritasosSor<int> s = new KupacPrioritasosSor<int>(2, (x, y) => x > y);
           s.Sorba(1);
           s.Sorba(2);
           Assert.Throws<NincsHelyKivetel>(() => s.Sorba(3));
       }

       [TestCase]
       public void TulKevesElemTeszt()
       {
           PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y);
           s.Sorba(1);
           s.Sorba(2);
           s.Sorba(3);
           s.Sorbol();
           s.Sorbol();
           s.Sorbol();
           Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
       }

       [TestCase]
       public void UresTeszt()
       {
           PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y);
           Assert.That(s.Ures, Is.True);
           s.Sorba(1);
           Assert.That(s.Ures, Is.False);
           s.Sorba(2);
           Assert.That(s.Ures, Is.False);
           s.Sorbol();
           Assert.That(s.Ures, Is.False);
           s.Elso();
           Assert.That(s.Ures, Is.False);
           s.Sorbol();
           Assert.That(s.Ures, Is.True);
       }

       [TestCase]
       public void SorbaSorbolElsoTeszt()
       {
           PrioritasosSor<int> s = new KupacPrioritasosSor<int>(10, (x, y) => x > y);
           s.Sorba(1);
           s.Sorba(4);
           Assert.Multiple(() =>
           {
               Assert.That(s.Elso(), Is.EqualTo(4));
               Assert.That(s.Sorbol(), Is.EqualTo(4));
               Assert.That(s.Elso(), Is.EqualTo(1));
           });
           s.Sorba(4);
           s.Sorba(2);
           s.Sorba(8);
           s.Sorba(3);
           Assert.That(s.Elso(), Is.EqualTo(8));
           s.Sorba(9);
           s.Sorba(5);
           Assert.Multiple(() =>
           {
               Assert.That(s.Elso(), Is.EqualTo(9));
               Assert.That(s.Elso(), Is.EqualTo(9));
               Assert.That(s.Sorbol(), Is.EqualTo(9));
               Assert.That(s.Elso(), Is.EqualTo(8));
           });
           s.Sorba(7);
           Assert.Multiple(() =>
           {
               Assert.That(s.Sorbol(), Is.EqualTo(8));
               Assert.That(s.Sorbol(), Is.EqualTo(7));
               Assert.That(s.Sorbol(), Is.EqualTo(5));
           });
           s.Sorba(2);
           Assert.Multiple(() =>
           {
               Assert.That(s.Sorbol(), Is.EqualTo(4));
               Assert.That(s.Sorbol(), Is.EqualTo(3));
               Assert.That(s.Sorbol(), Is.EqualTo(2));
               Assert.That(s.Sorbol(), Is.EqualTo(2));
               Assert.That(s.Elso(), Is.EqualTo(1));
               Assert.That(s.Sorbol(), Is.EqualTo(1));
           });
       }

       class PrioritasosSzoveg : IComparable
       {
           public string Szoveg { get; set; }
           public float Prioritas { get; set; }
           public PrioritasosSzoveg(string szoveg, float prioritas)
           {
               this.Szoveg = szoveg;
               this.Prioritas = prioritas;
           }

           public int CompareTo(object? obj)
           {
               if (obj is not PrioritasosSzoveg o)
                   throw new NullReferenceException();
               else
                   return Prioritas.CompareTo(o.Prioritas);
           }
       }

       [TestCase]
       public void PrioritasValtozasTeszt()
       {
           PrioritasosSzoveg a = new PrioritasosSzoveg("a", 10.0f);
           PrioritasosSzoveg b = new PrioritasosSzoveg("b", 5.0f);
           PrioritasosSzoveg c = new PrioritasosSzoveg("c", 2.0f);
           PrioritasosSzoveg d = new PrioritasosSzoveg("d", 12.0f);
           PrioritasosSzoveg e = new PrioritasosSzoveg("e", 15.0f);
           PrioritasosSzoveg f = new PrioritasosSzoveg("f", 9.0f);
           PrioritasosSzoveg g = new PrioritasosSzoveg("g", 2.0f);
           PrioritasosSor<PrioritasosSzoveg> s = new KupacPrioritasosSor<PrioritasosSzoveg>(10, (x, y) => x.CompareTo(y) > 0);
           s.Sorba(a);
           s.Sorba(b);
           s.Sorba(c);
           s.Sorba(d);
           s.Sorba(e);
           Assert.That(s.Elso().Szoveg, Is.EqualTo("e"));
           d.Prioritas = 22.0f;
           s.Frissit(d);
           Assert.That(s.Elso().Szoveg, Is.EqualTo("d"));
           d.Prioritas = 8.0f;
           s.Frissit(d);
           e.Prioritas = 7.0f;
           s.Frissit(e);
           Assert.That(s.Sorbol().Szoveg, Is.EqualTo("a"));
           s.Sorba(f);
           s.Sorba(g);
           Assert.Multiple(() =>
           {
               Assert.That(s.Sorbol().Szoveg, Is.EqualTo("f"));
               Assert.That(s.Sorbol().Szoveg, Is.EqualTo("d"));
               Assert.That(s.Sorbol().Szoveg, Is.EqualTo("e"));
               Assert.That(s.Sorbol().Szoveg, Is.EqualTo("b"));
           });
           c.Prioritas = 1.5f;
           s.Frissit(c);
           Assert.Multiple(() =>
           {
               Assert.That(s.Sorbol().Szoveg, Is.EqualTo("g"));
               Assert.That(s.Sorbol().Szoveg, Is.EqualTo("c"));
               Assert.That(s.Ures, Is.True);
           });
       }
   }

   [TestFixture(Category = "Adatszerkezetek", TestName = "11 - Kupac Külső Fügvénnyel Tesztek")]
   public class KupacKulsoFuggvennyelTesztek
   {
       /// <summary>
       /// Nincs külön rendező függvény, ezért ABC sorrendben rendez az IComparable alapján.
       /// </summary>
       [TestCase]
       public void KupacEpitesIComparableAlapjan()
       {
           KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (x, y) => x.CompareTo(y) > 0);
           ps.Sorba("oszibarack");
           ps.Sorba("alma");
           ps.Sorba("korte");
           ps.Sorba("birsalma");
           ps.Sorba("barack");
           ps.Sorba("dio");
           Assert.Multiple(() =>
           {
               Assert.That(ps.Sorbol(), Is.EqualTo("oszibarack"));
               Assert.That(ps.Sorbol(), Is.EqualTo("korte"));
               Assert.That(ps.Sorbol(), Is.EqualTo("dio"));
               Assert.That(ps.Sorbol(), Is.EqualTo("birsalma"));
               Assert.That(ps.Sorbol(), Is.EqualTo("barack"));
               Assert.That(ps.Sorbol(), Is.EqualTo("alma"));
           });
       }

       /// <summary>
       /// Van egy saját hossz alapú rendező függvény, ezért elsőként a leghosszabb stringeket adja vissza.
       /// </summary>
       [TestCase]
       public void KupacEpitesSajatFuggvennyel()
       {
           KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (ez, ennel) => ez.Length > ennel.Length);
           ps.Sorba("oszibarack");
           ps.Sorba("alma");
           ps.Sorba("korte");
           ps.Sorba("birsalma");
           ps.Sorba("barack");
           ps.Sorba("dio");
           Assert.Multiple(() =>
           {
               Assert.That(ps.Sorbol(), Is.EqualTo("oszibarack"));
               Assert.That(ps.Sorbol(), Is.EqualTo("birsalma"));
               Assert.That(ps.Sorbol(), Is.EqualTo("barack"));
               Assert.That(ps.Sorbol(), Is.EqualTo("korte"));
               Assert.That(ps.Sorbol(), Is.EqualTo("alma"));
               Assert.That(ps.Sorbol(), Is.EqualTo("dio"));
           });
       }
   }

   [TestFixture(Category = "Adatszerkezetek", TestName = "11 - Kupac Rendezés Tesztek")]
   public class KupacRendezesTesztek
   {
       [TestCase]
       public void KupacEpites()
       {
           int[] A = [1, 3, 2, 4, 9, 12, 32, 21, 12, 8, 11];
           _ = new Kupac<int>(A, A.Length, (x, y) => x > y);

           Assert.Multiple(() =>
           {
               for (int i = 1; i < A.Length; i++)
                   Assert.That(A[Kupac<int>.Szulo(i)] >= A[i], Is.True);
           });
       }

       [TestCase]
       public void KupacRendezes()
       {
           int[] A = [5, 8, 7, 0, 9, 6, 4, 1, 3, 2];
           KupacRendezes<int> k = new KupacRendezes<int>(A);
           k.Rendezes();

           Assert.Multiple(() =>
           {
               for (int i = 1; i < A.Length; i++)
                   Assert.That(A[i], Is.EqualTo(i));
           });
       }
   }
}