by ricsi

ALGA_heti_feladatok/Tesztek/00_Utils.cs

@@ -0,0 +1,72 @@
+using OE.ALGA.Paradigmak;
+
+namespace Guardian
+{
+    public static class Recursion
+    {
+        /// <summary>
+        /// This method is injected into every method and property call to check the current state
+        /// of the stack. If the number of calls on the stack exceeds 500, infinite recursion is
+        /// assumed and an exception is thrown, avoiding a complete program crash.
+        /// </summary>
+        /// <exception cref="System.StackOverflowException"></exception>
+        public static void CheckStackTrace()
+        {
+            System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace();
+            if (st.FrameCount > 500)
+                throw new System.StackOverflowException($"A stack overflow has occurred! Method call depth has reached the limit (500<=): {st.FrameCount}!");
+        }
+    }
+}
+
+namespace OE.ALGA.Tesztek
+{
+    #region Paradigmak
+    class TesztFeladat : IVegrehajthato
+    {
+        public string Azonosito { get; set; }
+        public bool Vegrehajtott { get; set; }
+
+        public void Vegrehajtas() => Vegrehajtott = true;
+        public TesztFeladat(string nev) => Azonosito = nev;
+    }
+    class TesztFuggoFeladat : TesztFeladat, IFuggo
+    {
+        public bool Vegrehajthato { get; set; }
+
+        public virtual bool FuggosegTeljesul => Vegrehajthato;
+
+        public TesztFuggoFeladat(string nev) : base(nev) { }
+    }
+    class TesztElokovetelmenytolFuggoFeladat : TesztFuggoFeladat
+    {
+        readonly TesztFeladat elokovetelmeny;
+
+        public override bool FuggosegTeljesul => base.FuggosegTeljesul && elokovetelmeny.Vegrehajtott;
+        public TesztElokovetelmenytolFuggoFeladat(string nev, TesztFeladat elokovetelmeny) : base(nev) { this.elokovetelmeny = elokovetelmeny; }
+    }
+    #endregion
+
+    #region Optimalizalas
+    public class PakolasTesztEsetek
+    {
+        public static readonly bool[] uresPakolas = [false, false, false, false, false, false];
+        public static readonly bool[] feligPakolas = [false, true, false, true, false, false];
+        public static readonly bool[] teljesPakolas = [true, true, true, true, true, true];
+
+        public static readonly int[] jegyzet_w = [2, 1, 1, 1, 3, 2];
+        public static readonly float[] jegyzet_p = [4, 3, 2, 8, 7, 5];
+        public static readonly int jegyzet_n = jegyzet_w.Length;
+        public static readonly int jegyzet_Wmax = 4;
+        public static readonly float jegyzet_optimalis_ertek = 16;
+        public static readonly bool[] jegyzet_optimalis_pakolas = [false, true, false, true, false, true];
+
+        public static readonly int[] nagy_w = [21, 41, 26, 11, 37, 25, 25, 44, 33, 29, 32, 52, 41, 62, 56, 81, 43];
+        public static readonly float[] nagy_p = [4, 3, 2, 8, 7, 5, 4, 3, 2, 5, 3, 9, 5, 1, 7, 9, 4];
+        public static readonly int nagy_n = nagy_w.Length;
+        public static readonly int nagy_Wmax = 100;
+        public static readonly float nagy_optimalis_ertek = 24;
+        public static readonly bool[] nagy_optimalis_pakolas = [true, false, false, true, true, true, false, false, false, false, false, false, false, false, false, false, false];
+    }
+    #endregion
+}

ALGA_heti_feladatok/Tesztek/01_ImperativParadigmaTesztek.cs

@@ -0,0 +1,280 @@
+using NUnit.Framework;
+using OE.ALGA.Paradigmak;
+
+
+namespace OE.ALGA.Tesztek.Paradigmak
+{
+    [TestFixture(Category = "Paradigmák", TestName = "01 - Feladat Tároló Tesztek")]
+    public class FeladatTaroloTesztek
+    {
+        [TestCase]
+        public void Ures()
+        {
+            FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(0);
+            TesztFeladat a = new TesztFeladat("a");
+            Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
+        }
+        [TestCase]
+        public void Felvesz()
+        {
+            FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(5);
+            TesztFeladat a = new TesztFeladat("a");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+        }
+
+        [TestCase]
+        public void TulsokatFelvesz()
+        {
+            FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(3);
+            TesztFeladat a = new TesztFeladat("a");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
+        }
+        [TestCase]
+        public void NincsMitVegrehajtani()
+        {
+            FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(2);
+            tarolo.MindentVegrehajt();
+        }
+        [TestCase]
+        public void MindentVegrehajt()
+        {
+            FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(2);
+            TesztFeladat a = new TesztFeladat("a");
+            TesztFeladat b = new TesztFeladat("b");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.False);
+                Assert.That(b.Vegrehajtott, Is.False);
+            });
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.True);
+                Assert.That(b.Vegrehajtott, Is.True);
+            });
+        }
+        [TestCase]
+        public void FelvettetVegrehajt()
+        {
+            FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10);
+            TesztFeladat a = new TesztFeladat("a");
+            TesztFeladat b = new TesztFeladat("b");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.False);
+                Assert.That(b.Vegrehajtott, Is.False);
+            });
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.True);
+                Assert.That(b.Vegrehajtott, Is.True);
+            });
+        }
+    }
+
+    [TestFixture(Category = "Paradigmák", TestName = "01 - Függő Feladat Tároló Tesztek")]
+    public class FuggoFeladatTaroloTesztek
+    {
+        [TestCase]
+        public void Felvesz()
+        {
+            FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
+            TesztFuggoFeladat a = new TesztFuggoFeladat("a");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+        }
+        [TestCase]
+        public void TulsokatFelvesz()
+        {
+            FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(3);
+            TesztFuggoFeladat a = new TesztFuggoFeladat("a");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
+        }
+        [TestCase]
+        public void NincsMitVegrehajtani()
+        {
+            FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(2);
+            tarolo.MindentVegrehajt();
+        }
+        [TestCase]
+        public void MindentVegrehajt()
+        {
+            FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(2);
+            TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
+            TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = true };
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.False);
+                Assert.That(b.Vegrehajtott, Is.False);
+            });
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.True);
+                Assert.That(b.Vegrehajtott, Is.True);
+            });
+        }
+        [TestCase]
+        public void VegrehajtasAmikorNemVegrehajthatok()
+        {
+            FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
+            TesztFuggoFeladat a = new TesztFuggoFeladat("a");
+            TesztFuggoFeladat b = new TesztFuggoFeladat("b");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.False);
+                Assert.That(b.Vegrehajtott, Is.False);
+            });
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.False);
+                Assert.That(b.Vegrehajtott, Is.False);
+            });
+        }
+        [TestCase]
+        public void VegrehajtasAmikorVegrehajthatok()
+        {
+            FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
+            TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
+            TesztFuggoFeladat b = new TesztFuggoFeladat("b");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.False);
+                Assert.That(b.Vegrehajtott, Is.False);
+            });
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.True);
+                Assert.That(b.Vegrehajtott, Is.False);
+            });
+            b.Vegrehajthato = true;
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.True);
+                Assert.That(b.Vegrehajtott, Is.True);
+            });
+        }
+    }
+    [TestFixture(Category = "Paradigmák", TestName = "01 - Feltételes Feladat Tároló Előkövetelményekkel Tesztek")]
+    public class FuggoFeladatTaroloElokovetelmenyekkelTesztek
+    {
+        [TestCase]
+        public void Elokovetelmenyes()
+        {
+            FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
+            TesztFuggoFeladat a = new TesztFuggoFeladat("a");
+            TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true };
+            // a->b
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.False);
+                Assert.That(b.Vegrehajtott, Is.False);
+            });
+            a.Vegrehajthato = true;
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.True);
+                Assert.That(b.Vegrehajtott, Is.True);
+            });
+        }
+        [TestCase]
+        public void TobbKorosElokovetelmenyes()
+        {
+            FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
+            TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
+            TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true };
+            TesztElokovetelmenytolFuggoFeladat c = new TesztElokovetelmenytolFuggoFeladat("c", a) { Vegrehajthato = true };
+            TesztElokovetelmenytolFuggoFeladat d = new TesztElokovetelmenytolFuggoFeladat("d", b) { Vegrehajthato = true };
+            // a->b->d
+            //  ->c
+            tarolo.Felvesz(d);
+            tarolo.Felvesz(c);
+            tarolo.Felvesz(b);
+            tarolo.Felvesz(a);
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.True);
+                Assert.That(b.Vegrehajtott, Is.False);  //a 'b' kiértékelése az 'a' végrehajtása előtt volt, ezért az még nem lett feldolgozva
+                Assert.That(c.Vegrehajtott, Is.False);  //a 'c' kiértékelése az 'a' végrehajtása előtt volt, ezért az még nem lett feldolgozva
+                Assert.That(d.Vegrehajtott, Is.False);
+            });
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.True);
+                Assert.That(b.Vegrehajtott, Is.True);
+                Assert.That(c.Vegrehajtott, Is.True);
+                Assert.That(d.Vegrehajtott, Is.False);  //a 'd' kiértékelése a 'b' végrehajtása előtt volt, ezért az még nem lett feldolgozva
+            });
+            tarolo.MindentVegrehajt();
+            Assert.Multiple(() =>
+            {
+                Assert.That(a.Vegrehajtott, Is.True);
+                Assert.That(b.Vegrehajtott, Is.True);
+                Assert.That(c.Vegrehajtott, Is.True);
+                Assert.That(d.Vegrehajtott, Is.True);
+            });
+        }
+    }
+    [TestFixture(Category = "Paradigmák", TestName = "01 - Bejáró Tesztek")]
+    class BejarasokTesztek
+    {
+        [TestCase]
+        public void FeladatTaroloBejaro()
+        {
+            FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10);
+            TesztFeladat a = new TesztFeladat("a");
+            TesztFeladat b = new TesztFeladat("b");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            string nevek = "";
+            foreach (TesztFeladat u in tarolo)
+                nevek += u.Azonosito;
+            Assert.That(nevek, Is.EqualTo("ab"));
+        }
+
+        [TestCase]
+        public void FuggoFeladatTaroloBejaro()
+        {
+            FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
+            TesztFuggoFeladat a = new TesztFuggoFeladat("a");
+            TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = true };
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            tarolo.MindentVegrehajt();
+            string nevek = "";
+            foreach (TesztFuggoFeladat u in tarolo)
+                if (u.Vegrehajtott)
+                    nevek += u.Azonosito;
+            Assert.That(nevek, Is.EqualTo("b"));
+        }
+    }
+}

