diff --git a/ALGA/03_Tomb.cs b/ALGA/03_Tomb.cs
index 05b7f48..5d63a54 100644
--- a/ALGA/03_Tomb.cs
+++ b/ALGA/03_Tomb.cs
@@ -13,19 +13,18 @@ namespace OE.ALGA.Adatszerkezetek
     {
         T[] tomb;
         int n = 0;
-        bool ures = true;
         public TombVerem(int l)
         {
             tomb = new T[l];
         }
         public bool Ures
         {
-            get { return ures; }
+            get { return n == 0; }
         }
 
         public T Felso()
         {
-            throw new NotImplementedException();
+            return tomb[n - 1];
         }
 
         public void Verembe(T ertek)
@@ -34,7 +33,6 @@ namespace OE.ALGA.Adatszerkezetek
             {
                 tomb[n] = ertek;
                 n++;
-                ures = false;
             }
             else
             {
@@ -44,22 +42,23 @@ namespace OE.ALGA.Adatszerkezetek
 
         public T Verembol()
         {
-            for (int i = tomb.Length;  i > 0; i--)
+            if (Ures)
             {
-                if (tomb[i] != null)
-                {
-                    return tomb[i];//should i actually delete it, or we are just courious whats the valueidk
-                }
+                throw new NincsElemKivetel();
             }
-            ures = true;
-            throw new NincsElemKivetel();
+            else
+            {
+                T ertek = tomb[n - 1];
+                n--;
+                return ertek;
+            }
+            
         }
     }
     public class TombSor<T> : Sor<T>
     {
         T[] tomb;
         int n = 0;
-        bool ures = true;
         public TombSor(int l)
         {
             tomb = new T[l];
@@ -67,7 +66,7 @@ namespace OE.ALGA.Adatszerkezetek
 
         public bool Ures
         {
-            get { return ures; }
+            get { return n == 0; }
         }
 
         public T Elso()
@@ -81,7 +80,6 @@ namespace OE.ALGA.Adatszerkezetek
             {
                 tomb[n] = ertek;
                 n++;
-                ures = false;
             }
             else
             {
@@ -91,24 +89,31 @@ namespace OE.ALGA.Adatszerkezetek
 
         public T Sorbol()
         {
-            for (int i = tomb.Length; i > 0; i--)
+            if (Ures)
             {
-                if (tomb[i] != null)
-                {
-                    return tomb[i];//should i actually delete it, or we are just courious whats the valueidk
-                }
+                throw new NincsElemKivetel();
+            }
+            else
+            {
+                T ertek = tomb[0];
+                T[] tmp = new T[tomb.Length];
+                n--;
+                for (int i = 1; i < tomb.Length; i++)
+                {
+                    tmp[i - 1] = tomb[i];
+                }
+                tomb = tmp;
+                return ertek;
             }
-            ures = true;
-            throw new NincsElemKivetel();
         }
     }
-    public class TombLista<T> : Lista<T>, IEnumerable<T>
+    public class TombLista<T> : Lista<T>, IEnumerable<T> 
     {
         T[] tomb;
         int n = 0;
-        public TombLista(int l)
+        public TombLista()
         {
-            tomb = new T[l];
+            tomb = new T[n];
         }
 
         public int Elemszam
@@ -123,29 +128,32 @@ namespace OE.ALGA.Adatszerkezetek
 
         public void Beszur(int index, T ertek)
         {
-            if (index < 0)
+            if (index < 0 || index > tomb.Length)
             {
                 throw new HibasIndexKivetel();
             }
-            if (index < tomb.Length && tomb[index] == null)
-            {
-                tomb[index] = ertek;
-            }
             else
             {
-                T[] tmp = new T[tomb.Length * 2];
-                for (int i = 0; i < index; i++)
+                if (index < tomb.Length && tomb[index] == null)
                 {
-                    tmp[i] = tomb[i];
+                    tomb[index] = ertek;
                 }
-                tmp[index] = ertek;
-                for (int i = index+1; i < tomb.Length; i++)
+                else
                 {
-                    tmp[i] = tomb[i];
+                    T[] tmp = new T[tomb.Length * 2];
+                    for (int i = 0; i < index; i++)
+                    {
+                        tmp[i] = tomb[i];
+                    }
+                    tmp[index] = ertek;
+                    for (int i = index + 1; i < tomb.Length; i++)
+                    {
+                        tmp[i] = tomb[i - 1];
+                    }
+                    tomb = tmp;
                 }
-                tomb = tmp;
+                n++;
             }
-            n++;
         }
 
         public IEnumerator<T> GetEnumerator()
@@ -163,7 +171,7 @@ namespace OE.ALGA.Adatszerkezetek
         {
             if (n < tomb.Length)
             {
-                tomb[n] = ertek;
+                tomb[n-1] = ertek;
             }
             else
             {
@@ -172,7 +180,7 @@ namespace OE.ALGA.Adatszerkezetek
                 {
                     tmp[i] = tomb[i];
                 }
-                tmp[n] = ertek;
+                tmp[n-1] = ertek;
                 tomb = tmp;
             }
             n++;
@@ -215,7 +223,7 @@ namespace OE.ALGA.Adatszerkezetek
             T[] tmp = new T[tomb.Length];
             for (int i = tomb.Length; i > 0; i--)
             {
-                if (i > n)//(ertek == tomb[i])
+                if (ertek.Equals(tomb[i]))
                 {
                     continue;
                 }
diff --git a/Tesztek/03_TombImplementacioTesztek.cs b/Tesztek/03_TombImplementacioTesztek.cs
index 9107b94..ca92237 100644
--- a/Tesztek/03_TombImplementacioTesztek.cs
+++ b/Tesztek/03_TombImplementacioTesztek.cs
@@ -1,399 +1,399 @@
-//using NUnit.Framework;
-//using OE.ALGA.Adatszerkezetek;
+using NUnit.Framework;
+using OE.ALGA.Adatszerkezetek;
 
-//namespace OE.ALGA.Tesztek.Adatszerkezetek
-//{
-//    [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Lista Tesztek")]
-//    public class TombListaTesztek
-//    {
-//        [TestCase]
-//        public void Elemszam()
-//        {
-//            Lista<string> l = new TombLista<string>();
-//            Assert.That(l.Elemszam, Is.EqualTo(0));
-//            l.Hozzafuz("A");
-//            Assert.That(l.Elemszam, Is.EqualTo(1));
-//            l.Hozzafuz("B");
-//            Assert.That(l.Elemszam, Is.EqualTo(2));
-//            l.Torol("A");
-//            Assert.That(l.Elemszam, Is.EqualTo(1));
-//        }
-//        [TestCase]
-//        public void Bejaras()
-//        {
-//            Lista<int> l = new TombLista<int>();
-//            l.Hozzafuz(1);
-//            l.Hozzafuz(3);
-//            l.Hozzafuz(2);
-//            string s = "";
-//            l.Bejar(x => { Guardian.Recursion.CheckStackTrace(); s += x.ToString(); });
-//            Assert.That(s, Is.EqualTo("132"));
-//        }
-//        [TestCase]
-//        public void Beszuras()
-//        {
-//            Lista<int> l = new TombLista<int>();
-//            l.Beszur(0, 1);
-//            l.Beszur(0, 2);
-//            l.Beszur(1, 3);
-//            l.Beszur(3, 4);
-//            l.Beszur(2, 5);
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(l.Kiolvas(0), Is.EqualTo(2));
-//                Assert.That(l.Kiolvas(1), Is.EqualTo(3));
-//                Assert.That(l.Kiolvas(2), Is.EqualTo(5));
-//                Assert.That(l.Kiolvas(3), Is.EqualTo(1));
-//                Assert.That(l.Kiolvas(4), Is.EqualTo(4));
-//            });
-//        }
-//        [TestCase]
-//        public void BeszurasUres()
-//        {
-//            Lista<string> l = new TombLista<string>();
-//            l.Beszur(0, "1");
-//            l.Beszur(0, "2");
-//            l.Beszur(1, "");
-//            l.Beszur(3, "");
-//            l.Beszur(2, "5");
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(l.Kiolvas(0), Is.EqualTo("2"));
-//                Assert.That(l.Kiolvas(1), Is.EqualTo(""));
-//                Assert.That(l.Kiolvas(2), Is.EqualTo("5"));
-//                Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
-//                Assert.That(l.Kiolvas(4), Is.EqualTo(""));
-//            });
-//        }
-//        [TestCase]
-//        public void HozzaFuzes()
-//        {
-//            Lista<int> l = new TombLista<int>();
-//            l.Hozzafuz(1);
-//            l.Hozzafuz(3);
-//            l.Hozzafuz(2);
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(l.Kiolvas(0), Is.EqualTo(1));
-//                Assert.That(l.Kiolvas(1), Is.EqualTo(3));
-//                Assert.That(l.Kiolvas(2), Is.EqualTo(2));
-//            });
-//        }
-//        [TestCase]
-//        public void HozzaFuzesUres()
-//        {
-//            Lista<string> l = new TombLista<string>();
-//            l.Hozzafuz("1");
-//            l.Hozzafuz("");
-//            l.Hozzafuz("");
-//            l.Hozzafuz("1");
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
-//                Assert.That(l.Kiolvas(1), Is.EqualTo(""));
-//                Assert.That(l.Kiolvas(2), Is.EqualTo(""));
-//                Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
-//            });
-//        }
-//        [TestCase]
-//        public void Novekedes()
-//        {
-//            Lista<int> l = new TombLista<int>();
-//            for (int i = 0; i < 1000; i++)
-//                l.Hozzafuz(i * i);
-//            Assert.That(l.Elemszam, Is.EqualTo(1000));
-//            Assert.Multiple(() =>
-//            {
-//                for (int i = 0; i < 1000; i++)
-//                    Assert.That(l.Kiolvas(i), Is.EqualTo(i * i));
-//            });
-//            Assert.That(l.Elemszam, Is.EqualTo(1000));
-//        }
-//        [TestCase]
-//        public void Torles()
-//        {
-//            Lista<int> l = new TombLista<int>();
-//            l.Hozzafuz(1);
-//            l.Hozzafuz(3);
-//            l.Hozzafuz(2);
-//            l.Hozzafuz(3);
-//            l.Hozzafuz(4);
-//            Assert.That(l.Elemszam, Is.EqualTo(5));
-//            l.Torol(3);
-//            Assert.That(l.Elemszam, Is.EqualTo(3));
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(l.Kiolvas(0), Is.EqualTo(1));
-//                Assert.That(l.Kiolvas(1), Is.EqualTo(2));
-//                Assert.That(l.Kiolvas(2), Is.EqualTo(4));
-//            });
-//        }
-//        [TestCase]
-//        public void TorlesNincsElem()
-//        {
-//            Lista<int> l = new TombLista<int>();
-//            Assert.That(l.Elemszam, Is.EqualTo(0));
-//            l.Torol(0);
-//            Assert.That(l.Elemszam, Is.EqualTo(0));
-//        }
-//        [TestCase]
-//        public void TorlesUres()
-//        {
-//            Lista<string> l = new TombLista<string>();
-//            l.Hozzafuz("1");
-//            l.Hozzafuz("");
-//            l.Hozzafuz("");
-//            l.Hozzafuz("");
-//            l.Hozzafuz("1");
-//            Assert.That(l.Elemszam, Is.EqualTo(5));
-//            l.Torol("");
-//            Assert.That(l.Elemszam, Is.EqualTo(2));
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
-//                Assert.That(l.Kiolvas(1), Is.EqualTo("1"));
-//            });
-//        }
-//        [TestCase]
-//        public void NemletezoTorles()
-//        {
-//            Lista<int> l = new TombLista<int>();
-//            l.Hozzafuz(1);
-//            l.Hozzafuz(2);
-//            l.Hozzafuz(3);
-//            Assert.That(l.Elemszam, Is.EqualTo(3));
-//            l.Torol(0);
-//            Assert.That(l.Elemszam, Is.EqualTo(3));
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(l.Kiolvas(0), Is.EqualTo(1));
-//                Assert.That(l.Kiolvas(1), Is.EqualTo(2));
-//                Assert.That(l.Kiolvas(2), Is.EqualTo(3));
-//            });
-//        }
-//        [TestCase]
-//        public void Modositas()
-//        {
-//            Lista<int> l = new TombLista<int>();
-//            l.Hozzafuz(1);
-//            l.Hozzafuz(3);
-//            l.Hozzafuz(2);
-//            l.Modosit(1, 5);
-//            l.Modosit(0, 4);
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(l.Kiolvas(0), Is.EqualTo(4));
-//                Assert.That(l.Kiolvas(1), Is.EqualTo(5));
-//                Assert.That(l.Kiolvas(2), Is.EqualTo(2));
-//            });
-//        }
-//        [TestCase]
-//        public void ForeachBejaras()
-//        {
-//            TombLista<string> l = new TombLista<string>();
-//            l.Hozzafuz("a");
-//            l.Hozzafuz("c");
-//            l.Hozzafuz("d");
-//            l.Hozzafuz("b");
-//            string osszefuzo = "";
-//            foreach (string x in l)
-//            {
-//                osszefuzo += x;
-//            }
-//            Assert.That(osszefuzo, Is.EqualTo("acdb"));
-//        }
+namespace OE.ALGA.Tesztek.Adatszerkezetek
+{
+   [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Lista Tesztek")]
+   public class TombListaTesztek
+   {
+       [TestCase]
+       public void Elemszam()
+       {
+           Lista<string> l = new TombLista<string>();
+           Assert.That(l.Elemszam, Is.EqualTo(0));
+           l.Hozzafuz("A");
+           Assert.That(l.Elemszam, Is.EqualTo(1));
+           l.Hozzafuz("B");
+           Assert.That(l.Elemszam, Is.EqualTo(2));
+           l.Torol("A");
+           Assert.That(l.Elemszam, Is.EqualTo(1));
+       }
+       [TestCase]
+       public void Bejaras()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(3);
+           l.Hozzafuz(2);
+           string s = "";
+           l.Bejar(x => { Guardian.Recursion.CheckStackTrace(); s += x.ToString(); });
+           Assert.That(s, Is.EqualTo("132"));
+       }
+       [TestCase]
+       public void Beszuras()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Beszur(0, 1);
+           l.Beszur(0, 2);
+           l.Beszur(1, 3);
+           l.Beszur(3, 4);
+           l.Beszur(2, 5);
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(2));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(3));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(5));
+               Assert.That(l.Kiolvas(3), Is.EqualTo(1));
+               Assert.That(l.Kiolvas(4), Is.EqualTo(4));
+           });
+       }
+       [TestCase]
+       public void BeszurasUres()
+       {
+           Lista<string> l = new TombLista<string>();
+           l.Beszur(0, "1");
+           l.Beszur(0, "2");
+           l.Beszur(1, "");
+           l.Beszur(3, "");
+           l.Beszur(2, "5");
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo("2"));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(""));
+               Assert.That(l.Kiolvas(2), Is.EqualTo("5"));
+               Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
+               Assert.That(l.Kiolvas(4), Is.EqualTo(""));
+           });
+       }
+       [TestCase]
+       public void HozzaFuzes()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(3);
+           l.Hozzafuz(2);
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(1));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(3));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(2));
+           });
+       }
+       [TestCase]
+       public void HozzaFuzesUres()
+       {
+           Lista<string> l = new TombLista<string>();
+           l.Hozzafuz("1");
+           l.Hozzafuz("");
+           l.Hozzafuz("");
+           l.Hozzafuz("1");
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(""));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(""));
+               Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
+           });
+       }
+       [TestCase]
+       public void Novekedes()
+       {
+           Lista<int> l = new TombLista<int>();
+           for (int i = 0; i < 1000; i++)
+               l.Hozzafuz(i * i);
+           Assert.That(l.Elemszam, Is.EqualTo(1000));
+           Assert.Multiple(() =>
+           {
+               for (int i = 0; i < 1000; i++)
+                   Assert.That(l.Kiolvas(i), Is.EqualTo(i * i));
+           });
+           Assert.That(l.Elemszam, Is.EqualTo(1000));
+       }
+       [TestCase]
+       public void Torles()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(3);
+           l.Hozzafuz(2);
+           l.Hozzafuz(3);
+           l.Hozzafuz(4);
+           Assert.That(l.Elemszam, Is.EqualTo(5));
+           l.Torol(3);
+           Assert.That(l.Elemszam, Is.EqualTo(3));
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(1));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(2));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(4));
+           });
+       }
+       [TestCase]
+       public void TorlesNincsElem()
+       {
+           Lista<int> l = new TombLista<int>();
+           Assert.That(l.Elemszam, Is.EqualTo(0));
+           l.Torol(0);
+           Assert.That(l.Elemszam, Is.EqualTo(0));
+       }
+       [TestCase]
+       public void TorlesUres()
+       {
+           Lista<string> l = new TombLista<string>();
+           l.Hozzafuz("1");
+           l.Hozzafuz("");
+           l.Hozzafuz("");
+           l.Hozzafuz("");
+           l.Hozzafuz("1");
+           Assert.That(l.Elemszam, Is.EqualTo(5));
+           l.Torol("");
+           Assert.That(l.Elemszam, Is.EqualTo(2));
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
+               Assert.That(l.Kiolvas(1), Is.EqualTo("1"));
+           });
+       }
+       [TestCase]
+       public void NemletezoTorles()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(2);
+           l.Hozzafuz(3);
+           Assert.That(l.Elemszam, Is.EqualTo(3));
+           l.Torol(0);
+           Assert.That(l.Elemszam, Is.EqualTo(3));
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(1));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(2));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(3));
+           });
+       }
+       [TestCase]
+       public void Modositas()
+       {
+           Lista<int> l = new TombLista<int>();
+           l.Hozzafuz(1);
+           l.Hozzafuz(3);
+           l.Hozzafuz(2);
+           l.Modosit(1, 5);
+           l.Modosit(0, 4);
+           Assert.Multiple(() =>
+           {
+               Assert.That(l.Kiolvas(0), Is.EqualTo(4));
+               Assert.That(l.Kiolvas(1), Is.EqualTo(5));
+               Assert.That(l.Kiolvas(2), Is.EqualTo(2));
+           });
+       }
+       [TestCase]
+       public void ForeachBejaras()
+       {
+           TombLista<string> l = new TombLista<string>();
+           l.Hozzafuz("a");
+           l.Hozzafuz("c");
+           l.Hozzafuz("d");
+           l.Hozzafuz("b");
+           string osszefuzo = "";
+           foreach (string x in l)
+           {
+               osszefuzo += x;
+           }
+           Assert.That(osszefuzo, Is.EqualTo("acdb"));
+       }
 
