Mirai/ALGA
1
0
Fork 0
mirror of https://github.com/Lendaia/oe-alga-feladatok.git synced 2026-04-23 12:26:07 +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

4
ALGA/Adatszerkezetek/12_SulyozottGraf.cs
View File

@@ -1,7 +1,5 @@
using System; using System;
using System.Data;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
namespace OE.ALGA.Adatszerkezetek namespace OE.ALGA.Adatszerkezetek
{ {

540
Tesztek/01_ImperativParadigmaTesztek.cs
View File

@@ -4,277 +4,277 @@ using OE.ALGA.Paradigmak;
namespace OE.ALGA.Tesztek.Paradigmak namespace OE.ALGA.Tesztek.Paradigmak
{ {
[TestFixture(Category = "Paradigmák", TestName = "01 - Feladat Tároló Tesztek")] [TestFixture(Category = "Paradigmák", TestName = "01 - Feladat Tároló Tesztek")]
public class FeladatTaroloTesztek public class FeladatTaroloTesztek
{ {
[TestCase] [TestCase]
public void Ures() public void Ures()
{ {
FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(0); FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(0);
TesztFeladat a = new TesztFeladat("a"); TesztFeladat a = new TesztFeladat("a");
Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a)); Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
} }
[TestCase] [TestCase]
public void Felvesz() public void Felvesz()
{ {
FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(5); FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(5);
TesztFeladat a = new TesztFeladat("a"); TesztFeladat a = new TesztFeladat("a");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
} }
[TestCase] [TestCase]
public void TulsokatFelvesz() public void TulsokatFelvesz()
{ {
FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(3); FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(3);
TesztFeladat a = new TesztFeladat("a"); TesztFeladat a = new TesztFeladat("a");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a)); Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
} }
[TestCase] [TestCase]
public void NincsMitVegrehajtani() public void NincsMitVegrehajtani()
{ {
FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(2); FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(2);
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
} }
[TestCase] [TestCase]
public void MindentVegrehajt() public void MindentVegrehajt()
{ {
FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(2); FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(2);
TesztFeladat a = new TesztFeladat("a"); TesztFeladat a = new TesztFeladat("a");
TesztFeladat b = new TesztFeladat("b"); TesztFeladat b = new TesztFeladat("b");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(b); tarolo.Felvesz(b);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.False); Assert.That(a.Vegrehajtott, Is.False);
Assert.That(b.Vegrehajtott, Is.False); Assert.That(b.Vegrehajtott, Is.False);
}); });
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.True); Assert.That(a.Vegrehajtott, Is.True);
Assert.That(b.Vegrehajtott, Is.True); Assert.That(b.Vegrehajtott, Is.True);
}); });
} }
[TestCase] [TestCase]
public void FelvettetVegrehajt() public void FelvettetVegrehajt()
{ {
FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10); FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10);
TesztFeladat a = new TesztFeladat("a"); TesztFeladat a = new TesztFeladat("a");
TesztFeladat b = new TesztFeladat("b"); TesztFeladat b = new TesztFeladat("b");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(b); tarolo.Felvesz(b);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.False); Assert.That(a.Vegrehajtott, Is.False);
Assert.That(b.Vegrehajtott, Is.False); Assert.That(b.Vegrehajtott, Is.False);
}); });
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.True); Assert.That(a.Vegrehajtott, Is.True);
Assert.That(b.Vegrehajtott, Is.True); Assert.That(b.Vegrehajtott, Is.True);
}); });
} }
} }
[TestFixture(Category = "Paradigmák", TestName = "01 - Függő Feladat Tároló Tesztek")] [TestFixture(Category = "Paradigmák", TestName = "01 - Függő Feladat Tároló Tesztek")]
public class FuggoFeladatTaroloTesztek public class FuggoFeladatTaroloTesztek
{ {
[TestCase] [TestCase]
public void Felvesz() public void Felvesz()
{ {
FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
TesztFuggoFeladat a = new TesztFuggoFeladat("a"); TesztFuggoFeladat a = new TesztFuggoFeladat("a");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
} }
[TestCase] [TestCase]
public void TulsokatFelvesz() public void TulsokatFelvesz()
{ {
FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(3); FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(3);
TesztFuggoFeladat a = new TesztFuggoFeladat("a"); TesztFuggoFeladat a = new TesztFuggoFeladat("a");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a)); Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
} }
[TestCase] [TestCase]
public void NincsMitVegrehajtani() public void NincsMitVegrehajtani()
{ {
FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(2); FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(2);
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
} }
[TestCase] [TestCase]
public void MindentVegrehajt() public void MindentVegrehajt()
{ {
FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(2); FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(2);
TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true }; TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = true }; TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = true };
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(b); tarolo.Felvesz(b);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.False); Assert.That(a.Vegrehajtott, Is.False);
Assert.That(b.Vegrehajtott, Is.False); Assert.That(b.Vegrehajtott, Is.False);
}); });
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.True); Assert.That(a.Vegrehajtott, Is.True);
Assert.That(b.Vegrehajtott, Is.True); Assert.That(b.Vegrehajtott, Is.True);
}); });
} }
[TestCase] [TestCase]
public void VegrehajtasAmikorNemVegrehajthatok() public void VegrehajtasAmikorNemVegrehajthatok()
{ {
FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
TesztFuggoFeladat a = new TesztFuggoFeladat("a"); TesztFuggoFeladat a = new TesztFuggoFeladat("a");
TesztFuggoFeladat b = new TesztFuggoFeladat("b"); TesztFuggoFeladat b = new TesztFuggoFeladat("b");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(b); tarolo.Felvesz(b);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.False); Assert.That(a.Vegrehajtott, Is.False);
Assert.That(b.Vegrehajtott, Is.False); Assert.That(b.Vegrehajtott, Is.False);
}); });
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.False); Assert.That(a.Vegrehajtott, Is.False);
Assert.That(b.Vegrehajtott, Is.False); Assert.That(b.Vegrehajtott, Is.False);
}); });
} }
[TestCase] [TestCase]
public void VegrehajtasAmikorVegrehajthatok() public void VegrehajtasAmikorVegrehajthatok()
{ {
FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true }; TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
TesztFuggoFeladat b = new TesztFuggoFeladat("b"); TesztFuggoFeladat b = new TesztFuggoFeladat("b");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(b); tarolo.Felvesz(b);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.False); Assert.That(a.Vegrehajtott, Is.False);
Assert.That(b.Vegrehajtott, Is.False); Assert.That(b.Vegrehajtott, Is.False);
}); });
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.True); Assert.That(a.Vegrehajtott, Is.True);
Assert.That(b.Vegrehajtott, Is.False); Assert.That(b.Vegrehajtott, Is.False);
}); });
b.Vegrehajthato = true; b.Vegrehajthato = true;
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.True); Assert.That(a.Vegrehajtott, Is.True);
Assert.That(b.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")] [TestFixture(Category = "Paradigmák", TestName = "01 - Feltételes Feladat Tároló Előkövetelményekkel Tesztek")]
public class FuggoFeladatTaroloElokovetelmenyekkelTesztek public class FuggoFeladatTaroloElokovetelmenyekkelTesztek
{ {
[TestCase] [TestCase]
public void Elokovetelmenyes() public void Elokovetelmenyes()
{ {
FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
TesztFuggoFeladat a = new TesztFuggoFeladat("a"); TesztFuggoFeladat a = new TesztFuggoFeladat("a");
TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true }; TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true };
// a->b // a->b
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(b); tarolo.Felvesz(b);
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.False); Assert.That(a.Vegrehajtott, Is.False);
Assert.That(b.Vegrehajtott, Is.False); Assert.That(b.Vegrehajtott, Is.False);
}); });
a.Vegrehajthato = true; a.Vegrehajthato = true;
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.True); Assert.That(a.Vegrehajtott, Is.True);
Assert.That(b.Vegrehajtott, Is.True); Assert.That(b.Vegrehajtott, Is.True);
}); });
} }
[TestCase] [TestCase]
public void TobbKorosElokovetelmenyes() public void TobbKorosElokovetelmenyes()
{ {
FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true }; TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true }; TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true };
TesztElokovetelmenytolFuggoFeladat c = new TesztElokovetelmenytolFuggoFeladat("c", a) { Vegrehajthato = true }; TesztElokovetelmenytolFuggoFeladat c = new TesztElokovetelmenytolFuggoFeladat("c", a) { Vegrehajthato = true };
TesztElokovetelmenytolFuggoFeladat d = new TesztElokovetelmenytolFuggoFeladat("d", b) { Vegrehajthato = true }; TesztElokovetelmenytolFuggoFeladat d = new TesztElokovetelmenytolFuggoFeladat("d", b) { Vegrehajthato = true };
// a->b->d // a->b->d
// ->c // ->c
tarolo.Felvesz(d); tarolo.Felvesz(d);
tarolo.Felvesz(c); tarolo.Felvesz(c);
tarolo.Felvesz(b); tarolo.Felvesz(b);
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.True); 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(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(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); Assert.That(d.Vegrehajtott, Is.False);
}); });
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.True); Assert.That(a.Vegrehajtott, Is.True);
Assert.That(b.Vegrehajtott, Is.True); Assert.That(b.Vegrehajtott, Is.True);
Assert.That(c.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 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(); tarolo.MindentVegrehajt();
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(a.Vegrehajtott, Is.True); Assert.That(a.Vegrehajtott, Is.True);
Assert.That(b.Vegrehajtott, Is.True); Assert.That(b.Vegrehajtott, Is.True);
Assert.That(c.Vegrehajtott, Is.True); Assert.That(c.Vegrehajtott, Is.True);
Assert.That(d.Vegrehajtott, Is.True); Assert.That(d.Vegrehajtott, Is.True);
}); });
} }
} }
[TestFixture(Category = "Paradigmák", TestName = "01 - Bejáró Tesztek")] [TestFixture(Category = "Paradigmák", TestName = "01 - Bejáró Tesztek")]
class BejarasokTesztek class BejarasokTesztek
{ {
[TestCase] [TestCase]
public void FeladatTaroloBejaro() public void FeladatTaroloBejaro()
{ {
FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10); FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10);
TesztFeladat a = new TesztFeladat("a"); TesztFeladat a = new TesztFeladat("a");
TesztFeladat b = new TesztFeladat("b"); TesztFeladat b = new TesztFeladat("b");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(b); tarolo.Felvesz(b);
string nevek = ""; string nevek = "";
foreach (TesztFeladat u in tarolo) foreach (TesztFeladat u in tarolo)
nevek += u.Azonosito; nevek += u.Azonosito;
Assert.That(nevek, Is.EqualTo("ab")); Assert.That(nevek, Is.EqualTo("ab"));
} }
[TestCase] [TestCase]
public void FuggoFeladatTaroloBejaro() public void FuggoFeladatTaroloBejaro()
{ {
FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
TesztFuggoFeladat a = new TesztFuggoFeladat("a"); TesztFuggoFeladat a = new TesztFuggoFeladat("a");
TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = true }; TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = true };
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(b); tarolo.Felvesz(b);
tarolo.MindentVegrehajt(); tarolo.MindentVegrehajt();
string nevek = ""; string nevek = "";
foreach (TesztFuggoFeladat u in tarolo) foreach (TesztFuggoFeladat u in tarolo)
if (u.Vegrehajtott) if (u.Vegrehajtott)
nevek += u.Azonosito; nevek += u.Azonosito;
Assert.That(nevek, Is.EqualTo("b")); 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; using OE.ALGA.Paradigmak;
namespace OE.ALGA.Tesztek namespace OE.ALGA.Tesztek.Paradigmak
{ {
[TestClass()] [TestFixture(Category = "Paradigmák", TestName = "02 - Feltételes Feladat Tároló Tesztek")]
public class FeltetelesFeladatTaroloTesztek public class FeltetelesFeladatTaroloTesztek
{ {
[TestMethod()] [TestCase]
public void FelveszTeszt() //F1.(a) public void Felvesz()
{ {
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10); FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(5);
TesztFeladat a = new TesztFeladat("a"); TesztFeladat a = new TesztFeladat("a");
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(a);
tarolo.Felvesz(a); }
tarolo.Felvesz(a); [TestCase]
} public void TulsokatFelvesz()
{
[TestMethod()] FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(3);
[ExpectedException(typeof(TaroloMegteltKivetel))] TesztFeladat a = new TesztFeladat("a");
public void TulsokatFelveszTeszt() //F1.(a) tarolo.Felvesz(a);
{ tarolo.Felvesz(a);
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(5); tarolo.Felvesz(a);
TesztFeladat a = new TesztFeladat("a"); Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
tarolo.Felvesz(a); }
tarolo.Felvesz(a); [TestCase]
tarolo.Felvesz(a); public void NincsMitVegrehajtani()
tarolo.Felvesz(a); {
tarolo.Felvesz(a); FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(2);
tarolo.Felvesz(a); tarolo.MindentVegrehajt();
} }
[TestCase]
[TestMethod()] public void MindenVegrehajtas()
public void MindenVegrehajtasTeszt() //F1.(a) {
{ FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(2);
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10); TesztFeladat a = new TesztFeladat("a");
TesztFeladat a = new TesztFeladat("a"); TesztFeladat b = new TesztFeladat("b");
TesztFeladat b = new TesztFeladat("b"); tarolo.Felvesz(a);
tarolo.Felvesz(a); tarolo.Felvesz(b);
tarolo.Felvesz(b); Assert.Multiple(() =>
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a.Vegrehajtott); {
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b.Vegrehajtott); Assert.That(a.Vegrehajtott, Is.False);
tarolo.MindentVegrehajt(); Assert.That(b.Vegrehajtott, Is.False);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a.Vegrehajtott); });
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(b.Vegrehajtott); tarolo.MindentVegrehajt();
} Assert.Multiple(() =>
{
[TestMethod()] Assert.That(a.Vegrehajtott, Is.True);
public void BejaroTeszt() //F1.(a) Assert.That(b.Vegrehajtott, Is.True);
{ });
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10); }
TesztFeladat a = new TesztFeladat("a"); [TestCase]
TesztFeladat b = new TesztFeladat("b"); public void FeltetelesVegrehajtas()
tarolo.Felvesz(a); {
tarolo.Felvesz(b); FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
string nevek = ""; TesztFeladat a1 = new TesztFeladat("a1");
foreach (TesztFeladat u in tarolo) TesztFeladat b1 = new TesztFeladat("b1");
{ TesztFeladat a2 = new TesztFeladat("a2");
nevek += u.Azonosito; tarolo.Felvesz(a1);
} tarolo.Felvesz(b1);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual("ab", nevek); tarolo.Felvesz(a2);
} Assert.Multiple(() =>
{
[TestMethod()] Assert.That(a1.Vegrehajtott, Is.False);
public void FeltetelesVegrehajtasTeszt() //F1.(b) Assert.That(b1.Vegrehajtott, Is.False);
{ Assert.That(a2.Vegrehajtott, Is.False);
FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10); });
TesztFeladat a1 = new TesztFeladat("a1"); tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a'; }); // csak 'a' kezdetűek végrehajtása
TesztFeladat b1 = new TesztFeladat("b1"); Assert.Multiple(() =>
TesztFeladat a2 = new TesztFeladat("a2"); {
tarolo.Felvesz(a1); Assert.That(a1.Vegrehajtott, Is.True);
tarolo.Felvesz(b1); Assert.That(b1.Vegrehajtott, Is.False);
tarolo.Felvesz(a2); Assert.That(a2.Vegrehajtott, Is.True);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a1.Vegrehajtott); });
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b1.Vegrehajtott); tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'b'; }); // csak 'b' kezdetűek végrehajtása
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a2.Vegrehajtott); Assert.Multiple(() =>
tarolo.FeltetelesVegrehajtas(x => x.Azonosito[0] == 'a'); // csak 'a' kezdetűek végrehajtása {
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a1.Vegrehajtott); Assert.That(a1.Vegrehajtott, Is.True);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b1.Vegrehajtott); Assert.That(b1.Vegrehajtott, Is.True);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a2.Vegrehajtott); Assert.That(a2.Vegrehajtott, Is.True);
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); [TestCase]
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a2.Vegrehajtott); public void FeltetelesFuggosegesVegrehajtas()
} {
FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10);
[TestMethod()] TesztFuggoFeladat a1 = new TesztFuggoFeladat("a1") { Vegrehajthato = true };
public void FeltetelesFuggosegesVegrehajtasTeszt() //F1.(b) TesztFuggoFeladat b1 = new TesztFuggoFeladat("b1") { Vegrehajthato = true };
{ TesztFuggoFeladat a2 = new TesztFuggoFeladat("a2") { Vegrehajthato = false };
FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10); tarolo.Felvesz(a1);
TesztFuggoFeladat a1 = new TesztFuggoFeladat("a1") { Vegrehajthato = true }; tarolo.Felvesz(b1);
TesztFuggoFeladat b1 = new TesztFuggoFeladat("b1") { Vegrehajthato = true }; tarolo.Felvesz(a2);
TesztFuggoFeladat a2 = new TesztFuggoFeladat("a2") { Vegrehajthato = false }; Assert.Multiple(() =>
tarolo.Felvesz(a1); {
tarolo.Felvesz(b1); Assert.That(a1.Vegrehajtott, Is.False);
tarolo.Felvesz(a2); Assert.That(b1.Vegrehajtott, Is.False);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a1.Vegrehajtott); Assert.That(a2.Vegrehajtott, Is.False);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b1.Vegrehajtott); });
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a2.Vegrehajtott); tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a' && x.FuggosegTeljesul; }); // csak 'a' kezdetű és végrehajtható
tarolo.FeltetelesVegrehajtas(x => x.Azonosito[0] == 'a' && x.FuggosegTeljesul); // csak 'a' kezdetű és végrehajtható Assert.Multiple(() =>
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a1.Vegrehajtott); {
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(b1.Vegrehajtott); Assert.That(a1.Vegrehajtott, Is.True);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a2.Vegrehajtott); Assert.That(b1.Vegrehajtott, Is.False);
tarolo.FeltetelesVegrehajtas(x => x.Azonosito[0] == 'b' && x.FuggosegTeljesul); // csak 'b' kezdetű és végrehajtható Assert.That(a2.Vegrehajtott, Is.False);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a1.Vegrehajtott); });
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(b1.Vegrehajtott); tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'b' && x.FuggosegTeljesul; }); // csak 'b' kezdetű és végrehajtható
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsFalse(a2.Vegrehajtott); Assert.Multiple(() =>
a2.Vegrehajthato = true; {
tarolo.FeltetelesVegrehajtas(x => x.Azonosito[0] == 'a' && x.FuggosegTeljesul); // csak 'a' kezdetű és végrehajtható Assert.That(a1.Vegrehajtott, Is.True);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a1.Vegrehajtott); Assert.That(b1.Vegrehajtott, Is.True);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(b1.Vegrehajtott); Assert.That(a2.Vegrehajtott, Is.False);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.IsTrue(a2.Vegrehajtott); });
} a2.Vegrehajthato = true;
tarolo.FeltetelesVegrehajtas(x => { Guardian.Recursion.CheckStackTrace(); return x.Azonosito[0] == 'a' && x.FuggosegTeljesul; }); // csak 'a' kezdetű és végrehajtható
[TestMethod()] Assert.Multiple(() =>
public void FeltetelesBejaroTeszt() //F3.(b) {
{ Assert.That(a1.Vegrehajtott, Is.True);
FeltetelesFeladatTarolo<TesztFuggoFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFuggoFeladat>(10); Assert.That(b1.Vegrehajtott, Is.True);
tarolo.BejaroFeltetel = (x => x.FuggosegTeljesul); Assert.That(a2.Vegrehajtott, Is.True);
TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true }; });
TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = false }; }
TesztFuggoFeladat c = new TesztFuggoFeladat("c") { Vegrehajthato = true }; [TestCase]
tarolo.Felvesz(a); public void Bejaro()
tarolo.Felvesz(b); {
tarolo.Felvesz(c); FeltetelesFeladatTarolo<TesztFeladat> tarolo = new FeltetelesFeladatTarolo<TesztFeladat>(10);
string nevek = ""; TesztFeladat a = new TesztFeladat("a");
foreach (TesztFeladat u in tarolo) TesztFeladat b = new TesztFeladat("b");
{ tarolo.Felvesz(a);
nevek += u.Azonosito; tarolo.Felvesz(b);
} string nevek = "";
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual("ac", 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);
}
}
}