ALGA_heti_feladatok/Tesztek/02_FunkcionalisParadigmaTesztek.cs

@@ -0,0 +1,136 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using OE.ALGA.Paradigmak;
+
+namespace OE.ALGA.Tesztek
+{
+    [TestClass()]
+    public class FeltetelesFeladatTaroloTesztek
+    {
+        [TestMethod()]
+        public void FelveszTeszt() //F1.(a)
+        {
+            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
+            TesztFeladat a = new TesztFeladat("a");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+        }
+
+        [TestMethod()]
+        [ExpectedException(typeof(TaroloMegteltKivetel))]
+        public void TulsokatFelveszTeszt() //F1.(a)
+        {
+            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(5);
+            TesztFeladat a = new TesztFeladat("a");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(a);
+        }
+
+        [TestMethod()]
+        public void MindenVegrehajtasTeszt() //F1.(a)
+        {
+            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
+            TesztFeladat a = new TesztFeladat("a");
+            TesztFeladat b = new TesztFeladat("b");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b.Vegrehajtott);
+            tarolo.MindentVegrehajt();
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(b.Vegrehajtott);
+        }
+
+        [TestMethod()]
+        public void BejaroTeszt() //F1.(a)
+        {
+            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
+            TesztFeladat a = new TesztFeladat("a");
+            TesztFeladat b = new TesztFeladat("b");
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            string nevek = "";
+            foreach (TesztFeladat u in tarolo)
+            {
+                nevek += u.Azonosito;
+            }
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual("ab", nevek);
+        }
+
+        [TestMethod()]
+        public void FeltetelesVegrehajtasTeszt() //F1.(b)
+        {
+            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
+            TesztFeladat a1 = new TesztFeladat("a1");
+            TesztFeladat b1 = new TesztFeladat("b1");
+            TesztFeladat a2 = new TesztFeladat("a2");
+            tarolo.Felvesz(a1);
+            tarolo.Felvesz(b1);
+            tarolo.Felvesz(a2);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a2.Vegrehajtott);
+            tarolo.FeltetelesVegrehajtas(x => x.Azonosito[0] == 'a'); // csak 'a' kezdetűek végrehajtása
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a2.Vegrehajtott);
+            tarolo.FeltetelesVegrehajtas(x => x.Azonosito[0] == 'b'); // csak 'b' kezdetűek végrehajtása
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(b1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a2.Vegrehajtott);
+        }
+
+        [TestMethod()]
+        public void FeltetelesFuggosegesVegrehajtasTeszt() //F1.(b)
+        {
+            FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10);
+            TesztFuggoFeladat a1 = new TesztFuggoFeladat("a1") { Vegrehajthato = true };
+            TesztFuggoFeladat b1 = new TesztFuggoFeladat("b1") { Vegrehajthato = true };
+            TesztFuggoFeladat a2 = new TesztFuggoFeladat("a2") { Vegrehajthato = false };
+            tarolo.Felvesz(a1);
+            tarolo.Felvesz(b1);
+            tarolo.Felvesz(a2);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a2.Vegrehajtott);
+            tarolo.FeltetelesVegrehajtas(x => x.Azonosito[0] == 'a' && x.FuggosegTeljesul); // csak 'a' kezdetű és végrehajtható
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a2.Vegrehajtott);
+            tarolo.FeltetelesVegrehajtas(x => x.Azonosito[0] == 'b' && x.FuggosegTeljesul); // csak 'b' kezdetű és végrehajtható
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(b1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a2.Vegrehajtott);
+            a2.Vegrehajthato = true;
+            tarolo.FeltetelesVegrehajtas(x => x.Azonosito[0] == 'a' && x.FuggosegTeljesul); // csak 'a' kezdetű és végrehajtható
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(b1.Vegrehajtott);
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a2.Vegrehajtott);
+        }
+
+        [TestMethod()]
+        public void FeltetelesBejaroTeszt() //F3.(b)
+        {
+            FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10);
+            tarolo.BejaroFeltetel = (x => x.FuggosegTeljesul);
+            TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
+            TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = false };
+            TesztFuggoFeladat c = new TesztFuggoFeladat("c") { Vegrehajthato = true };
+            tarolo.Felvesz(a);
+            tarolo.Felvesz(b);
+            tarolo.Felvesz(c);
+            string nevek = "";
+            foreach (TesztFeladat u in tarolo)
+            {
+                nevek += u.Azonosito;
+            }
+            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual("ac", nevek);
+        }
+    }
+}

ALGA_heti_feladatok/Tesztek/02_FunkconalisParadigmaTesztek.cs

@@ -0,0 +1,154 @@
+//using NUnit.Framework;
+//using OE.ALGA.Paradigmak;
+
+//namespace OE.ALGA.Tesztek.Paradigmak
+//{
+//    [TestFixture(Category = "Paradigmák", TestName = "02 - Feltételes Feladat Tároló Tesztek")]
+//    public class FeltetelesFeladatTaroloTesztek
+//    {
+//        [TestCase]
+//        public void Felvesz()
+//        {
+//            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(5);
+//            TesztFeladat a = new TesztFeladat("a");
+//            tarolo.Felvesz(a);
+//            tarolo.Felvesz(a);
+//            tarolo.Felvesz(a);
+//        }
+//        [TestCase]
+//        public void TulsokatFelvesz()
+//        {
+//            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(3);
+//            TesztFeladat a = new TesztFeladat("a");
+//            tarolo.Felvesz(a);
+//            tarolo.Felvesz(a);
+//            tarolo.Felvesz(a);
+//            Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
+//        }
+//        [TestCase]
+//        public void NincsMitVegrehajtani()
+//        {
+//            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(2);
+//            tarolo.MindentVegrehajt();
+//        }
+//        [TestCase]
+//        public void MindenVegrehajtas()
+//        {
+//            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(2);
+//            TesztFeladat a = new TesztFeladat("a");
+//            TesztFeladat b = new TesztFeladat("b");
+//            tarolo.Felvesz(a);
+//            tarolo.Felvesz(b);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a.Vegrehajtott, Is.False);
+//                Assert.That(b.Vegrehajtott, Is.False);
+//            });
+//            tarolo.MindentVegrehajt();
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a.Vegrehajtott, Is.True);
+//                Assert.That(b.Vegrehajtott, Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void FeltetelesVegrehajtas()
+//        {
+//            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
+//            TesztFeladat a1 = new TesztFeladat("a1");
+//            TesztFeladat b1 = new TesztFeladat("b1");
+//            TesztFeladat a2 = new TesztFeladat("a2");
+//            tarolo.Felvesz(a1);
+//            tarolo.Felvesz(b1);
+//            tarolo.Felvesz(a2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a1.Vegrehajtott, Is.False);
+//                Assert.That(b1.Vegrehajtott, Is.False);
+//                Assert.That(a2.Vegrehajtott, Is.False);
+//            });
+//            tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a'; }); // csak 'a' kezdetűek végrehajtása
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a1.Vegrehajtott, Is.True);
+//                Assert.That(b1.Vegrehajtott, Is.False);
+//                Assert.That(a2.Vegrehajtott, Is.True);
+//            });
+//            tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'b'; }); // csak 'b' kezdetűek végrehajtása
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a1.Vegrehajtott, Is.True);
+//                Assert.That(b1.Vegrehajtott, Is.True);
+//                Assert.That(a2.Vegrehajtott, Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void FeltetelesFuggosegesVegrehajtas()
+//        {
+//            FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10);
+//            TesztFuggoFeladat a1 = new TesztFuggoFeladat("a1") { Vegrehajthato = true };
+//            TesztFuggoFeladat b1 = new TesztFuggoFeladat("b1") { Vegrehajthato = true };
+//            TesztFuggoFeladat a2 = new TesztFuggoFeladat("a2") { Vegrehajthato = false };
+//            tarolo.Felvesz(a1);
+//            tarolo.Felvesz(b1);
+//            tarolo.Felvesz(a2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a1.Vegrehajtott, Is.False);
+//                Assert.That(b1.Vegrehajtott, Is.False);
+//                Assert.That(a2.Vegrehajtott, Is.False);
+//            });
+//            tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a' && x.FuggosegTeljesul; }); // csak 'a' kezdetű és végrehajtható
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a1.Vegrehajtott, Is.True);
+//                Assert.That(b1.Vegrehajtott, Is.False);
+//                Assert.That(a2.Vegrehajtott, Is.False);
+//            });
+//            tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'b' && x.FuggosegTeljesul; }); // csak 'b' kezdetű és végrehajtható
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a1.Vegrehajtott, Is.True);
+//                Assert.That(b1.Vegrehajtott, Is.True);
+//                Assert.That(a2.Vegrehajtott, Is.False);
+//            });
+//            a2.Vegrehajthato = true;
+//            tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a' && x.FuggosegTeljesul; }); // csak 'a' kezdetű és végrehajtható
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a1.Vegrehajtott, Is.True);
+//                Assert.That(b1.Vegrehajtott, Is.True);
+//                Assert.That(a2.Vegrehajtott, Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void Bejaro()
+//        {
+//            FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
+//            TesztFeladat a = new TesztFeladat("a");
+//            TesztFeladat b = new TesztFeladat("b");
+//            tarolo.Felvesz(a);
+//            tarolo.Felvesz(b);
+//            string nevek = "";
+//            foreach (TesztFeladat u in tarolo)
+//                nevek += u.Azonosito;
+//            Assert.That(nevek, Is.EqualTo("ab"));
+//        }
+//        [TestCase]
+//        public void FeltetelesBejaro()
+//        {
+//            FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10);
+//            tarolo.BejaroFeltetel = (x => { Guardian.Recursion.CheckStackTrace(); return x.FuggosegTeljesul; });
+//            TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
+//            TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = false };
+//            TesztFuggoFeladat c = new TesztFuggoFeladat("c") { Vegrehajthato = true };
+//            tarolo.Felvesz(a);
+//            tarolo.Felvesz(b);
+//            tarolo.Felvesz(c);
+//            string nevek = "";
+//            foreach (TesztFeladat u in tarolo)
+//                nevek += u.Azonosito;
+//            Assert.That(nevek, Is.EqualTo("ac"));
+//        }
+//    }
+//}

ALGA_heti_feladatok/Tesztek/03_TombImplementacioTesztek.cs