-//    }
+   }
 
-//    [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Sor Tesztek")]
-//    public class TombSorTesztek
-//    {
-//        [TestCase]
-//        public void Ures()
-//        {
-//            Sor<int> s = new TombSor<int>(0);
-//            Assert.That(s.Ures, Is.True);
-//            Assert.Throws<NincsHelyKivetel>(() => s.Sorba(1));
-//        }
-//        [TestCase]
-//        public void AlapMukodes()
-//        {
-//            Sor<int> s = new TombSor<int>(3);
-//            Assert.That(s.Ures, Is.True);
-//            s.Sorba(1);
-//            Assert.That(s.Ures, Is.False);
-//            s.Sorba(3);
-//            Assert.That(s.Ures, Is.False);
-//            s.Sorba(2);
-//            Assert.That(s.Ures, Is.False);
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(s.Sorbol(), Is.EqualTo(1));
-//                Assert.That(s.Ures, Is.False);
-//                Assert.That(s.Sorbol(), Is.EqualTo(3));
-//                Assert.That(s.Ures, Is.False);
-//                Assert.That(s.Sorbol(), Is.EqualTo(2));
-//                Assert.That(s.Ures, Is.True);
-//            });
-//        }
-//        [TestCase]
-//        public void UresElem()
-//        {
-//            Sor<string> s = new TombSor<string>(3);
-//            s.Sorba("");
-//            s.Sorba("1");
-//            s.Sorba("");
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(s.Sorbol(), Is.EqualTo(""));
-//                Assert.That(s.Sorbol(), Is.EqualTo("1"));
-//                Assert.That(s.Sorbol(), Is.EqualTo(""));
-//            });
-//        }
-//        [TestCase]
-//        public void Korbeeres()
-//        {
-//            Sor<int> s = new TombSor<int>(3);
-//            s.Sorba(1);
-//            s.Sorba(3);
-//            s.Sorba(2);
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(s.Sorbol(), Is.EqualTo(1));
-//                Assert.That(s.Sorbol(), Is.EqualTo(3));
-//            });
-//            s.Sorba(4);
-//            s.Sorba(5);
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(s.Sorbol(), Is.EqualTo(2));
-//                Assert.That(s.Sorbol(), Is.EqualTo(4));
-//                Assert.That(s.Sorbol(), Is.EqualTo(5));
-//            });
-//        }
-//        [TestCase]
-//        public void TulSokElem()
-//        {
-//            Sor<int> s = new TombSor<int>(3);
-//            s.Sorba(1);
-//            s.Sorba(3);
-//            s.Sorba(2);
-//            Assert.Throws<NincsHelyKivetel>(() => s.Sorba(4));
-//        }
+   [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Sor Tesztek")]
+   public class TombSorTesztek
+   {
+       [TestCase]
+       public void Ures()
+       {
+           Sor<int> s = new TombSor<int>(0);
+           Assert.That(s.Ures, Is.True);
+           Assert.Throws<NincsHelyKivetel>(() => s.Sorba(1));
+       }
+       [TestCase]
+       public void AlapMukodes()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           Assert.That(s.Ures, Is.True);
+           s.Sorba(1);
+           Assert.That(s.Ures, Is.False);
+           s.Sorba(3);
+           Assert.That(s.Ures, Is.False);
+           s.Sorba(2);
+           Assert.That(s.Ures, Is.False);
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Sorbol(), Is.EqualTo(1));
+               Assert.That(s.Ures, Is.False);
+               Assert.That(s.Sorbol(), Is.EqualTo(3));
+               Assert.That(s.Ures, Is.False);
+               Assert.That(s.Sorbol(), Is.EqualTo(2));
+               Assert.That(s.Ures, Is.True);
+           });
+       }
+       [TestCase]
+       public void UresElem()
+       {
+           Sor<string> s = new TombSor<string>(3);
+           s.Sorba("");
+           s.Sorba("1");
+           s.Sorba("");
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Sorbol(), Is.EqualTo(""));
+               Assert.That(s.Sorbol(), Is.EqualTo("1"));
+               Assert.That(s.Sorbol(), Is.EqualTo(""));
+           });
+       }
+       [TestCase]
+       public void Korbeeres()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           s.Sorba(1);
+           s.Sorba(3);
+           s.Sorba(2);
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Sorbol(), Is.EqualTo(1));
+               Assert.That(s.Sorbol(), Is.EqualTo(3));
+           });
+           s.Sorba(4);
+           s.Sorba(5);
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Sorbol(), Is.EqualTo(2));
+               Assert.That(s.Sorbol(), Is.EqualTo(4));
+               Assert.That(s.Sorbol(), Is.EqualTo(5));
+           });
+       }
+       [TestCase]
+       public void TulSokElem()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           s.Sorba(1);
+           s.Sorba(3);
+           s.Sorba(2);
+           Assert.Throws<NincsHelyKivetel>(() => s.Sorba(4));
+       }
 
