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

Microsoft.VisualStudio.TestTools.UnitTesting -> NUnit.Framework

Browse Source
This commit is contained in:
Sanyo
2025-09-08 07:19:22 +02:00
parent 78859a5b2b
commit 0951fc94da
46 changed files with 2614 additions and 1445 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
ALGA/ADT.cs
View File

@@ -1,4 +1,6 @@
namespace OE.ALGA.Adatszerkezetek
using System;
namespace OE.ALGA
{
public interface Lista<T>
{

6
ALGA/ALGA.csproj
View File

@@ -1,10 +1,10 @@
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<ImplicitUsings>disable</ImplicitUsings>
<Nullable>enable</Nullable>
<RootNamespace>OE.ALGA.Adatszerkezetek</RootNamespace>
<RootNamespace>OE.ALGA</RootNamespace>
</PropertyGroup>
</Project>

8
ALGA/Adatszerkezetek/03_TombImplementacio.cs Normal file
View File

@@ -0,0 +1,8 @@
using System;
using System.Collections;
using System.Collections.Generic;
namespace OE.ALGA.Adatszerkezetek
{
// 3. heti labor feladat - Tesztek: 03_TombImplementacioTesztek.cs
}

8
ALGA/Adatszerkezetek/04_LancoltImplementacio.cs Normal file
View File

@@ -0,0 +1,8 @@
using System;
using System.Collections;
using System.Collections.Generic;
namespace OE.ALGA.Adatszerkezetek
{
// 4. heti labor feladat - Tesztek: 04_LancoltImplementacioTesztek.cs
}

6
ALGA/Adatszerkezetek/05_BinarisKeresoFa.cs Normal file
View File

@@ -0,0 +1,6 @@
using System;
namespace OE.ALGA.Adatszerkezetek
{
// 5. heti labor feladat - Tesztek: 05_BinarisKeresoFaTesztek.cs
}

6
ALGA/Adatszerkezetek/06_Szotar.cs Normal file
View File

@@ -0,0 +1,6 @@
using System;
namespace OE.ALGA.Adatszerkezetek
{
// 6. heti labor feladat - Tesztek: 06_SzotarTesztek.cs
}

6
ALGA/Adatszerkezetek/10_SulyozotlanGraf.cs Normal file
View File

@@ -0,0 +1,6 @@
using System;
namespace OE.ALGA.Adatszerkezetek
{
// 10. heti labor feladat - Tesztek: 10_SulyozatlanGrafTesztek.cs
}

6
ALGA/Adatszerkezetek/11_Kupac.cs Normal file
View File

@@ -0,0 +1,6 @@
using System;
namespace OE.ALGA.Adatszerkezetek
{
// 11. heti labor feladat - Tesztek: 11_KupacTesztek.cs
}

6
ALGA/Adatszerkezetek/12_SulyozottGraf.cs Normal file
View File

@@ -0,0 +1,6 @@
using System;
namespace OE.ALGA.Adatszerkezetek
{
// 12. heti labor feladat - Tesztek: 12_SulyozottGrafTesztek.cs
}

6
ALGA/Optimalizalas/07_NyersEro.cs Normal file
View File

@@ -0,0 +1,6 @@
using System;
namespace OE.ALGA.Optimalizalas
{
// 7. heti labor feladat - Tesztek: 07_NyersEroTesztek.cs
}

4
ALGA/Optimalizalas/08_DinamikusProgramozas.cs Normal file
View File

@@ -0,0 +1,4 @@
namespace OE.ALGA.Optimalizalas
{
// 8. heti labor feladat - Tesztek: 08_DinamikusProgramozasTesztek.cs
}

6
ALGA/Optimalizalas/09_VisszalepesesKereses.cs Normal file
View File

@@ -0,0 +1,6 @@
using System;
namespace OE.ALGA.Optimalizalas
{
// 9. heti labor feladat - Tesztek: 09VisszalepesesKeresesTesztek.cs
}

9
ALGA/Paradigmak/01_ImperativParadigma.cs Normal file
View File

@@ -0,0 +1,9 @@
using System;
using System.Collections;
using System.Collections.Generic;
namespace OE.ALGA.Paradigmak
{
// 1. heti labor feladat - Tesztek: 01_ImperativParadigmaTesztek.cs
}

8
ALGA/Paradigmak/02_FunkcionalisParadigma.cs Normal file
View File

@@ -0,0 +1,8 @@
using System;
using System.Collections;
using System.Collections.Generic;
namespace OE.ALGA.Paradigmak
{
// 2. heti labor feladat - Tesztek: 02_FunkcionálisParadigmaTesztek.cs
}

6
ALGA/README.md Normal file
View File

@@ -0,0 +1,6 @@
# Tudnivalók a projekttel kapcsolatban
- A félév során elkészítendő feladatokhoz tartozó fájlok a megadott mappában létre vannak hozva.
- A megoldást minden esetben a fájlon belül lévő névtérbe kell elkészíteni.
- A fejlesztés során az adott feladathoz tartozó teszt fájl (például: *Tesztek/01_ImperativParadigmaTesztek.cs*) tartalma legyen futtatható (*Ctrl+A*, majd *Ctrl+K+U*).
- Későbbi hetek feladatai felhasználhatják egy korábbi hét feladatának megoldását, így érdemes a korábbi teszteket is folyamatosan figyelemmel kísérni, mivel azoknak továbbra is hibátlanul le kell futniuk.
- A teszteknél hiányzó *IVegrehajthato* és *IFuggo* interfészek elkészítése az első hét feladata.

19
ALGA_heti_feladatok.sln
View File

@@ -1,4 +1,4 @@
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34330.188
@@ -12,14 +12,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Engine", "Engine\Engine.csp
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ALGA", "ALGA\ALGA.csproj", "{F1EF1714-78CB-4FDC-9CE2-B9A7D9F94729}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Tesztek", "Tesztek\Tesztek.csproj", "{87FEB91B-F223-432E-9A58-1CD0D6894896}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sandbox", "Sandbox\Sandbox.csproj", "{2517350C-751A-4876-AEDE-D6AE9D6815C7}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{18C1E947-7BE8-466A-AF69-8EDAF6ADEB3E}"
ProjectSection(SolutionItems) = preProject
.editorconfig = .editorconfig
EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sandbox", "Sandbox\Sandbox.csproj", "{2517350C-751A-4876-AEDE-D6AE9D6815C7}"
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Tesztek", "Tesztek\Tesztek.csproj", "{AFE58A8F-D9BA-4EBF-810D-F7E07E5A296C}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -39,14 +34,14 @@ Global
{F1EF1714-78CB-4FDC-9CE2-B9A7D9F94729}.Debug|Any CPU.Build.0 = Debug|Any CPU
{F1EF1714-78CB-4FDC-9CE2-B9A7D9F94729}.Release|Any CPU.ActiveCfg = Release|Any CPU
{F1EF1714-78CB-4FDC-9CE2-B9A7D9F94729}.Release|Any CPU.Build.0 = Release|Any CPU
{87FEB91B-F223-432E-9A58-1CD0D6894896}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{87FEB91B-F223-432E-9A58-1CD0D6894896}.Debug|Any CPU.Build.0 = Debug|Any CPU
{87FEB91B-F223-432E-9A58-1CD0D6894896}.Release|Any CPU.ActiveCfg = Release|Any CPU
{87FEB91B-F223-432E-9A58-1CD0D6894896}.Release|Any CPU.Build.0 = Release|Any CPU
{2517350C-751A-4876-AEDE-D6AE9D6815C7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{2517350C-751A-4876-AEDE-D6AE9D6815C7}.Debug|Any CPU.Build.0 = Debug|Any CPU
{2517350C-751A-4876-AEDE-D6AE9D6815C7}.Release|Any CPU.ActiveCfg = Release|Any CPU
{2517350C-751A-4876-AEDE-D6AE9D6815C7}.Release|Any CPU.Build.0 = Release|Any CPU
{AFE58A8F-D9BA-4EBF-810D-F7E07E5A296C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{AFE58A8F-D9BA-4EBF-810D-F7E07E5A296C}.Debug|Any CPU.Build.0 = Debug|Any CPU
{AFE58A8F-D9BA-4EBF-810D-F7E07E5A296C}.Release|Any CPU.ActiveCfg = Release|Any CPU
{AFE58A8F-D9BA-4EBF-810D-F7E07E5A296C}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

2
ALGAme/ALGAme.csproj
View File

@@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>

2
ALGAme/Jatek.cs
View File

@@ -1,4 +1,4 @@
using OE.ALGA.Engine;
using OE.ALGA.Engine;
namespace OE.ALGA.ALGAme
{

2
ALGAme/Program.cs
View File

@@ -1,4 +1,4 @@
using OE.ALGA.ALGAme;
using OE.ALGA.ALGAme;
Jatek jatek = new Jatek();
jatek.Start();

2
Engine/AlapTipusok.cs
View File

@@ -1,4 +1,4 @@
namespace OE.ALGA.Engine
namespace OE.ALGA.Engine
{
public class KetElemuVektor : IComparable
{

2
Engine/Backend.cs
View File

@@ -1,4 +1,4 @@
namespace OE.ALGA.Engine
namespace OE.ALGA.Engine
{
public class Backend
{

2
Engine/BillentyuzetKezelo.cs
View File

@@ -1,4 +1,4 @@
namespace OE.ALGA.Engine
namespace OE.ALGA.Engine
{
public interface IBillentyuLenyomasKezelo
{

2
Engine/Engine.csproj
View File

@@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>

2
Engine/GlobalSuppressions.cs
View File

@@ -1,4 +1,4 @@
// This file is used by Code Analysis to maintain SuppressMessage
// This file is used by Code Analysis to maintain SuppressMessage
// attributes that are applied to this project.
// Project-level suppressions either have no target or are given
// a specific target and scoped to a namespace, type, member, etc.

2
Engine/Kivetelek.cs
View File

@@ -1,4 +1,4 @@
namespace OE.ALGA.Engine
namespace OE.ALGA.Engine
{
public class UtkozesKivetel : Exception
{

2
Engine/KonzolMegjelenito.cs
View File

@@ -1,4 +1,4 @@
using System.Text;
using System.Text;
namespace OE.ALGA.Engine
{

2
Engine/OrajelGenerator.cs
View File

@@ -1,4 +1,4 @@
namespace OE.ALGA.Engine
namespace OE.ALGA.Engine
{
public interface IOrajelFogado
{

2
Engine/Parameterek.cs
View File

@@ -1,4 +1,4 @@
namespace OE.ALGA.Engine
namespace OE.ALGA.Engine
{
public static class Param
{

2
Engine/Terkep.cs
View File

@@ -1,4 +1,4 @@
namespace OE.ALGA.Engine
namespace OE.ALGA.Engine
{
public class Terkep : INezopont
{

2
Sandbox/Program.cs
View File

@@ -1,4 +1,4 @@
namespace OE.ALGA.Sandbox
namespace OE.ALGA.Sandbox
{
internal class Program
{

2
Sandbox/Sandbox.csproj
View File

@@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>

72
Tesztek/00_Utils.cs Normal file
View File

@@ -0,0 +1,72 @@
using OE.ALGA.Paradigmak;
namespace Guardian
{
public static class Recursion
{
/// <summary>
/// This method is injected into every method and property call to check the current state
/// of the stack. If the number of calls on the stack exceeds 500, infinite recursion is
/// assumed and an exception is thrown, avoiding a complete program crash.
/// </summary>
/// <exception cref="System.StackOverflowException"></exception>
public static void CheckStackTrace()
{
System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace();
if (st.FrameCount > 500)
throw new System.StackOverflowException($"A stack overflow has occurred! Method call depth has reached the limit (500<=): {st.FrameCount}!");
}
}
}
namespace OE.ALGA.Tesztek
{
#region Paradigmak
class TesztFeladat : IVegrehajthato
{
public string Azonosito { get; set; }
public bool Vegrehajtott { get; set; }
public void Vegrehajtas() => Vegrehajtott = true;
public TesztFeladat(string nev) => Azonosito = nev;
}
class TesztFuggoFeladat : TesztFeladat, IFuggo
{
public bool Vegrehajthato { get; set; }
public virtual bool FuggosegTeljesul => Vegrehajthato;
public TesztFuggoFeladat(string nev) : base(nev) { }
}
class TesztElokovetelmenytolFuggoFeladat : TesztFuggoFeladat
{
readonly TesztFeladat elokovetelmeny;
public override bool FuggosegTeljesul => base.FuggosegTeljesul && elokovetelmeny.Vegrehajtott;
public TesztElokovetelmenytolFuggoFeladat(string nev, TesztFeladat elokovetelmeny) : base(nev) { this.elokovetelmeny = elokovetelmeny; }
}
#endregion
#region Optimalizalas
public class PakolasTesztEsetek
{
public static readonly bool[] uresPakolas = [false, false, false, false, false, false];
public static readonly bool[] feligPakolas = [false, true, false, true, false, false];
public static readonly bool[] teljesPakolas = [true, true, true, true, true, true];
public static readonly int[] jegyzet_w = [2, 1, 1, 1, 3, 2];
public static readonly float[] jegyzet_p = [4, 3, 2, 8, 7, 5];
public static readonly int jegyzet_n = jegyzet_w.Length;
public static readonly int jegyzet_Wmax = 4;
public static readonly float jegyzet_optimalis_ertek = 16;
public static readonly bool[] jegyzet_optimalis_pakolas = [false, true, false, true, false, true];
public static readonly int[] nagy_w = [21, 41, 26, 11, 37, 25, 25, 44, 33, 29, 32, 52, 41, 62, 56, 81, 43];
public static readonly float[] nagy_p = [4, 3, 2, 8, 7, 5, 4, 3, 2, 5, 3, 9, 5, 1, 7, 9, 4];
public static readonly int nagy_n = nagy_w.Length;
public static readonly int nagy_Wmax = 100;
public static readonly float nagy_optimalis_ertek = 24;
public static readonly bool[] nagy_optimalis_pakolas = [true, false, false, true, true, true, false, false, false, false, false, false, false, false, false, false, false];
}
#endregion
}

537
Tesztek/01_ImperativParadigmaTesztek.cs
View File

@@ -1,257 +1,280 @@
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using OE.ALGA.Paradigmak;
//
// namespace OE.ALGA.Tesztek
// {
// class TesztFeladat : IVegrehajthato //F1.
// {
// public string Azonosito { get; set; }
//
// public bool Vegrehajtott { get; set; }
//
// public void Vegrehajtas()
// {
// Vegrehajtott = true;
// }
//
// public TesztFeladat(string nev)
// {
// this.Azonosito = nev;
// }
// }
//
// [TestClass()]
// public class FeladatTaroloTeszt
// {
// [TestMethod()]
// public void FelveszTeszt() //F2.(c)
// {
// FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(5);
// 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() //F2.(c)
// {
// FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<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 VegrehajtasTeszt() //F2.(d)
// {
// FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10);
// TesztFeladat a = new TesztFeladat("a");
// TesztFeladat b = new TesztFeladat("b");
// tarolo.Felvesz(a);
// tarolo.Felvesz(b);
// Assert.IsFalse(a.Vegrehajtott);
// Assert.IsFalse(b.Vegrehajtott);
// tarolo.MindentVegrehajt();
// Assert.IsTrue(a.Vegrehajtott);
// Assert.IsTrue(b.Vegrehajtott);
// }
// }
//
// class TesztFuggoFeladat : TesztFeladat, IFuggo //F3.
// {
// public bool Vegrehajthato { get; set; }
//
// public virtual bool FuggosegTeljesul
// {
// get
// {
// return Vegrehajthato;
// }
// }
//
// public TesztFuggoFeladat(string nev) : base(nev)
// {
// }
// }
//
// [TestClass()]
// public class FuggoFeladatTaroloTeszt //F4.
// {
// [TestMethod()]
// public void FelveszTeszt()
// {
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
// TesztFuggoFeladat a = new TesztFuggoFeladat("a");
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// }
//
// [TestMethod()]
// [ExpectedException(typeof(TaroloMegteltKivetel))]
// public void TulsokatFelveszTeszt()
// {
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
// TesztFuggoFeladat a = new TesztFuggoFeladat("a");
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// }
//
// [TestMethod()]
// public void VegrehajtasAmikorNemVegrehajthatokTeszt()
// {
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
// TesztFuggoFeladat a = new TesztFuggoFeladat("a");
// TesztFuggoFeladat b = new TesztFuggoFeladat("b");
// tarolo.Felvesz(a);
// tarolo.Felvesz(b);
// Assert.IsFalse(a.Vegrehajtott);
// Assert.IsFalse(b.Vegrehajtott);
// tarolo.MindentVegrehajt();
// Assert.IsFalse(a.Vegrehajtott);
// Assert.IsFalse(b.Vegrehajtott);
// }
//
// [TestMethod()]
// public void VegrehajtasAmikorVegrehajthatokTeszt()
// {
// 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.IsFalse(a.Vegrehajtott);
// Assert.IsFalse(b.Vegrehajtott);
// tarolo.MindentVegrehajt();
// Assert.IsTrue(a.Vegrehajtott);
// Assert.IsFalse(b.Vegrehajtott);
// b.Vegrehajthato = true;
// tarolo.MindentVegrehajt();
// Assert.IsTrue(a.Vegrehajtott);
// Assert.IsTrue(b.Vegrehajtott);
// }
// }
//
// class TesztElokovetelmenytolFuggoFeladat : TesztFuggoFeladat //F4.
// {
// readonly TesztFeladat elokovetelmeny;
//
// public TesztElokovetelmenytolFuggoFeladat(string nev, TesztFeladat elokovetelmeny) : base(nev)
// {
// this.elokovetelmeny = elokovetelmeny;
// }
//
// public override bool FuggosegTeljesul
// {
// get
// {
// return base.FuggosegTeljesul && elokovetelmeny.Vegrehajtott;
// }
// }
// }
//
// [TestClass()]
// public class FuggoFeladatTaroloElokovetelmenyekkelTeszt //F4.
// {
// [TestMethod()]
// public void ElokovetelmenyesTeszt()
// {
// 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.IsFalse(a.Vegrehajtott);
// Assert.IsFalse(b.Vegrehajtott);
// a.Vegrehajthato = true;
// tarolo.MindentVegrehajt();
// Assert.IsTrue(a.Vegrehajtott);
// Assert.IsTrue(b.Vegrehajtott);
// }
//
// [TestMethod()]
// public void TobbKorosElokovetelmenyesTeszt()
// {
// 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.IsTrue(a.Vegrehajtott);
// Assert.IsFalse(b.Vegrehajtott); // a 'b' kiértékelése az 'a' végrehajtása előtt volt, ezért az még nem lett feldolgozva
// Assert.IsFalse(c.Vegrehajtott); // a 'c' kiértékelése az 'a' végrehajtása előtt volt, ezért az még nem lett feldolgozva
// Assert.IsFalse(d.Vegrehajtott);
// tarolo.MindentVegrehajt();
// Assert.IsTrue(a.Vegrehajtott);
// Assert.IsTrue(b.Vegrehajtott);
// Assert.IsTrue(c.Vegrehajtott);
// Assert.IsFalse(d.Vegrehajtott); // 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.IsTrue(a.Vegrehajtott);
// Assert.IsTrue(b.Vegrehajtott);
// Assert.IsTrue(c.Vegrehajtott);
// Assert.IsTrue(d.Vegrehajtott);
// }
// }
//
// class BejarasokTeszt //F5.
// {
// [TestMethod()]
// public void FeladatTaroloBejaroTeszt()
// {
// 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.AreEqual("ab", nevek);
// }
//
// [TestMethod()]
// public void FuggoFeladatTaroloBejaroTeszt()
// {
// 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.AreEqual("b", nevek);
// }
//
// }
// }
//using NUnit.Framework;
//using OE.ALGA.Paradigmak;
//namespace OE.ALGA.Tesztek.Paradigmak
//{
// [TestFixture(Category = "Paradigmák", TestName = "01 - Feladat Tároló Tesztek")]
// public class FeladatTaroloTesztek
// {
// [TestCase]
// public void Ures()
// {
// FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(0);
// TesztFeladat a = new TesztFeladat("a");
// Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
// }
// [TestCase]
// public void Felvesz()
// {
// FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(5);
// TesztFeladat a = new TesztFeladat("a");
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// tarolo.Felvesz(a);
// }
// [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"));
// }
// [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"));
// }
// }
//}

154
Tesztek/02_FunkconalisParadigmaTesztek.cs Normal file
View File

@@ -0,0 +1,154 @@
//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"));
// }
// }
//}

662
Tesztek/03_TombImplementacioTesztek.cs
View File

@@ -1,263 +1,399 @@
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek
// {
// [TestClass()]
// public class TombVeremTesztek
// {
// [TestMethod()]
// public void MindenJolMukodik() //F1.
// {
// Verem<int> v = new TombVerem<int>(3);
// 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(NincsHelyKivetel))]
// public void TulSokElem() //F1.
// {
// Verem<int> v = new TombVerem<int>(3);
// v.Verembe(1);
// v.Verembe(3);
// v.Verembe(2);
// v.Verembe(4);
// }
//
// [TestMethod()]
// [ExpectedException(typeof(NincsElemKivetel))]
// public void TulKevesElem() //F1.
// {
// Verem<int> v = new TombVerem<int>(3);
// v.Verembe(1);
// v.Verembe(3);
// v.Verembe(2);
// v.Verembol();
// v.Verembol();
// v.Verembol();
// v.Verembol();
// }
//
// [TestMethod()]
// public void Felso() //F1.
// {
// Verem<int> v = new TombVerem<int>(3);
// 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() //F1.
// {
// Verem<int> v = new TombVerem<int>(2);
// Assert.IsTrue(v.Ures);
// v.Verembe(1);
// Assert.IsFalse(v.Ures);
// v.Verembol();
// Assert.IsTrue(v.Ures);
// }
// }
//
// [TestClass()]
// public class TombSorTesztek
// {
// [TestMethod()]
// public void AlapMukodes() //F2.
// {
// Sor<int> s = new TombSor<int>(3);
// 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()]
// public void Korbeeres() //F2.
// {
// Sor<int> s = new TombSor<int>(3);
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// Assert.AreEqual(1, s.Sorbol());
// Assert.AreEqual(3, s.Sorbol());
// s.Sorba(4);
// s.Sorba(5);
// Assert.AreEqual(2, s.Sorbol());
// Assert.AreEqual(4, s.Sorbol());
// Assert.AreEqual(5, s.Sorbol());
// }
//
// [TestMethod()]
// [ExpectedException(typeof(NincsHelyKivetel))]
// public void TulSokElem() //F2.
// {
// Sor<int> s = new TombSor<int>(3);
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// s.Sorba(4);
// }
//
// [TestMethod()]
// [ExpectedException(typeof(NincsElemKivetel))]
// public void TulKevesElem() //F2.
// {
// Sor<int> s = new TombSor<int>(3);
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// s.Sorbol();
// s.Sorbol();
// s.Sorbol();
// s.Sorbol();
// }
//
// [TestMethod()]
// public void Elso() //F2.
// {
// Sor<int> s = new TombSor<int>(3);
// 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() //F2.
// {
// Sor<int> s = new TombSor<int>(2);
// Assert.IsTrue(s.Ures);
// s.Sorba(1);
// Assert.IsFalse(s.Ures);
// s.Sorbol();
// Assert.IsTrue(s.Ures);
// }
// }
//
// [TestClass]
// public class TombListaTesztek
// {
// [TestMethod]
// public void Bejaras() //F3.
// {
// Lista<int> l = new TombLista<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() //F3.
// {
// Lista<int> l = new TombLista<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() //F3.
// {
// Lista<string> l = new TombLista<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() //F3.
// {
// Lista<int> l = new TombLista<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() //F3.
// {
// Lista<int> l = new TombLista<int>();
// l.Beszur(0, 1);
// l.Beszur(0, 2);
// l.Beszur(1, 3);
// l.Beszur(3, 4);
// l.Beszur(2, 5);
// Assert.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() //F3.
// {
// Lista<int> l = new TombLista<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() //F3.
// {
// Lista<int> l = new TombLista<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() //F4.
// {
// TombLista<string> l = new TombLista<string>();
// l.Hozzafuz("a");
// l.Hozzafuz("c");
// l.Hozzafuz("d");
// l.Hozzafuz("b");
// string osszefuzo = "";
// foreach(string x in l)
// {
// osszefuzo += x;
// }
// Assert.AreEqual("acdb", osszefuzo);
// }
// }
// }
//using NUnit.Framework;
//using OE.ALGA.Adatszerkezetek;
//namespace OE.ALGA.Tesztek.Adatszerkezetek
//{
// [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Lista Tesztek")]
// public class TombListaTesztek
// {
// [TestCase]
// public void Elemszam()
// {
// Lista<string> l = new TombLista<string>();
// Assert.That(l.Elemszam, Is.EqualTo(0));
// l.Hozzafuz("A");
// Assert.That(l.Elemszam, Is.EqualTo(1));
// l.Hozzafuz("B");
// Assert.That(l.Elemszam, Is.EqualTo(2));
// l.Torol("A");
// Assert.That(l.Elemszam, Is.EqualTo(1));
// }
// [TestCase]
// public void Bejaras()
// {
// Lista<int> l = new TombLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(3);
// l.Hozzafuz(2);
// string s = "";
// l.Bejar(x => { Guardian.Recursion.CheckStackTrace(); s += x.ToString(); });
// Assert.That(s, Is.EqualTo("132"));
// }
// [TestCase]
// public void Beszuras()
// {
// Lista<int> l = new TombLista<int>();
// l.Beszur(0, 1);
// l.Beszur(0, 2);
// l.Beszur(1, 3);
// l.Beszur(3, 4);
// l.Beszur(2, 5);
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(2));
// Assert.That(l.Kiolvas(1), Is.EqualTo(3));
// Assert.That(l.Kiolvas(2), Is.EqualTo(5));
// Assert.That(l.Kiolvas(3), Is.EqualTo(1));
// Assert.That(l.Kiolvas(4), Is.EqualTo(4));
// });
// }
// [TestCase]
// public void BeszurasUres()
// {
// Lista<string> l = new TombLista<string>();
// l.Beszur(0, "1");
// l.Beszur(0, "2");
// l.Beszur(1, "");
// l.Beszur(3, "");
// l.Beszur(2, "5");
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo("2"));
// Assert.That(l.Kiolvas(1), Is.EqualTo(""));
// Assert.That(l.Kiolvas(2), Is.EqualTo("5"));
// Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
// Assert.That(l.Kiolvas(4), Is.EqualTo(""));
// });
// }
// [TestCase]
// public void HozzaFuzes()
// {
// Lista<int> l = new TombLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(3);
// l.Hozzafuz(2);
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(1));
// Assert.That(l.Kiolvas(1), Is.EqualTo(3));
// Assert.That(l.Kiolvas(2), Is.EqualTo(2));
// });
// }
// [TestCase]
// public void HozzaFuzesUres()
// {
// Lista<string> l = new TombLista<string>();
// l.Hozzafuz("1");
// l.Hozzafuz("");
// l.Hozzafuz("");
// l.Hozzafuz("1");
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
// Assert.That(l.Kiolvas(1), Is.EqualTo(""));
// Assert.That(l.Kiolvas(2), Is.EqualTo(""));
// Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
// });
// }
// [TestCase]
// public void Novekedes()
// {
// Lista<int> l = new TombLista<int>();
// for (int i = 0; i < 1000; i++)
// l.Hozzafuz(i * i);
// Assert.That(l.Elemszam, Is.EqualTo(1000));
// Assert.Multiple(() =>
// {
// for (int i = 0; i < 1000; i++)
// Assert.That(l.Kiolvas(i), Is.EqualTo(i * i));
// });
// Assert.That(l.Elemszam, Is.EqualTo(1000));
// }
// [TestCase]
// public void Torles()
// {
// Lista<int> l = new TombLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(3);
// l.Hozzafuz(2);
// l.Hozzafuz(3);
// l.Hozzafuz(4);
// Assert.That(l.Elemszam, Is.EqualTo(5));
// l.Torol(3);
// Assert.That(l.Elemszam, Is.EqualTo(3));
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(1));
// Assert.That(l.Kiolvas(1), Is.EqualTo(2));
// Assert.That(l.Kiolvas(2), Is.EqualTo(4));
// });
// }
// [TestCase]
// public void TorlesNincsElem()
// {
// Lista<int> l = new TombLista<int>();
// Assert.That(l.Elemszam, Is.EqualTo(0));
// l.Torol(0);
// Assert.That(l.Elemszam, Is.EqualTo(0));
// }
// [TestCase]
// public void TorlesUres()
// {
// Lista<string> l = new TombLista<string>();
// l.Hozzafuz("1");
// l.Hozzafuz("");
// l.Hozzafuz("");
// l.Hozzafuz("");
// l.Hozzafuz("1");
// Assert.That(l.Elemszam, Is.EqualTo(5));
// l.Torol("");
// Assert.That(l.Elemszam, Is.EqualTo(2));
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
// Assert.That(l.Kiolvas(1), Is.EqualTo("1"));
// });
// }
// [TestCase]
// public void NemletezoTorles()
// {
// Lista<int> l = new TombLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(2);
// l.Hozzafuz(3);
// Assert.That(l.Elemszam, Is.EqualTo(3));
// l.Torol(0);
// Assert.That(l.Elemszam, Is.EqualTo(3));
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(1));
// Assert.That(l.Kiolvas(1), Is.EqualTo(2));
// Assert.That(l.Kiolvas(2), Is.EqualTo(3));
// });
// }
// [TestCase]
// public void Modositas()
// {
// Lista<int> l = new TombLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(3);
// l.Hozzafuz(2);
// l.Modosit(1, 5);
// l.Modosit(0, 4);
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(4));
// Assert.That(l.Kiolvas(1), Is.EqualTo(5));
// Assert.That(l.Kiolvas(2), Is.EqualTo(2));
// });
// }
// [TestCase]
// public void ForeachBejaras()
// {
// TombLista<string> l = new TombLista<string>();
// l.Hozzafuz("a");
// l.Hozzafuz("c");
// l.Hozzafuz("d");
// l.Hozzafuz("b");
// string osszefuzo = "";
// foreach (string x in l)
// {
// osszefuzo += x;
// }
// Assert.That(osszefuzo, Is.EqualTo("acdb"));
// }
// }
// [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Sor Tesztek")]
// public class TombSorTesztek
// {
// [TestCase]
// public void Ures()
// {
// Sor<int> s = new TombSor<int>(0);
// Assert.That(s.Ures, Is.True);
// Assert.Throws<NincsHelyKivetel>(() => s.Sorba(1));
// }
// [TestCase]
// public void AlapMukodes()
// {
// Sor<int> s = new TombSor<int>(3);
// Assert.That(s.Ures, Is.True);
// s.Sorba(1);
// Assert.That(s.Ures, Is.False);
// s.Sorba(3);
// Assert.That(s.Ures, Is.False);
// s.Sorba(2);
// Assert.That(s.Ures, Is.False);
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol(), Is.EqualTo(1));
// Assert.That(s.Ures, Is.False);
// Assert.That(s.Sorbol(), Is.EqualTo(3));
// Assert.That(s.Ures, Is.False);
// Assert.That(s.Sorbol(), Is.EqualTo(2));
// Assert.That(s.Ures, Is.True);
// });
// }
// [TestCase]
// public void UresElem()
// {
// Sor<string> s = new TombSor<string>(3);
// s.Sorba("");
// s.Sorba("1");
// s.Sorba("");
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol(), Is.EqualTo(""));
// Assert.That(s.Sorbol(), Is.EqualTo("1"));
// Assert.That(s.Sorbol(), Is.EqualTo(""));
// });
// }
// [TestCase]
// public void Korbeeres()
// {
// Sor<int> s = new TombSor<int>(3);
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol(), Is.EqualTo(1));
// Assert.That(s.Sorbol(), Is.EqualTo(3));
// });
// s.Sorba(4);
// s.Sorba(5);
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol(), Is.EqualTo(2));
// Assert.That(s.Sorbol(), Is.EqualTo(4));
// Assert.That(s.Sorbol(), Is.EqualTo(5));
// });
// }
// [TestCase]
// public void TulSokElem()
// {
// Sor<int> s = new TombSor<int>(3);
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// Assert.Throws<NincsHelyKivetel>(() => s.Sorba(4));
// }
// [TestCase]
// public void TulKevesElem()
// {
// Sor<int> s = new TombSor<int>(3);
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// s.Sorbol();
// s.Sorbol();
// s.Sorbol();
// Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
// }
// [TestCase]
// public void Elso()
// {
// Sor<int> s = new TombSor<int>(3);
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// Assert.Multiple(() =>
// {
// Assert.That(s.Elso(), Is.EqualTo(1));
// Assert.That(s.Elso(), Is.EqualTo(1));
// });
// s.Sorbol();
// Assert.That(s.Elso(), Is.EqualTo(3));
// }
// }
// [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Verem Tesztek")]
// public class TombVeremTesztek
// {
// [TestCase]
// public void Ures()
// {
// Verem<int> v = new TombVerem<int>(0);
// Assert.That(v.Ures, Is.True);
// Assert.Throws<NincsHelyKivetel>(() => v.Verembe(1));
// }
// [TestCase]
// public void AlapMukodes()
// {
// Verem<int> v = new TombVerem<int>(3);
// Assert.That(v.Ures, Is.True);
// v.Verembe(1);
// Assert.That(v.Ures, Is.False);
// v.Verembe(3);
// Assert.That(v.Ures, Is.False);
// v.Verembe(2);
// Assert.That(v.Ures, Is.False);
// Assert.That(v.Verembol(), Is.EqualTo(2));
// Assert.That(v.Ures, Is.False);
// v.Verembe(4);
// Assert.That(v.Ures, Is.False);
// Assert.Multiple(() =>
// {
// Assert.That(v.Verembol(), Is.EqualTo(4));
// Assert.That(v.Ures, Is.False);
// Assert.That(v.Verembol(), Is.EqualTo(3));
// Assert.That(v.Ures, Is.False);
// Assert.That(v.Verembol(), Is.EqualTo(1));
// Assert.That(v.Ures, Is.True);
// });
// }
// [TestCase]
// public void UresElem()
// {
// Verem<string> v = new TombVerem<string>(3);
// v.Verembe("");
// v.Verembe("1");
// v.Verembe("");
// Assert.Multiple(() =>
// {
// Assert.That(v.Verembol(), Is.EqualTo(""));
// Assert.That(v.Verembol(), Is.EqualTo("1"));
// Assert.That(v.Verembol(), Is.EqualTo(""));
// });
// }
// [TestCase]
// public void TulSokElem()
// {
// Verem<int> v = new TombVerem<int>(3);
// v.Verembe(1);
// v.Verembe(3);
// v.Verembe(2);
// Assert.Throws<NincsHelyKivetel>(() => v.Verembe(4));
// }
// [TestCase]
// public void TulKevesElem()
// {
// Verem<int> v = new TombVerem<int>(3);
// v.Verembe(1);
// v.Verembe(3);
// v.Verembe(2);
// v.Verembol();
// v.Verembol();
// v.Verembol();
// Assert.Throws<NincsElemKivetel>(() => v.Verembol());
// }
// [TestCase]
// public void Felso()
// {
// Verem<int> v = new TombVerem<int>(3);
// v.Verembe(1);
// v.Verembe(3);
// v.Verembe(2);
// Assert.Multiple(() =>
// {
// Assert.That(v.Felso(), Is.EqualTo(2));
// Assert.That(v.Felso(), Is.EqualTo(2));
// });
// v.Verembol();
// Assert.That(v.Felso(), Is.EqualTo(3));
// }
// }
//}

353
Tesztek/04_LancoltImplementacioTesztek.cs Normal file
View File

@@ -0,0 +1,353 @@
//using NUnit.Framework;
//using OE.ALGA.Adatszerkezetek;
//namespace OE.ALGA.Tesztek.Adatszerkezetek
//{
// [TestFixture(Category = "Adatszerkezetek", TestName = "04 - Lancolt Lista Tesztek")]
// public class LancoltListaTesztek
// {
// [TestCase]
// public void Elemszam()
// {
// Lista<string> l = new LancoltLista<string>();
// Assert.That(l.Elemszam, Is.EqualTo(0));
// l.Hozzafuz("A");
// Assert.That(l.Elemszam, Is.EqualTo(1));
// l.Hozzafuz("B");
// Assert.That(l.Elemszam, Is.EqualTo(2));
// l.Torol("A");
// Assert.That(l.Elemszam, Is.EqualTo(1));
// }
// [TestCase]
// public void Bejaras()
// {
// Lista<int> l = new LancoltLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(3);
// l.Hozzafuz(2);
// string s = "";
// l.Bejar(x => { Guardian.Recursion.CheckStackTrace(); s += x.ToString(); });
// Assert.That(s, Is.EqualTo("132"));
// }
// [TestCase]
// public void Beszuras()
// {
// Lista<int> l = new LancoltLista<int>();
// l.Beszur(0, 1);
// l.Beszur(0, 2);
// l.Beszur(1, 3);
// l.Beszur(3, 4);
// l.Beszur(2, 5);
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(2));
// Assert.That(l.Kiolvas(1), Is.EqualTo(3));
// Assert.That(l.Kiolvas(2), Is.EqualTo(5));
// Assert.That(l.Kiolvas(3), Is.EqualTo(1));
// Assert.That(l.Kiolvas(4), Is.EqualTo(4));
// });
// }
// [TestCase]
// public void BeszurasUres()
// {
// Lista<string> l = new LancoltLista<string>();
// l.Beszur(0, "1");
// l.Beszur(0, "2");
// l.Beszur(1, "");
// l.Beszur(3, "");
// l.Beszur(2, "5");
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo("2"));
// Assert.That(l.Kiolvas(1), Is.EqualTo(""));
// Assert.That(l.Kiolvas(2), Is.EqualTo("5"));
// Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
// Assert.That(l.Kiolvas(4), Is.EqualTo(""));
// });
// }
// [TestCase]
// public void HozzaFuzes()
// {
// Lista<int> l = new LancoltLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(3);
// l.Hozzafuz(2);
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(1));
// Assert.That(l.Kiolvas(1), Is.EqualTo(3));
// Assert.That(l.Kiolvas(2), Is.EqualTo(2));
// });
// }
// [TestCase]
// public void HozzaFuzesUres()
// {
// Lista<string> l = new LancoltLista<string>();
// l.Hozzafuz("1");
// l.Hozzafuz("");
// l.Hozzafuz("");
// l.Hozzafuz("1");
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
// Assert.That(l.Kiolvas(1), Is.EqualTo(""));
// Assert.That(l.Kiolvas(2), Is.EqualTo(""));
// Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
// });
// }
// [TestCase]
// public void Novekedes()
// {
// Lista<int> l = new LancoltLista<int>();
// for (int i = 0; i < 1000; i++)
// l.Hozzafuz(i * i);
// Assert.That(l.Elemszam, Is.EqualTo(1000));
// Assert.Multiple(() =>
// {
// for (int i = 0; i < 1000; i++)
// Assert.That(l.Kiolvas(i), Is.EqualTo(i * i));
// });
// Assert.That(l.Elemszam, Is.EqualTo(1000));
// }
// [TestCase]
// public void Torles()
// {
// Lista<int> l = new LancoltLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(3);
// l.Hozzafuz(2);
// l.Hozzafuz(3);
// l.Hozzafuz(4);
// Assert.That(l.Elemszam, Is.EqualTo(5));
// l.Torol(3);
// Assert.That(l.Elemszam, Is.EqualTo(3));
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(1));
// Assert.That(l.Kiolvas(1), Is.EqualTo(2));
// Assert.That(l.Kiolvas(2), Is.EqualTo(4));
// });
// }
// [TestCase]
// public void TorlesNincsElem()
// {
// Lista<int> l = new LancoltLista<int>();
// Assert.That(l.Elemszam, Is.EqualTo(0));
// l.Torol(0);
// Assert.That(l.Elemszam, Is.EqualTo(0));
// }
// [TestCase]
// public void TorlesUres()
// {
// Lista<string> l = new LancoltLista<string>();
// l.Hozzafuz("1");
// l.Hozzafuz("");
// l.Hozzafuz("");
// l.Hozzafuz("");
// l.Hozzafuz("1");
// Assert.That(l.Elemszam, Is.EqualTo(5));
// l.Torol("");
// Assert.That(l.Elemszam, Is.EqualTo(2));
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
// Assert.That(l.Kiolvas(1), Is.EqualTo("1"));
// });
// }
// [TestCase]
// public void NemletezoTorles()
// {
// Lista<int> l = new LancoltLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(2);
// l.Hozzafuz(3);
// Assert.That(l.Elemszam, Is.EqualTo(3));
// l.Torol(0);
// Assert.That(l.Elemszam, Is.EqualTo(3));
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(1));
// Assert.That(l.Kiolvas(1), Is.EqualTo(2));
// Assert.That(l.Kiolvas(2), Is.EqualTo(3));
// });
// }
// [TestCase]
// public void Modositas()
// {
// Lista<int> l = new LancoltLista<int>();
// l.Hozzafuz(1);
// l.Hozzafuz(3);
// l.Hozzafuz(2);
// l.Modosit(1, 5);
// l.Modosit(0, 4);
// Assert.Multiple(() =>
// {
// Assert.That(l.Kiolvas(0), Is.EqualTo(4));
// Assert.That(l.Kiolvas(1), Is.EqualTo(5));
// Assert.That(l.Kiolvas(2), Is.EqualTo(2));
// });
// }
// [TestCase]
// public void ForeachBejaras()
// {
// 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.That(osszefuzo, Is.EqualTo("acdb"));
// }
// }
// [TestFixture(Category = "Adatszerkezetek", TestName = "04 - Lancolt Sor Tesztek")]
// public class LancoltSorTesztek
// {
// [TestCase]
// public void Ures()
// {
// Sor<int> s = new LancoltSor<int>();
// Assert.That(s.Ures, Is.True);
// Assert.Throws<NincsElemKivetel>(() => s.Elso());
// Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
// s.Sorba(1);
// Assert.That(s.Ures, Is.False);
// s.Sorbol();
// Assert.That(s.Ures, Is.True);
// }
// [TestCase]
// public void AlapMukodes()
// {
// Sor<int> s = new LancoltSor<int>();
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol(), Is.EqualTo(1));
// Assert.That(s.Sorbol(), Is.EqualTo(3));
// Assert.That(s.Sorbol(), Is.EqualTo(2));
// });
// }
// [TestCase]
// public void UresElem()
// {
// Sor<string> s = new LancoltSor<string>();
// s.Sorba("");
// s.Sorba("1");
// s.Sorba("");
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol(), Is.EqualTo(""));
// Assert.That(s.Sorbol(), Is.EqualTo("1"));
// Assert.That(s.Sorbol(), Is.EqualTo(""));
// });
// }
// [TestCase]
// public void TulKevesElem()
// {
// Sor<int> s = new LancoltSor<int>();
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// s.Sorbol();
// s.Sorbol();
// s.Sorbol();
// Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
// }
// [TestCase]
// public void Elso()
// {
// Sor<int> s = new LancoltSor<int>();
// s.Sorba(1);
// s.Sorba(3);
// s.Sorba(2);
// Assert.Multiple(() =>
// {
// Assert.That(s.Elso(), Is.EqualTo(1));
// Assert.That(s.Elso(), Is.EqualTo(1));
// });
// s.Sorbol();
// Assert.That(s.Elso(), Is.EqualTo(3));
// }
// }
// [TestFixture(Category = "Adatszerkezetek", TestName = "04 - Lancolt Verem Tesztek")]
// public class LancoltVeremTesztek
// {
// [TestCase]
// public void Ures()
// {
// Verem<int> v = new LancoltVerem<int>();
// Assert.That(v.Ures, Is.True);
// Assert.Throws<NincsElemKivetel>(() => v.Felso());
// Assert.Throws<NincsElemKivetel>(() => v.Verembol());
// v.Verembe(1);
// Assert.That(v.Ures, Is.False);
// v.Verembol();
// Assert.That(v.Ures, Is.True);
// }
// [TestCase]
// public void AlapMukodes()
// {
// Verem<int> v = new LancoltVerem<int>();
// v.Verembe(1);
// v.Verembe(3);
// v.Verembe(2);
// Assert.That(v.Verembol(), Is.EqualTo(2));
// v.Verembe(4);
// Assert.Multiple(() =>
// {
// Assert.That(v.Verembol(), Is.EqualTo(4));
// Assert.That(v.Verembol(), Is.EqualTo(3));
// Assert.That(v.Verembol(), Is.EqualTo(1));
// });
// }
// [TestCase]
// public void UresElem()
// {
// Verem<string> v = new LancoltVerem<string>();
// v.Verembe("");
// v.Verembe("1");
// v.Verembe("");
// Assert.Multiple(() =>
// {
// Assert.That(v.Verembol(), Is.EqualTo(""));
// Assert.That(v.Verembol(), Is.EqualTo("1"));
// Assert.That(v.Verembol(), Is.EqualTo(""));
// });
// }
// [TestCase]
// public void TulKevesElem()
// {
// Verem<int> v = new LancoltVerem<int>();
// v.Verembe(1);
// v.Verembe(3);
// v.Verembe(2);
// v.Verembol();
// v.Verembol();
// v.Verembol();
// Assert.Throws<NincsElemKivetel>(() => v.Verembol());
// }
// [TestCase]
// public void Felso()
// {
// Verem<int> v = new LancoltVerem<int>();
// v.Verembe(1);
// v.Verembe(3);
// v.Verembe(2);
// Assert.Multiple(() =>
// {
// Assert.That(v.Felso(), Is.EqualTo(2));
// Assert.That(v.Felso(), Is.EqualTo(2));
// });
// v.Verembol();
// Assert.That(v.Felso(), Is.EqualTo(3));
// }
// }
//}

193
Tesztek/05_BinarisKeresoFaTesztek.cs
View File

@@ -1,68 +1,125 @@
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek
// {
// [TestClass()]
// public class FaHalmazTesztek
// {
// [TestMethod()]
// public void Beszuras() //F4.
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(1);
// v.Beszur(3);
// v.Beszur(2);
// Assert.IsTrue(v.Eleme(1));
// Assert.IsTrue(v.Eleme(2));
// Assert.IsTrue(v.Eleme(3));
// Assert.IsFalse(v.Eleme(4));
// }
//
// [TestMethod()]
// public void Torles() //F5.
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(1);
// v.Beszur(3);
// v.Beszur(2);
// v.Torol(2);
// Assert.IsTrue(v.Eleme(1));
// Assert.IsFalse(v.Eleme(2));
// Assert.IsTrue(v.Eleme(3));
// Assert.IsFalse(v.Eleme(4));
// }
//
// [TestMethod()]
// public void DuplaBeszuras() //F5.
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(1);
// v.Beszur(2);
// v.Beszur(3);
// v.Beszur(2);
// v.Torol(2);
// Assert.IsTrue(v.Eleme(1));
// Assert.IsFalse(v.Eleme(2));
// Assert.IsTrue(v.Eleme(3));
// Assert.IsFalse(v.Eleme(4));
// }
//
// [TestMethod()]
// public void PreorderBejaras() //F6.
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(5);
// v.Beszur(3);
// v.Beszur(1);
// v.Beszur(8);
// v.Beszur(4);
// v.Beszur(9);
// v.Beszur(7);
// string osszefuzo = "";
// v.Bejar(x => osszefuzo += x);
// Assert.AreEqual("5314879", osszefuzo);
// }
//
// }
// }
//using NUnit.Framework;
//using OE.ALGA.Adatszerkezetek;
//namespace OE.ALGA.Tesztek.Adatszerkezetek
//{
// [TestFixture(Category = "Adatszerkezetek", TestName = "05 - Fa Halmaz Tesztek")]
// public class FaHalmazTesztek
// {
// [TestCase]
// public void BeszurasUres()
// {
// Halmaz<string> v = new FaHalmaz<string>();
// v.Beszur("");
// Assert.Multiple(() =>
// {
// Assert.That(v.Eleme(""), Is.True);
// });
// }
// [TestCase]
// public void Beszuras()
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(1);
// v.Beszur(3);
// v.Beszur(2);
// Assert.Multiple(() =>
// {
// Assert.That(v.Eleme(1), Is.True);
// Assert.That(v.Eleme(2), Is.True);
// Assert.That(v.Eleme(3), Is.True);
// });
// }
// [TestCase]
// public void DuplaBeszuras()
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(1);
// v.Beszur(2);
// v.Beszur(3);
// v.Beszur(2);
// Assert.Multiple(() =>
// {
// Assert.That(v.Eleme(1), Is.True);
// Assert.That(v.Eleme(2), Is.True);
// Assert.That(v.Eleme(3), Is.True);
// });
// }
// [TestCase]
// public void Torles()
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(1);
// v.Beszur(3);
// v.Beszur(2);
// v.Torol(2);
// Assert.Multiple(() =>
// {
// Assert.That(v.Eleme(1), Is.True);
// Assert.That(v.Eleme(2), Is.False);
// Assert.That(v.Eleme(3), Is.True);
// });
// }
// [TestCase]
// public void TorlesUres()
// {
// Halmaz<string> v = new FaHalmaz<string>();
// v.Beszur("");
// v.Beszur("1");
// v.Beszur("");
// v.Torol("");
// Assert.Multiple(() =>
// {
// Assert.That(v.Eleme(""), Is.False);
// Assert.That(v.Eleme("1"), Is.True);
// });
// }
// [TestCase]
// public void NemletezoTorles()
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(1);
// v.Beszur(3);
// v.Beszur(2);
// Assert.Throws<NincsElemKivetel>(() => v.Torol(0));
// Assert.Multiple(() =>
// {
// Assert.That(v.Eleme(1), Is.True);
// Assert.That(v.Eleme(2), Is.True);
// Assert.That(v.Eleme(3), Is.True);
// });
// }
// [TestCase]
// public void DuplaTorles()
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(1);
// v.Beszur(2);
// v.Beszur(3);
// v.Beszur(2);
// v.Torol(2);
// Assert.Multiple(() =>
// {
// Assert.That(v.Eleme(1), Is.True);
// Assert.That(v.Eleme(2), Is.False);
// Assert.That(v.Eleme(3), Is.True);
// Assert.That(v.Eleme(4), Is.False);
// });
// }
// [TestCase]
// public void PreorderBejaras()
// {
// Halmaz<int> v = new FaHalmaz<int>();
// v.Beszur(5);
// v.Beszur(3);
// v.Beszur(1);
// v.Beszur(8);
// v.Beszur(4);
// v.Beszur(9);
// v.Beszur(7);
// string osszefuzo = "";
// v.Bejar(x => osszefuzo += x);
// Assert.That(osszefuzo, Is.EqualTo("5314879"));
// }
// }
//}

197
Tesztek/06_SzotarTesztek.cs
View File

@@ -1,85 +1,112 @@
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek
// {
// [TestClass()]
// public class SzotarTesztek
// {
// public static int TesztHasitoFuggveny(string kulcs) //F2.(f)
// {
// if (string.IsNullOrEmpty(kulcs))
// return 0;
// int sum = 0;
// foreach (char c in kulcs.ToCharArray())
// sum += ((byte)c);
// return (sum * sum); // a modulo osztást a szótárnak kell végeznie, mert ő tudja csak a belső tömb méretet
// }
//
// [TestMethod()]
// public void AlapMukodes() //F2.(f)
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.AreEqual(5, sz.Kiolvas("Bela"));
// Assert.AreEqual(2, sz.Kiolvas("Lajos"));
// }
//
// [TestMethod()]
// public void AlapertelmezettHasitoFuggvennyel() //F2.(f)
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.AreEqual(5, sz.Kiolvas("Bela"));
// Assert.AreEqual(2, sz.Kiolvas("Lajos"));
// }
//
// [TestMethod()]
// public void Kulcsutkozes() //F2.(f)
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Bale", 15);
// sz.Beir("Lajos", 2);
// sz.Beir("Lasoj", 12);
// Assert.AreEqual(5, sz.Kiolvas("Bela"));
// Assert.AreEqual(2, sz.Kiolvas("Lajos"));
// Assert.AreEqual(15, sz.Kiolvas("Bale"));
// Assert.AreEqual(12, sz.Kiolvas("Lasoj"));
// }
//
// [TestMethod()]
// [ExpectedException(typeof(HibasKulcsKivetel))]
// public void NincsElem() //F2.(f)
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// sz.Kiolvas("Ferenc");
// }
//
// [TestMethod()]
// public void TorlesMarad() //F2.(g)
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// sz.Torol("Bela");
// Assert.AreEqual(2, sz.Kiolvas("Lajos"));
// }
//
// [TestMethod()]
// [ExpectedException(typeof(HibasKulcsKivetel))]
// public void TorlesEltunt() //F2.(g)
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// sz.Torol("Bela");
// sz.Kiolvas("Bela");
// }
// }
//
// }
//using NUnit.Framework;
//using OE.ALGA.Adatszerkezetek;
//namespace OE.ALGA.Tesztek.Adatszerkezetek
//{
// [TestFixture(Category = "Adatszerkezetek", TestName = "06 - Szótár Tesztek")]
// public class SzotarTesztek
// {
// private static int TesztHasitoFuggveny(string kulcs)
// {
// if (string.IsNullOrEmpty(kulcs))
// return 0;
// int sum = 0;
// foreach (char c in kulcs.ToCharArray())
// sum += ((byte)c);
// return sum * sum; // a modulo osztást a szótárnak kell végeznie, mert ő tudja csak a belső tömb méretet
// }
// [TestCase]
// public void AlapMukodes()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.Multiple(() =>
// {
// Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
// Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// });
// }
// [TestCase]
// public void AlapertelmezettHasitoFuggvennyel() //F2.(f)
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.Multiple(() =>
// {
// Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
// Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// });
// }
// [TestCase]
// public void Kulcsutkozes()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Bale", 15);
// sz.Beir("Lajos", 2);
// sz.Beir("Lasoj", 12);
// Assert.Multiple(() =>
// {
// Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
// Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// Assert.That(sz.Kiolvas("Bale"), Is.EqualTo(15));
// Assert.That(sz.Kiolvas("Lasoj"), Is.EqualTo(12));
// });
// }
// [TestCase]
// public void NullElem()
// {
// Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
// sz.Beir("null", null!);
// }
// [TestCase]
// public void UresKulcs()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("", 0);
// }
// [TestCase]
// public void UresElem()
// {
// Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", "");
// }
// [TestCase]
// public void NincsElem()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.Throws<HibasKulcsKivetel>(() => sz.Kiolvas("Ferenc"));
// }
// [TestCase]
// public void TorlesNull()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// Assert.Throws<HibasKulcsKivetel>(() => sz.Torol(null!));
// }
// [TestCase]
// public void TorlesMarad()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// sz.Torol("Bela");
// Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// }
// [TestCase]
// public void TorlesEltunt()
// {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2);
// sz.Torol("Bela");
// Assert.Throws<HibasKulcsKivetel>(() => sz.Kiolvas("Bela"));
// }
// }
//}

271
Tesztek/07_NyersEroTesztek.cs
View File

@@ -1,109 +1,162 @@
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using OE.ALGA.Optimalizalas;
//
// namespace OE.ALGA.Tesztek
// {
// public class PakolasTesztEsetek //F1.
// {
// public static readonly bool[] uresPakolas = new bool[] { false, false, false, false, false, false };
// public static readonly bool[] feligPakolas = new bool[] { false, true, false, true, false, false };
// public static readonly bool[] teljesPakolas = new bool[] { true, true, true, true, true, true };
//
// public static readonly int[] jegyzet_w = new int[] { 2, 1, 1, 1, 3, 2 };
// public static readonly float[] jegyzet_p = new float[] { 4, 3, 2, 8, 7, 5 };
// public static readonly int jegyzet_n = jegyzet_w.Length;
// public static readonly int jegyzet_Wmax = 4;
// public static readonly float jegyzet_optimalis_ertek = 16;
// public static readonly bool[] jegyzet_optimalis_pakolas = new bool[] { false, true, false, true, false, true };
//
// public static readonly int[] nagy_w = new int[] { 21, 41, 26, 11, 37, 25, 25, 44, 33, 29, 32, 52, 41, 62, 56, 81, 43 };
// public static readonly float[] nagy_p = new float[] { 4, 3, 2, 8, 7, 5, 4, 3, 2, 5, 3, 9, 5, 1, 7, 9, 4 };
// public static readonly int nagy_n = nagy_w.Length;
// public static readonly int nagy_Wmax = 100;
// public static readonly float nagy_optimalis_ertek = 24;
// }
//
// [TestClass()]
// public class HatizsakTesztek
// {
//
// [TestMethod()]
// public void SulyTeszt() //F1.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// Assert.AreEqual(0, problema.OsszSuly(PakolasTesztEsetek.uresPakolas));
// Assert.AreEqual(10, problema.OsszSuly(PakolasTesztEsetek.teljesPakolas));
// Assert.AreEqual(2, problema.OsszSuly(PakolasTesztEsetek.feligPakolas));
// }
//
// [TestMethod()]
// public void JosagTeszt() //F1.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// Assert.AreEqual(0, problema.OsszErtek(PakolasTesztEsetek.uresPakolas));
// Assert.AreEqual(29, problema.OsszErtek(PakolasTesztEsetek.teljesPakolas));
// Assert.AreEqual(11, problema.OsszErtek(PakolasTesztEsetek.feligPakolas));
// }
//
// [TestMethod()]
// public void ErvenyesTeszt() //F1.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// Assert.IsTrue(problema.Ervenyes(PakolasTesztEsetek.uresPakolas));
// Assert.IsFalse(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas));
// Assert.IsTrue(problema.Ervenyes(PakolasTesztEsetek.feligPakolas));
// }
// }
//
// [TestClass()]
// public class NyersEroTesztek
// {
// [TestMethod()]
// public void TombLegnagyobbEleme() //F2.
// {
// int[] A = { 4, 6, 7, 4, 2, 1 };
// NyersEro<int> opt = new NyersEro<int>(
// A.Length,
// x => A[x-1],
// x => x);
// Assert.AreEqual(7, opt.OptimalisMegoldas());
// }
// }
//
// [TestClass()]
// public class NyersEroHatizsakPakolasTesztek
// {
// [TestMethod()]
// public void JegyzetbenLevoPeldaErtekTeszt() //F3.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
// Assert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_ertek, opt.OptimalisErtek());
// }
//
// [TestMethod()]
// public void JegyzetbenLevoPeldaMegoldasTeszt() //F3.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
// CollectionAssert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_pakolas, opt.OptimalisMegoldas());
// }
//
// [TestMethod()]
// public void NagyPeldaMegoldasTeszt() //F3.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
// NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
// Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek());
// }
//
// [TestMethod()]
// public void LepesszamVizsgalat() //F3.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
// NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema);
// Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek());
// Console.WriteLine("Lépésszám: " + opt.LepesSzam);
// }
// }
// }
//using NUnit.Framework;
//using System;
//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 - 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));
// });
// }
// }
//}

109
Tesztek/08_DinamikusProgramozasTesztek.cs
View File

@@ -1,42 +1,67 @@
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using OE.ALGA.Optimalizalas;
//
// namespace OE.ALGA.Tesztek
// {
// [TestClass()]
// public class DinamikusProgramozasTesztek
// {
// [TestMethod()]
// public void JegyzetbenLevoPeldaErtekTeszt() //F1.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// Assert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_ertek, opt.OptimalisErtek());
// }
//
// [TestMethod()]
// public void JegyzetbenLevoPeldaMegoldasTeszt() //F1.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// CollectionAssert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_pakolas, opt.OptimalisMegoldas());
// }
//
// [TestMethod()]
// public void NagyPeldaMegoldasTeszt() //F1.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek());
// }
//
// [TestMethod()]
// public void LepesszamVizsgalat() //F1.
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek());
// Console.WriteLine("Lépésszám: " + opt.LepesSzam);
// }
// }
// }
//using NUnit.Framework;
//using System;
//using OE.ALGA.Optimalizalas;
//namespace OE.ALGA.Tesztek.Optimalizalas
//{
// [TestFixture(Category = "Optimalizalas", TestName = "08 - Dinamikus Programozás Tesztek")]
// public class DinamikusProgramozasTesztek
// {
// [TestCase]
// public void UresTeszt()
// {
// HatizsakProblema problema = new HatizsakProblema(0, 0, [], []);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(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);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// Assert.Multiple(() =>
// {
// Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.jegyzet_optimalis_ertek));
// Assert.That(opt.LepesSzam, Is.EqualTo(24));
// });
// }
// [TestCase]
// public void JegyzetbenLevoPeldaMegoldasTeszt()
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// Assert.Multiple(() =>
// {
// Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.jegyzet_optimalis_pakolas));
// Assert.That(opt.LepesSzam, Is.EqualTo(24));
// });
// }
// [TestCase]
// public void NagyPeldaMegoldasErtekTeszt()
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// Assert.Multiple(() =>
// {
// Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.nagy_optimalis_ertek));
// Assert.That(opt.LepesSzam, Is.EqualTo(1700));
// });
// }
// [TestCase]
// public void NagyPeldaMegoldasTeszt()
// {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// Assert.Multiple(() =>
// {
// Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(PakolasTesztEsetek.nagy_optimalis_pakolas));
// Assert.That(opt.LepesSzam, Is.EqualTo(1700));
// });
// }
// }
//}

103
Tesztek/09_VisszalepesesKereses.cs Normal file
View File

@@ -0,0 +1,103 @@
//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));
// });
// }
// }
//}

257
Tesztek/10_SulyozatlanGrafTesztek.cs
View File

@@ -1,119 +1,138 @@
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek
// {
// [TestClass]
// public class CsucsMatrixGrafTesztek
// {
// [TestMethod]
// public void MindenCsucsTeszt() //F2.
// {
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2);
// Assert.IsTrue(csg.Csucsok.Eleme(0));
// Assert.IsTrue(csg.Csucsok.Eleme(1));
// }
//
// [TestMethod]
// public void MindenElTeszt() //F2.
// {
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3);
// csg.UjEl(0, 1);
// csg.UjEl(0, 2);
// csg.UjEl(1, 2);
//
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(0, 0)));
// Assert.IsTrue(csg.Elek.Eleme(new EgeszGrafEl(0, 1)));
// Assert.IsTrue(csg.Elek.Eleme(new EgeszGrafEl(0, 2)));
//
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(1, 0)));
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(1, 1)));
// Assert.IsTrue(csg.Elek.Eleme(new EgeszGrafEl(1, 2)));
//
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(2, 0)));
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(2, 1)));
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(2, 2)));
// }
//
// [TestMethod]
// public void VezetElTeszt() //F2.
// {
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2);
// Assert.IsFalse(csg.VezetEl(0, 1));
// csg.UjEl(0, 1);
// Assert.IsTrue(csg.VezetEl(0, 1));
// Assert.IsFalse(csg.VezetEl(1, 0));
// }
//
// [TestMethod]
// public void SzomszedsagTeszt() //F2.
// {
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3);
// csg.UjEl(0, 1);
// csg.UjEl(0, 2);
// csg.UjEl(1, 2);
//
// Halmaz<int> a_szomszedai = csg.Szomszedai(0);
// Halmaz<int> b_szomszedai = csg.Szomszedai(1);
// Halmaz<int> c_szomszedai = csg.Szomszedai(2);
//
// Assert.IsFalse(a_szomszedai.Eleme(0));
// Assert.IsTrue(a_szomszedai.Eleme(1));
// Assert.IsTrue(a_szomszedai.Eleme(2));
//
// Assert.IsFalse(b_szomszedai.Eleme(0));
// Assert.IsFalse(b_szomszedai.Eleme(1));
// Assert.IsTrue(b_szomszedai.Eleme(2));
//
// Assert.IsFalse(c_szomszedai.Eleme(0));
// Assert.IsFalse(c_szomszedai.Eleme(1));
// Assert.IsFalse(c_szomszedai.Eleme(2));
// }
// }
//
// [TestClass]
// public class GrafBejarasTesztek
// {
// [TestMethod]
// public void SzelessegiBejarasTeszt() //F3.(a)
// {
// CsucsmatrixSulyozatlanEgeszGraf g = new CsucsmatrixSulyozatlanEgeszGraf(6);
// g.UjEl(0, 1);
// g.UjEl(1, 2);
// g.UjEl(1, 4);
// g.UjEl(2, 3);
// g.UjEl(2, 4);
// g.UjEl(4, 3);
// g.UjEl(3, 0);
//
// string ut = "";
// Halmaz<int> elertCsucsok = GrafBejarasok.SzelessegiBejaras(g, 0, (a) => { ut += a; });
//
// Assert.IsTrue(ut == "01243" || ut == "01423");
// for (int i = 0; i <= 4; i++)
// Assert.IsTrue(elertCsucsok.Eleme(i));
// Assert.IsFalse(elertCsucsok.Eleme(6));
// }
//
// [TestMethod]
// public void MelysegiBejarasTeszt() //F3.(c)
// {
// CsucsmatrixSulyozatlanEgeszGraf g = new CsucsmatrixSulyozatlanEgeszGraf(6);
// g.UjEl(0, 1);
// g.UjEl(1, 2);
// g.UjEl(1, 4);
// g.UjEl(2, 3);
// g.UjEl(2, 4);
// g.UjEl(4, 3);
// g.UjEl(3, 0);
//
// string ut = "";
// Halmaz<int> elertCsucsok = GrafBejarasok.MelysegiBejaras(g, 0, (a) => { ut += a; });
//
// Assert.IsTrue(ut == "01243" || ut == "01432" || ut == "01234");
// for (int i = 0; i <= 4; i++)
// Assert.IsTrue(elertCsucsok.Eleme(i));
// Assert.IsFalse(elertCsucsok.Eleme(6));
// }
// }
// }
//using NUnit.Framework;
//using OE.ALGA.Adatszerkezetek;
//namespace OE.ALGA.Tesztek.Adatszerkezetek
//{
// [TestFixture(Category = "Adatszerkezetek", TestName = "10 - Csúcsmátrix Gráf Tesztek")]
// public class CsucsMatrixGrafTesztek
// {
// [TestCase]
// public void MindenCsucsTeszt()
// {
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2);
// Assert.Multiple(() =>
// {
// Assert.That(csg.Csucsok.Eleme(0), Is.True);
// Assert.That(csg.Csucsok.Eleme(1), Is.True);
// });
// }
// [TestCase]
// public void MindenElTeszt()
// {
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3);
// csg.UjEl(0, 1);
// csg.UjEl(0, 2);
// csg.UjEl(1, 2);
// Assert.Multiple(() =>
// {
// Assert.That(csg.Elek.Eleme(new EgeszGrafEl(0, 0)), Is.False);
// Assert.That(csg.Elek.Eleme(new EgeszGrafEl(0, 1)), Is.True);
// Assert.That(csg.Elek.Eleme(new EgeszGrafEl(0, 2)), Is.True);
// Assert.That(csg.Elek.Eleme(new EgeszGrafEl(1, 0)), Is.False);
// Assert.That(csg.Elek.Eleme(new EgeszGrafEl(1, 1)), Is.False);
// Assert.That(csg.Elek.Eleme(new EgeszGrafEl(1, 2)), Is.True);
// Assert.That(csg.Elek.Eleme(new EgeszGrafEl(2, 0)), Is.False);
// Assert.That(csg.Elek.Eleme(new EgeszGrafEl(2, 1)), Is.False);
// Assert.That(csg.Elek.Eleme(new EgeszGrafEl(2, 2)), Is.False);
// });
// }
// [TestCase]
// public void VezetElTeszt()
// {
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2);
// Assert.That(csg.VezetEl(0, 1), Is.False);
// csg.UjEl(0, 1);
// Assert.Multiple(() =>
// {
// Assert.That(csg.VezetEl(0, 1), Is.True);
// Assert.That(csg.VezetEl(1, 0), Is.False);
// });
// }
// [TestCase]
// public void SzomszedsagTeszt()
// {
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3);
// csg.UjEl(0, 1);
// csg.UjEl(0, 2);
// csg.UjEl(1, 2);
// Halmaz<int> a_szomszedai = csg.Szomszedai(0);
// Halmaz<int> b_szomszedai = csg.Szomszedai(1);
// Halmaz<int> c_szomszedai = csg.Szomszedai(2);
// Assert.Multiple(() =>
// {
// Assert.That(a_szomszedai.Eleme(0), Is.False);
// Assert.That(a_szomszedai.Eleme(1), Is.True);
// Assert.That(a_szomszedai.Eleme(2), Is.True);
// Assert.That(b_szomszedai.Eleme(0), Is.False);
// Assert.That(b_szomszedai.Eleme(1), Is.False);
// Assert.That(b_szomszedai.Eleme(2), Is.True);
// Assert.That(c_szomszedai.Eleme(0), Is.False);
// Assert.That(c_szomszedai.Eleme(1), Is.False);
// Assert.That(c_szomszedai.Eleme(2), Is.False);
// });
// }
// }
// [TestFixture(Category = "Adatszerkezetek", TestName = "10 - Gráf Bejárás Tesztek")]
// public class GrafBejarasTesztek
// {
// [TestCase]
// public void SzelessegiBejarasTeszt()
// {
// CsucsmatrixSulyozatlanEgeszGraf g = new CsucsmatrixSulyozatlanEgeszGraf(6);
// g.UjEl(0, 1);
// g.UjEl(1, 2);
// g.UjEl(1, 4);
// g.UjEl(2, 3);
// g.UjEl(2, 4);
// g.UjEl(4, 3);
// g.UjEl(3, 0);
// string ut = "";
// Halmaz<int> elertCsucsok = GrafBejarasok.SzelessegiBejaras(g, 0, (a) => { ut += a; });
// Assert.Multiple(() =>
// {
// Assert.That(ut == "01243" || ut == "01423", Is.True);
// for (int i = 0; i <= 4; i++)
// Assert.That(elertCsucsok.Eleme(i), Is.True);
// Assert.That(elertCsucsok.Eleme(6), Is.False);
// });
// }
// [TestCase]
// public void MelysegiBejarasTeszt()
// {
// CsucsmatrixSulyozatlanEgeszGraf g = new CsucsmatrixSulyozatlanEgeszGraf(6);
// g.UjEl(0, 1);
// g.UjEl(1, 2);
// g.UjEl(1, 4);
// g.UjEl(2, 3);
// g.UjEl(2, 4);
// g.UjEl(4, 3);
// g.UjEl(3, 0);
// string ut = "";
// Halmaz<int> elertCsucsok = GrafBejarasok.MelysegiBejaras(g, 0, (a) => { ut += a; });
// Assert.Multiple(() =>
// {
// Assert.That(ut == "01243" || ut == "01432" || ut == "01234", Is.True);
// for (int i = 0; i <= 4; i++)
// Assert.That(elertCsucsok.Eleme(i), Is.True);
// Assert.That(elertCsucsok.Eleme(6), Is.False);
// });
// }
// }
//}