@@ -0,0 +1,399 @@
+using NUnit.Framework;
+using OE.ALGA.Adatszerkezetek;
+
+namespace OE.ALGA.Tesztek.Adatszerkezetek
+{
+   [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Lista Tesztek")]
+   public class TombListaTesztek
+   {
+       [TestCase]
+       public void Elemszam()
+       {
+           Lista<string> l = new TombLista<string>();
+           Assert.That(l.Elemszam, Is.EqualTo(0));
+           l.Hozzafuz("A");
+           Assert.That(l.Elemszam, Is.EqualTo(1));
+           l.Hozzafuz("B");
+           Assert.That(l.Elemszam, Is.EqualTo(2));
+           l.Torol("A");
+           Assert.That(l.Elemszam, Is.EqualTo(1));
+       }
+       [TestCase]
+       public void Bejaras()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(3);
+           l.Hozzafuz(2);
+           string s = "";
+           l.Bejar(x => { Guardian.Recursion.CheckStackTrace(); s += x.ToString(); });
+           Assert.That(s, Is.EqualTo("132"));
+       }
+       [TestCase]
+       public void Beszuras()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Beszur(0, 1);
+           l.Beszur(0, 2);
+           l.Beszur(1, 3);
+           l.Beszur(3, 4);
+           l.Beszur(2, 5);
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(2));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(3));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(5));
+               Assert.That(l.Kiolvas(3), Is.EqualTo(1));
+               Assert.That(l.Kiolvas(4), Is.EqualTo(4));
+           });
+       }
+       [TestCase]
+       public void BeszurasUres()
+       {
+           Lista<string> l = new TombLista<string>();
+           l.Beszur(0, "1");
+           l.Beszur(0, "2");
+           l.Beszur(1, "");
+           l.Beszur(3, "");
+           l.Beszur(2, "5");
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo("2"));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(""));
+               Assert.That(l.Kiolvas(2), Is.EqualTo("5"));
+               Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
+               Assert.That(l.Kiolvas(4), Is.EqualTo(""));
+           });
+       }
+       [TestCase]
+       public void HozzaFuzes()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(3);
+           l.Hozzafuz(2);
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(1));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(3));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(2));
+           });
+       }
+       [TestCase]
+       public void HozzaFuzesUres()
+       {
+           Lista<string> l = new TombLista<string>();
+           l.Hozzafuz("1");
+           l.Hozzafuz("");
+           l.Hozzafuz("");
+           l.Hozzafuz("1");
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(""));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(""));
+               Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
+           });
+       }
+       [TestCase]
+       public void Novekedes()
+       {
+           Lista<int> l = new TombLista<int>();
+           for (int i = 0; i < 1000; i++)
+               l.Hozzafuz(i * i);
+           Assert.That(l.Elemszam, Is.EqualTo(1000));
+           Assert.Multiple(() =>
+           {
+               for (int i = 0; i < 1000; i++)
+                   Assert.That(l.Kiolvas(i), Is.EqualTo(i * i));
+           });
+           Assert.That(l.Elemszam, Is.EqualTo(1000));
+       }
+       [TestCase]
+       public void Torles()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(3);
+           l.Hozzafuz(2);
+           l.Hozzafuz(3);
+           l.Hozzafuz(4);
+           Assert.That(l.Elemszam, Is.EqualTo(5));
+           l.Torol(3);
+           Assert.That(l.Elemszam, Is.EqualTo(3));
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(1));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(2));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(4));
+           });
+       }
+       [TestCase]
+       public void TorlesNincsElem()
+       {
+           Lista<int> l = new TombLista<int>();
+           Assert.That(l.Elemszam, Is.EqualTo(0));
+           l.Torol(0);
+           Assert.That(l.Elemszam, Is.EqualTo(0));
+       }
+       [TestCase]
+       public void TorlesUres()
+       {
+           Lista<string> l = new TombLista<string>();
+           l.Hozzafuz("1");
+           l.Hozzafuz("");
+           l.Hozzafuz("");
+           l.Hozzafuz("");
+           l.Hozzafuz("1");
+           Assert.That(l.Elemszam, Is.EqualTo(5));
+           l.Torol("");
+           Assert.That(l.Elemszam, Is.EqualTo(2));
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
+               Assert.That(l.Kiolvas(1), Is.EqualTo("1"));
+           });
+       }
+       [TestCase]
+       public void NemletezoTorles()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(2);
+           l.Hozzafuz(3);
+           Assert.That(l.Elemszam, Is.EqualTo(3));
+           l.Torol(0);
+           Assert.That(l.Elemszam, Is.EqualTo(3));
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(1));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(2));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(3));
+           });
+       }
+       [TestCase]
+       public void Modositas()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(3);
+           l.Hozzafuz(2);
+           l.Modosit(1, 5);
+           l.Modosit(0, 4);
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(4));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(5));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(2));
+           });
+       }
+       [TestCase]
+       public void ForeachBejaras()
+       {
+           TombLista<string> l = new TombLista<string>();
+           l.Hozzafuz("a");
+           l.Hozzafuz("c");
+           l.Hozzafuz("d");
+           l.Hozzafuz("b");
+           string osszefuzo = "";
+           foreach (string x in l)
+           {
+               osszefuzo += x;
+           }
+           Assert.That(osszefuzo, Is.EqualTo("acdb"));
+       }
+
+   }
+
+   [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Sor Tesztek")]
+   public class TombSorTesztek
+   {
+       [TestCase]
+       public void Ures()
+       {
+           Sor<int> s = new TombSor<int>(0);
+           Assert.That(s.Ures, Is.True);
+           Assert.Throws<NincsHelyKivetel>(() => s.Sorba(1));
+       }
+       [TestCase]
+       public void AlapMukodes()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           Assert.That(s.Ures, Is.True);
+           s.Sorba(1);
+           Assert.That(s.Ures, Is.False);
+           s.Sorba(3);
+           Assert.That(s.Ures, Is.False);
+           s.Sorba(2);
+           Assert.That(s.Ures, Is.False);
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Sorbol(), Is.EqualTo(1));
+               Assert.That(s.Ures, Is.False);
+               Assert.That(s.Sorbol(), Is.EqualTo(3));
+               Assert.That(s.Ures, Is.False);
+               Assert.That(s.Sorbol(), Is.EqualTo(2));
+               Assert.That(s.Ures, Is.True);
+           });
+       }
+       [TestCase]
+       public void UresElem()
+       {
+           Sor<string> s = new TombSor<string>(3);
+           s.Sorba("");
+           s.Sorba("1");
+           s.Sorba("");
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Sorbol(), Is.EqualTo(""));
+               Assert.That(s.Sorbol(), Is.EqualTo("1"));
+               Assert.That(s.Sorbol(), Is.EqualTo(""));
+           });
+       }
+       [TestCase]
+       public void Korbeeres()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           s.Sorba(1);
+           s.Sorba(3);
+           s.Sorba(2);
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Sorbol(), Is.EqualTo(1));
+               Assert.That(s.Sorbol(), Is.EqualTo(3));
+           });
+           s.Sorba(4);
+           s.Sorba(5);
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Sorbol(), Is.EqualTo(2));
+               Assert.That(s.Sorbol(), Is.EqualTo(4));
+               Assert.That(s.Sorbol(), Is.EqualTo(5));
+           });
+       }
+       [TestCase]
+       public void TulSokElem()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           s.Sorba(1);
+           s.Sorba(3);
+           s.Sorba(2);
+           Assert.Throws<NincsHelyKivetel>(() => s.Sorba(4));
+       }
+
+       [TestCase]
+       public void TulKevesElem()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           s.Sorba(1);
+           s.Sorba(3);
+           s.Sorba(2);
+           s.Sorbol();
+           s.Sorbol();
+           s.Sorbol();
+           Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
+       }
+       [TestCase]
+       public void Elso()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           s.Sorba(1);
+           s.Sorba(3);
+           s.Sorba(2);
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Elso(), Is.EqualTo(1));
+               Assert.That(s.Elso(), Is.EqualTo(1));
+           });
+           s.Sorbol();
+           Assert.That(s.Elso(), Is.EqualTo(3));
+       }
+   }
+
+   [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Verem Tesztek")]
+   public class TombVeremTesztek
+   {
+       [TestCase]
+       public void Ures()
+       {
+           Verem<int> v = new TombVerem<int>(0);
+           Assert.That(v.Ures, Is.True);
+           Assert.Throws<NincsHelyKivetel>(() => v.Verembe(1));
+       }
+       [TestCase]
+       public void AlapMukodes()
+       {
+           Verem<int> v = new TombVerem<int>(3);
+           Assert.That(v.Ures, Is.True);
+           v.Verembe(1);
+           Assert.That(v.Ures, Is.False);
+           v.Verembe(3);
+           Assert.That(v.Ures, Is.False);
+           v.Verembe(2);
+           Assert.That(v.Ures, Is.False);
+           Assert.That(v.Verembol(), Is.EqualTo(2));
+           Assert.That(v.Ures, Is.False);
+           v.Verembe(4);
+           Assert.That(v.Ures, Is.False);
+           Assert.Multiple(() =>
+           {
+               Assert.That(v.Verembol(), Is.EqualTo(4));
+               Assert.That(v.Ures, Is.False);
+               Assert.That(v.Verembol(), Is.EqualTo(3));
+               Assert.That(v.Ures, Is.False);
+               Assert.That(v.Verembol(), Is.EqualTo(1));
+               Assert.That(v.Ures, Is.True);
+           });
+       }
+       [TestCase]
+       public void UresElem()
+       {
+           Verem<string> v = new TombVerem<string>(3);
+           v.Verembe("");
+           v.Verembe("1");
+           v.Verembe("");
+           Assert.Multiple(() =>
+           {
+               Assert.That(v.Verembol(), Is.EqualTo(""));
+               Assert.That(v.Verembol(), Is.EqualTo("1"));
+               Assert.That(v.Verembol(), Is.EqualTo(""));
+           });
+       }
+       [TestCase]
+       public void TulSokElem()
+       {
+           Verem<int> v = new TombVerem<int>(3);
+           v.Verembe(1);
+           v.Verembe(3);
+           v.Verembe(2);
+           Assert.Throws<NincsHelyKivetel>(() => v.Verembe(4));
+       }
+       [TestCase]
+       public void TulKevesElem()
+       {
+           Verem<int> v = new TombVerem<int>(3);
+           v.Verembe(1);
+           v.Verembe(3);
+           v.Verembe(2);
+           v.Verembol();
+           v.Verembol();
+           v.Verembol();
+           Assert.Throws<NincsElemKivetel>(() => v.Verembol());
+       }
+       [TestCase]
+       public void Felso()
+       {
+           Verem<int> v = new TombVerem<int>(3);
+           v.Verembe(1);
+           v.Verembe(3);
+           v.Verembe(2);
+           Assert.Multiple(() =>
+           {
+               Assert.That(v.Felso(), Is.EqualTo(2));
+               Assert.That(v.Felso(), Is.EqualTo(2));
+           });
+           v.Verembol();
+           Assert.That(v.Felso(), Is.EqualTo(3));
+       }
+   }
+}