-//        [TestCase]
-//        public void TulKevesElem()
-//        {
-//            Sor<int> s = new TombSor<int>(3);
-//            s.Sorba(1);
-//            s.Sorba(3);
-//            s.Sorba(2);
-//            s.Sorbol();
-//            s.Sorbol();
-//            s.Sorbol();
-//            Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
-//        }
-//        [TestCase]
-//        public void Elso()
-//        {
-//            Sor<int> s = new TombSor<int>(3);
-//            s.Sorba(1);
-//            s.Sorba(3);
-//            s.Sorba(2);
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(s.Elso(), Is.EqualTo(1));
-//                Assert.That(s.Elso(), Is.EqualTo(1));
-//            });
-//            s.Sorbol();
-//            Assert.That(s.Elso(), Is.EqualTo(3));
-//        }
-//    }
+       [TestCase]
+       public void TulKevesElem()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           s.Sorba(1);
+           s.Sorba(3);
+           s.Sorba(2);
+           s.Sorbol();
+           s.Sorbol();
+           s.Sorbol();
+           Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
+       }
+       [TestCase]
+       public void Elso()
+       {
+           Sor<int> s = new TombSor<int>(3);
+           s.Sorba(1);
+           s.Sorba(3);
+           s.Sorba(2);
+           Assert.Multiple(() =>
+           {
+               Assert.That(s.Elso(), Is.EqualTo(1));
+               Assert.That(s.Elso(), Is.EqualTo(1));
+           });
+           s.Sorbol();
+           Assert.That(s.Elso(), Is.EqualTo(3));
+       }
+   }
 