451
Tesztek/11_KupacTesztek.cs
View File

@@ -1,211 +1,240 @@
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek
// {
// [TestClass()]
// public class KupacRendezesTesztek
// {
// [TestMethod()]
// public void KupacEpites() //F1.
// {
// int[] A = [1, 3, 2, 4, 9, 12, 32, 21, 12, 8, 11];
// _ = new Kupac<int>(A, A.Length, (x, y) => x > y);
//
// for (int i = 1; i < A.Length; i++)
// Assert.IsTrue(A[Kupac<int>.Szulo(i)] >= A[i]);
// }
//
// [TestMethod()]
// public void KupacRendezes() //F2.
// {
// int[] A = [5, 8, 7, 0, 9, 6, 4, 1, 3, 2];
// KupacRendezes<int> k = new KupacRendezes<int>(A);
// k.Rendezes();
//
// for (int i = 0; i < A.Length; i++)
// Assert.AreEqual(i, A[i]);
// }
// }
//
// [TestClass()]
// public class KupacPrioritasosSorTesztek
// {
// [TestMethod()]
// [ExpectedException(typeof(NincsHelyKivetel))]
// public void TulSokElemTeszt() //F3.
// {
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(2, (x, y) => x > y);
// s.Sorba(1);
// s.Sorba(2);
// s.Sorba(3);
// }
//
// [TestMethod()]
// [ExpectedException(typeof(NincsElemKivetel))]
// public void TulKevesElemTeszt() //F3.
// {
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y);
// s.Sorba(1);
// s.Sorba(2);
// s.Sorba(3);
// s.Sorbol();
// s.Sorbol();
// s.Sorbol();
// s.Sorbol();
// }
//
// [TestMethod()]
// public void UresTeszt() //F3.
// {
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y);
// Assert.IsTrue(s.Ures);
// s.Sorba(1);
// Assert.IsFalse(s.Ures);
// s.Sorba(2);
// Assert.IsFalse(s.Ures);
// s.Sorbol();
// Assert.IsFalse(s.Ures);
// s.Elso();
// Assert.IsFalse(s.Ures);
// s.Sorbol();
// Assert.IsTrue(s.Ures);
// }
//
// [TestMethod()]
// public void SorbaSorbolElsoTeszt() //F3.
// {
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(10, (x, y) => x > y);
// s.Sorba(1);
// s.Sorba(4);
// Assert.AreEqual(4, s.Elso());
// Assert.AreEqual(4, s.Sorbol());
// Assert.AreEqual(1, s.Elso());
// s.Sorba(4);
// s.Sorba(2);
// s.Sorba(8);
// s.Sorba(3);
// Assert.AreEqual(8, s.Elso());
// s.Sorba(9);
// s.Sorba(5);
// Assert.AreEqual(9, s.Elso());
// Assert.AreEqual(9, s.Elso());
// Assert.AreEqual(9, s.Sorbol());
// Assert.AreEqual(8, s.Elso());
// s.Sorba(7);
// Assert.AreEqual(8, s.Sorbol());
// Assert.AreEqual(7, s.Sorbol());
// Assert.AreEqual(5, s.Sorbol());
// s.Sorba(2);
// Assert.AreEqual(4, s.Sorbol());
// Assert.AreEqual(3, s.Sorbol());
// Assert.AreEqual(2, s.Sorbol());
// Assert.AreEqual(2, s.Sorbol());
// Assert.AreEqual(1, s.Elso());
// Assert.AreEqual(1, s.Sorbol());
// }
//
// class PrioritasosSzoveg : IComparable //F3.
// {
// public string Szoveg { get; set; }
// public float Prioritas { get; set; }
// public PrioritasosSzoveg(string szoveg, float prioritas)
// {
// this.Szoveg = szoveg;
// this.Prioritas = prioritas;
// }
//
// public int CompareTo(object? obj)
// {
// if (obj is not PrioritasosSzoveg o)
// throw new NullReferenceException();
// else
// return Prioritas.CompareTo(o.Prioritas);
// }
// }
//
// [TestMethod()]
// public void PrioritasValtozasTeszt() //F3.
// {
// PrioritasosSzoveg a = new PrioritasosSzoveg("a", 10.0f);
// PrioritasosSzoveg b = new PrioritasosSzoveg("b", 5.0f);
// PrioritasosSzoveg c = new PrioritasosSzoveg("c", 2.0f);
// PrioritasosSzoveg d = new PrioritasosSzoveg("d", 12.0f);
// PrioritasosSzoveg e = new PrioritasosSzoveg("e", 15.0f);
// PrioritasosSzoveg f = new PrioritasosSzoveg("f", 9.0f);
// PrioritasosSzoveg g = new PrioritasosSzoveg("g", 2.0f);
// PrioritasosSor<PrioritasosSzoveg> s = new KupacPrioritasosSor<PrioritasosSzoveg>(10, (x, y) => x.CompareTo(y) > 0);
// s.Sorba(a);
// s.Sorba(b);
// s.Sorba(c);
// s.Sorba(d);
// s.Sorba(e);
// Assert.AreEqual("e", s.Elso().Szoveg);
// d.Prioritas = 22.0f;
// s.Frissit(d);
// Assert.AreEqual("d", s.Elso().Szoveg);
// d.Prioritas = 8.0f;
// s.Frissit(d);
// e.Prioritas = 7.0f;
// s.Frissit(e);
// Assert.AreEqual("a", s.Sorbol().Szoveg);
// s.Sorba(f);
// s.Sorba(g);
// Assert.AreEqual("f", s.Sorbol().Szoveg);
// Assert.AreEqual("d", s.Sorbol().Szoveg);
// Assert.AreEqual("e", s.Sorbol().Szoveg);
// Assert.AreEqual("b", s.Sorbol().Szoveg);
// c.Prioritas = 1.5f;
// s.Frissit(c);
// Assert.AreEqual("g", s.Sorbol().Szoveg);
// Assert.AreEqual("c", s.Sorbol().Szoveg);
// Assert.IsTrue(s.Ures);
// }
// }
//
// [TestClass()]
// public class KupacTesztekKulsoFuggvennyel //F3.
// {
// /// <summary>
// /// Nincs külön rendező függvény, ezért ABC sorrendben rendez az IComparable alapján.
// /// </summary>
// [TestMethod()]
// public void KupacEpitesIComparableAlapjan()
// {
// KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (x, y) => x.CompareTo(y) > 0);
// ps.Sorba("oszibarack");
// ps.Sorba("alma");
// ps.Sorba("korte");
// ps.Sorba("birsalma");
// ps.Sorba("barack");
// ps.Sorba("dio");
// Assert.AreEqual("oszibarack", ps.Sorbol());
// Assert.AreEqual("korte", ps.Sorbol());
// Assert.AreEqual("dio", ps.Sorbol());
// Assert.AreEqual("birsalma", ps.Sorbol());
// Assert.AreEqual("barack", ps.Sorbol());
// Assert.AreEqual("alma", ps.Sorbol());
// }
//
// /// <summary>
// /// Van egy saját hossz alapú rendező függvény, ezért elsőként a leghosszabb stringeket adja vissza.
// /// </summary>
// [TestMethod()]
// public void KupacEpitesSajatFuggvennyel() //F3.
// {
// KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (ez, ennel) => ez.Length > ennel.Length);
// ps.Sorba("oszibarack");
// ps.Sorba("alma");
// ps.Sorba("korte");
// ps.Sorba("birsalma");
// ps.Sorba("barack");
// ps.Sorba("dio");
// Assert.AreEqual("oszibarack", ps.Sorbol());
// Assert.AreEqual("birsalma", ps.Sorbol());
// Assert.AreEqual("barack", ps.Sorbol());
// Assert.AreEqual("korte", ps.Sorbol());
// Assert.AreEqual("alma", ps.Sorbol());
// Assert.AreEqual("dio", ps.Sorbol());
// }
// }
// }
//using NUnit.Framework;
//using System;
//using OE.ALGA.Adatszerkezetek;
//namespace OE.ALGA.Tesztek.Adatszerkezetek
//{
// [TestFixture(Category = "Adatszerkezetek", TestName = "11 - Kupac Prioritásos Sor Tesztek")]
// public class KupacPrioritasosSorTesztek
// {
// [TestCase]
// public void TulSokElemTeszt()
// {
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(2, (x, y) => x > y);
// s.Sorba(1);
// s.Sorba(2);
// Assert.Throws<NincsHelyKivetel>(() => s.Sorba(3));
// }
// [TestCase]
// public void TulKevesElemTeszt()
// {
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y);
// s.Sorba(1);
// s.Sorba(2);
// s.Sorba(3);
// s.Sorbol();
// s.Sorbol();
// s.Sorbol();
// Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
// }
// [TestCase]
// public void UresTeszt()
// {
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y);
// Assert.That(s.Ures, Is.True);
// s.Sorba(1);
// Assert.That(s.Ures, Is.False);
// s.Sorba(2);
// Assert.That(s.Ures, Is.False);
// s.Sorbol();
// Assert.That(s.Ures, Is.False);
// s.Elso();
// Assert.That(s.Ures, Is.False);
// s.Sorbol();
// Assert.That(s.Ures, Is.True);
// }
// [TestCase]
// public void SorbaSorbolElsoTeszt()
// {
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(10, (x, y) => x > y);
// s.Sorba(1);
// s.Sorba(4);
// Assert.Multiple(() =>
// {
// Assert.That(s.Elso(), Is.EqualTo(4));
// Assert.That(s.Sorbol(), Is.EqualTo(4));
// Assert.That(s.Elso(), Is.EqualTo(1));
// });
// s.Sorba(4);
// s.Sorba(2);
// s.Sorba(8);
// s.Sorba(3);
// Assert.That(s.Elso(), Is.EqualTo(8));
// s.Sorba(9);
// s.Sorba(5);
// Assert.Multiple(() =>
// {
// Assert.That(s.Elso(), Is.EqualTo(9));
// Assert.That(s.Elso(), Is.EqualTo(9));
// Assert.That(s.Sorbol(), Is.EqualTo(9));
// Assert.That(s.Elso(), Is.EqualTo(8));
// });
// s.Sorba(7);
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol(), Is.EqualTo(8));
// Assert.That(s.Sorbol(), Is.EqualTo(7));
// Assert.That(s.Sorbol(), Is.EqualTo(5));
// });
// s.Sorba(2);
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol(), Is.EqualTo(4));
// Assert.That(s.Sorbol(), Is.EqualTo(3));
// Assert.That(s.Sorbol(), Is.EqualTo(2));
// Assert.That(s.Sorbol(), Is.EqualTo(2));
// Assert.That(s.Elso(), Is.EqualTo(1));
// Assert.That(s.Sorbol(), Is.EqualTo(1));
// });
// }
// class PrioritasosSzoveg : IComparable
// {
// public string Szoveg { get; set; }
// public float Prioritas { get; set; }
// public PrioritasosSzoveg(string szoveg, float prioritas)
// {
// this.Szoveg = szoveg;
// this.Prioritas = prioritas;
// }
// public int CompareTo(object? obj)
// {
// if (obj is not PrioritasosSzoveg o)
// throw new NullReferenceException();
// else
// return Prioritas.CompareTo(o.Prioritas);
// }
// }
// [TestCase]
// public void PrioritasValtozasTeszt()
// {
// PrioritasosSzoveg a = new PrioritasosSzoveg("a", 10.0f);
// PrioritasosSzoveg b = new PrioritasosSzoveg("b", 5.0f);
// PrioritasosSzoveg c = new PrioritasosSzoveg("c", 2.0f);
// PrioritasosSzoveg d = new PrioritasosSzoveg("d", 12.0f);
// PrioritasosSzoveg e = new PrioritasosSzoveg("e", 15.0f);
// PrioritasosSzoveg f = new PrioritasosSzoveg("f", 9.0f);
// PrioritasosSzoveg g = new PrioritasosSzoveg("g", 2.0f);
// PrioritasosSor<PrioritasosSzoveg> s = new KupacPrioritasosSor<PrioritasosSzoveg>(10, (x, y) => x.CompareTo(y) > 0);
// s.Sorba(a);
// s.Sorba(b);
// s.Sorba(c);
// s.Sorba(d);
// s.Sorba(e);
// Assert.That(s.Elso().Szoveg, Is.EqualTo("e"));
// d.Prioritas = 22.0f;
// s.Frissit(d);
// Assert.That(s.Elso().Szoveg, Is.EqualTo("d"));
// d.Prioritas = 8.0f;
// s.Frissit(d);
// e.Prioritas = 7.0f;
// s.Frissit(e);
// Assert.That(s.Sorbol().Szoveg, Is.EqualTo("a"));
// s.Sorba(f);
// s.Sorba(g);
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol().Szoveg, Is.EqualTo("f"));
// Assert.That(s.Sorbol().Szoveg, Is.EqualTo("d"));
// Assert.That(s.Sorbol().Szoveg, Is.EqualTo("e"));
// Assert.That(s.Sorbol().Szoveg, Is.EqualTo("b"));
// });
// c.Prioritas = 1.5f;
// s.Frissit(c);
// Assert.Multiple(() =>
// {
// Assert.That(s.Sorbol().Szoveg, Is.EqualTo("g"));
// Assert.That(s.Sorbol().Szoveg, Is.EqualTo("c"));
// Assert.That(s.Ures, Is.True);
// });
// }
// }
// [TestFixture(Category = "Adatszerkezetek", TestName = "11 - Kupac Külső Fügvénnyel Tesztek")]
// public class KupacKulsoFuggvennyelTesztek
// {
// /// <summary>
// /// Nincs külön rendező függvény, ezért ABC sorrendben rendez az IComparable alapján.
// /// </summary>
// [TestCase]
// public void KupacEpitesIComparableAlapjan()
// {
// KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (x, y) => x.CompareTo(y) > 0);
// ps.Sorba("oszibarack");
// ps.Sorba("alma");
// ps.Sorba("korte");
// ps.Sorba("birsalma");
// ps.Sorba("barack");
// ps.Sorba("dio");
// Assert.Multiple(() =>
// {
// Assert.That(ps.Sorbol(), Is.EqualTo("oszibarack"));
// Assert.That(ps.Sorbol(), Is.EqualTo("korte"));
// Assert.That(ps.Sorbol(), Is.EqualTo("dio"));
// Assert.That(ps.Sorbol(), Is.EqualTo("birsalma"));
// Assert.That(ps.Sorbol(), Is.EqualTo("barack"));
// Assert.That(ps.Sorbol(), Is.EqualTo("alma"));
// });
// }
// /// <summary>
// /// Van egy saját hossz alapú rendező függvény, ezért elsőként a leghosszabb stringeket adja vissza.
// /// </summary>
// [TestCase]
// public void KupacEpitesSajatFuggvennyel()
// {
// KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (ez, ennel) => ez.Length > ennel.Length);
// ps.Sorba("oszibarack");
// ps.Sorba("alma");
// ps.Sorba("korte");
// ps.Sorba("birsalma");
// ps.Sorba("barack");
// ps.Sorba("dio");
// Assert.Multiple(() =>
// {
// Assert.That(ps.Sorbol(), Is.EqualTo("oszibarack"));
// Assert.That(ps.Sorbol(), Is.EqualTo("birsalma"));
// Assert.That(ps.Sorbol(), Is.EqualTo("barack"));
// Assert.That(ps.Sorbol(), Is.EqualTo("korte"));
// Assert.That(ps.Sorbol(), Is.EqualTo("alma"));
// Assert.That(ps.Sorbol(), Is.EqualTo("dio"));
// });
// }
// }
// [TestFixture(Category = "Adatszerkezetek", TestName = "11 - Kupac Rendezés Tesztek")]
// public class KupacRendezesTesztek
// {
// [TestCase]
// public void KupacEpites()
// {
// int[] A = [1, 3, 2, 4, 9, 12, 32, 21, 12, 8, 11];
// _ = new Kupac<int>(A, A.Length, (x, y) => x > y);
// Assert.Multiple(() =>
// {
// for (int i = 1; i < A.Length; i++)
// Assert.That(A[Kupac<int>.Szulo(i)] >= A[i], Is.True);
// });
// }
// [TestCase]
// public void KupacRendezes()
// {
// int[] A = [5, 8, 7, 0, 9, 6, 4, 1, 3, 2];
// KupacRendezes<int> k = new KupacRendezes<int>(A);
// k.Rendezes();
// Assert.Multiple(() =>
// {
// for (int i = 1; i < A.Length; i++)
// Assert.That(A[i], Is.EqualTo(i));
// });
// }
// }
//}