ALGA_heti_feladatok/Tesztek/04_EgyszeruLancTesztek.cs

@@ -0,0 +1,226 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using OE.ALGA.Adatszerkezetek;
+using Assert = Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace OE.ALGA.Tesztek
+{
+    [TestClass()]
+    public class LancoltVeremTesztek
+    {
+        [TestMethod()]
+        public void MindenJolMukodik() //F2.
+        {
+            Verem<int> v = new LancoltVerem<int>();
+            v.Verembe(1);
+            v.Verembe(3);
+            v.Verembe(2);
+            Assert.AreEqual(2, v.Verembol());
+            v.Verembe(4);
+            Assert.AreEqual(4, v.Verembol());
+            Assert.AreEqual(3, v.Verembol());
+            Assert.AreEqual(1, v.Verembol());
+        }
+
+        [TestMethod()]
+        [ExpectedException(typeof(NincsElemKivetel))]
+        public void TulKevesElem() //F2.
+        {
+            Verem<int> v = new LancoltVerem<int>();
+            v.Verembe(1);
+            v.Verembe(3);
+            v.Verembe(2);
+            v.Verembol();
+            v.Verembol();
+            v.Verembol();
+            v.Verembol();
+        }
+
+        [TestMethod()]
+        public void Felso() //F2.
+        {
+            Verem<int> v = new LancoltVerem<int>();
+            v.Verembe(1);
+            v.Verembe(3);
+            v.Verembe(2);
+            Assert.AreEqual(2, v.Felso());
+            Assert.AreEqual(2, v.Felso());
+            v.Verembol();
+            Assert.AreEqual(3, v.Felso());
+        }
+
+        [TestMethod()]
+        public void Ures() //F2.
+        {
+            Verem<int> v = new LancoltVerem<int>();
+            Assert.IsTrue(v.Ures);
+            v.Verembe(1);
+            Assert.IsFalse(v.Ures);
+            v.Verembol();
+            Assert.IsTrue(v.Ures);
+        }
+    }
+
+    [TestClass()]
+    public class LancoltSorTesztek
+    {
+        [TestMethod()]
+        public void AlapMukodes() //F3.
+        {
+            Sor<int> s = new LancoltSor<int>();
+            s.Sorba(1);
+            s.Sorba(3);
+            s.Sorba(2);
+            Assert.AreEqual(1, s.Sorbol());
+            Assert.AreEqual(3, s.Sorbol());
+            Assert.AreEqual(2, s.Sorbol());
+        }
+
+        [TestMethod()]
+        [ExpectedException(typeof(NincsElemKivetel))]
+        public void TulKevesElem() //F3.
+        {
+            Sor<int> s = new LancoltSor<int>();
+            s.Sorba(1);
+            s.Sorba(3);
+            s.Sorba(2);
+            s.Sorbol();
+            s.Sorbol();
+            s.Sorbol();
+            s.Sorbol();
+        }
+
+        [TestMethod()]
+        public void Elso() //F3.
+        {
+            Sor<int> s = new LancoltSor<int>();
+            s.Sorba(1);
+            s.Sorba(3);
+            s.Sorba(2);
+            Assert.AreEqual(1, s.Elso());
+            Assert.AreEqual(1, s.Elso());
+            s.Sorbol();
+            Assert.AreEqual(3, s.Elso());
+        }
+
+        [TestMethod()]
+        public void Ures() //F3.
+        {
+            Sor<int> s = new LancoltSor<int>();
+            Assert.IsTrue(s.Ures);
+            s.Sorba(1);
+            Assert.IsFalse(s.Ures);
+            s.Sorbol();
+            Assert.IsTrue(s.Ures);
+        }
+    }
+
+    [TestClass]
+    public class LancoltListaTesztek
+    {
+        [TestMethod]
+        public void Bejaras() //F4.
+        {
+            Lista<int> l = new LancoltLista<int>();
+            l.Hozzafuz(1);
+            l.Hozzafuz(3);
+            l.Hozzafuz(2);
+            string s = "";
+            l.Bejar(x => s += x.ToString());
+            Assert.AreEqual("132", s);
+        }
+
+        [TestMethod]
+        public void HozzaFuzes() //F4.
+        {
+            Lista<int> l = new LancoltLista<int>();
+            l.Hozzafuz(1);
+            l.Hozzafuz(3);
+            l.Hozzafuz(2);
+            Assert.AreEqual(1, l.Kiolvas(0));
+            Assert.AreEqual(3, l.Kiolvas(1));
+            Assert.AreEqual(2, l.Kiolvas(2));
+        }
+
+        [TestMethod]
+        public void Meret() //F4.
+        {
+            Lista<string> l = new LancoltLista<string>();
+            Assert.AreEqual(0, l.Elemszam);
+            l.Hozzafuz("A");
+            Assert.AreEqual(1, l.Elemszam);
+            l.Hozzafuz("B");
+            Assert.AreEqual(2, l.Elemszam);
+        }
+
+        [TestMethod]
+        public void Novekedes() //F4.
+        {
+            Lista<int> l = new LancoltLista<int>();
+            for (int i = 0; i < 1000; i++)
+                l.Hozzafuz(i * i);
+            for (int i = 0; i < 1000; i++)
+                Assert.AreEqual(i * i, l.Kiolvas(i));
+        }
+
+        [TestMethod]
+        public void Beszuras() //F4.
+        {
+            Lista<int> l = new LancoltLista<int>();
+            l.Beszur(0, 1);
+            l.Beszur(0, 2);
+            l.Beszur(1, 3);
+            l.Beszur(3, 4);
+            l.Beszur(2, 5);
+            Assert.AreEqual(2, l.Kiolvas(0));
+            Assert.AreEqual(3, l.Kiolvas(1));
+            Assert.AreEqual(5, l.Kiolvas(2));
+            Assert.AreEqual(1, l.Kiolvas(3));
+            Assert.AreEqual(4, l.Kiolvas(4));
+        }
+
+        [TestMethod]
+        public void Torles() //F4.
+        {
+            Lista<int> l = new LancoltLista<int>();
+            l.Hozzafuz(1);
+            l.Hozzafuz(3);
+            l.Hozzafuz(2);
+            l.Hozzafuz(3);
+            l.Hozzafuz(4);
+            l.Torol(3);
+            Assert.AreEqual(1, l.Kiolvas(0));
+            Assert.AreEqual(2, l.Kiolvas(1));
+            Assert.AreEqual(4, l.Kiolvas(2));
+        }
+
+        [TestMethod]
+        public void Modositas() //F4.
+        {
+            Lista<int> l = new LancoltLista<int>();
+            l.Hozzafuz(1);
+            l.Hozzafuz(3);
+            l.Hozzafuz(2);
+            l.Modosit(1, 5);
+            l.Modosit(0, 4);
+            Assert.AreEqual(4, l.Kiolvas(0));
+            Assert.AreEqual(5, l.Kiolvas(1));
+            Assert.AreEqual(2, l.Kiolvas(2));
+        }
+
+        [TestMethod]
+        public void ForeachBejaras() //F5.
+        {
+            LancoltLista<string> l = new LancoltLista<string>();
+            l.Hozzafuz("a");
+            l.Hozzafuz("c");
+            l.Hozzafuz("d");
+            l.Hozzafuz("b");
+            string osszefuzo = "";
+            foreach (string x in l)
+            {
+                osszefuzo += x;
+            }
+            Assert.AreEqual("acdb", osszefuzo);
+        }
+    }
+}

ALGA_heti_feladatok/Tesztek/04_LancoltImplementacioTesztek.cs

