diff --git a/ALGA/Paradigmak/01_ImperativParadigma.cs b/ALGA/Paradigmak/01_ImperativParadigma.cs
index 0fea543..a9a87fd 100644
--- a/ALGA/Paradigmak/01_ImperativParadigma.cs
+++ b/ALGA/Paradigmak/01_ImperativParadigma.cs
@@ -4,6 +4,126 @@ using System.Collections.Generic;
 
 namespace OE.ALGA.Paradigmak
 {
-    // 1. heti labor feladat - Tesztek: 01_ImperativParadigmaTesztek.cs
-}
+    public interface IVegrehajthato
+    {
+        public void Vegrehajtas();
+    }
 
+    public interface IFuggo
+    {
+        public bool FuggosegTeljesul
+        {
+            get;
+        }
+    }
+
+    public class TaroloMegteltKivetel : Exception
+    {
+
+    }
+
+    public class FeladatTarolo<T> : IEnumerable<T> where T : IVegrehajthato
+    {
+        internal T[] tarolo;
+        internal int n;
+
+        public FeladatTarolo(int l)
+        {
+            tarolo = new T[l];
+            n = 0;
+        }
+
+        public void Felvesz(T t)
+        {
+            if (n <= tarolo.Length)
+            {
+                tarolo[n] = t;
+                n++;
+            }
+            else
+            {
+                throw new TaroloMegteltKivetel();
+            }
+        }
+
+        public IEnumerator GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+
+        virtual public void MindentVegrehajt()
+        {
+            foreach (T t in tarolo)
+            {
+                t.Vegrehajtas();
+            }
+        }
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        {
+            FeladatTaroloBejaro<T> bejaro = new FeladatTaroloBejaro<T>(tarolo, n);
+            return bejaro;
+        }
+
+    }
+
+    public class FuggoFeladatTarolo<T> : FeladatTarolo<T> where T : IVegrehajthato, IFuggo
+    {
+        public FuggoFeladatTarolo(int l) : base(l)
+        {
+
+        }
+        override public void MindentVegrehajt()
+        {
+            foreach (T t in tarolo)
+            {
+                if (t.FuggosegTeljesul)
+                {
+                    t.Vegrehajtas();
+                }
+            }
+        }
+    }
+    public class FeladatTaroloBejaro<T> : IEnumerator<T>
+    {
+        T[] tarolo;
+        int n;
+        int aktualisindex;
+
+        public FeladatTaroloBejaro(T[] tarolo, int n)
+        {
+            this.tarolo = tarolo;
+            this.n = n;
+            aktualisindex = 0;
+        }
+        public T Current
+        {
+            get { return tarolo[aktualisindex]; }
+        }
+
+        object IEnumerator.Current => throw new NotImplementedException();
+
+        public void Dispose()
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool MoveNext()
+        {
+            if (aktualisindex < n-1)
+            {
+                aktualisindex++;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public void Reset()
+        {
+            aktualisindex = -1;
+        }
+    }
+}
diff --git a/ALGA/Paradigmak/02_FunkcionalisParadigma.cs b/ALGA/Paradigmak/02_FunkcionalisParadigma.cs
index eae62c4..2a74d77 100644
--- a/ALGA/Paradigmak/02_FunkcionalisParadigma.cs
+++ b/ALGA/Paradigmak/02_FunkcionalisParadigma.cs
@@ -4,5 +4,71 @@ using System.Collections.Generic;
 
 namespace OE.ALGA.Paradigmak
 {
-    // 2. heti labor feladat - Tesztek: 02_FunkcionálisParadigmaTesztek.cs
-}
+    public class FeltetelesFeladatTarolo<T> : FeladatTarolo<T> where T : IVegrehajthato
+    {
+        public FeltetelesFeladatTarolo(int l) : base(l)
+        {
+
+        }
+        public void FeltetelesVegrehajtas(Func<T, bool> feltetel)
+        {
+            foreach (T t in tarolo)
+            {
+                if (feltetel(t))
+                {
+                    t.Vegrehajtas();
+                }
+            }
+        }
+    }
+    public class FeltetelesFeladatTaroloBejaro<T> : IEnumerator<T>
+    {
+        T[] tarolo;
+        int n;
+        int aktualisindex;
+        public Func<T, bool> Feltetel
+        {
+            get;
+        }
+        public T Current
+        {
+            get { return tarolo[aktualisindex]; }
+        }
+        public FeltetelesFeladatTaroloBejaro(T[] tarolo, int n, Func<T, bool> feltetel)
+        {
+            this.tarolo = tarolo;
+            this.n = n;
+            aktualisindex = 0;
+            Feltetel = feltetel;
+        }
+        object IEnumerator.Current => throw new NotImplementedException();
+
+        public void Dispose()
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool MoveNext()
+        {
+            if (aktualisindex < n - 1)
+            {
+                aktualisindex++;
+                if (Feltetel(tarolo[aktualisindex]))
+                {
+                    return true;
+                }
+                MoveNext();
+                return false;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        public void Reset()
+        {
+            aktualisindex = -1;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Tesztek/01_ImperativParadigmaTesztek.cs b/Tesztek/01_ImperativParadigmaTesztek.cs
index 0cee136..397dec9 100644
--- a/Tesztek/01_ImperativParadigmaTesztek.cs
+++ b/Tesztek/01_ImperativParadigmaTesztek.cs
@@ -1,280 +1,280 @@
-//using NUnit.Framework;
-//using OE.ALGA.Paradigmak;
+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);
-//        }
+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);
-//            });
-//        }
-//    }
+        [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"));
-//        }
-//    }
-//}
\ No newline at end of file
+        [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