530
Tesztek/12_SulyozottGrafTesztek.cs
View File

@@ -1,252 +1,278 @@
// using Microsoft.VisualStudio.TestTools.UnitTesting;
// using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek
// {
// [TestClass]
// public class CsucsMatrixSulyozottGrafTesztek
// {
// [TestMethod]
// public void MindenCsucsTeszt() //F2.
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
// Assert.IsTrue(csg.Csucsok.Eleme(0));
// Assert.IsTrue(csg.Csucsok.Eleme(1));
// }
//
// [TestMethod]
// public void MindenElTeszt() //F2.
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 2.0f);
// csg.UjEl(1, 2, 3.0f);
//
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 0, 0.0f)));
// Assert.IsTrue(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 1.0f)));
// Assert.IsTrue(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 2.0f)));
//
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 0, 0.0f)));
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 1, 0.0f)));
// Assert.IsTrue(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 3.0f)));
//
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 0, 0.0f)));
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 1, 0.0f)));
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 2, 0.0f)));
// }
//
// [TestMethod]
// public void VezetElTeszt() //F2.
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
// Assert.IsFalse(csg.VezetEl(0, 1));
// csg.UjEl(0, 1, 1.0f);
// Assert.IsTrue(csg.VezetEl(0, 1));
// Assert.IsFalse(csg.VezetEl(1, 0));
// }
//
// [TestMethod]
// public void SzomszedsagTeszt() //F2.
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 1.0f);
// csg.UjEl(1, 2, 1.0f);
//
// Halmaz<int> a_szomszedai = csg.Szomszedai(0);
// Halmaz<int> b_szomszedai = csg.Szomszedai(1);
// Halmaz<int> c_szomszedai = csg.Szomszedai(2);
//
// Assert.IsFalse(a_szomszedai.Eleme(0));
// Assert.IsTrue(a_szomszedai.Eleme(1));
// Assert.IsTrue(a_szomszedai.Eleme(2));
//
// Assert.IsFalse(b_szomszedai.Eleme(0));
// Assert.IsFalse(b_szomszedai.Eleme(1));
// Assert.IsTrue(b_szomszedai.Eleme(2));
//
// Assert.IsFalse(c_szomszedai.Eleme(0));
// Assert.IsFalse(c_szomszedai.Eleme(1));
// Assert.IsFalse(c_szomszedai.Eleme(2));
// }
//
// [TestMethod]
// [ExpectedException(typeof(NincsElKivetel))]
// public void NemLetezoElTeszt() //F2.
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 1.0f);
// csg.Suly(1, 0);
// }
//
// [TestMethod]
// public void ElSulyTeszt() //F2.
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 2.0f);
// csg.UjEl(0, 2, 3.0f);
// float szum = 0.0f;
// csg.Elek.Bejar(x => szum += csg.Suly(x.Honnan, x.Hova));
// Assert.AreEqual(5.0f, szum);
// }
// }
//
// [TestClass]
// public class GrafUtkeresesTesztek
// {
// [TestMethod]
// public void DijkstraKicsiGrafTeszt() //F3.
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f);
// Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 0);
// Assert.AreEqual(0.0f, hossz.Kiolvas(0));
// Assert.AreEqual(10.0f, hossz.Kiolvas(1));
// Assert.AreEqual(20.0f, hossz.Kiolvas(2));
//
// csg.UjEl(1, 2, 5.0f);
// hossz = Utkereses.Dijkstra(csg, 0);
// Assert.AreEqual(0.0f, hossz.Kiolvas(0));
// Assert.AreEqual(10.0f, hossz.Kiolvas(1));
// Assert.AreEqual(15.0f, hossz.Kiolvas(2));
// }
//
// [TestMethod]
// public void DijkstraJegyzetGrafTeszt() //F3.
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(7);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 3, 2.0f);
// csg.UjEl(0, 4, 4.0f);
//
// csg.UjEl(1, 0, 1.0f);
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 9.0f);
//
// csg.UjEl(2, 1, 9.0f);
// csg.UjEl(2, 3, 5.0f);
// csg.UjEl(2, 5, 1.0f);
//
// csg.UjEl(3, 0, 2.0f);
// csg.UjEl(3, 1, 2.0f);
// csg.UjEl(3, 2, 5.0f);
// csg.UjEl(3, 5, 3.0f);
//
// csg.UjEl(5, 2, 1.0f);
// csg.UjEl(5, 3, 3.0f);
// csg.UjEl(5, 6, 3.0f);
//
// csg.UjEl(6, 5, 3.0f);
//
// Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 1);
// Assert.AreEqual(1.0f, hossz.Kiolvas(0));
// Assert.AreEqual(0.0f, hossz.Kiolvas(1));
// Assert.AreEqual(6.0f, hossz.Kiolvas(2));
// Assert.AreEqual(2.0f, hossz.Kiolvas(3));
// Assert.AreEqual(5.0f, hossz.Kiolvas(4));
// Assert.AreEqual(5.0f, hossz.Kiolvas(5));
// Assert.AreEqual(8.0f, hossz.Kiolvas(6));
// }
// }
//
// [TestClass]
// public class GrafMininmalisFeszitofaTesztek
// {
// [TestMethod]
// public void KisPrimTeszt() //F4.(a)
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f);
// csg.UjEl(1, 2, 5.0f);
// Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
// Assert.AreEqual(0, elek.Kiolvas(1));
// Assert.AreEqual(1, elek.Kiolvas(2));
// }
//
// [TestMethod]
// public void NagyPrimTeszt() //F4.(a)
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
// csg.UjEl(0, 1, 5.0f);
// csg.UjEl(0, 3, 4.0f);
//
// csg.UjEl(1, 0, 5.0f);
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 1.0f);
//
// csg.UjEl(2, 1, 1.0f);
// csg.UjEl(2, 3, 3.0f);
// csg.UjEl(2, 4, 4.0f);
//
// csg.UjEl(3, 0, 4.0f);
// csg.UjEl(3, 1, 2.0f);
// csg.UjEl(3, 2, 3.0f);
// csg.UjEl(3, 4, 1.0f);
//
// csg.UjEl(4, 2, 4.0f);
// csg.UjEl(4, 3, 1.0f);
//
// Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
// float sum = 0.0f;
// csg.Csucsok.Bejar(x =>
// {
// if (x != 0)
// {
// int p = elek.Kiolvas(x);
// sum += csg.Suly(p, x);
// }
// }
// );
// Assert.AreEqual(8.0f, sum);
// }
//
// [TestMethod]
// public void KisKruskalTeszt() //F4.(b)
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f);
// csg.UjEl(1, 2, 5.0f);
// Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
// Assert.IsTrue(elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 10.0f)));
// Assert.IsFalse(elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 20.0f)));
// Assert.IsTrue(elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 5.0f)));
// }
//
// [TestMethod]
// public void NagyKruskalTeszt() //F4.(b)
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
// csg.UjEl(0, 1, 5.0f);
// csg.UjEl(0, 3, 4.0f);
//
// csg.UjEl(1, 0, 5.0f);
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 1.0f);
//
// csg.UjEl(2, 1, 1.0f);
// csg.UjEl(2, 3, 3.0f);
// csg.UjEl(2, 4, 4.0f);
//
// csg.UjEl(3, 0, 4.0f);
// csg.UjEl(3, 1, 2.0f);
// csg.UjEl(3, 2, 3.0f);
// csg.UjEl(3, 4, 1.0f);
//
// csg.UjEl(4, 2, 4.0f);
// csg.UjEl(4, 3, 1.0f);
//
// Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
// float sum = 0.0f;
// elek.Bejar(x =>
// {
// sum += x.Suly;
// }
// );
// Assert.AreEqual(8.0f, sum);
// }
// }
// }
//using NUnit.Framework;
//using OE.ALGA.Adatszerkezetek;
//namespace OE.ALGA.Tesztek.Adatszerkezetek
//{
// [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Csúcs Mátrix Súlyozott Gráf Tesztek")]
// public class CsucsMatrixSulyozottGrafTesztek
// {
// [TestCase]
// public void MindenCsucsTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
// Assert.Multiple(() =>
// {
// Assert.That(csg.Csucsok.Eleme(0), Is.True);
// Assert.That(csg.Csucsok.Eleme(1), Is.True);
// });
// }
// [TestCase]
// public void MindenElTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 2.0f);
// csg.UjEl(1, 2, 3.0f);
// Assert.Multiple(() =>
// {
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 0, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 1.0f)), Is.True);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 2.0f)), Is.True);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 0, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 1, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 3.0f)), Is.True);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 0, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 1, 0.0f)), Is.False);
// Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 2, 0.0f)), Is.False);
// });
// }
// [TestCase]
// public void VezetElTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
// Assert.That(csg.VezetEl(0, 1), Is.False);
// csg.UjEl(0, 1, 1.0f);
// Assert.Multiple(() =>
// {
// Assert.That(csg.VezetEl(0, 1), Is.True);
// Assert.That(csg.VezetEl(1, 0), Is.False);
// });
// }
// [TestCase]
// public void SzomszedsagTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 1.0f);
// csg.UjEl(1, 2, 1.0f);
// Halmaz<int> a_szomszedai = csg.Szomszedai(0);
// Halmaz<int> b_szomszedai = csg.Szomszedai(1);
// Halmaz<int> c_szomszedai = csg.Szomszedai(2);
// Assert.Multiple(() =>
// {
// Assert.That(a_szomszedai.Eleme(0), Is.False);
// Assert.That(a_szomszedai.Eleme(1), Is.True);
// Assert.That(a_szomszedai.Eleme(2), Is.True);
// Assert.That(b_szomszedai.Eleme(0), Is.False);
// Assert.That(b_szomszedai.Eleme(1), Is.False);
// Assert.That(b_szomszedai.Eleme(2), Is.True);
// Assert.That(c_szomszedai.Eleme(0), Is.False);
// Assert.That(c_szomszedai.Eleme(1), Is.False);
// Assert.That(c_szomszedai.Eleme(2), Is.False);
// });
// }
// [TestCase]
// public void NemLetezoElTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 1.0f);
// Assert.Throws<NincsElKivetel>(() => csg.Suly(1, 0));
// }
// [TestCase]
// public void ElSulyTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 2.0f);
// csg.UjEl(0, 2, 3.0f);
// float szum = 0.0f;
// csg.Elek.Bejar(x => szum += csg.Suly(x.Honnan, x.Hova));
// Assert.That(szum, Is.EqualTo(5.0f));
// }
// }
// [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Min Feszítőfa Tesztek")]
// public class GrafMinFeszitofaTesztek
// {
// [TestCase]
// public void KisPrimTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f);
// csg.UjEl(1, 2, 5.0f);
// Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
// Assert.Multiple(() =>
// {
// Assert.That(elek.Kiolvas(1), Is.EqualTo(0));
// Assert.That(elek.Kiolvas(2), Is.EqualTo(1));
// });
// }
// [TestCase]
// public void NagyPrimTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
// csg.UjEl(0, 1, 5.0f);
// csg.UjEl(0, 3, 4.0f);
// csg.UjEl(1, 0, 5.0f);
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 1.0f);
// csg.UjEl(2, 1, 1.0f);
// csg.UjEl(2, 3, 3.0f);
// csg.UjEl(2, 4, 4.0f);
// csg.UjEl(3, 0, 4.0f);
// csg.UjEl(3, 1, 2.0f);
// csg.UjEl(3, 2, 3.0f);
// csg.UjEl(3, 4, 1.0f);
// csg.UjEl(4, 2, 4.0f);
// csg.UjEl(4, 3, 1.0f);
// Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
// float sum = 0.0f;
// csg.Csucsok.Bejar(x =>
// {
// if (x != 0)
// {
// int p = elek.Kiolvas(x);
// sum += csg.Suly(p, x);
// }
// }
// );
// Assert.That(sum, Is.EqualTo(8.0f));
// }
// [TestCase]
// public void KisKruskalTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f);
// csg.UjEl(1, 2, 5.0f);
// Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
// Assert.Multiple(() =>
// {
// Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 10.0f)), Is.True);
// Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 20.0f)), Is.False);
// Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 5.0f)), Is.True);
// });
// }
// [TestCase]
// public void NagyKruskalTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
// csg.UjEl(0, 1, 5.0f);
// csg.UjEl(0, 3, 4.0f);
// csg.UjEl(1, 0, 5.0f);
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 1.0f);
// csg.UjEl(2, 1, 1.0f);
// csg.UjEl(2, 3, 3.0f);
// csg.UjEl(2, 4, 4.0f);
// csg.UjEl(3, 0, 4.0f);
// csg.UjEl(3, 1, 2.0f);
// csg.UjEl(3, 2, 3.0f);
// csg.UjEl(3, 4, 1.0f);
// csg.UjEl(4, 2, 4.0f);
// csg.UjEl(4, 3, 1.0f);
// Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
// float sum = 0.0f;
// elek.Bejar(x =>
// {
// sum += x.Suly;
// }
// );
// Assert.That(sum, Is.EqualTo(8.0f));
// }
// }
// [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Útkeresés Tesztek")]
// public class GrafUtkeresesTesztek
// {
// [TestCase]
// public void DijkstraKicsiGrafTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f);
// Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 0);
// Assert.Multiple(() =>
// {
// Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
// Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
// Assert.That(hossz.Kiolvas(2), Is.EqualTo(20.0f));
// });
// csg.UjEl(1, 2, 5.0f);
// hossz = Utkereses.Dijkstra(csg, 0);
// Assert.Multiple(() =>
// {
// Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
// Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
// Assert.That(hossz.Kiolvas(2), Is.EqualTo(15.0f));
// });
// }
// [TestCase]
// public void DijkstraJegyzetGrafTeszt()
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(7);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 3, 2.0f);
// csg.UjEl(0, 4, 4.0f);
// csg.UjEl(1, 0, 1.0f);
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 9.0f);
// csg.UjEl(2, 1, 9.0f);
// csg.UjEl(2, 3, 5.0f);
// csg.UjEl(2, 5, 1.0f);
// csg.UjEl(3, 0, 2.0f);
// csg.UjEl(3, 1, 2.0f);
// csg.UjEl(3, 2, 5.0f);
// csg.UjEl(3, 5, 3.0f);
// csg.UjEl(5, 2, 1.0f);
// csg.UjEl(5, 3, 3.0f);
// csg.UjEl(5, 6, 3.0f);
// csg.UjEl(6, 5, 3.0f);
// Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 1);
// Assert.Multiple(() =>
// {
// Assert.That(hossz.Kiolvas(0), Is.EqualTo(1.0f));
// Assert.That(hossz.Kiolvas(1), Is.EqualTo(0.0f));
// Assert.That(hossz.Kiolvas(2), Is.EqualTo(6.0f));
// Assert.That(hossz.Kiolvas(3), Is.EqualTo(2.0f));
// Assert.That(hossz.Kiolvas(4), Is.EqualTo(5.0f));
// Assert.That(hossz.Kiolvas(5), Is.EqualTo(5.0f));
// Assert.That(hossz.Kiolvas(6), Is.EqualTo(8.0f));
// });
// }
// }
//}