@@ -0,0 +1,353 @@
+//using NUnit.Framework;
+//using OE.ALGA.Adatszerkezetek;
+
+//namespace OE.ALGA.Tesztek.Adatszerkezetek
+//{
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "04 - Lancolt Lista Tesztek")]
+//    public class LancoltListaTesztek
+//    {
+//        [TestCase]
+//        public void Elemszam()
+//        {
+//            Lista<string> l = new LancoltLista<string>();
+//            Assert.That(l.Elemszam, Is.EqualTo(0));
+//            l.Hozzafuz("A");
+//            Assert.That(l.Elemszam, Is.EqualTo(1));
+//            l.Hozzafuz("B");
+//            Assert.That(l.Elemszam, Is.EqualTo(2));
+//            l.Torol("A");
+//            Assert.That(l.Elemszam, Is.EqualTo(1));
+//        }
+//        [TestCase]
+//        public void Bejaras()
+//        {
+//            Lista<int> l = new LancoltLista<int>();
+//            l.Hozzafuz(1);
+//            l.Hozzafuz(3);
+//            l.Hozzafuz(2);
+//            string s = "";
+//            l.Bejar(x => { Guardian.Recursion.CheckStackTrace(); s += x.ToString(); });
+//            Assert.That(s, Is.EqualTo("132"));
+//        }
+//        [TestCase]
+//        public void Beszuras()
+//        {
+//            Lista<int> l = new LancoltLista<int>();
+//            l.Beszur(0, 1);
+//            l.Beszur(0, 2);
+//            l.Beszur(1, 3);
+//            l.Beszur(3, 4);
+//            l.Beszur(2, 5);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(l.Kiolvas(0), Is.EqualTo(2));
+//                Assert.That(l.Kiolvas(1), Is.EqualTo(3));
+//                Assert.That(l.Kiolvas(2), Is.EqualTo(5));
+//                Assert.That(l.Kiolvas(3), Is.EqualTo(1));
+//                Assert.That(l.Kiolvas(4), Is.EqualTo(4));
+//            });
+//        }
+//        [TestCase]
+//        public void BeszurasUres()
+//        {
+//            Lista<string> l = new LancoltLista<string>();
+//            l.Beszur(0, "1");
+//            l.Beszur(0, "2");
+//            l.Beszur(1, "");
+//            l.Beszur(3, "");
+//            l.Beszur(2, "5");
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(l.Kiolvas(0), Is.EqualTo("2"));
+//                Assert.That(l.Kiolvas(1), Is.EqualTo(""));
+//                Assert.That(l.Kiolvas(2), Is.EqualTo("5"));
+//                Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
+//                Assert.That(l.Kiolvas(4), Is.EqualTo(""));
+//            });
+//        }
+//        [TestCase]
+//        public void HozzaFuzes()
+//        {
+//            Lista<int> l = new LancoltLista<int>();
+//            l.Hozzafuz(1);
+//            l.Hozzafuz(3);
+//            l.Hozzafuz(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(l.Kiolvas(0), Is.EqualTo(1));
+//                Assert.That(l.Kiolvas(1), Is.EqualTo(3));
+//                Assert.That(l.Kiolvas(2), Is.EqualTo(2));
+//            });
+//        }
+//        [TestCase]
+//        public void HozzaFuzesUres()
+//        {
+//            Lista<string> l = new LancoltLista<string>();
+//            l.Hozzafuz("1");
+//            l.Hozzafuz("");
+//            l.Hozzafuz("");
+//            l.Hozzafuz("1");
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
+//                Assert.That(l.Kiolvas(1), Is.EqualTo(""));
+//                Assert.That(l.Kiolvas(2), Is.EqualTo(""));
+//                Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
+//            });
+//        }
+//        [TestCase]
+//        public void Novekedes()
+//        {
+//            Lista<int> l = new LancoltLista<int>();
+//            for (int i = 0; i < 1000; i++)
+//                l.Hozzafuz(i * i);
+//            Assert.That(l.Elemszam, Is.EqualTo(1000));
+//            Assert.Multiple(() =>
+//            {
+//                for (int i = 0; i < 1000; i++)
+//                    Assert.That(l.Kiolvas(i), Is.EqualTo(i * i));
+//            });
+//            Assert.That(l.Elemszam, Is.EqualTo(1000));
+//        }
+//        [TestCase]
+//        public void Torles()
+//        {
+//            Lista<int> l = new LancoltLista<int>();
+//            l.Hozzafuz(1);
+//            l.Hozzafuz(3);
+//            l.Hozzafuz(2);
+//            l.Hozzafuz(3);
+//            l.Hozzafuz(4);
+//            Assert.That(l.Elemszam, Is.EqualTo(5));
+//            l.Torol(3);
+//            Assert.That(l.Elemszam, Is.EqualTo(3));
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(l.Kiolvas(0), Is.EqualTo(1));
+//                Assert.That(l.Kiolvas(1), Is.EqualTo(2));
+//                Assert.That(l.Kiolvas(2), Is.EqualTo(4));
+//            });
+//        }
+//        [TestCase]
+//        public void TorlesNincsElem()
+//        {
+//            Lista<int> l = new LancoltLista<int>();
+//            Assert.That(l.Elemszam, Is.EqualTo(0));
+//            l.Torol(0);
+//            Assert.That(l.Elemszam, Is.EqualTo(0));
+//        }
+//        [TestCase]
+//        public void TorlesUres()
+//        {
+//            Lista<string> l = new LancoltLista<string>();
+//            l.Hozzafuz("1");
+//            l.Hozzafuz("");
+//            l.Hozzafuz("");
+//            l.Hozzafuz("");
+//            l.Hozzafuz("1");
+//            Assert.That(l.Elemszam, Is.EqualTo(5));
+//            l.Torol("");
+//            Assert.That(l.Elemszam, Is.EqualTo(2));
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
+//                Assert.That(l.Kiolvas(1), Is.EqualTo("1"));
+//            });
+//        }
+//        [TestCase]
+//        public void NemletezoTorles()
+//        {
+//            Lista<int> l = new LancoltLista<int>();
+//            l.Hozzafuz(1);
+//            l.Hozzafuz(2);
+//            l.Hozzafuz(3);
+//            Assert.That(l.Elemszam, Is.EqualTo(3));
+//            l.Torol(0);
+//            Assert.That(l.Elemszam, Is.EqualTo(3));
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(l.Kiolvas(0), Is.EqualTo(1));
+//                Assert.That(l.Kiolvas(1), Is.EqualTo(2));
+//                Assert.That(l.Kiolvas(2), Is.EqualTo(3));
+//            });
+//        }
+//        [TestCase]
+//        public void Modositas()
+//        {
+//            Lista<int> l = new LancoltLista<int>();
+//            l.Hozzafuz(1);
+//            l.Hozzafuz(3);
+//            l.Hozzafuz(2);
+//            l.Modosit(1, 5);
+//            l.Modosit(0, 4);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(l.Kiolvas(0), Is.EqualTo(4));
+//                Assert.That(l.Kiolvas(1), Is.EqualTo(5));
+//                Assert.That(l.Kiolvas(2), Is.EqualTo(2));
+//            });
+//        }
+//        [TestCase]
+//        public void ForeachBejaras()
+//        {
+//            LancoltLista<string> l = new LancoltLista<string>();
+//            l.Hozzafuz("a");
+//            l.Hozzafuz("c");
+//            l.Hozzafuz("d");
+//            l.Hozzafuz("b");
+//            string osszefuzo = "";
+//            foreach (string x in l)
+//            {
+//                osszefuzo += x;
+//            }
+//            Assert.That(osszefuzo, Is.EqualTo("acdb"));
+//        }
+//    }
+
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "04 - Lancolt Sor Tesztek")]
+//    public class LancoltSorTesztek
+//    {
+//        [TestCase]
+//        public void Ures()
+//        {
+//            Sor<int> s = new LancoltSor<int>();
+//            Assert.That(s.Ures, Is.True);
+//            Assert.Throws<NincsElemKivetel>(() => s.Elso());
+//            Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
+//            s.Sorba(1);
+//            Assert.That(s.Ures, Is.False);
+//            s.Sorbol();
+//            Assert.That(s.Ures, Is.True);
+//        }
+//        [TestCase]
+//        public void AlapMukodes()
+//        {
+//            Sor<int> s = new LancoltSor<int>();
+//            s.Sorba(1);
+//            s.Sorba(3);
+//            s.Sorba(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(s.Sorbol(), Is.EqualTo(1));
+//                Assert.That(s.Sorbol(), Is.EqualTo(3));
+//                Assert.That(s.Sorbol(), Is.EqualTo(2));
+//            });
+//        }
+//        [TestCase]
+//        public void UresElem()
+//        {
+//            Sor<string> s = new LancoltSor<string>();
+//            s.Sorba("");
+//            s.Sorba("1");
+//            s.Sorba("");
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(s.Sorbol(), Is.EqualTo(""));
+//                Assert.That(s.Sorbol(), Is.EqualTo("1"));
+//                Assert.That(s.Sorbol(), Is.EqualTo(""));
+//            });
+//        }
+//        [TestCase]
+//        public void TulKevesElem()
+//        {
+//            Sor<int> s = new LancoltSor<int>();
+//            s.Sorba(1);
+//            s.Sorba(3);
+//            s.Sorba(2);
+//            s.Sorbol();
+//            s.Sorbol();
+//            s.Sorbol();
+//            Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
+//        }
+//        [TestCase]
+//        public void Elso()
+//        {
+//            Sor<int> s = new LancoltSor<int>();
+//            s.Sorba(1);
+//            s.Sorba(3);
+//            s.Sorba(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(s.Elso(), Is.EqualTo(1));
+//                Assert.That(s.Elso(), Is.EqualTo(1));
+//            });
+//            s.Sorbol();
+//            Assert.That(s.Elso(), Is.EqualTo(3));
+//        }
+//    }
+
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "04 - Lancolt Verem Tesztek")]
+//    public class LancoltVeremTesztek
+//    {
+//        [TestCase]
+//        public void Ures()
+//        {
+//            Verem<int> v = new LancoltVerem<int>();
+//            Assert.That(v.Ures, Is.True);
+//            Assert.Throws<NincsElemKivetel>(() => v.Felso());
+//            Assert.Throws<NincsElemKivetel>(() => v.Verembol());
+//            v.Verembe(1);
+//            Assert.That(v.Ures, Is.False);
+//            v.Verembol();
+//            Assert.That(v.Ures, Is.True);
+//        }
+//        [TestCase]
+//        public void AlapMukodes()
+//        {
+//            Verem<int> v = new LancoltVerem<int>();
+//            v.Verembe(1);
+//            v.Verembe(3);
+//            v.Verembe(2);
+//            Assert.That(v.Verembol(), Is.EqualTo(2));
+//            v.Verembe(4);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Verembol(), Is.EqualTo(4));
+//                Assert.That(v.Verembol(), Is.EqualTo(3));
+//                Assert.That(v.Verembol(), Is.EqualTo(1));
+//            });
+//        }
+//        [TestCase]
+//        public void UresElem()
+//        {
+//            Verem<string> v = new LancoltVerem<string>();
+//            v.Verembe("");
+//            v.Verembe("1");
+//            v.Verembe("");
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Verembol(), Is.EqualTo(""));
+//                Assert.That(v.Verembol(), Is.EqualTo("1"));
+//                Assert.That(v.Verembol(), Is.EqualTo(""));
+//            });
+//        }
+//        [TestCase]
+//        public void TulKevesElem()
+//        {
+//            Verem<int> v = new LancoltVerem<int>();
+//            v.Verembe(1);
+//            v.Verembe(3);
+//            v.Verembe(2);
+//            v.Verembol();
+//            v.Verembol();
+//            v.Verembol();
+//            Assert.Throws<NincsElemKivetel>(() => v.Verembol());
+//        }
+//        [TestCase]
+//        public void Felso()
+//        {
+//            Verem<int> v = new LancoltVerem<int>();
+//            v.Verembe(1);
+//            v.Verembe(3);
+//            v.Verembe(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Felso(), Is.EqualTo(2));
+//                Assert.That(v.Felso(), Is.EqualTo(2));
+//            });
+//            v.Verembol();
+//            Assert.That(v.Felso(), Is.EqualTo(3));
+//        }
+
+//    }
+//}

ALGA_heti_feladatok/Tesztek/05_BinarisKeresoFaTesztek.cs

