diff --git a/ALGA/Adatszerkezetek/12_SulyozottGraf.cs b/ALGA/Adatszerkezetek/12_SulyozottGraf.cs
index 2e91492..6668571 100644
--- a/ALGA/Adatszerkezetek/12_SulyozottGraf.cs
+++ b/ALGA/Adatszerkezetek/12_SulyozottGraf.cs
@@ -1,7 +1,5 @@
 using System;
-using System.Data;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
+
 
 namespace OE.ALGA.Adatszerkezetek
 {
@@ -202,7 +200,7 @@ namespace OE.ALGA.Adatszerkezetek
                         minimum = x;
                     }
                 });
-                
+
                 feszitofa.Torol(minimum);
 
                 if (vhalmaz.Kiolvas(minimum.Honnan) != vhalmaz.Kiolvas(minimum.Hova))
diff --git a/Tesztek/01_ImperativParadigmaTesztek.cs b/Tesztek/01_ImperativParadigmaTesztek.cs
index 397dec9..2e8e05c 100644
--- a/Tesztek/01_ImperativParadigmaTesztek.cs
+++ b/Tesztek/01_ImperativParadigmaTesztek.cs
@@ -4,277 +4,277 @@ 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);
-        }
+   [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);
-            });
-        }
-    }
+       [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"));
-        }
+   [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"));
-        }
-    }
+       [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"));
+       }
+   }
 }
\ No newline at end of file
diff --git a/Tesztek/02_FunkcionalisParadigmaTesztek.cs b/Tesztek/02_FunkcionalisParadigmaTesztek.cs
index 220227e..f64cd08 100644
--- a/Tesztek/02_FunkcionalisParadigmaTesztek.cs
+++ b/Tesztek/02_FunkcionalisParadigmaTesztek.cs
@@ -1,136 +1,154 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using OE.ALGA.Paradigmak;
 
-namespace OE.ALGA.Tesztek
+namespace OE.ALGA.Tesztek.Paradigmak
 {
-    [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);
-        }
-    }
+   [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"));
+       }
+   }
 }
diff --git a/Tesztek/02_FunkconalisParadigmaTesztek.cs b/Tesztek/02_FunkconalisParadigmaTesztek.cs
deleted file mode 100644
index b56954f..0000000
--- a/Tesztek/02_FunkconalisParadigmaTesztek.cs
+++ /dev/null
@@ -1,154 +0,0 @@
-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"));
-       }
-   }
-}
\ No newline at end of file
diff --git a/Tesztek/04_EgyszeruLancTesztek.cs b/Tesztek/04_EgyszeruLancTesztek.cs
deleted file mode 100644
index 4a254e5..0000000
--- a/Tesztek/04_EgyszeruLancTesztek.cs
+++ /dev/null
@@ -1,226 +0,0 @@
-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);
-        }
-    }
-}
diff --git a/Tesztek/07_NyersEroTesztek.cs b/Tesztek/07_NyersEroTesztek.cs
index 59d5553..2f23b64 100644
--- a/Tesztek/07_NyersEroTesztek.cs
+++ b/Tesztek/07_NyersEroTesztek.cs
@@ -4,159 +4,159 @@ 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 - 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 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));
-            });
-        }
-    }
-}
+   [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));
+           });
+       }
+   }
+}
\ No newline at end of file
diff --git a/Tesztek/09_VisszalepesesKereses.cs b/Tesztek/09_VisszalepesesKereses.cs
deleted file mode 100644
index 1d64477..0000000
--- a/Tesztek/09_VisszalepesesKereses.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-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));
-           });
-       }
-   }
-}
\ No newline at end of file
diff --git a/Tesztek/09_VisszalepesesKeresesTesztek.cs b/Tesztek/09_VisszalepesesKeresesTesztek.cs
index a6c14a7..68c10d4 100644
--- a/Tesztek/09_VisszalepesesKeresesTesztek.cs
+++ b/Tesztek/09_VisszalepesesKeresesTesztek.cs
@@ -1,80 +1,103 @@
-using System;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NUnit.Framework;
 using OE.ALGA.Optimalizalas;
 
-namespace OE.ALGA.Tesztek
+namespace OE.ALGA.Tesztek.Optimalizalas
 {
-    [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);
-            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_ertek, opt.OptimalisErtek());
-        }
+   [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));
+           });
+       }
+   }
 
-        [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);
-            Microsoft.VisualStudio.TestTools.UnitTesting.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);
-            Microsoft.VisualStudio.TestTools.UnitTesting.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);
-            Microsoft.VisualStudio.TestTools.UnitTesting.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);
-            Microsoft.VisualStudio.TestTools.UnitTesting.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);
-            Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek());
-            Console.WriteLine("Lépésszám: " + opt.LepesSzam);
-        }
-    }
+   [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));
+           });
+       }
+   }
 }
diff --git a/Tesztek/Tesztek.csproj b/Tesztek/Tesztek.csproj
index b24444c..d555b12 100644
--- a/Tesztek/Tesztek.csproj
+++ b/Tesztek/Tesztek.csproj
@@ -12,8 +12,6 @@
 
   <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>