-//    [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Verem Tesztek")]
-//    public class TombVeremTesztek
-//    {
-//        [TestCase]
-//        public void Ures()
-//        {
-//            Verem<int> v = new TombVerem<int>(0);
-//            Assert.That(v.Ures, Is.True);
-//            Assert.Throws<NincsHelyKivetel>(() => v.Verembe(1));
-//        }
-//        [TestCase]
-//        public void AlapMukodes()
-//        {
-//            Verem<int> v = new TombVerem<int>(3);
-//            Assert.That(v.Ures, Is.True);
-//            v.Verembe(1);
-//            Assert.That(v.Ures, Is.False);
-//            v.Verembe(3);
-//            Assert.That(v.Ures, Is.False);
-//            v.Verembe(2);
-//            Assert.That(v.Ures, Is.False);
-//            Assert.That(v.Verembol(), Is.EqualTo(2));
-//            Assert.That(v.Ures, Is.False);
-//            v.Verembe(4);
-//            Assert.That(v.Ures, Is.False);
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(v.Verembol(), Is.EqualTo(4));
-//                Assert.That(v.Ures, Is.False);
-//                Assert.That(v.Verembol(), Is.EqualTo(3));
-//                Assert.That(v.Ures, Is.False);
-//                Assert.That(v.Verembol(), Is.EqualTo(1));
-//                Assert.That(v.Ures, Is.True);
-//            });
-//        }
-//        [TestCase]
-//        public void UresElem()
-//        {
-//            Verem<string> v = new TombVerem<string>(3);
-//            v.Verembe("");
-//            v.Verembe("1");
-//            v.Verembe("");
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(v.Verembol(), Is.EqualTo(""));
-//                Assert.That(v.Verembol(), Is.EqualTo("1"));
-//                Assert.That(v.Verembol(), Is.EqualTo(""));
-//            });
-//        }
-//        [TestCase]
-//        public void TulSokElem()
-//        {
-//            Verem<int> v = new TombVerem<int>(3);
-//            v.Verembe(1);
-//            v.Verembe(3);
-//            v.Verembe(2);
-//            Assert.Throws<NincsHelyKivetel>(() => v.Verembe(4));
-//        }
-//        [TestCase]
-//        public void TulKevesElem()
-//        {
-//            Verem<int> v = new TombVerem<int>(3);
-//            v.Verembe(1);
-//            v.Verembe(3);
-//            v.Verembe(2);
-//            v.Verembol();
-//            v.Verembol();
-//            v.Verembol();
-//            Assert.Throws<NincsElemKivetel>(() => v.Verembol());
-//        }
-//        [TestCase]
-//        public void Felso()
-//        {
-//            Verem<int> v = new TombVerem<int>(3);
-//            v.Verembe(1);
-//            v.Verembe(3);
-//            v.Verembe(2);
-//            Assert.Multiple(() =>
-//            {
-//                Assert.That(v.Felso(), Is.EqualTo(2));
-//                Assert.That(v.Felso(), Is.EqualTo(2));
-//            });
-//            v.Verembol();
-//            Assert.That(v.Felso(), Is.EqualTo(3));
-//        }
-//    }
-//}
\ No newline at end of file
+   [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Verem Tesztek")]
+   public class TombVeremTesztek
+   {
+       [TestCase]
+       public void Ures()
+       {
+           Verem<int> v = new TombVerem<int>(0);
+           Assert.That(v.Ures, Is.True);
+           Assert.Throws<NincsHelyKivetel>(() => v.Verembe(1));
+       }
+       [TestCase]
+       public void AlapMukodes()
+       {
+           Verem<int> v = new TombVerem<int>(3);
+           Assert.That(v.Ures, Is.True);
+           v.Verembe(1);
+           Assert.That(v.Ures, Is.False);
+           v.Verembe(3);
+           Assert.That(v.Ures, Is.False);
+           v.Verembe(2);
+           Assert.That(v.Ures, Is.False);
+           Assert.That(v.Verembol(), Is.EqualTo(2));
+           Assert.That(v.Ures, Is.False);
+           v.Verembe(4);
+           Assert.That(v.Ures, Is.False);
+           Assert.Multiple(() =>
+           {
+               Assert.That(v.Verembol(), Is.EqualTo(4));
+               Assert.That(v.Ures, Is.False);
+               Assert.That(v.Verembol(), Is.EqualTo(3));
+               Assert.That(v.Ures, Is.False);
+               Assert.That(v.Verembol(), Is.EqualTo(1));
+               Assert.That(v.Ures, Is.True);
+           });
+       }
+       [TestCase]
+       public void UresElem()
+       {
+           Verem<string> v = new TombVerem<string>(3);
+           v.Verembe("");
+           v.Verembe("1");
+           v.Verembe("");
+           Assert.Multiple(() =>
+           {
+               Assert.That(v.Verembol(), Is.EqualTo(""));
+               Assert.That(v.Verembol(), Is.EqualTo("1"));
+               Assert.That(v.Verembol(), Is.EqualTo(""));
+           });
+       }
+       [TestCase]
+       public void TulSokElem()
+       {
+           Verem<int> v = new TombVerem<int>(3);
+           v.Verembe(1);
+           v.Verembe(3);
+           v.Verembe(2);
+           Assert.Throws<NincsHelyKivetel>(() => v.Verembe(4));
+       }
+       [TestCase]
+       public void TulKevesElem()
+       {
+           Verem<int> v = new TombVerem<int>(3);
+           v.Verembe(1);
+           v.Verembe(3);
+           v.Verembe(2);
+           v.Verembol();
+           v.Verembol();
+           v.Verembol();
+           Assert.Throws<NincsElemKivetel>(() => v.Verembol());
+       }
+       [TestCase]
+       public void Felso()
+       {
+           Verem<int> v = new TombVerem<int>(3);
+           v.Verembe(1);
+           v.Verembe(3);
+           v.Verembe(2);
+           Assert.Multiple(() =>
+           {
+               Assert.That(v.Felso(), Is.EqualTo(2));
+               Assert.That(v.Felso(), Is.EqualTo(2));
+           });
+           v.Verembol();
+           Assert.That(v.Felso(), Is.EqualTo(3));
+       }
+   }
+}
\ No newline at end of file