@@ -0,0 +1,125 @@
+//using NUnit.Framework;
+//using OE.ALGA.Adatszerkezetek;
+
+//namespace OE.ALGA.Tesztek.Adatszerkezetek
+//{
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "05 - Fa Halmaz Tesztek")]
+//    public class FaHalmazTesztek
+//    {
+//        [TestCase]
+//        public void BeszurasUres()
+//        {
+//            Halmaz<string> v = new FaHalmaz<string>();
+//            v.Beszur("");
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Eleme(""), Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void Beszuras()
+//        {
+//            Halmaz<int> v = new FaHalmaz<int>();
+//            v.Beszur(1);
+//            v.Beszur(3);
+//            v.Beszur(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Eleme(1), Is.True);
+//                Assert.That(v.Eleme(2), Is.True);
+//                Assert.That(v.Eleme(3), Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void DuplaBeszuras()
+//        {
+//            Halmaz<int> v = new FaHalmaz<int>();
+//            v.Beszur(1);
+//            v.Beszur(2);
+//            v.Beszur(3);
+//            v.Beszur(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Eleme(1), Is.True);
+//                Assert.That(v.Eleme(2), Is.True);
+//                Assert.That(v.Eleme(3), Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void Torles()
+//        {
+//            Halmaz<int> v = new FaHalmaz<int>();
+//            v.Beszur(1);
+//            v.Beszur(3);
+//            v.Beszur(2);
+//            v.Torol(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Eleme(1), Is.True);
+//                Assert.That(v.Eleme(2), Is.False);
+//                Assert.That(v.Eleme(3), Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void TorlesUres()
+//        {
+//            Halmaz<string> v = new FaHalmaz<string>();
+//            v.Beszur("");
+//            v.Beszur("1");
+//            v.Beszur("");
+//            v.Torol("");
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Eleme(""), Is.False);
+//                Assert.That(v.Eleme("1"), Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void NemletezoTorles()
+//        {
+//            Halmaz<int> v = new FaHalmaz<int>();
+//            v.Beszur(1);
+//            v.Beszur(3);
+//            v.Beszur(2);
+//            Assert.Throws<NincsElemKivetel>(() => v.Torol(0));
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Eleme(1), Is.True);
+//                Assert.That(v.Eleme(2), Is.True);
+//                Assert.That(v.Eleme(3), Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void DuplaTorles()
+//        {
+//            Halmaz<int> v = new FaHalmaz<int>();
+//            v.Beszur(1);
+//            v.Beszur(2);
+//            v.Beszur(3);
+//            v.Beszur(2);
+//            v.Torol(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(v.Eleme(1), Is.True);
+//                Assert.That(v.Eleme(2), Is.False);
+//                Assert.That(v.Eleme(3), Is.True);
+//                Assert.That(v.Eleme(4), Is.False);
+//            });
+//        }
+//        [TestCase]
+//        public void PreorderBejaras()
+//        {
+//            Halmaz<int> v = new FaHalmaz<int>();
+//            v.Beszur(5);
+//            v.Beszur(3);
+//            v.Beszur(1);
+//            v.Beszur(8);
+//            v.Beszur(4);
+//            v.Beszur(9);
+//            v.Beszur(7);
+//            string osszefuzo = "";
+//            v.Bejar(x => osszefuzo += x);
+//            Assert.That(osszefuzo, Is.EqualTo("5314879"));
+//        }
+//    }
+//}

ALGA_heti_feladatok/Tesztek/06_SzotarTesztek.cs

@@ -0,0 +1,112 @@
+//using NUnit.Framework;
+//using OE.ALGA.Adatszerkezetek;
+
+//namespace OE.ALGA.Tesztek.Adatszerkezetek
+//{
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "06 - Szótár Tesztek")]
+//    public class SzotarTesztek
+//    {
+//        private static int TesztHasitoFuggveny(string kulcs)
+//        {
+//            if (string.IsNullOrEmpty(kulcs))
+//                return 0;
+//            int sum = 0;
+//            foreach (char c in kulcs.ToCharArray())
+//                sum += ((byte)c);
+//            return sum * sum; // a modulo osztást a szótárnak kell végeznie, mert ő tudja csak a belső tömb méretet
+//        }
+
+//        [TestCase]
+//        public void AlapMukodes()
+//        {
+//            Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
+//            sz.Beir("Bela", 5);
+//            sz.Beir("Lajos", 2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
+//                Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
+//            });
+//        }
+//        [TestCase]
+//        public void AlapertelmezettHasitoFuggvennyel() //F2.(f)
+//        {
+//            Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10);
+//            sz.Beir("Bela", 5);
+//            sz.Beir("Lajos", 2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
+//                Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
+//            });
+//        }
+//        [TestCase]
+//        public void Kulcsutkozes()
+//        {
+//            Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
+//            sz.Beir("Bela", 5);
+//            sz.Beir("Bale", 15);
+//            sz.Beir("Lajos", 2);
+//            sz.Beir("Lasoj", 12);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
+//                Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
+//                Assert.That(sz.Kiolvas("Bale"), Is.EqualTo(15));
+//                Assert.That(sz.Kiolvas("Lasoj"), Is.EqualTo(12));
+//            });
+//        }
+//        [TestCase]
+//        public void NullElem()
+//        {
+//            Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
+//            sz.Beir("null", null!);
+//        }
+//        [TestCase]
+//        public void UresKulcs()
+//        {
+//            Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
+//            sz.Beir("", 0);
+//        }
+//        [TestCase]
+//        public void UresElem()
+//        {
+//            Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
+//            sz.Beir("Bela", "");
+//        }
+//        [TestCase]
+//        public void NincsElem()
+//        {
+//            Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
+//            sz.Beir("Bela", 5);
+//            sz.Beir("Lajos", 2);
+//            Assert.Throws<HibasKulcsKivetel>(() => sz.Kiolvas("Ferenc"));
+//        }
+//        [TestCase]
+//        public void TorlesNull()
+//        {
+//            Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
+//            sz.Beir("Bela", 5);
+//            sz.Beir("Lajos", 2);
+//            Assert.Throws<HibasKulcsKivetel>(() => sz.Torol(null!));
+//        }
+//        [TestCase]
+//        public void TorlesMarad()
+//        {
+//            Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
+//            sz.Beir("Bela", 5);
+//            sz.Beir("Lajos", 2);
+//            sz.Torol("Bela");
+//            Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
+//        }
+//        [TestCase]
+//        public void TorlesEltunt()
+//        {
+//            Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
+//            sz.Beir("Bela", 5);
+//            sz.Beir("Lajos", 2);
+//            sz.Torol("Bela");
+//            Assert.Throws<HibasKulcsKivetel>(() => sz.Kiolvas("Bela"));
+//        }
+//    }
+//}

ALGA_heti_feladatok/Tesztek/07_NyersEroTesztek.cs

@@ -0,0 +1,162 @@
+//using NUnit.Framework;
+//using System;
+//using OE.ALGA.Optimalizalas;
+
+//namespace OE.ALGA.Tesztek.Optimalizalas
+//{
+//    [TestFixture(Category = "Optimalizalas", TestName = "07 - Hátiszák Tesztek")]
+//    public class HatizsakTesztek
+//    {
+//        [TestCase]
+//        public void UresTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(0, 0, [], []);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(problema.OsszSuly(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
+//                Assert.That(problema.OsszSuly(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(0));
+//                Assert.That(problema.OsszSuly(PakolasTesztEsetek.feligPakolas), Is.EqualTo(0));
+//            });
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(problema.OsszErtek(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
+//                Assert.That(problema.OsszErtek(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(0));
+//                Assert.That(problema.OsszErtek(PakolasTesztEsetek.feligPakolas), Is.EqualTo(0));
+//            });
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(problema.Ervenyes(PakolasTesztEsetek.uresPakolas), Is.True);
+//                Assert.That(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas), Is.True);
+//                Assert.That(problema.Ervenyes(PakolasTesztEsetek.feligPakolas), Is.True);
+//            });
+//        }
+//        [TestCase]
+//        public void SulyTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(problema.OsszSuly(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
+//                Assert.That(problema.OsszSuly(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(10));
+//                Assert.That(problema.OsszSuly(PakolasTesztEsetek.feligPakolas), Is.EqualTo(2));
+//            });
+//        }
+//        [TestCase]
+//        public void JosagTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(problema.OsszErtek(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
+//                Assert.That(problema.OsszErtek(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(29));
+//                Assert.That(problema.OsszErtek(PakolasTesztEsetek.feligPakolas), Is.EqualTo(11));
+//            });
+//        }
+//        [TestCase]
+//        public void ErvenyesTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(problema.Ervenyes(PakolasTesztEsetek.uresPakolas), Is.True);
+//                Assert.That(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas), Is.False);
+//                Assert.That(problema.Ervenyes(PakolasTesztEsetek.feligPakolas), Is.True);
+//            });
+//        }
+//    }
+
+//    [TestFixture(Category = "Optimalizalas", TestName = "07 - Nyers Ero Tesztek")]
+//    public class NyersEroTesztek
+//    {
+//        [TestCase]
+//        public void UresTeszt()
+//        {
+//            int[] A = { 4, 6, 7, 4, 2, 1 };
+//            NyersEro<int> opt = new NyersEro<int>(
+//                0,
+//                x => { Guardian.Recursion.CheckStackTrace(); return A[x - 1]; },
+//                x => { Guardian.Recursion.CheckStackTrace(); return x; });
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisMegoldas(), Is.EqualTo(4));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(0));
+//            });
+//        }
+//        [TestCase]
+//        public void TombLegnagyobbEleme()
+//        {
+//            int[] A = { 4, 6, 7, 4, 2, 1 };
+//            NyersEro<int> opt = new NyersEro<int>(
+//                A.Length,
+//                x => { Guardian.Recursion.CheckStackTrace(); return A[x - 1]; },
+//                x => { Guardian.Recursion.CheckStackTrace(); return x; });
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisMegoldas(), Is.EqualTo(7));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(5));
+//            });
+//        }
+
+//    }
+
+//    [TestFixture(Category = "Optimalizalas", TestName = "07 - Nyers Ero Hátizsák Pakolás Tesztek")]
+//    public class NyersEroHatizsakPakolasTesztek
+//    {
+//        [TestCase]
+//        public void UresTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(0, 0, [], []);
+//            NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(0));
+//                Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(Array.Empty<bool>()));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(0));
+//            });
+//        }
+//        [TestCase]
+//        public void JegyzetbenLevoPeldaErtekTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.jegyzet_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(63));
+//            });
+//        }
+//        [TestCase]
+//        public void JegyzetbenLevoPeldaMegoldasTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.jegyzet_optimalis_pakolas));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(63));
+//            });
+//        }
+//        [TestCase]
+//        public void NagyPeldaMegoldasErtekTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//            NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(131071));
+//            });
+//        }
+//        [TestCase]
+//        public void NagyPeldaMegoldasTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//            NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.nagy_optimalis_pakolas));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(131071));
+//            });
+//        }
+//    }
+//}

ALGA_heti_feladatok/Tesztek/08_DinamikusProgramozasTesztek.cs

