Mirai/ALGA
1
0
Fork 0
mirror of https://github.com/Lendaia/oe-alga-feladatok.git synced 2026-04-23 04:16:32 +01:00
Code Issues Packages Projects Releases Wiki Activity

hmhmhmhmhmhmhm

Browse Source
This commit is contained in:
Lendaia Mirai
2026-01-12 12:29:05 +01:00
parent b18d3cd9f1
commit cf4cfe65bb
9 changed files with 673 additions and 1119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
ALGA/Adatszerkezetek/12_SulyozottGraf.cs
View File

@@ -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))

540
Tesztek/01_ImperativParadigmaTesztek.cs
View File

@@ -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"));
}
}
}

282
Tesztek/02_FunkcionalisParadigmaTesztek.cs
View File

@@ -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"));
}
}
}

154
Tesztek/02_FunkconalisParadigmaTesztek.cs
View File

@@ -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"));
}
}
}

226
Tesztek/04_EgyszeruLancTesztek.cs
View File

@@ -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);
}
}
}

306
Tesztek/07_NyersEroTesztek.cs
View File

@@ -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));
});
}
}
}

103
Tesztek/09_VisszalepesesKereses.cs
View File

@@ -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));
});
}
}
}

173
Tesztek/09_VisszalepesesKeresesTesztek.cs
View File

@@ -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));
});
}
}
}

2
Tesztek/Tesztek.csproj
View File

@@ -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>