3
Tesztek/NOTES.md Normal file
View File

@@ -0,0 +1,3 @@
## Duplikált tesztek a Test Explorer-ben
Az **NUnit 3 VS Test Adapter** ismert hibája, hogy amennyiben a *TestFixture*-be a *TestName* értéket kap, akkor a **Test Explorer**-ben kétszer fognak megjelenni a tesztek.
Issue: https://github.com/nunit/nunit3-vs-adapter/issues/729

19
Tesztek/Tesztek.csproj
View File

@@ -2,23 +2,30 @@
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<ImplicitUsings>disable</ImplicitUsings>
<Nullable>enable</Nullable>
<SatelliteResourceLanguages>en</SatelliteResourceLanguages>
<IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject>
<RootNamespace>OE.ALGA.Tesztek</RootNamespace>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
<PackageReference Include="MSTest.TestAdapter" Version="3.0.4" />
<PackageReference Include="MSTest.TestFramework" Version="3.0.4" />
<PackageReference Include="coverlet.collector" Version="6.0.0" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
<PackageReference Include="NUnit" Version="4.4.0" />
<PackageReference Include="NUnit.Analyzers" Version="4.10.0">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="NUnit3TestAdapter" Version="5.1.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\ALGA\ALGA.csproj" />
</ItemGroup>
<ItemGroup>
<Using Include="NUnit.Framework" />
</ItemGroup>
</Project>