@@ -0,0 +1,67 @@
+//using NUnit.Framework;
+//using System;
+//using OE.ALGA.Optimalizalas;
+
+//namespace OE.ALGA.Tesztek.Optimalizalas
+//{
+//    [TestFixture(Category = "Optimalizalas", TestName = "08 - Dinamikus Programozás Tesztek")]
+//    public class DinamikusProgramozasTesztek
+//    {
+//        [TestCase]
+//        public void UresTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(0, 0, [], []);
+//            DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(0));
+//                Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(Array.Empty<bool>()));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(0));
+//            });
+//        }
+//        [TestCase]
+//        public void JegyzetbenLevoPeldaErtekTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.jegyzet_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(24));
+//            });
+//        }
+//        [TestCase]
+//        public void JegyzetbenLevoPeldaMegoldasTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.jegyzet_optimalis_pakolas));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(24));
+//            });
+//        }
+//        [TestCase]
+//        public void NagyPeldaMegoldasErtekTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//            DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(1700));
+//            });
+//        }
+//        [TestCase]
+//        public void NagyPeldaMegoldasTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//            DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.nagy_optimalis_pakolas));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(1700));
+//            });
+//        }
+//    }
+//}

ALGA_heti_feladatok/Tesztek/09_VisszalepesesKereses.cs

@@ -0,0 +1,103 @@
+//using NUnit.Framework;
+//using OE.ALGA.Optimalizalas;
+
+//namespace OE.ALGA.Tesztek.Optimalizalas
+//{
+//    [TestFixture(Category = "Optimalizalas", TestName = "09 - Visszalépéses Keresés Tesztek")]
+//    public class VisszalepesesKeresesTesztek
+//    {
+//        [TestCase]
+//        public void JegyzetbenLevoPeldaErtekTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.jegyzet_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(98));
+//            });
+//        }
+//        [TestCase]
+//        public void JegyzetbenLevoPeldaMegoldasTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.jegyzet_optimalis_pakolas));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(98));
+//            });
+//        }
+//        [TestCase]
+//        public void NagyPeldaMegoldasTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//            VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(4832));
+//            });
+//        }
+//        [TestCase]
+//        public void LepesszamVizsgalat()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//            VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(4832));
+//            });
+//        }
+//    }
+
+//    [TestFixture(Category = "Optimalizalas", TestName = "09 - Szétválasztás és Korlátozás Tesztek")]
+//    public class SzetvalasztasEsKorlatozasTesztek
+//    {
+//        [TestCase]
+//        public void JegyzetbenLevoPeldaErtekTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.jegyzet_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(62));
+//            });
+//        }
+//        [TestCase]
+//        public void JegyzetbenLevoPeldaMegoldasTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//            SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.jegyzet_optimalis_pakolas));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(62));
+//            });
+//        }
+//        [TestCase]
+//        public void NagyPeldaMegoldasTeszt()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//            SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(618));
+//            });
+//        }
+//        [TestCase]
+//        public void LepesszamVizsgalat()
+//        {
+//            HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//            SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
+//                Assert.That(opt.LepesSzam, Is.EqualTo(618));
+//            });
+//        }
+//    }
+//}

ALGA_heti_feladatok/Tesztek/09_VisszalepesesKeresesTesztek.cs

@@ -0,0 +1,79 @@
+// using Microsoft.VisualStudio.TestTools.UnitTesting;
+// using OE.ALGA.Optimalizalas;
+// 
+// namespace OE.ALGA.Tesztek
+// {
+//     [TestClass()]
+//     public class VisszalepesesKeresesTesztek
+//     {
+//         [TestMethod()]
+//         public void JegyzetbenLevoPeldaErtekTeszt() //F2.
+//         {
+//             HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//             VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema);
+//             Assert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_ertek, opt.OptimalisErtek());
+//         }
+// 
+//         [TestMethod()]
+//         public void JegyzetbenLevoPeldaMegoldasTeszt() //F2.
+//         {
+//             HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//             VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema);
+//             CollectionAssert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_pakolas, opt.OptimalisMegoldas());
+//         }
+// 
+//         [TestMethod()]
+//         public void NagyPeldaMegoldasTeszt() //F2.
+//         {
+//             HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//             VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema);
+//             Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek());
+//         }
+// 
+//         [TestMethod()]
+//         public void LepesszamVizsgalat() //F2.
+//         {
+//             HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//             VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema);
+//             Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek());
+//             Console.WriteLine("Lépésszám: " + opt.LepesSzam);
+//         }
+//     }
+// 
+//     [TestClass()]
+//     public class SzetvalasztasEsKorlatozasTesztek
+//     {
+//         [TestMethod()]
+//         public void JegyzetbenLevoPeldaErtekTeszt() //F4.
+//         {
+//             HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//             SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
+//             Assert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_ertek, opt.OptimalisErtek());
+//         }
+// 
+//         [TestMethod()]
+//         public void JegyzetbenLevoPeldaMegoldasTeszt() //F4.
+//         {
+//             HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
+//             SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
+//             CollectionAssert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_pakolas, opt.OptimalisMegoldas());
+//         }
+// 
+//         [TestMethod()]
+//         public void NagyPeldaMegoldasTeszt() //F4.
+//         {
+//             HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//             SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
+//             Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek());
+//         }
+// 
+//         [TestMethod()]
+//         public void LepesszamVizsgalat() //F4.
+//         {
+//             HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
+//             SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
+//             Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek());
+//             Console.WriteLine("Lépésszám: " + opt.LepesSzam);
+//         }
+//     }
+// }

ALGA_heti_feladatok/Tesztek/10_SulyozatlanGrafTesztek.cs

@@ -0,0 +1,138 @@
+//using NUnit.Framework;
+//using OE.ALGA.Adatszerkezetek;
+
+
+//namespace OE.ALGA.Tesztek.Adatszerkezetek
+//{
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "10 - Csúcsmátrix Gráf Tesztek")]
+//    public class CsucsMatrixGrafTesztek
+//    {
+//        [TestCase]
+//        public void MindenCsucsTeszt()
+//        {
+//            CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(csg.Csucsok.Eleme(0), Is.True);
+//                Assert.That(csg.Csucsok.Eleme(1), Is.True);
+//            });
+//        }
+
+//        [TestCase]
+//        public void MindenElTeszt()
+//        {
+//            CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3);
+//            csg.UjEl(0, 1);
+//            csg.UjEl(0, 2);
+//            csg.UjEl(1, 2);
+
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(csg.Elek.Eleme(new EgeszGrafEl(0, 0)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new EgeszGrafEl(0, 1)), Is.True);
+//                Assert.That(csg.Elek.Eleme(new EgeszGrafEl(0, 2)), Is.True);
+
+//                Assert.That(csg.Elek.Eleme(new EgeszGrafEl(1, 0)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new EgeszGrafEl(1, 1)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new EgeszGrafEl(1, 2)), Is.True);
+
+//                Assert.That(csg.Elek.Eleme(new EgeszGrafEl(2, 0)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new EgeszGrafEl(2, 1)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new EgeszGrafEl(2, 2)), Is.False);
+//            });
+//        }
+
+//        [TestCase]
+//        public void VezetElTeszt()
+//        {
+//            CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2);
+//            Assert.That(csg.VezetEl(0, 1), Is.False);
+//            csg.UjEl(0, 1);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(csg.VezetEl(0, 1), Is.True);
+//                Assert.That(csg.VezetEl(1, 0), Is.False);
+//            });
+//        }
+
+//        [TestCase]
+//        public void SzomszedsagTeszt()
+//        {
+//            CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3);
+//            csg.UjEl(0, 1);
+//            csg.UjEl(0, 2);
+//            csg.UjEl(1, 2);
+
+//            Halmaz<int> a_szomszedai = csg.Szomszedai(0);
+//            Halmaz<int> b_szomszedai = csg.Szomszedai(1);
+//            Halmaz<int> c_szomszedai = csg.Szomszedai(2);
+
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a_szomszedai.Eleme(0), Is.False);
+//                Assert.That(a_szomszedai.Eleme(1), Is.True);
+//                Assert.That(a_szomszedai.Eleme(2), Is.True);
+
+//                Assert.That(b_szomszedai.Eleme(0), Is.False);
+//                Assert.That(b_szomszedai.Eleme(1), Is.False);
+//                Assert.That(b_szomszedai.Eleme(2), Is.True);
+
+//                Assert.That(c_szomszedai.Eleme(0), Is.False);
+//                Assert.That(c_szomszedai.Eleme(1), Is.False);
+//                Assert.That(c_szomszedai.Eleme(2), Is.False);
+//            });
+//        }
+//    }
+
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "10 - Gráf Bejárás Tesztek")]
+//    public class GrafBejarasTesztek
+//    {
+//        [TestCase]
+//        public void SzelessegiBejarasTeszt()
+//        {
+//            CsucsmatrixSulyozatlanEgeszGraf g = new CsucsmatrixSulyozatlanEgeszGraf(6);
+//            g.UjEl(0, 1);
+//            g.UjEl(1, 2);
+//            g.UjEl(1, 4);
+//            g.UjEl(2, 3);
+//            g.UjEl(2, 4);
+//            g.UjEl(4, 3);
+//            g.UjEl(3, 0);
+
+//            string ut = "";
+//            Halmaz<int> elertCsucsok = GrafBejarasok.SzelessegiBejaras(g, 0, (a) => { ut += a; });
+
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(ut == "01243" || ut == "01423", Is.True);
+//                for (int i = 0; i <= 4; i++)
+//                    Assert.That(elertCsucsok.Eleme(i), Is.True);
+//                Assert.That(elertCsucsok.Eleme(6), Is.False);
+//            });
+//        }
+
+//        [TestCase]
+//        public void MelysegiBejarasTeszt()
+//        {
+//            CsucsmatrixSulyozatlanEgeszGraf g = new CsucsmatrixSulyozatlanEgeszGraf(6);
+//            g.UjEl(0, 1);
+//            g.UjEl(1, 2);
+//            g.UjEl(1, 4);
+//            g.UjEl(2, 3);
+//            g.UjEl(2, 4);
+//            g.UjEl(4, 3);
+//            g.UjEl(3, 0);
+
+//            string ut = "";
+//            Halmaz<int> elertCsucsok = GrafBejarasok.MelysegiBejaras(g, 0, (a) => { ut += a; });
+
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(ut == "01243" || ut == "01432" || ut == "01234", Is.True);
+//                for (int i = 0; i <= 4; i++)
+//                    Assert.That(elertCsucsok.Eleme(i), Is.True);
+//                Assert.That(elertCsucsok.Eleme(6), Is.False);
+//            });
+//        }
+//    }
+//}