304
Tesztek/07_NyersEroTesztek.cs
View File

@@ -4,159 +4,159 @@ using OE.ALGA.Optimalizalas;
namespace OE.ALGA.Tesztek.Optimalizalas namespace OE.ALGA.Tesztek.Optimalizalas
{ {
[TestFixture(Category = "Optimalizalas", TestName = "07 - Hátiszák Tesztek")] [TestFixture(Category = "Optimalizalas", TestName = "07 - Hátiszák Tesztek")]
public class HatizsakTesztek public class HatizsakTesztek
{ {
[TestCase] [TestCase]
public void UresTeszt() public void UresTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(0, 0, [], []); HatizsakProblema problema = new HatizsakProblema(0, 0, [], []);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(problema.OsszSuly(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0)); Assert.That(problema.OsszSuly(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
Assert.That(problema.OsszSuly(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(0)); Assert.That(problema.OsszSuly(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(0));
Assert.That(problema.OsszSuly(PakolasTesztEsetek.feligPakolas), Is.EqualTo(0)); Assert.That(problema.OsszSuly(PakolasTesztEsetek.feligPakolas), Is.EqualTo(0));
}); });
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(problema.OsszErtek(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0)); Assert.That(problema.OsszErtek(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
Assert.That(problema.OsszErtek(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(0)); Assert.That(problema.OsszErtek(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(0));
Assert.That(problema.OsszErtek(PakolasTesztEsetek.feligPakolas), Is.EqualTo(0)); Assert.That(problema.OsszErtek(PakolasTesztEsetek.feligPakolas), Is.EqualTo(0));
}); });
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(problema.Ervenyes(PakolasTesztEsetek.uresPakolas), Is.True); Assert.That(problema.Ervenyes(PakolasTesztEsetek.uresPakolas), Is.True);
Assert.That(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas), Is.True); Assert.That(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas), Is.True);
Assert.That(problema.Ervenyes(PakolasTesztEsetek.feligPakolas), Is.True); Assert.That(problema.Ervenyes(PakolasTesztEsetek.feligPakolas), Is.True);
}); });
} }
[TestCase] [TestCase]
public void SulyTeszt() public void SulyTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(problema.OsszSuly(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0)); Assert.That(problema.OsszSuly(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
Assert.That(problema.OsszSuly(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(10)); Assert.That(problema.OsszSuly(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(10));
Assert.That(problema.OsszSuly(PakolasTesztEsetek.feligPakolas), Is.EqualTo(2)); Assert.That(problema.OsszSuly(PakolasTesztEsetek.feligPakolas), Is.EqualTo(2));
}); });
} }
[TestCase] [TestCase]
public void JosagTeszt() public void JosagTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(problema.OsszErtek(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0)); Assert.That(problema.OsszErtek(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
Assert.That(problema.OsszErtek(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(29)); Assert.That(problema.OsszErtek(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(29));
Assert.That(problema.OsszErtek(PakolasTesztEsetek.feligPakolas), Is.EqualTo(11)); Assert.That(problema.OsszErtek(PakolasTesztEsetek.feligPakolas), Is.EqualTo(11));
}); });
} }
[TestCase] [TestCase]
public void ErvenyesTeszt() public void ErvenyesTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(problema.Ervenyes(PakolasTesztEsetek.uresPakolas), Is.True); Assert.That(problema.Ervenyes(PakolasTesztEsetek.uresPakolas), Is.True);
Assert.That(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas), Is.False); Assert.That(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas), Is.False);
Assert.That(problema.Ervenyes(PakolasTesztEsetek.feligPakolas), Is.True); Assert.That(problema.Ervenyes(PakolasTesztEsetek.feligPakolas), Is.True);
}); });
} }
} }
[TestFixture(Category = "Optimalizalas", TestName = "07 - Nyers Ero Tesztek")] [TestFixture(Category = "Optimalizalas", TestName = "07 - Nyers Ero Tesztek")]
public class NyersEroTesztek public class NyersEroTesztek
{ {
[TestCase] [TestCase]
public void UresTeszt() public void UresTeszt()
{ {
int[] A = { 4, 6, 7, 4, 2, 1 }; int[] A = { 4, 6, 7, 4, 2, 1 };
NyersEro<int> opt = new NyersEro<int>( NyersEro<int> opt = new NyersEro<int>(
0, 0,
x => { Guardian.Recursion.CheckStackTrace(); return A[x - 1]; }, x => { Guardian.Recursion.CheckStackTrace(); return A[x - 1]; },
x => { Guardian.Recursion.CheckStackTrace(); return x; }); x => { Guardian.Recursion.CheckStackTrace(); return x; });
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(opt.OptimalisMegoldas(), Is.EqualTo(4)); Assert.That(opt.OptimalisMegoldas(), Is.EqualTo(4));
Assert.That(opt.LepesSzam, Is.EqualTo(0)); Assert.That(opt.LepesSzam, Is.EqualTo(0));
}); });
} }
[TestCase] [TestCase]
public void TombLegnagyobbEleme() public void TombLegnagyobbEleme()
{ {
int[] A = { 4, 6, 7, 4, 2, 1 }; int[] A = { 4, 6, 7, 4, 2, 1 };
NyersEro<int> opt = new NyersEro<int>( NyersEro<int> opt = new NyersEro<int>(
A.Length, A.Length,
x => { Guardian.Recursion.CheckStackTrace(); return A[x - 1]; }, x => { Guardian.Recursion.CheckStackTrace(); return A[x - 1]; },
x => { Guardian.Recursion.CheckStackTrace(); return x; }); x => { Guardian.Recursion.CheckStackTrace(); return x; });
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(opt.OptimalisMegoldas(), Is.EqualTo(7)); Assert.That(opt.OptimalisMegoldas(), Is.EqualTo(7));
Assert.That(opt.LepesSzam, Is.EqualTo(5)); Assert.That(opt.LepesSzam, Is.EqualTo(5));
}); });
} }
} }
[TestFixture(Category = "Optimalizalas", TestName = "07 - Nyers Ero Hátizsák Pakolás Tesztek")] [TestFixture(Category = "Optimalizalas", TestName = "07 - Nyers Ero Hátizsák Pakolás Tesztek")]
public class NyersEroHatizsakPakolasTesztek public class NyersEroHatizsakPakolasTesztek
{ {
[TestCase] [TestCase]
public void UresTeszt() public void UresTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(0, 0, [], []); HatizsakProblema problema = new HatizsakProblema(0, 0, [], []);
NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema); NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(opt.OptimalisErtek(), Is.EqualTo(0)); Assert.That(opt.OptimalisErtek(), Is.EqualTo(0));
Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(Array.Empty<bool>())); Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(Array.Empty<bool>()));
Assert.That(opt.LepesSzam, Is.EqualTo(0)); Assert.That(opt.LepesSzam, Is.EqualTo(0));
}); });
} }
[TestCase] [TestCase]
public void JegyzetbenLevoPeldaErtekTeszt() public void JegyzetbenLevoPeldaErtekTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema); NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.jegyzet_optimalis_ertek)); Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.jegyzet_optimalis_ertek));
Assert.That(opt.LepesSzam, Is.EqualTo(63)); Assert.That(opt.LepesSzam, Is.EqualTo(63));
}); });
} }
[TestCase] [TestCase]
public void JegyzetbenLevoPeldaMegoldasTeszt() public void JegyzetbenLevoPeldaMegoldasTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema); NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.jegyzet_optimalis_pakolas)); Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.jegyzet_optimalis_pakolas));
Assert.That(opt.LepesSzam, Is.EqualTo(63)); Assert.That(opt.LepesSzam, Is.EqualTo(63));
}); });
} }
[TestCase] [TestCase]
public void NagyPeldaMegoldasErtekTeszt() public void NagyPeldaMegoldasErtekTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p); HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema); NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek)); Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
Assert.That(opt.LepesSzam, Is.EqualTo(131071)); Assert.That(opt.LepesSzam, Is.EqualTo(131071));
}); });
} }
[TestCase] [TestCase]
public void NagyPeldaMegoldasTeszt() public void NagyPeldaMegoldasTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p); HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema); NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
Assert.Multiple(() => Assert.Multiple(() =>
{ {
Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.nagy_optimalis_pakolas)); Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.nagy_optimalis_pakolas));
Assert.That(opt.LepesSzam, Is.EqualTo(131071)); 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 NUnit.Framework;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OE.ALGA.Optimalizalas; using OE.ALGA.Optimalizalas;
namespace OE.ALGA.Tesztek namespace OE.ALGA.Tesztek.Optimalizalas
{ {
[TestClass()] [TestFixture(Category = "Optimalizalas", TestName = "09 - Visszalépéses Keresés Tesztek")]
public class VisszalepesesKeresesTesztek public class VisszalepesesKeresesTesztek
{ {
[TestMethod()] [TestCase]
public void JegyzetbenLevoPeldaErtekTeszt() //F2. public void JegyzetbenLevoPeldaErtekTeszt()
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema); VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema);
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_ertek, opt.OptimalisErtek()); 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()] [TestFixture(Category = "Optimalizalas", TestName = "09 - Szétválasztás és Korlátozás Tesztek")]
public void JegyzetbenLevoPeldaMegoldasTeszt() //F2. public class SzetvalasztasEsKorlatozasTesztek
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); [TestCase]
VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema); public void JegyzetbenLevoPeldaErtekTeszt()
CollectionAssert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_pakolas, opt.OptimalisMegoldas()); {
} HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
[TestMethod()] Assert.Multiple(() =>
public void NagyPeldaMegoldasTeszt() //F2. {
{ Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.jegyzet_optimalis_ertek));
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p); Assert.That(opt.LepesSzam, Is.EqualTo(62));
VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema); });
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek()); }
} [TestCase]
public void JegyzetbenLevoPeldaMegoldasTeszt()
[TestMethod()] {
public void LepesszamVizsgalat() //F2. HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
{ SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p); Assert.Multiple(() =>
VisszalepesesHatizsakPakolas opt = new VisszalepesesHatizsakPakolas(problema); {
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek()); Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.jegyzet_optimalis_pakolas));
Console.WriteLine("Lépésszám: " + opt.LepesSzam); Assert.That(opt.LepesSzam, Is.EqualTo(62));
} });
} }
[TestCase]
[TestClass()] public void NagyPeldaMegoldasTeszt()
public class SzetvalasztasEsKorlatozasTesztek {
{ HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
[TestMethod()] SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
public void JegyzetbenLevoPeldaErtekTeszt() //F4. Assert.Multiple(() =>
{ {
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema); Assert.That(opt.LepesSzam, Is.EqualTo(618));
Microsoft.VisualStudio.TestTools.UnitTesting.Assert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_ertek, opt.OptimalisErtek()); });
} }
[TestCase]
[TestMethod()] public void LepesszamVizsgalat()
public void JegyzetbenLevoPeldaMegoldasTeszt() //F4. {
{ HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema);
SzetvalasztasEsKorlatozasHatizsakPakolas opt = new SzetvalasztasEsKorlatozasHatizsakPakolas(problema); Assert.Multiple(() =>
CollectionAssert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_pakolas, opt.OptimalisMegoldas()); {
} Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
Assert.That(opt.LepesSzam, Is.EqualTo(618));
[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);
}
}
} }

2
Tesztek/Tesztek.csproj
View File

@@ -12,8 +12,6 @@
<ItemGroup> <ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" /> <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" Version="4.4.0" />
<PackageReference Include="NUnit.Analyzers" Version="4.10.0"> <PackageReference Include="NUnit.Analyzers" Version="4.10.0">
<PrivateAssets>all</PrivateAssets> <PrivateAssets>all</PrivateAssets>