ALGA_heti_feladatok/Tesztek/11_KupacTesztek.cs

@@ -0,0 +1,240 @@
+//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));
+//            });
+//        }
+//    }
+//}

ALGA_heti_feladatok/Tesztek/12_SulyozottGrafTesztek.cs

@@ -0,0 +1,278 @@
+//using NUnit.Framework;
+//using OE.ALGA.Adatszerkezetek;
+
+//namespace OE.ALGA.Tesztek.Adatszerkezetek
+//{
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Csúcs Mátrix Súlyozott Gráf Tesztek")]
+//    public class CsucsMatrixSulyozottGrafTesztek
+//    {
+//        [TestCase]
+//        public void MindenCsucsTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(csg.Csucsok.Eleme(0), Is.True);
+//                Assert.That(csg.Csucsok.Eleme(1), Is.True);
+//            });
+//        }
+
+//        [TestCase]
+//        public void MindenElTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
+//            csg.UjEl(0, 1, 1.0f);
+//            csg.UjEl(0, 2, 2.0f);
+//            csg.UjEl(1, 2, 3.0f);
+
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 0, 0.0f)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 1.0f)), Is.True);
+//                Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 2.0f)), Is.True);
+
+//                Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 0, 0.0f)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 1, 0.0f)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 3.0f)), Is.True);
+
+//                Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 0, 0.0f)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 1, 0.0f)), Is.False);
+//                Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 2, 0.0f)), Is.False);
+//            });
+//        }
+
+//        [TestCase]
+//        public void VezetElTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
+//            Assert.That(csg.VezetEl(0, 1), Is.False);
+//            csg.UjEl(0, 1, 1.0f);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(csg.VezetEl(0, 1), Is.True);
+//                Assert.That(csg.VezetEl(1, 0), Is.False);
+//            });
+//        }
+
+//        [TestCase]
+//        public void SzomszedsagTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
+//            csg.UjEl(0, 1, 1.0f);
+//            csg.UjEl(0, 2, 1.0f);
+//            csg.UjEl(1, 2, 1.0f);
+
+//            Halmaz<int> a_szomszedai = csg.Szomszedai(0);
+//            Halmaz<int> b_szomszedai = csg.Szomszedai(1);
+//            Halmaz<int> c_szomszedai = csg.Szomszedai(2);
+
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(a_szomszedai.Eleme(0), Is.False);
+//                Assert.That(a_szomszedai.Eleme(1), Is.True);
+//                Assert.That(a_szomszedai.Eleme(2), Is.True);
+
+//                Assert.That(b_szomszedai.Eleme(0), Is.False);
+//                Assert.That(b_szomszedai.Eleme(1), Is.False);
+//                Assert.That(b_szomszedai.Eleme(2), Is.True);
+
+//                Assert.That(c_szomszedai.Eleme(0), Is.False);
+//                Assert.That(c_szomszedai.Eleme(1), Is.False);
+//                Assert.That(c_szomszedai.Eleme(2), Is.False);
+//            });
+//        }
+
+//        [TestCase]
+//        public void NemLetezoElTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
+//            csg.UjEl(0, 1, 1.0f);
+//            csg.UjEl(0, 2, 1.0f);
+//            Assert.Throws<NincsElKivetel>(() => csg.Suly(1, 0));
+//        }
+
+//        [TestCase]
+//        public void ElSulyTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
+//            csg.UjEl(0, 1, 2.0f);
+//            csg.UjEl(0, 2, 3.0f);
+//            float szum = 0.0f;
+//            csg.Elek.Bejar(x => szum += csg.Suly(x.Honnan, x.Hova));
+//            Assert.That(szum, Is.EqualTo(5.0f));
+//        }
+//    }
+
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Min Feszítőfa Tesztek")]
+//    public class GrafMinFeszitofaTesztek
+//    {
+//        [TestCase]
+//        public void KisPrimTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
+//            csg.UjEl(0, 1, 10.0f);
+//            csg.UjEl(0, 2, 20.0f);
+//            csg.UjEl(1, 2, 5.0f);
+//            Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(elek.Kiolvas(1), Is.EqualTo(0));
+//                Assert.That(elek.Kiolvas(2), Is.EqualTo(1));
+//            });
+//        }
+
+//        [TestCase]
+//        public void NagyPrimTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
+//            csg.UjEl(0, 1, 5.0f);
+//            csg.UjEl(0, 3, 4.0f);
+
+//            csg.UjEl(1, 0, 5.0f);
+//            csg.UjEl(1, 3, 2.0f);
+//            csg.UjEl(1, 2, 1.0f);
+
+//            csg.UjEl(2, 1, 1.0f);
+//            csg.UjEl(2, 3, 3.0f);
+//            csg.UjEl(2, 4, 4.0f);
+
+//            csg.UjEl(3, 0, 4.0f);
+//            csg.UjEl(3, 1, 2.0f);
+//            csg.UjEl(3, 2, 3.0f);
+//            csg.UjEl(3, 4, 1.0f);
+
+//            csg.UjEl(4, 2, 4.0f);
+//            csg.UjEl(4, 3, 1.0f);
+
+//            Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
+//            float sum = 0.0f;
+//            csg.Csucsok.Bejar(x =>
+//            {
+//                if (x != 0)
+//                {
+//                    int p = elek.Kiolvas(x);
+//                    sum += csg.Suly(p, x);
+//                }
+//            }
+//            );
+//            Assert.That(sum, Is.EqualTo(8.0f));
+//        }
+
+//        [TestCase]
+//        public void KisKruskalTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
+//            csg.UjEl(0, 1, 10.0f);
+//            csg.UjEl(0, 2, 20.0f);
+//            csg.UjEl(1, 2, 5.0f);
+//            Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 10.0f)), Is.True);
+//                Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 20.0f)), Is.False);
+//                Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 5.0f)), Is.True);
+//            });
+//        }
+
+//        [TestCase]
+//        public void NagyKruskalTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
+//            csg.UjEl(0, 1, 5.0f);
+//            csg.UjEl(0, 3, 4.0f);
+
+//            csg.UjEl(1, 0, 5.0f);
+//            csg.UjEl(1, 3, 2.0f);
+//            csg.UjEl(1, 2, 1.0f);
+
+//            csg.UjEl(2, 1, 1.0f);
+//            csg.UjEl(2, 3, 3.0f);
+//            csg.UjEl(2, 4, 4.0f);
+
+//            csg.UjEl(3, 0, 4.0f);
+//            csg.UjEl(3, 1, 2.0f);
+//            csg.UjEl(3, 2, 3.0f);
+//            csg.UjEl(3, 4, 1.0f);
+
+//            csg.UjEl(4, 2, 4.0f);
+//            csg.UjEl(4, 3, 1.0f);
+
+//            Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
+//            float sum = 0.0f;
+//            elek.Bejar(x =>
+//            {
+//                sum += x.Suly;
+//            }
+//            );
+//            Assert.That(sum, Is.EqualTo(8.0f));
+//        }
+//    }
+
+//    [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Útkeresés Tesztek")]
+//    public class GrafUtkeresesTesztek
+//    {
+//        [TestCase]
+//        public void DijkstraKicsiGrafTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
+//            csg.UjEl(0, 1, 10.0f);
+//            csg.UjEl(0, 2, 20.0f);
+//            Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 0);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
+//                Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
+//                Assert.That(hossz.Kiolvas(2), Is.EqualTo(20.0f));
+//            });
+
+//            csg.UjEl(1, 2, 5.0f);
+//            hossz = Utkereses.Dijkstra(csg, 0);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
+//                Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
+//                Assert.That(hossz.Kiolvas(2), Is.EqualTo(15.0f));
+//            });
+//        }
+
+//        [TestCase]
+//        public void DijkstraJegyzetGrafTeszt()
+//        {
+//            CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(7);
+//            csg.UjEl(0, 1, 1.0f);
+//            csg.UjEl(0, 3, 2.0f);
+//            csg.UjEl(0, 4, 4.0f);
+
+//            csg.UjEl(1, 0, 1.0f);
+//            csg.UjEl(1, 3, 2.0f);
+//            csg.UjEl(1, 2, 9.0f);
+
+//            csg.UjEl(2, 1, 9.0f);
+//            csg.UjEl(2, 3, 5.0f);
+//            csg.UjEl(2, 5, 1.0f);
+
+//            csg.UjEl(3, 0, 2.0f);
+//            csg.UjEl(3, 1, 2.0f);
+//            csg.UjEl(3, 2, 5.0f);
+//            csg.UjEl(3, 5, 3.0f);
+
+//            csg.UjEl(5, 2, 1.0f);
+//            csg.UjEl(5, 3, 3.0f);
+//            csg.UjEl(5, 6, 3.0f);
+
+//            csg.UjEl(6, 5, 3.0f);
+
+//            Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 1);
+//            Assert.Multiple(() =>
+//            {
+//                Assert.That(hossz.Kiolvas(0), Is.EqualTo(1.0f));
+//                Assert.That(hossz.Kiolvas(1), Is.EqualTo(0.0f));
+//                Assert.That(hossz.Kiolvas(2), Is.EqualTo(6.0f));
+//                Assert.That(hossz.Kiolvas(3), Is.EqualTo(2.0f));
+//                Assert.That(hossz.Kiolvas(4), Is.EqualTo(5.0f));
+//                Assert.That(hossz.Kiolvas(5), Is.EqualTo(5.0f));
+//                Assert.That(hossz.Kiolvas(6), Is.EqualTo(8.0f));
+//            });
+//        }
+//    }
+//}

ALGA_heti_feladatok/Tesztek/NOTES.md

@@ -0,0 +1,3 @@
+## Duplikált tesztek a Test Explorer-ben
+Az **NUnit 3 VS Test Adapter** ismert hibája, hogy amennyiben a *TestFixture*-be a *TestName* értéket kap, akkor a **Test Explorer**-ben kétszer fognak megjelenni a tesztek.
+Issue: https://github.com/nunit/nunit3-vs-adapter/issues/729

ALGA_heti_feladatok/Tesztek/Tesztek.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+	<SatelliteResourceLanguages>en</SatelliteResourceLanguages>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" Version="17.14.2" />
+    <PackageReference Include="MSTest" Version="3.10.4" />
+    <PackageReference Include="NUnit" Version="4.4.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.10.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="NUnit3TestAdapter" Version="5.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ALGA\ALGA.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="NUnit.Framework" />
+  </ItemGroup>
+
+</Project>