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

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

2
ALGAme/ALGAme.csproj
View File

@@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk"> <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup> <PropertyGroup>
<OutputType>Exe</OutputType> <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 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 jatek = new Jatek();
jatek.Start(); jatek.Start();

2
Engine/AlapTipusok.cs
View File

@@ -1,4 +1,4 @@
namespace OE.ALGA.Engine namespace OE.ALGA.Engine
{ {
public class KetElemuVektor : IComparable 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 public class Backend
{ {

2
Engine/BillentyuzetKezelo.cs
View File

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

2
Engine/Engine.csproj
View File

@@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk"> <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup> <PropertyGroup>
<TargetFramework>net8.0</TargetFramework> <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. // attributes that are applied to this project.
// Project-level suppressions either have no target or are given // Project-level suppressions either have no target or are given
// a specific target and scoped to a namespace, type, member, etc. // 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 public class UtkozesKivetel : Exception
{ {

2
Engine/KonzolMegjelenito.cs
View File

@@ -1,4 +1,4 @@
using System.Text; using System.Text;
namespace OE.ALGA.Engine 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 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 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 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 internal class Program
{ {

2
Sandbox/Sandbox.csproj
View File

@@ -1,4 +1,4 @@
<Project Sdk="Microsoft.NET.Sdk"> <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup> <PropertyGroup>
<OutputType>Exe</OutputType> <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 NUnit.Framework;
// using OE.ALGA.Paradigmak; //using OE.ALGA.Paradigmak;
//
// namespace OE.ALGA.Tesztek
// { //namespace OE.ALGA.Tesztek.Paradigmak
// class TesztFeladat : IVegrehajthato //F1. //{
// { // [TestFixture(Category = "Paradigmák", TestName = "01 - Feladat Tároló Tesztek")]
// public string Azonosito { get; set; } // public class FeladatTaroloTesztek
// // {
// public bool Vegrehajtott { get; set; } // [TestCase]
// // public void Ures()
// public void Vegrehajtas() // {
// { // FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(0);
// Vegrehajtott = true; // TesztFeladat a = new TesztFeladat("a");
// } // Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
// // }
// public TesztFeladat(string nev) // [TestCase]
// { // public void Felvesz()
// this.Azonosito = nev; // {
// } // FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(5);
// } // TesztFeladat a = new TesztFeladat("a");
// // tarolo.Felvesz(a);
// [TestClass()] // tarolo.Felvesz(a);
// public class FeladatTaroloTeszt // tarolo.Felvesz(a);
// { // }
// [TestMethod()]
// public void FelveszTeszt() //F2.(c) // [TestCase]
// { // public void TulsokatFelvesz()
// FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(5); // {
// TesztFeladat a = new TesztFeladat("a"); // FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(3);
// tarolo.Felvesz(a); // TesztFeladat a = new TesztFeladat("a");
// tarolo.Felvesz(a); // tarolo.Felvesz(a);
// tarolo.Felvesz(a); // tarolo.Felvesz(a);
// tarolo.Felvesz(a); // tarolo.Felvesz(a);
// tarolo.Felvesz(a); // Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
// } // }
// // [TestCase]
// [TestMethod()] // public void NincsMitVegrehajtani()
// [ExpectedException(typeof(TaroloMegteltKivetel))] // {
// public void TulsokatFelveszTeszt() //F2.(c) // FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(2);
// { // tarolo.MindentVegrehajt();
// FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(5); // }
// TesztFeladat a = new TesztFeladat("a"); // [TestCase]
// tarolo.Felvesz(a); // public void MindentVegrehajt()
// tarolo.Felvesz(a); // {
// tarolo.Felvesz(a); // FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(2);
// tarolo.Felvesz(a); // TesztFeladat a = new TesztFeladat("a");
// tarolo.Felvesz(a); // TesztFeladat b = new TesztFeladat("b");
// tarolo.Felvesz(a); // tarolo.Felvesz(a);
// } // tarolo.Felvesz(b);
// // Assert.Multiple(() =>
// [TestMethod()] // {
// public void VegrehajtasTeszt() //F2.(d) // Assert.That(a.Vegrehajtott, Is.False);
// { // Assert.That(b.Vegrehajtott, Is.False);
// FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10); // });
// TesztFeladat a = new TesztFeladat("a"); // tarolo.MindentVegrehajt();
// TesztFeladat b = new TesztFeladat("b"); // Assert.Multiple(() =>
// tarolo.Felvesz(a); // {
// tarolo.Felvesz(b); // Assert.That(a.Vegrehajtott, Is.True);
// Assert.IsFalse(a.Vegrehajtott); // Assert.That(b.Vegrehajtott, Is.True);
// Assert.IsFalse(b.Vegrehajtott); // });
// tarolo.MindentVegrehajt(); // }
// Assert.IsTrue(a.Vegrehajtott); // [TestCase]
// Assert.IsTrue(b.Vegrehajtott); // public void FelvettetVegrehajt()
// } // {
// } // FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10);
// // TesztFeladat a = new TesztFeladat("a");
// class TesztFuggoFeladat : TesztFeladat, IFuggo //F3. // TesztFeladat b = new TesztFeladat("b");
// { // tarolo.Felvesz(a);
// public bool Vegrehajthato { get; set; } // tarolo.Felvesz(b);
// // Assert.Multiple(() =>
// public virtual bool FuggosegTeljesul // {
// { // Assert.That(a.Vegrehajtott, Is.False);
// get // Assert.That(b.Vegrehajtott, Is.False);
// { // });
// return Vegrehajthato; // tarolo.MindentVegrehajt();
// } // Assert.Multiple(() =>
// } // {
// // Assert.That(a.Vegrehajtott, Is.True);
// public TesztFuggoFeladat(string nev) : base(nev) // Assert.That(b.Vegrehajtott, Is.True);
// { // });
// } // }
// } // }
//
// [TestClass()] // [TestFixture(Category = "Paradigmák", TestName = "01 - Függő Feladat Tároló Tesztek")]
// public class FuggoFeladatTaroloTeszt //F4. // public class FuggoFeladatTaroloTesztek
// { // {
// [TestMethod()] // [TestCase]
// public void FelveszTeszt() // public void Felvesz()
// { // {
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); // FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
// TesztFuggoFeladat a = new TesztFuggoFeladat("a"); // TesztFuggoFeladat a = new TesztFuggoFeladat("a");
// tarolo.Felvesz(a); // tarolo.Felvesz(a);
// tarolo.Felvesz(a); // tarolo.Felvesz(a);
// tarolo.Felvesz(a); // tarolo.Felvesz(a);
// tarolo.Felvesz(a); // }
// tarolo.Felvesz(a); // [TestCase]
// } // public void TulsokatFelvesz()
// // {
// [TestMethod()] // FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(3);
// [ExpectedException(typeof(TaroloMegteltKivetel))] // TesztFuggoFeladat a = new TesztFuggoFeladat("a");
// public void TulsokatFelveszTeszt() // tarolo.Felvesz(a);
// { // tarolo.Felvesz(a);
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); // tarolo.Felvesz(a);
// TesztFuggoFeladat a = new TesztFuggoFeladat("a"); // Assert.Throws<TaroloMegteltKivetel>(() => tarolo.Felvesz(a));
// tarolo.Felvesz(a); // }
// tarolo.Felvesz(a); // [TestCase]
// tarolo.Felvesz(a); // public void NincsMitVegrehajtani()
// tarolo.Felvesz(a); // {
// tarolo.Felvesz(a); // FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(2);
// tarolo.Felvesz(a); // tarolo.MindentVegrehajt();
// } // }
// // [TestCase]
// [TestMethod()] // public void MindentVegrehajt()
// public void VegrehajtasAmikorNemVegrehajthatokTeszt() // {
// { // FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(2);
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); // TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
// TesztFuggoFeladat a = new TesztFuggoFeladat("a"); // TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = true };
// TesztFuggoFeladat b = new TesztFuggoFeladat("b"); // tarolo.Felvesz(a);
// tarolo.Felvesz(a); // tarolo.Felvesz(b);
// tarolo.Felvesz(b); // Assert.Multiple(() =>
// Assert.IsFalse(a.Vegrehajtott); // {
// Assert.IsFalse(b.Vegrehajtott); // Assert.That(a.Vegrehajtott, Is.False);
// tarolo.MindentVegrehajt(); // Assert.That(b.Vegrehajtott, Is.False);
// Assert.IsFalse(a.Vegrehajtott); // });
// Assert.IsFalse(b.Vegrehajtott); // tarolo.MindentVegrehajt();
// } // Assert.Multiple(() =>
// // {
// [TestMethod()] // Assert.That(a.Vegrehajtott, Is.True);
// public void VegrehajtasAmikorVegrehajthatokTeszt() // Assert.That(b.Vegrehajtott, Is.True);
// { // });
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); // }
// TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true }; // [TestCase]
// TesztFuggoFeladat b = new TesztFuggoFeladat("b"); // public void VegrehajtasAmikorNemVegrehajthatok()
// tarolo.Felvesz(a); // {
// tarolo.Felvesz(b); // FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
// Assert.IsFalse(a.Vegrehajtott); // TesztFuggoFeladat a = new TesztFuggoFeladat("a");
// Assert.IsFalse(b.Vegrehajtott); // TesztFuggoFeladat b = new TesztFuggoFeladat("b");
// tarolo.MindentVegrehajt(); // tarolo.Felvesz(a);
// Assert.IsTrue(a.Vegrehajtott); // tarolo.Felvesz(b);
// Assert.IsFalse(b.Vegrehajtott); // Assert.Multiple(() =>
// b.Vegrehajthato = true; // {
// tarolo.MindentVegrehajt(); // Assert.That(a.Vegrehajtott, Is.False);
// Assert.IsTrue(a.Vegrehajtott); // Assert.That(b.Vegrehajtott, Is.False);
// Assert.IsTrue(b.Vegrehajtott); // });
// } // tarolo.MindentVegrehajt();
// } // Assert.Multiple(() =>
// // {
// class TesztElokovetelmenytolFuggoFeladat : TesztFuggoFeladat //F4. // Assert.That(a.Vegrehajtott, Is.False);
// { // Assert.That(b.Vegrehajtott, Is.False);
// readonly TesztFeladat elokovetelmeny; // });
// // }
// public TesztElokovetelmenytolFuggoFeladat(string nev, TesztFeladat elokovetelmeny) : base(nev) // [TestCase]
// { // public void VegrehajtasAmikorVegrehajthatok()
// this.elokovetelmeny = elokovetelmeny; // {
// } // FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
// // TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
// public override bool FuggosegTeljesul // TesztFuggoFeladat b = new TesztFuggoFeladat("b");
// { // tarolo.Felvesz(a);
// get // tarolo.Felvesz(b);
// { // Assert.Multiple(() =>
// return base.FuggosegTeljesul && elokovetelmeny.Vegrehajtott; // {
// } // Assert.That(a.Vegrehajtott, Is.False);
// } // Assert.That(b.Vegrehajtott, Is.False);
// } // });
// // tarolo.MindentVegrehajt();
// [TestClass()] // Assert.Multiple(() =>
// public class FuggoFeladatTaroloElokovetelmenyekkelTeszt //F4. // {
// { // Assert.That(a.Vegrehajtott, Is.True);
// [TestMethod()] // Assert.That(b.Vegrehajtott, Is.False);
// public void ElokovetelmenyesTeszt() // });
// { // b.Vegrehajthato = true;
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); // tarolo.MindentVegrehajt();
// TesztFuggoFeladat a = new TesztFuggoFeladat("a"); // Assert.Multiple(() =>
// TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true }; // {
// // a->b // Assert.That(a.Vegrehajtott, Is.True);
// tarolo.Felvesz(a); // Assert.That(b.Vegrehajtott, Is.True);
// tarolo.Felvesz(b); // });
// tarolo.MindentVegrehajt(); // }
// Assert.IsFalse(a.Vegrehajtott); // }
// Assert.IsFalse(b.Vegrehajtott); // [TestFixture(Category = "Paradigmák", TestName = "01 - Feltételes Feladat Tároló Előkövetelményekkel Tesztek")]
// a.Vegrehajthato = true; // public class FuggoFeladatTaroloElokovetelmenyekkelTesztek
// tarolo.MindentVegrehajt(); // {
// Assert.IsTrue(a.Vegrehajtott); // [TestCase]
// Assert.IsTrue(b.Vegrehajtott); // public void Elokovetelmenyes()
// } // {
// // FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
// [TestMethod()] // TesztFuggoFeladat a = new TesztFuggoFeladat("a");
// public void TobbKorosElokovetelmenyesTeszt() // TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true };
// { // // a->b
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); // tarolo.Felvesz(a);
// TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true }; // tarolo.Felvesz(b);
// TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true }; // tarolo.MindentVegrehajt();
// TesztElokovetelmenytolFuggoFeladat c = new TesztElokovetelmenytolFuggoFeladat("c", a) { Vegrehajthato = true }; // Assert.Multiple(() =>
// TesztElokovetelmenytolFuggoFeladat d = new TesztElokovetelmenytolFuggoFeladat("d", b) { Vegrehajthato = true }; // {
// // a->b->d // Assert.That(a.Vegrehajtott, Is.False);
// // ->c // Assert.That(b.Vegrehajtott, Is.False);
// tarolo.Felvesz(d); // });
// tarolo.Felvesz(c); // a.Vegrehajthato = true;
// tarolo.Felvesz(b); // tarolo.MindentVegrehajt();
// tarolo.Felvesz(a); // Assert.Multiple(() =>
// tarolo.MindentVegrehajt(); // {
// Assert.IsTrue(a.Vegrehajtott); // Assert.That(a.Vegrehajtott, Is.True);
// 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.That(b.Vegrehajtott, Is.True);
// 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(); // [TestCase]
// Assert.IsTrue(a.Vegrehajtott); // public void TobbKorosElokovetelmenyes()
// Assert.IsTrue(b.Vegrehajtott); // {
// Assert.IsTrue(c.Vegrehajtott); // FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5);
// 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 // TesztFuggoFeladat a = new TesztFuggoFeladat("a") { Vegrehajthato = true };
// tarolo.MindentVegrehajt(); // TesztElokovetelmenytolFuggoFeladat b = new TesztElokovetelmenytolFuggoFeladat("b", a) { Vegrehajthato = true };
// Assert.IsTrue(a.Vegrehajtott); // TesztElokovetelmenytolFuggoFeladat c = new TesztElokovetelmenytolFuggoFeladat("c", a) { Vegrehajthato = true };
// Assert.IsTrue(b.Vegrehajtott); // TesztElokovetelmenytolFuggoFeladat d = new TesztElokovetelmenytolFuggoFeladat("d", b) { Vegrehajthato = true };
// Assert.IsTrue(c.Vegrehajtott); // // a->b->d
// Assert.IsTrue(d.Vegrehajtott); // // ->c
// } // tarolo.Felvesz(d);
// } // tarolo.Felvesz(c);
// // tarolo.Felvesz(b);
// class BejarasokTeszt //F5. // tarolo.Felvesz(a);
// { // tarolo.MindentVegrehajt();
// [TestMethod()] // Assert.Multiple(() =>
// public void FeladatTaroloBejaroTeszt() // {
// { // Assert.That(a.Vegrehajtott, Is.True);
// FeladatTarolo<TesztFeladat> tarolo = new FeladatTarolo<TesztFeladat>(10); // 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
// TesztFeladat a = new TesztFeladat("a"); // 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
// TesztFeladat b = new TesztFeladat("b"); // Assert.That(d.Vegrehajtott, Is.False);
// tarolo.Felvesz(a); // });
// tarolo.Felvesz(b); // tarolo.MindentVegrehajt();
// string nevek = ""; // Assert.Multiple(() =>
// foreach (TesztFeladat u in tarolo) // {
// { // Assert.That(a.Vegrehajtott, Is.True);
// nevek += u.Azonosito; // Assert.That(b.Vegrehajtott, Is.True);
// } // Assert.That(c.Vegrehajtott, Is.True);
// Assert.AreEqual("ab", nevek); // 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();
// [TestMethod()] // Assert.Multiple(() =>
// public void FuggoFeladatTaroloBejaroTeszt() // {
// { // Assert.That(a.Vegrehajtott, Is.True);
// FuggoFeladatTarolo<TesztFuggoFeladat> tarolo = new FuggoFeladatTarolo<TesztFuggoFeladat>(5); // Assert.That(b.Vegrehajtott, Is.True);
// TesztFuggoFeladat a = new TesztFuggoFeladat("a"); // Assert.That(c.Vegrehajtott, Is.True);
// TesztFuggoFeladat b = new TesztFuggoFeladat("b") { Vegrehajthato = true }; // Assert.That(d.Vegrehajtott, Is.True);
// tarolo.Felvesz(a); // });
// tarolo.Felvesz(b); // }
// tarolo.MindentVegrehajt(); // }
// string nevek = ""; // [TestFixture(Category = "Paradigmák", TestName = "01 - Bejáró Tesztek")]
// foreach (TesztFuggoFeladat u in tarolo) // class BejarasokTesztek
// { // {
// if (u.Vegrehajtott) // [TestCase]
// nevek += u.Azonosito; // public void FeladatTaroloBejaro()
// } // {
// Assert.AreEqual("b", nevek); // 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 NUnit.Framework;
// using OE.ALGA.Adatszerkezetek; //using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek //namespace OE.ALGA.Tesztek.Adatszerkezetek
// { //{
// [TestClass()] // [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Lista Tesztek")]
// public class TombVeremTesztek // public class TombListaTesztek
// { // {
// [TestMethod()] // [TestCase]
// public void MindenJolMukodik() //F1. // public void Elemszam()
// { // {
// Verem<int> v = new TombVerem<int>(3); // Lista<string> l = new TombLista<string>();
// v.Verembe(1); // Assert.That(l.Elemszam, Is.EqualTo(0));
// v.Verembe(3); // l.Hozzafuz("A");
// v.Verembe(2); // Assert.That(l.Elemszam, Is.EqualTo(1));
// Assert.AreEqual(2, v.Verembol()); // l.Hozzafuz("B");
// v.Verembe(4); // Assert.That(l.Elemszam, Is.EqualTo(2));
// Assert.AreEqual(4, v.Verembol()); // l.Torol("A");
// Assert.AreEqual(3, v.Verembol()); // Assert.That(l.Elemszam, Is.EqualTo(1));
// Assert.AreEqual(1, v.Verembol()); // }
// } // [TestCase]
// // public void Bejaras()
// [TestMethod()] // {
// [ExpectedException(typeof(NincsHelyKivetel))] // Lista<int> l = new TombLista<int>();
// public void TulSokElem() //F1. // l.Hozzafuz(1);
// { // l.Hozzafuz(3);
// Verem<int> v = new TombVerem<int>(3); // l.Hozzafuz(2);
// v.Verembe(1); // string s = "";
// v.Verembe(3); // l.Bejar(x => { Guardian.Recursion.CheckStackTrace(); s += x.ToString(); });
// v.Verembe(2); // Assert.That(s, Is.EqualTo("132"));
// v.Verembe(4); // }
// } // [TestCase]
// // public void Beszuras()
// [TestMethod()] // {
// [ExpectedException(typeof(NincsElemKivetel))] // Lista<int> l = new TombLista<int>();
// public void TulKevesElem() //F1. // l.Beszur(0, 1);
// { // l.Beszur(0, 2);
// Verem<int> v = new TombVerem<int>(3); // l.Beszur(1, 3);
// v.Verembe(1); // l.Beszur(3, 4);
// v.Verembe(3); // l.Beszur(2, 5);
// v.Verembe(2); // Assert.Multiple(() =>
// v.Verembol(); // {
// v.Verembol(); // Assert.That(l.Kiolvas(0), Is.EqualTo(2));
// v.Verembol(); // Assert.That(l.Kiolvas(1), Is.EqualTo(3));
// v.Verembol(); // Assert.That(l.Kiolvas(2), Is.EqualTo(5));
// } // Assert.That(l.Kiolvas(3), Is.EqualTo(1));
// // Assert.That(l.Kiolvas(4), Is.EqualTo(4));
// [TestMethod()] // });
// public void Felso() //F1. // }
// { // [TestCase]
// Verem<int> v = new TombVerem<int>(3); // public void BeszurasUres()
// v.Verembe(1); // {
// v.Verembe(3); // Lista<string> l = new TombLista<string>();
// v.Verembe(2); // l.Beszur(0, "1");
// Assert.AreEqual(2, v.Felso()); // l.Beszur(0, "2");
// Assert.AreEqual(2, v.Felso()); // l.Beszur(1, "");
// v.Verembol(); // l.Beszur(3, "");
// Assert.AreEqual(3, v.Felso()); // l.Beszur(2, "5");
// } // Assert.Multiple(() =>
// // {
// [TestMethod()] // Assert.That(l.Kiolvas(0), Is.EqualTo("2"));
// public void Ures() //F1. // Assert.That(l.Kiolvas(1), Is.EqualTo(""));
// { // Assert.That(l.Kiolvas(2), Is.EqualTo("5"));
// Verem<int> v = new TombVerem<int>(2); // Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
// Assert.IsTrue(v.Ures); // Assert.That(l.Kiolvas(4), Is.EqualTo(""));
// v.Verembe(1); // });
// Assert.IsFalse(v.Ures); // }
// v.Verembol(); // [TestCase]
// Assert.IsTrue(v.Ures); // public void HozzaFuzes()
// } // {
// } // Lista<int> l = new TombLista<int>();
// // l.Hozzafuz(1);
// [TestClass()] // l.Hozzafuz(3);
// public class TombSorTesztek // l.Hozzafuz(2);
// { // Assert.Multiple(() =>
// [TestMethod()] // {
// public void AlapMukodes() //F2. // Assert.That(l.Kiolvas(0), Is.EqualTo(1));
// { // Assert.That(l.Kiolvas(1), Is.EqualTo(3));
// Sor<int> s = new TombSor<int>(3); // Assert.That(l.Kiolvas(2), Is.EqualTo(2));
// s.Sorba(1); // });
// s.Sorba(3); // }
// s.Sorba(2); // [TestCase]
// Assert.AreEqual(1, s.Sorbol()); // public void HozzaFuzesUres()
// Assert.AreEqual(3, s.Sorbol()); // {
// Assert.AreEqual(2, s.Sorbol()); // Lista<string> l = new TombLista<string>();
// } // l.Hozzafuz("1");
// // l.Hozzafuz("");
// [TestMethod()] // l.Hozzafuz("");
// public void Korbeeres() //F2. // l.Hozzafuz("1");
// { // Assert.Multiple(() =>
// Sor<int> s = new TombSor<int>(3); // {
// s.Sorba(1); // Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
// s.Sorba(3); // Assert.That(l.Kiolvas(1), Is.EqualTo(""));
// s.Sorba(2); // Assert.That(l.Kiolvas(2), Is.EqualTo(""));
// Assert.AreEqual(1, s.Sorbol()); // Assert.That(l.Kiolvas(3), Is.EqualTo("1"));
// Assert.AreEqual(3, s.Sorbol()); // });
// s.Sorba(4); // }
// s.Sorba(5); // [TestCase]
// Assert.AreEqual(2, s.Sorbol()); // public void Novekedes()
// Assert.AreEqual(4, s.Sorbol()); // {
// Assert.AreEqual(5, s.Sorbol()); // Lista<int> l = new TombLista<int>();
// } // for (int i = 0; i < 1000; i++)
// // l.Hozzafuz(i * i);
// [TestMethod()] // Assert.That(l.Elemszam, Is.EqualTo(1000));
// [ExpectedException(typeof(NincsHelyKivetel))] // Assert.Multiple(() =>
// public void TulSokElem() //F2. // {
// { // for (int i = 0; i < 1000; i++)
// Sor<int> s = new TombSor<int>(3); // Assert.That(l.Kiolvas(i), Is.EqualTo(i * i));
// s.Sorba(1); // });
// s.Sorba(3); // Assert.That(l.Elemszam, Is.EqualTo(1000));
// s.Sorba(2); // }
// s.Sorba(4); // [TestCase]
// } // public void Torles()
// // {
// [TestMethod()] // Lista<int> l = new TombLista<int>();
// [ExpectedException(typeof(NincsElemKivetel))] // l.Hozzafuz(1);
// public void TulKevesElem() //F2. // l.Hozzafuz(3);
// { // l.Hozzafuz(2);
// Sor<int> s = new TombSor<int>(3); // l.Hozzafuz(3);
// s.Sorba(1); // l.Hozzafuz(4);
// s.Sorba(3); // Assert.That(l.Elemszam, Is.EqualTo(5));
// s.Sorba(2); // l.Torol(3);
// s.Sorbol(); // Assert.That(l.Elemszam, Is.EqualTo(3));
// s.Sorbol(); // Assert.Multiple(() =>
// s.Sorbol(); // {
// s.Sorbol(); // Assert.That(l.Kiolvas(0), Is.EqualTo(1));
// } // Assert.That(l.Kiolvas(1), Is.EqualTo(2));
// // Assert.That(l.Kiolvas(2), Is.EqualTo(4));
// [TestMethod()] // });
// public void Elso() //F2. // }
// { // [TestCase]
// Sor<int> s = new TombSor<int>(3); // public void TorlesNincsElem()
// s.Sorba(1); // {
// s.Sorba(3); // Lista<int> l = new TombLista<int>();
// s.Sorba(2); // Assert.That(l.Elemszam, Is.EqualTo(0));
// Assert.AreEqual(1, s.Elso()); // l.Torol(0);
// Assert.AreEqual(1, s.Elso()); // Assert.That(l.Elemszam, Is.EqualTo(0));
// s.Sorbol(); // }
// Assert.AreEqual(3, s.Elso()); // [TestCase]
// } // public void TorlesUres()
// // {
// [TestMethod()] // Lista<string> l = new TombLista<string>();
// public void Ures() //F2. // l.Hozzafuz("1");
// { // l.Hozzafuz("");
// Sor<int> s = new TombSor<int>(2); // l.Hozzafuz("");
// Assert.IsTrue(s.Ures); // l.Hozzafuz("");
// s.Sorba(1); // l.Hozzafuz("1");
// Assert.IsFalse(s.Ures); // Assert.That(l.Elemszam, Is.EqualTo(5));
// s.Sorbol(); // l.Torol("");
// Assert.IsTrue(s.Ures); // Assert.That(l.Elemszam, Is.EqualTo(2));
// } // Assert.Multiple(() =>
// } // {
// // Assert.That(l.Kiolvas(0), Is.EqualTo("1"));
// [TestClass] // Assert.That(l.Kiolvas(1), Is.EqualTo("1"));
// public class TombListaTesztek // });
// { // }
// [TestMethod] // [TestCase]
// public void Bejaras() //F3. // public void NemletezoTorles()
// { // {
// Lista<int> l = new TombLista<int>(); // Lista<int> l = new TombLista<int>();
// l.Hozzafuz(1); // l.Hozzafuz(1);
// l.Hozzafuz(3); // l.Hozzafuz(2);
// l.Hozzafuz(2); // l.Hozzafuz(3);
// string s = ""; // Assert.That(l.Elemszam, Is.EqualTo(3));
// l.Bejar(x => s += x.ToString()); // l.Torol(0);
// Assert.AreEqual("132", s); // Assert.That(l.Elemszam, Is.EqualTo(3));
// } // Assert.Multiple(() =>
// // {
// [TestMethod] // Assert.That(l.Kiolvas(0), Is.EqualTo(1));
// public void HozzaFuzes() //F3. // Assert.That(l.Kiolvas(1), Is.EqualTo(2));
// { // Assert.That(l.Kiolvas(2), Is.EqualTo(3));
// Lista<int> l = new TombLista<int>(); // });
// l.Hozzafuz(1); // }
// l.Hozzafuz(3); // [TestCase]
// l.Hozzafuz(2); // public void Modositas()
// Assert.AreEqual(1, l.Kiolvas(0)); // {
// Assert.AreEqual(3, l.Kiolvas(1)); // Lista<int> l = new TombLista<int>();
// Assert.AreEqual(2, l.Kiolvas(2)); // l.Hozzafuz(1);
// } // l.Hozzafuz(3);
// // l.Hozzafuz(2);
// [TestMethod] // l.Modosit(1, 5);
// public void Meret() //F3. // l.Modosit(0, 4);
// { // Assert.Multiple(() =>
// Lista<string> l = new TombLista<string>(); // {
// Assert.AreEqual(0, l.Elemszam); // Assert.That(l.Kiolvas(0), Is.EqualTo(4));
// l.Hozzafuz("A"); // Assert.That(l.Kiolvas(1), Is.EqualTo(5));
// Assert.AreEqual(1, l.Elemszam); // Assert.That(l.Kiolvas(2), Is.EqualTo(2));
// l.Hozzafuz("B"); // });
// Assert.AreEqual(2, l.Elemszam); // }
// } // [TestCase]
// // public void ForeachBejaras()
// [TestMethod] // {
// public void Novekedes() //F3. // TombLista<string> l = new TombLista<string>();
// { // l.Hozzafuz("a");
// Lista<int> l = new TombLista<int>(); // l.Hozzafuz("c");
// for (int i = 0; i < 1000; i++) // l.Hozzafuz("d");
// l.Hozzafuz(i * i); // l.Hozzafuz("b");
// for (int i = 0; i < 1000; i++) // string osszefuzo = "";
// Assert.AreEqual(i * i, l.Kiolvas(i)); // foreach (string x in l)
// } // {
// // osszefuzo += x;
// [TestMethod] // }
// public void Beszuras() //F3. // Assert.That(osszefuzo, Is.EqualTo("acdb"));
// { // }
// Lista<int> l = new TombLista<int>();
// l.Beszur(0, 1); // }
// l.Beszur(0, 2);
// l.Beszur(1, 3); // [TestFixture(Category = "Adatszerkezetek", TestName = "03 - Tömb Sor Tesztek")]
// l.Beszur(3, 4); // public class TombSorTesztek
// l.Beszur(2, 5); // {
// Assert.AreEqual(2, l.Kiolvas(0)); // [TestCase]
// Assert.AreEqual(3, l.Kiolvas(1)); // public void Ures()
// Assert.AreEqual(5, l.Kiolvas(2)); // {
// Assert.AreEqual(1, l.Kiolvas(3)); // Sor<int> s = new TombSor<int>(0);
// Assert.AreEqual(4, l.Kiolvas(4)); // Assert.That(s.Ures, Is.True);
// } // Assert.Throws<NincsHelyKivetel>(() => s.Sorba(1));
// // }
// [TestMethod] // [TestCase]
// public void Torles() //F3. // public void AlapMukodes()
// { // {
// Lista<int> l = new TombLista<int>(); // Sor<int> s = new TombSor<int>(3);
// l.Hozzafuz(1); // Assert.That(s.Ures, Is.True);
// l.Hozzafuz(3); // s.Sorba(1);
// l.Hozzafuz(2); // Assert.That(s.Ures, Is.False);
// l.Hozzafuz(3); // s.Sorba(3);
// l.Hozzafuz(4); // Assert.That(s.Ures, Is.False);
// l.Torol(3); // s.Sorba(2);
// Assert.AreEqual(1, l.Kiolvas(0)); // Assert.That(s.Ures, Is.False);
// Assert.AreEqual(2, l.Kiolvas(1)); // Assert.Multiple(() =>
// Assert.AreEqual(4, l.Kiolvas(2)); // {
// } // Assert.That(s.Sorbol(), Is.EqualTo(1));
// // Assert.That(s.Ures, Is.False);
// [TestMethod] // Assert.That(s.Sorbol(), Is.EqualTo(3));
// public void Modositas() //F3. // Assert.That(s.Ures, Is.False);
// { // Assert.That(s.Sorbol(), Is.EqualTo(2));
// Lista<int> l = new TombLista<int>(); // Assert.That(s.Ures, Is.True);
// l.Hozzafuz(1); // });
// l.Hozzafuz(3); // }
// l.Hozzafuz(2); // [TestCase]
// l.Modosit(1, 5); // public void UresElem()
// l.Modosit(0, 4); // {
// Assert.AreEqual(4, l.Kiolvas(0)); // Sor<string> s = new TombSor<string>(3);
// Assert.AreEqual(5, l.Kiolvas(1)); // s.Sorba("");
// Assert.AreEqual(2, l.Kiolvas(2)); // s.Sorba("1");
// } // s.Sorba("");
// // Assert.Multiple(() =>
// [TestMethod] // {
// public void ForeachBejaras() //F4. // Assert.That(s.Sorbol(), Is.EqualTo(""));
// { // Assert.That(s.Sorbol(), Is.EqualTo("1"));
// TombLista<string> l = new TombLista<string>(); // Assert.That(s.Sorbol(), Is.EqualTo(""));
// l.Hozzafuz("a"); // });
// l.Hozzafuz("c"); // }
// l.Hozzafuz("d"); // [TestCase]
// l.Hozzafuz("b"); // public void Korbeeres()
// string osszefuzo = ""; // {
// foreach(string x in l) // Sor<int> s = new TombSor<int>(3);
// { // s.Sorba(1);
// osszefuzo += x; // s.Sorba(3);
// } // s.Sorba(2);
// Assert.AreEqual("acdb", osszefuzo); // 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 NUnit.Framework;
// using OE.ALGA.Adatszerkezetek; //using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek //namespace OE.ALGA.Tesztek.Adatszerkezetek
// { //{
// [TestClass()] // [TestFixture(Category = "Adatszerkezetek", TestName = "05 - Fa Halmaz Tesztek")]
// public class FaHalmazTesztek // public class FaHalmazTesztek
// { // {
// [TestMethod()] // [TestCase]
// public void Beszuras() //F4. // public void BeszurasUres()
// { // {
// Halmaz<int> v = new FaHalmaz<int>(); // Halmaz<string> v = new FaHalmaz<string>();
// v.Beszur(1); // v.Beszur("");
// v.Beszur(3); // Assert.Multiple(() =>
// v.Beszur(2); // {
// Assert.IsTrue(v.Eleme(1)); // Assert.That(v.Eleme(""), Is.True);
// Assert.IsTrue(v.Eleme(2)); // });
// Assert.IsTrue(v.Eleme(3)); // }
// Assert.IsFalse(v.Eleme(4)); // [TestCase]
// } // public void Beszuras()
// // {
// [TestMethod()] // Halmaz<int> v = new FaHalmaz<int>();
// public void Torles() //F5. // v.Beszur(1);
// { // v.Beszur(3);
// Halmaz<int> v = new FaHalmaz<int>(); // v.Beszur(2);
// v.Beszur(1); // Assert.Multiple(() =>
// v.Beszur(3); // {
// v.Beszur(2); // Assert.That(v.Eleme(1), Is.True);
// v.Torol(2); // Assert.That(v.Eleme(2), Is.True);
// Assert.IsTrue(v.Eleme(1)); // Assert.That(v.Eleme(3), Is.True);
// Assert.IsFalse(v.Eleme(2)); // });
// Assert.IsTrue(v.Eleme(3)); // }
// Assert.IsFalse(v.Eleme(4)); // [TestCase]
// } // public void DuplaBeszuras()
// // {
// [TestMethod()] // Halmaz<int> v = new FaHalmaz<int>();
// public void DuplaBeszuras() //F5. // v.Beszur(1);
// { // v.Beszur(2);
// Halmaz<int> v = new FaHalmaz<int>(); // v.Beszur(3);
// v.Beszur(1); // v.Beszur(2);
// v.Beszur(2); // Assert.Multiple(() =>
// v.Beszur(3); // {
// v.Beszur(2); // Assert.That(v.Eleme(1), Is.True);
// v.Torol(2); // Assert.That(v.Eleme(2), Is.True);
// Assert.IsTrue(v.Eleme(1)); // Assert.That(v.Eleme(3), Is.True);
// Assert.IsFalse(v.Eleme(2)); // });
// Assert.IsTrue(v.Eleme(3)); // }
// Assert.IsFalse(v.Eleme(4)); // [TestCase]
// } // public void Torles()
// // {
// [TestMethod()] // Halmaz<int> v = new FaHalmaz<int>();
// public void PreorderBejaras() //F6. // v.Beszur(1);
// { // v.Beszur(3);
// Halmaz<int> v = new FaHalmaz<int>(); // v.Beszur(2);
// v.Beszur(5); // v.Torol(2);
// v.Beszur(3); // Assert.Multiple(() =>
// v.Beszur(1); // {
// v.Beszur(8); // Assert.That(v.Eleme(1), Is.True);
// v.Beszur(4); // Assert.That(v.Eleme(2), Is.False);
// v.Beszur(9); // Assert.That(v.Eleme(3), Is.True);
// v.Beszur(7); // });
// string osszefuzo = ""; // }
// v.Bejar(x => osszefuzo += x); // [TestCase]
// Assert.AreEqual("5314879", osszefuzo); // 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 NUnit.Framework;
// using OE.ALGA.Adatszerkezetek; //using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek //namespace OE.ALGA.Tesztek.Adatszerkezetek
// { //{
// [TestClass()] // [TestFixture(Category = "Adatszerkezetek", TestName = "06 - Szótár Tesztek")]
// public class SzotarTesztek // public class SzotarTesztek
// { // {
// public static int TesztHasitoFuggveny(string kulcs) //F2.(f) // private static int TesztHasitoFuggveny(string kulcs)
// { // {
// if (string.IsNullOrEmpty(kulcs)) // if (string.IsNullOrEmpty(kulcs))
// return 0; // return 0;
// int sum = 0; // int sum = 0;
// foreach (char c in kulcs.ToCharArray()) // foreach (char c in kulcs.ToCharArray())
// sum += ((byte)c); // 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 // return sum * sum; // a modulo osztást a szótárnak kell végeznie, mert ő tudja csak a belső tömb méretet
// } // }
//
// [TestMethod()] // [TestCase]
// public void AlapMukodes() //F2.(f) // public void AlapMukodes()
// { // {
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny); // Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
// sz.Beir("Bela", 5); // sz.Beir("Bela", 5);
// sz.Beir("Lajos", 2); // sz.Beir("Lajos", 2);
// Assert.AreEqual(5, sz.Kiolvas("Bela")); // Assert.Multiple(() =>
// Assert.AreEqual(2, sz.Kiolvas("Lajos")); // {
// } // Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
// // Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// [TestMethod()] // });
// public void AlapertelmezettHasitoFuggvennyel() //F2.(f) // }
// { // [TestCase]
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10); // public void AlapertelmezettHasitoFuggvennyel() //F2.(f)
// sz.Beir("Bela", 5); // {
// sz.Beir("Lajos", 2); // Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10);
// Assert.AreEqual(5, sz.Kiolvas("Bela")); // sz.Beir("Bela", 5);
// Assert.AreEqual(2, sz.Kiolvas("Lajos")); // sz.Beir("Lajos", 2);
// } // Assert.Multiple(() =>
// // {
// [TestMethod()] // Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
// public void Kulcsutkozes() //F2.(f) // Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// { // });
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny); // }
// sz.Beir("Bela", 5); // [TestCase]
// sz.Beir("Bale", 15); // public void Kulcsutkozes()
// sz.Beir("Lajos", 2); // {
// sz.Beir("Lasoj", 12); // Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(10, TesztHasitoFuggveny);
// Assert.AreEqual(5, sz.Kiolvas("Bela")); // sz.Beir("Bela", 5);
// Assert.AreEqual(2, sz.Kiolvas("Lajos")); // sz.Beir("Bale", 15);
// Assert.AreEqual(15, sz.Kiolvas("Bale")); // sz.Beir("Lajos", 2);
// Assert.AreEqual(12, sz.Kiolvas("Lasoj")); // sz.Beir("Lasoj", 12);
// } // Assert.Multiple(() =>
// // {
// [TestMethod()] // Assert.That(sz.Kiolvas("Bela"), Is.EqualTo(5));
// [ExpectedException(typeof(HibasKulcsKivetel))] // Assert.That(sz.Kiolvas("Lajos"), Is.EqualTo(2));
// public void NincsElem() //F2.(f) // Assert.That(sz.Kiolvas("Bale"), Is.EqualTo(15));
// { // Assert.That(sz.Kiolvas("Lasoj"), Is.EqualTo(12));
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny); // });
// sz.Beir("Bela", 5); // }
// sz.Beir("Lajos", 2); // [TestCase]
// sz.Kiolvas("Ferenc"); // public void NullElem()
// } // {
// // Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
// [TestMethod()] // sz.Beir("null", null!);
// public void TorlesMarad() //F2.(g) // }
// { // [TestCase]
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny); // public void UresKulcs()
// sz.Beir("Bela", 5); // {
// sz.Beir("Lajos", 2); // Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Torol("Bela"); // sz.Beir("", 0);
// Assert.AreEqual(2, sz.Kiolvas("Lajos")); // }
// } // [TestCase]
// // public void UresElem()
// [TestMethod()] // {
// [ExpectedException(typeof(HibasKulcsKivetel))] // Szotar<string, string> sz = new HasitoSzotarTulcsordulasiTerulettel<string, string>(5, TesztHasitoFuggveny);
// public void TorlesEltunt() //F2.(g) // sz.Beir("Bela", "");
// { // }
// Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny); // [TestCase]
// sz.Beir("Bela", 5); // public void NincsElem()
// sz.Beir("Lajos", 2); // {
// sz.Torol("Bela"); // Szotar<string, int> sz = new HasitoSzotarTulcsordulasiTerulettel<string, int>(5, TesztHasitoFuggveny);
// sz.Kiolvas("Bela"); // 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 NUnit.Framework;
// using OE.ALGA.Optimalizalas; //using System;
// //using OE.ALGA.Optimalizalas;
// namespace OE.ALGA.Tesztek
// { //namespace OE.ALGA.Tesztek.Optimalizalas
// public class PakolasTesztEsetek //F1. //{
// { // [TestFixture(Category = "Optimalizalas", TestName = "07 - Hátiszák Tesztek")]
// public static readonly bool[] uresPakolas = new bool[] { false, false, false, false, false, false }; // public class HatizsakTesztek
// 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 }; // [TestCase]
// // public void UresTeszt()
// 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 }; // HatizsakProblema problema = new HatizsakProblema(0, 0, [], []);
// public static readonly int jegyzet_n = jegyzet_w.Length; // Assert.Multiple(() =>
// public static readonly int jegyzet_Wmax = 4; // {
// public static readonly float jegyzet_optimalis_ertek = 16; // Assert.That(problema.OsszSuly(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
// public static readonly bool[] jegyzet_optimalis_pakolas = new bool[] { false, true, false, true, false, true }; // Assert.That(problema.OsszSuly(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(0));
// // Assert.That(problema.OsszSuly(PakolasTesztEsetek.feligPakolas), Is.EqualTo(0));
// 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 }; // Assert.Multiple(() =>
// public static readonly int nagy_n = nagy_w.Length; // {
// public static readonly int nagy_Wmax = 100; // Assert.That(problema.OsszErtek(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
// public static readonly float nagy_optimalis_ertek = 24; // Assert.That(problema.OsszErtek(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(0));
// } // Assert.That(problema.OsszErtek(PakolasTesztEsetek.feligPakolas), Is.EqualTo(0));
// // });
// [TestClass()] // Assert.Multiple(() =>
// public class HatizsakTesztek // {
// { // Assert.That(problema.Ervenyes(PakolasTesztEsetek.uresPakolas), Is.True);
// // Assert.That(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas), Is.True);
// [TestMethod()] // Assert.That(problema.Ervenyes(PakolasTesztEsetek.feligPakolas), Is.True);
// public void SulyTeszt() //F1. // });
// { // }
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); // [TestCase]
// Assert.AreEqual(0, problema.OsszSuly(PakolasTesztEsetek.uresPakolas)); // public void SulyTeszt()
// Assert.AreEqual(10, problema.OsszSuly(PakolasTesztEsetek.teljesPakolas)); // {
// Assert.AreEqual(2, problema.OsszSuly(PakolasTesztEsetek.feligPakolas)); // HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// } // Assert.Multiple(() =>
// // {
// [TestMethod()] // Assert.That(problema.OsszSuly(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
// public void JosagTeszt() //F1. // Assert.That(problema.OsszSuly(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(10));
// { // Assert.That(problema.OsszSuly(PakolasTesztEsetek.feligPakolas), Is.EqualTo(2));
// 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)); // [TestCase]
// Assert.AreEqual(11, problema.OsszErtek(PakolasTesztEsetek.feligPakolas)); // public void JosagTeszt()
// } // {
// // HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// [TestMethod()] // Assert.Multiple(() =>
// public void ErvenyesTeszt() //F1. // {
// { // Assert.That(problema.OsszErtek(PakolasTesztEsetek.uresPakolas), Is.EqualTo(0));
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); // Assert.That(problema.OsszErtek(PakolasTesztEsetek.teljesPakolas), Is.EqualTo(29));
// Assert.IsTrue(problema.Ervenyes(PakolasTesztEsetek.uresPakolas)); // Assert.That(problema.OsszErtek(PakolasTesztEsetek.feligPakolas), Is.EqualTo(11));
// Assert.IsFalse(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas)); // });
// Assert.IsTrue(problema.Ervenyes(PakolasTesztEsetek.feligPakolas)); // }
// } // [TestCase]
// } // public void ErvenyesTeszt()
// // {
// [TestClass()] // HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// public class NyersEroTesztek // Assert.Multiple(() =>
// { // {
// [TestMethod()] // Assert.That(problema.Ervenyes(PakolasTesztEsetek.uresPakolas), Is.True);
// public void TombLegnagyobbEleme() //F2. // Assert.That(problema.Ervenyes(PakolasTesztEsetek.teljesPakolas), Is.False);
// { // Assert.That(problema.Ervenyes(PakolasTesztEsetek.feligPakolas), Is.True);
// int[] A = { 4, 6, 7, 4, 2, 1 }; // });
// NyersEro<int> opt = new NyersEro<int>( // }
// A.Length, // }
// x => A[x-1],
// x => x); // [TestFixture(Category = "Optimalizalas", TestName = "07 - Nyers Ero Tesztek")]
// Assert.AreEqual(7, opt.OptimalisMegoldas()); // public class NyersEroTesztek
// } // {
// } // [TestCase]
// // public void UresTeszt()
// [TestClass()] // {
// public class NyersEroHatizsakPakolasTesztek // int[] A = { 4, 6, 7, 4, 2, 1 };
// { // NyersEro<int> opt = new NyersEro<int>(
// [TestMethod()] // 0,
// public void JegyzetbenLevoPeldaErtekTeszt() //F3. // x => { Guardian.Recursion.CheckStackTrace(); return A[x - 1]; },
// { // x => { Guardian.Recursion.CheckStackTrace(); return x; });
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); // Assert.Multiple(() =>
// NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema); // {
// Assert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_ertek, opt.OptimalisErtek()); // Assert.That(opt.OptimalisMegoldas(), Is.EqualTo(4));
// } // Assert.That(opt.LepesSzam, Is.EqualTo(0));
// // });
// [TestMethod()] // }
// public void JegyzetbenLevoPeldaMegoldasTeszt() //F3. // [TestCase]
// { // public void TombLegnagyobbEleme()
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); // {
// NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema); // int[] A = { 4, 6, 7, 4, 2, 1 };
// CollectionAssert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_pakolas, opt.OptimalisMegoldas()); // NyersEro<int> opt = new NyersEro<int>(
// } // A.Length,
// // x => { Guardian.Recursion.CheckStackTrace(); return A[x - 1]; },
// [TestMethod()] // x => { Guardian.Recursion.CheckStackTrace(); return x; });
// public void NagyPeldaMegoldasTeszt() //F3. // Assert.Multiple(() =>
// { // {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p); // Assert.That(opt.OptimalisMegoldas(), Is.EqualTo(7));
// NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema); // Assert.That(opt.LepesSzam, Is.EqualTo(5));
// Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek()); // });
// } // }
//
// [TestMethod()] // }
// public void LepesszamVizsgalat() //F3.
// { // [TestFixture(Category = "Optimalizalas", TestName = "07 - Nyers Ero Hátizsák Pakolás Tesztek")]
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p); // public class NyersEroHatizsakPakolasTesztek
// NyersEroHatizsakPakolas opt = new NyersEroHatizsakPakolas(problema); // {
// Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek()); // [TestCase]
// Console.WriteLine("Lépésszám: " + opt.LepesSzam); // 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 NUnit.Framework;
// using OE.ALGA.Optimalizalas; //using System;
// //using OE.ALGA.Optimalizalas;
// namespace OE.ALGA.Tesztek
// { //namespace OE.ALGA.Tesztek.Optimalizalas
// [TestClass()] //{
// public class DinamikusProgramozasTesztek // [TestFixture(Category = "Optimalizalas", TestName = "08 - Dinamikus Programozás Tesztek")]
// { // public class DinamikusProgramozasTesztek
// [TestMethod()] // {
// public void JegyzetbenLevoPeldaErtekTeszt() //F1. // [TestCase]
// { // public void UresTeszt()
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p); // {
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema); // HatizsakProblema problema = new HatizsakProblema(0, 0, [], []);
// Assert.AreEqual(PakolasTesztEsetek.jegyzet_optimalis_ertek, opt.OptimalisErtek()); // DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// } // Assert.Multiple(() =>
// // {
// [TestMethod()] // Assert.That(opt.OptimalisErtek(), Is.EqualTo(0));
// public void JegyzetbenLevoPeldaMegoldasTeszt() //F1. // Assert.That(opt.OptimalisMegoldas(), Is.EquivalentTo(Array.Empty<bool>()));
// { // Assert.That(opt.LepesSzam, Is.EqualTo(0));
// 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()); // [TestCase]
// } // public void JegyzetbenLevoPeldaErtekTeszt()
// // {
// [TestMethod()] // HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// public void NagyPeldaMegoldasTeszt() //F1. // DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// { // Assert.Multiple(() =>
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p); // {
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema); // Assert.That(opt.OptimalisErtek(), Is.EqualTo(PakolasTesztEsetek.jegyzet_optimalis_ertek));
// Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek()); // Assert.That(opt.LepesSzam, Is.EqualTo(24));
// } // });
// // }
// [TestMethod()] // [TestCase]
// public void LepesszamVizsgalat() //F1. // public void JegyzetbenLevoPeldaMegoldasTeszt()
// { // {
// HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.nagy_n, PakolasTesztEsetek.nagy_Wmax, PakolasTesztEsetek.nagy_w, PakolasTesztEsetek.nagy_p); // HatizsakProblema problema = new HatizsakProblema(PakolasTesztEsetek.jegyzet_n, PakolasTesztEsetek.jegyzet_Wmax, PakolasTesztEsetek.jegyzet_w, PakolasTesztEsetek.jegyzet_p);
// DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema); // DinamikusHatizsakPakolas opt = new DinamikusHatizsakPakolas(problema);
// Assert.AreEqual(PakolasTesztEsetek.nagy_optimalis_ertek, opt.OptimalisErtek()); // Assert.Multiple(() =>
// Console.WriteLine("Lépésszám: " + opt.LepesSzam); // {
// } // 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 NUnit.Framework;
// using OE.ALGA.Adatszerkezetek; //using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek
// { //namespace OE.ALGA.Tesztek.Adatszerkezetek
// [TestClass] //{
// public class CsucsMatrixGrafTesztek // [TestFixture(Category = "Adatszerkezetek", TestName = "10 - Csúcsmátrix Gráf Tesztek")]
// { // public class CsucsMatrixGrafTesztek
// [TestMethod] // {
// public void MindenCsucsTeszt() //F2. // [TestCase]
// { // public void MindenCsucsTeszt()
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2); // {
// Assert.IsTrue(csg.Csucsok.Eleme(0)); // CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2);
// Assert.IsTrue(csg.Csucsok.Eleme(1)); // Assert.Multiple(() =>
// } // {
// // Assert.That(csg.Csucsok.Eleme(0), Is.True);
// [TestMethod] // Assert.That(csg.Csucsok.Eleme(1), Is.True);
// public void MindenElTeszt() //F2. // });
// { // }
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3);
// csg.UjEl(0, 1); // [TestCase]
// csg.UjEl(0, 2); // public void MindenElTeszt()
// csg.UjEl(1, 2); // {
// // CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3);
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(0, 0))); // csg.UjEl(0, 1);
// Assert.IsTrue(csg.Elek.Eleme(new EgeszGrafEl(0, 1))); // csg.UjEl(0, 2);
// Assert.IsTrue(csg.Elek.Eleme(new EgeszGrafEl(0, 2))); // csg.UjEl(1, 2);
//
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(1, 0))); // Assert.Multiple(() =>
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(1, 1))); // {
// Assert.IsTrue(csg.Elek.Eleme(new EgeszGrafEl(1, 2))); // Assert.That(csg.Elek.Eleme(new EgeszGrafEl(0, 0)), Is.False);
// // Assert.That(csg.Elek.Eleme(new EgeszGrafEl(0, 1)), Is.True);
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(2, 0))); // Assert.That(csg.Elek.Eleme(new EgeszGrafEl(0, 2)), Is.True);
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(2, 1)));
// Assert.IsFalse(csg.Elek.Eleme(new EgeszGrafEl(2, 2))); // 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);
// [TestMethod]
// public void VezetElTeszt() //F2. // Assert.That(csg.Elek.Eleme(new EgeszGrafEl(2, 0)), Is.False);
// { // Assert.That(csg.Elek.Eleme(new EgeszGrafEl(2, 1)), Is.False);
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2); // Assert.That(csg.Elek.Eleme(new EgeszGrafEl(2, 2)), Is.False);
// Assert.IsFalse(csg.VezetEl(0, 1)); // });
// csg.UjEl(0, 1); // }
// Assert.IsTrue(csg.VezetEl(0, 1));
// Assert.IsFalse(csg.VezetEl(1, 0)); // [TestCase]
// } // public void VezetElTeszt()
// // {
// [TestMethod] // CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(2);
// public void SzomszedsagTeszt() //F2. // Assert.That(csg.VezetEl(0, 1), Is.False);
// { // csg.UjEl(0, 1);
// CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3); // Assert.Multiple(() =>
// csg.UjEl(0, 1); // {
// csg.UjEl(0, 2); // Assert.That(csg.VezetEl(0, 1), Is.True);
// csg.UjEl(1, 2); // Assert.That(csg.VezetEl(1, 0), Is.False);
// // });
// Halmaz<int> a_szomszedai = csg.Szomszedai(0); // }
// Halmaz<int> b_szomszedai = csg.Szomszedai(1);
// Halmaz<int> c_szomszedai = csg.Szomszedai(2); // [TestCase]
// // public void SzomszedsagTeszt()
// Assert.IsFalse(a_szomszedai.Eleme(0)); // {
// Assert.IsTrue(a_szomszedai.Eleme(1)); // CsucsmatrixSulyozatlanEgeszGraf csg = new CsucsmatrixSulyozatlanEgeszGraf(3);
// Assert.IsTrue(a_szomszedai.Eleme(2)); // csg.UjEl(0, 1);
// // csg.UjEl(0, 2);
// Assert.IsFalse(b_szomszedai.Eleme(0)); // csg.UjEl(1, 2);
// Assert.IsFalse(b_szomszedai.Eleme(1));
// Assert.IsTrue(b_szomszedai.Eleme(2)); // Halmaz<int> a_szomszedai = csg.Szomszedai(0);
// // Halmaz<int> b_szomszedai = csg.Szomszedai(1);
// Assert.IsFalse(c_szomszedai.Eleme(0)); // Halmaz<int> c_szomszedai = csg.Szomszedai(2);
// Assert.IsFalse(c_szomszedai.Eleme(1));
// Assert.IsFalse(c_szomszedai.Eleme(2)); // Assert.Multiple(() =>
// } // {
// } // Assert.That(a_szomszedai.Eleme(0), Is.False);
// // Assert.That(a_szomszedai.Eleme(1), Is.True);
// [TestClass] // Assert.That(a_szomszedai.Eleme(2), Is.True);
// public class GrafBejarasTesztek
// { // Assert.That(b_szomszedai.Eleme(0), Is.False);
// [TestMethod] // Assert.That(b_szomszedai.Eleme(1), Is.False);
// public void SzelessegiBejarasTeszt() //F3.(a) // Assert.That(b_szomszedai.Eleme(2), Is.True);
// {
// CsucsmatrixSulyozatlanEgeszGraf g = new CsucsmatrixSulyozatlanEgeszGraf(6); // Assert.That(c_szomszedai.Eleme(0), Is.False);
// g.UjEl(0, 1); // Assert.That(c_szomszedai.Eleme(1), Is.False);
// g.UjEl(1, 2); // Assert.That(c_szomszedai.Eleme(2), Is.False);
// g.UjEl(1, 4); // });
// g.UjEl(2, 3); // }
// g.UjEl(2, 4); // }
// g.UjEl(4, 3);
// g.UjEl(3, 0); // [TestFixture(Category = "Adatszerkezetek", TestName = "10 - Gráf Bejárás Tesztek")]
// // public class GrafBejarasTesztek
// string ut = ""; // {
// Halmaz<int> elertCsucsok = GrafBejarasok.SzelessegiBejaras(g, 0, (a) => { ut += a; }); // [TestCase]
// // public void SzelessegiBejarasTeszt()
// Assert.IsTrue(ut == "01243" || ut == "01423"); // {
// for (int i = 0; i <= 4; i++) // CsucsmatrixSulyozatlanEgeszGraf g = new CsucsmatrixSulyozatlanEgeszGraf(6);
// Assert.IsTrue(elertCsucsok.Eleme(i)); // g.UjEl(0, 1);
// Assert.IsFalse(elertCsucsok.Eleme(6)); // g.UjEl(1, 2);
// } // g.UjEl(1, 4);
// // g.UjEl(2, 3);
// [TestMethod] // g.UjEl(2, 4);
// public void MelysegiBejarasTeszt() //F3.(c) // g.UjEl(4, 3);
// { // g.UjEl(3, 0);
// CsucsmatrixSulyozatlanEgeszGraf g = new CsucsmatrixSulyozatlanEgeszGraf(6);
// g.UjEl(0, 1); // string ut = "";
// g.UjEl(1, 2); // Halmaz<int> elertCsucsok = GrafBejarasok.SzelessegiBejaras(g, 0, (a) => { ut += a; });
// g.UjEl(1, 4);
// g.UjEl(2, 3); // Assert.Multiple(() =>
// g.UjEl(2, 4); // {
// g.UjEl(4, 3); // Assert.That(ut == "01243" || ut == "01423", Is.True);
// g.UjEl(3, 0); // for (int i = 0; i <= 4; i++)
// // Assert.That(elertCsucsok.Eleme(i), Is.True);
// string ut = ""; // Assert.That(elertCsucsok.Eleme(6), Is.False);
// 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++) // [TestCase]
// Assert.IsTrue(elertCsucsok.Eleme(i)); // public void MelysegiBejarasTeszt()
// Assert.IsFalse(elertCsucsok.Eleme(6)); // {
// } // 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 NUnit.Framework;
// using OE.ALGA.Adatszerkezetek; //using System;
// //using OE.ALGA.Adatszerkezetek;
// namespace OE.ALGA.Tesztek
// { //namespace OE.ALGA.Tesztek.Adatszerkezetek
// [TestClass()] //{
// public class KupacRendezesTesztek // [TestFixture(Category = "Adatszerkezetek", TestName = "11 - Kupac Prioritásos Sor Tesztek")]
// { // public class KupacPrioritasosSorTesztek
// [TestMethod()] // {
// public void KupacEpites() //F1. // [TestCase]
// { // public void TulSokElemTeszt()
// int[] A = [1, 3, 2, 4, 9, 12, 32, 21, 12, 8, 11]; // {
// _ = new Kupac<int>(A, A.Length, (x, y) => x > y); // PrioritasosSor<int> s = new KupacPrioritasosSor<int>(2, (x, y) => x > y);
// // s.Sorba(1);
// for (int i = 1; i < A.Length; i++) // s.Sorba(2);
// Assert.IsTrue(A[Kupac<int>.Szulo(i)] >= A[i]); // Assert.Throws<NincsHelyKivetel>(() => s.Sorba(3));
// } // }
//
// [TestMethod()] // [TestCase]
// public void KupacRendezes() //F2. // public void TulKevesElemTeszt()
// { // {
// int[] A = [5, 8, 7, 0, 9, 6, 4, 1, 3, 2]; // PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y);
// KupacRendezes<int> k = new KupacRendezes<int>(A); // s.Sorba(1);
// k.Rendezes(); // s.Sorba(2);
// // s.Sorba(3);
// for (int i = 0; i < A.Length; i++) // s.Sorbol();
// Assert.AreEqual(i, A[i]); // s.Sorbol();
// } // s.Sorbol();
// } // Assert.Throws<NincsElemKivetel>(() => s.Sorbol());
// // }
// [TestClass()]
// public class KupacPrioritasosSorTesztek // [TestCase]
// { // public void UresTeszt()
// [TestMethod()] // {
// [ExpectedException(typeof(NincsHelyKivetel))] // PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y);
// public void TulSokElemTeszt() //F3. // Assert.That(s.Ures, Is.True);
// { // s.Sorba(1);
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(2, (x, y) => x > y); // Assert.That(s.Ures, Is.False);
// s.Sorba(1); // s.Sorba(2);
// s.Sorba(2); // Assert.That(s.Ures, Is.False);
// s.Sorba(3); // s.Sorbol();
// } // Assert.That(s.Ures, Is.False);
// // s.Elso();
// [TestMethod()] // Assert.That(s.Ures, Is.False);
// [ExpectedException(typeof(NincsElemKivetel))] // s.Sorbol();
// public void TulKevesElemTeszt() //F3. // Assert.That(s.Ures, Is.True);
// { // }
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y);
// s.Sorba(1); // [TestCase]
// s.Sorba(2); // public void SorbaSorbolElsoTeszt()
// s.Sorba(3); // {
// s.Sorbol(); // PrioritasosSor<int> s = new KupacPrioritasosSor<int>(10, (x, y) => x > y);
// s.Sorbol(); // s.Sorba(1);
// s.Sorbol(); // s.Sorba(4);
// s.Sorbol(); // Assert.Multiple(() =>
// } // {
// // Assert.That(s.Elso(), Is.EqualTo(4));
// [TestMethod()] // Assert.That(s.Sorbol(), Is.EqualTo(4));
// public void UresTeszt() //F3. // Assert.That(s.Elso(), Is.EqualTo(1));
// { // });
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(5, (x, y) => x > y); // s.Sorba(4);
// Assert.IsTrue(s.Ures); // s.Sorba(2);
// s.Sorba(1); // s.Sorba(8);
// Assert.IsFalse(s.Ures); // s.Sorba(3);
// s.Sorba(2); // Assert.That(s.Elso(), Is.EqualTo(8));
// Assert.IsFalse(s.Ures); // s.Sorba(9);
// s.Sorbol(); // s.Sorba(5);
// Assert.IsFalse(s.Ures); // Assert.Multiple(() =>
// s.Elso(); // {
// Assert.IsFalse(s.Ures); // Assert.That(s.Elso(), Is.EqualTo(9));
// s.Sorbol(); // Assert.That(s.Elso(), Is.EqualTo(9));
// Assert.IsTrue(s.Ures); // Assert.That(s.Sorbol(), Is.EqualTo(9));
// } // Assert.That(s.Elso(), Is.EqualTo(8));
// // });
// [TestMethod()] // s.Sorba(7);
// public void SorbaSorbolElsoTeszt() //F3. // Assert.Multiple(() =>
// { // {
// PrioritasosSor<int> s = new KupacPrioritasosSor<int>(10, (x, y) => x > y); // Assert.That(s.Sorbol(), Is.EqualTo(8));
// s.Sorba(1); // Assert.That(s.Sorbol(), Is.EqualTo(7));
// s.Sorba(4); // Assert.That(s.Sorbol(), Is.EqualTo(5));
// Assert.AreEqual(4, s.Elso()); // });
// Assert.AreEqual(4, s.Sorbol()); // s.Sorba(2);
// Assert.AreEqual(1, s.Elso()); // Assert.Multiple(() =>
// s.Sorba(4); // {
// s.Sorba(2); // Assert.That(s.Sorbol(), Is.EqualTo(4));
// s.Sorba(8); // Assert.That(s.Sorbol(), Is.EqualTo(3));
// s.Sorba(3); // Assert.That(s.Sorbol(), Is.EqualTo(2));
// Assert.AreEqual(8, s.Elso()); // Assert.That(s.Sorbol(), Is.EqualTo(2));
// s.Sorba(9); // Assert.That(s.Elso(), Is.EqualTo(1));
// s.Sorba(5); // Assert.That(s.Sorbol(), Is.EqualTo(1));
// Assert.AreEqual(9, s.Elso()); // });
// Assert.AreEqual(9, s.Elso()); // }
// Assert.AreEqual(9, s.Sorbol());
// Assert.AreEqual(8, s.Elso()); // class PrioritasosSzoveg : IComparable
// s.Sorba(7); // {
// Assert.AreEqual(8, s.Sorbol()); // public string Szoveg { get; set; }
// Assert.AreEqual(7, s.Sorbol()); // public float Prioritas { get; set; }
// Assert.AreEqual(5, s.Sorbol()); // public PrioritasosSzoveg(string szoveg, float prioritas)
// s.Sorba(2); // {
// Assert.AreEqual(4, s.Sorbol()); // this.Szoveg = szoveg;
// Assert.AreEqual(3, s.Sorbol()); // this.Prioritas = prioritas;
// Assert.AreEqual(2, s.Sorbol()); // }
// Assert.AreEqual(2, s.Sorbol());
// Assert.AreEqual(1, s.Elso()); // public int CompareTo(object? obj)
// Assert.AreEqual(1, s.Sorbol()); // {
// } // if (obj is not PrioritasosSzoveg o)
// // throw new NullReferenceException();
// class PrioritasosSzoveg : IComparable //F3. // else
// { // return Prioritas.CompareTo(o.Prioritas);
// public string Szoveg { get; set; } // }
// public float Prioritas { get; set; } // }
// public PrioritasosSzoveg(string szoveg, float prioritas)
// { // [TestCase]
// this.Szoveg = szoveg; // public void PrioritasValtozasTeszt()
// this.Prioritas = prioritas; // {
// } // PrioritasosSzoveg a = new PrioritasosSzoveg("a", 10.0f);
// // PrioritasosSzoveg b = new PrioritasosSzoveg("b", 5.0f);
// public int CompareTo(object? obj) // PrioritasosSzoveg c = new PrioritasosSzoveg("c", 2.0f);
// { // PrioritasosSzoveg d = new PrioritasosSzoveg("d", 12.0f);
// if (obj is not PrioritasosSzoveg o) // PrioritasosSzoveg e = new PrioritasosSzoveg("e", 15.0f);
// throw new NullReferenceException(); // PrioritasosSzoveg f = new PrioritasosSzoveg("f", 9.0f);
// else // PrioritasosSzoveg g = new PrioritasosSzoveg("g", 2.0f);
// return Prioritas.CompareTo(o.Prioritas); // PrioritasosSor<PrioritasosSzoveg> s = new KupacPrioritasosSor<PrioritasosSzoveg>(10, (x, y) => x.CompareTo(y) > 0);
// } // s.Sorba(a);
// } // s.Sorba(b);
// // s.Sorba(c);
// [TestMethod()] // s.Sorba(d);
// public void PrioritasValtozasTeszt() //F3. // s.Sorba(e);
// { // Assert.That(s.Elso().Szoveg, Is.EqualTo("e"));
// PrioritasosSzoveg a = new PrioritasosSzoveg("a", 10.0f); // d.Prioritas = 22.0f;
// PrioritasosSzoveg b = new PrioritasosSzoveg("b", 5.0f); // s.Frissit(d);
// PrioritasosSzoveg c = new PrioritasosSzoveg("c", 2.0f); // Assert.That(s.Elso().Szoveg, Is.EqualTo("d"));
// PrioritasosSzoveg d = new PrioritasosSzoveg("d", 12.0f); // d.Prioritas = 8.0f;
// PrioritasosSzoveg e = new PrioritasosSzoveg("e", 15.0f); // s.Frissit(d);
// PrioritasosSzoveg f = new PrioritasosSzoveg("f", 9.0f); // e.Prioritas = 7.0f;
// PrioritasosSzoveg g = new PrioritasosSzoveg("g", 2.0f); // s.Frissit(e);
// PrioritasosSor<PrioritasosSzoveg> s = new KupacPrioritasosSor<PrioritasosSzoveg>(10, (x, y) => x.CompareTo(y) > 0); // Assert.That(s.Sorbol().Szoveg, Is.EqualTo("a"));
// s.Sorba(a); // s.Sorba(f);
// s.Sorba(b); // s.Sorba(g);
// s.Sorba(c); // Assert.Multiple(() =>
// s.Sorba(d); // {
// s.Sorba(e); // Assert.That(s.Sorbol().Szoveg, Is.EqualTo("f"));
// Assert.AreEqual("e", s.Elso().Szoveg); // Assert.That(s.Sorbol().Szoveg, Is.EqualTo("d"));
// d.Prioritas = 22.0f; // Assert.That(s.Sorbol().Szoveg, Is.EqualTo("e"));
// s.Frissit(d); // Assert.That(s.Sorbol().Szoveg, Is.EqualTo("b"));
// Assert.AreEqual("d", s.Elso().Szoveg); // });
// d.Prioritas = 8.0f; // c.Prioritas = 1.5f;
// s.Frissit(d); // s.Frissit(c);
// e.Prioritas = 7.0f; // Assert.Multiple(() =>
// s.Frissit(e); // {
// Assert.AreEqual("a", s.Sorbol().Szoveg); // Assert.That(s.Sorbol().Szoveg, Is.EqualTo("g"));
// s.Sorba(f); // Assert.That(s.Sorbol().Szoveg, Is.EqualTo("c"));
// s.Sorba(g); // Assert.That(s.Ures, Is.True);
// 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; // [TestFixture(Category = "Adatszerkezetek", TestName = "11 - Kupac Külső Fügvénnyel Tesztek")]
// s.Frissit(c); // public class KupacKulsoFuggvennyelTesztek
// Assert.AreEqual("g", s.Sorbol().Szoveg); // {
// Assert.AreEqual("c", s.Sorbol().Szoveg); // /// <summary>
// Assert.IsTrue(s.Ures); // /// Nincs külön rendező függvény, ezért ABC sorrendben rendez az IComparable alapján.
// } // /// </summary>
// } // [TestCase]
// // public void KupacEpitesIComparableAlapjan()
// [TestClass()] // {
// public class KupacTesztekKulsoFuggvennyel //F3. // KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (x, y) => x.CompareTo(y) > 0);
// { // ps.Sorba("oszibarack");
// /// <summary> // ps.Sorba("alma");
// /// Nincs külön rendező függvény, ezért ABC sorrendben rendez az IComparable alapján. // ps.Sorba("korte");
// /// </summary> // ps.Sorba("birsalma");
// [TestMethod()] // ps.Sorba("barack");
// public void KupacEpitesIComparableAlapjan() // ps.Sorba("dio");
// { // Assert.Multiple(() =>
// KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (x, y) => x.CompareTo(y) > 0); // {
// ps.Sorba("oszibarack"); // Assert.That(ps.Sorbol(), Is.EqualTo("oszibarack"));
// ps.Sorba("alma"); // Assert.That(ps.Sorbol(), Is.EqualTo("korte"));
// ps.Sorba("korte"); // Assert.That(ps.Sorbol(), Is.EqualTo("dio"));
// ps.Sorba("birsalma"); // Assert.That(ps.Sorbol(), Is.EqualTo("birsalma"));
// ps.Sorba("barack"); // Assert.That(ps.Sorbol(), Is.EqualTo("barack"));
// ps.Sorba("dio"); // Assert.That(ps.Sorbol(), Is.EqualTo("alma"));
// Assert.AreEqual("oszibarack", ps.Sorbol()); // });
// Assert.AreEqual("korte", ps.Sorbol()); // }
// Assert.AreEqual("dio", ps.Sorbol());
// Assert.AreEqual("birsalma", ps.Sorbol()); // /// <summary>
// Assert.AreEqual("barack", ps.Sorbol()); // /// Van egy saját hossz alapú rendező függvény, ezért elsőként a leghosszabb stringeket adja vissza.
// Assert.AreEqual("alma", ps.Sorbol()); // /// </summary>
// } // [TestCase]
// // public void KupacEpitesSajatFuggvennyel()
// /// <summary> // {
// /// Van egy saját hossz alapú rendező függvény, ezért elsőként a leghosszabb stringeket adja vissza. // KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (ez, ennel) => ez.Length > ennel.Length);
// /// </summary> // ps.Sorba("oszibarack");
// [TestMethod()] // ps.Sorba("alma");
// public void KupacEpitesSajatFuggvennyel() //F3. // ps.Sorba("korte");
// { // ps.Sorba("birsalma");
// KupacPrioritasosSor<string> ps = new KupacPrioritasosSor<string>(10, (ez, ennel) => ez.Length > ennel.Length); // ps.Sorba("barack");
// ps.Sorba("oszibarack"); // ps.Sorba("dio");
// ps.Sorba("alma"); // Assert.Multiple(() =>
// ps.Sorba("korte"); // {
// ps.Sorba("birsalma"); // Assert.That(ps.Sorbol(), Is.EqualTo("oszibarack"));
// ps.Sorba("barack"); // Assert.That(ps.Sorbol(), Is.EqualTo("birsalma"));
// ps.Sorba("dio"); // Assert.That(ps.Sorbol(), Is.EqualTo("barack"));
// Assert.AreEqual("oszibarack", ps.Sorbol()); // Assert.That(ps.Sorbol(), Is.EqualTo("korte"));
// Assert.AreEqual("birsalma", ps.Sorbol()); // Assert.That(ps.Sorbol(), Is.EqualTo("alma"));
// Assert.AreEqual("barack", ps.Sorbol()); // Assert.That(ps.Sorbol(), Is.EqualTo("dio"));
// Assert.AreEqual("korte", ps.Sorbol()); // });
// Assert.AreEqual("alma", ps.Sorbol()); // }
// Assert.AreEqual("dio", ps.Sorbol()); // }
// }
// } // [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 NUnit.Framework;
// using OE.ALGA.Adatszerkezetek; //using OE.ALGA.Adatszerkezetek;
//
// namespace OE.ALGA.Tesztek //namespace OE.ALGA.Tesztek.Adatszerkezetek
// { //{
// [TestClass] // [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Csúcs Mátrix Súlyozott Gráf Tesztek")]
// public class CsucsMatrixSulyozottGrafTesztek // public class CsucsMatrixSulyozottGrafTesztek
// { // {
// [TestMethod] // [TestCase]
// public void MindenCsucsTeszt() //F2. // public void MindenCsucsTeszt()
// { // {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2); // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
// Assert.IsTrue(csg.Csucsok.Eleme(0)); // Assert.Multiple(() =>
// Assert.IsTrue(csg.Csucsok.Eleme(1)); // {
// } // Assert.That(csg.Csucsok.Eleme(0), Is.True);
// // Assert.That(csg.Csucsok.Eleme(1), Is.True);
// [TestMethod] // });
// public void MindenElTeszt() //F2. // }
// {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3); // [TestCase]
// csg.UjEl(0, 1, 1.0f); // public void MindenElTeszt()
// csg.UjEl(0, 2, 2.0f); // {
// csg.UjEl(1, 2, 3.0f); // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// // csg.UjEl(0, 1, 1.0f);
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 0, 0.0f))); // csg.UjEl(0, 2, 2.0f);
// Assert.IsTrue(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 1.0f))); // csg.UjEl(1, 2, 3.0f);
// Assert.IsTrue(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 2.0f)));
// // Assert.Multiple(() =>
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 0, 0.0f))); // {
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 1, 0.0f))); // Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(0, 0, 0.0f)), Is.False);
// Assert.IsTrue(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 3.0f))); // 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.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 0, 0.0f)));
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 1, 0.0f))); // Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(1, 0, 0.0f)), Is.False);
// Assert.IsFalse(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 2, 0.0f))); // 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);
//
// [TestMethod] // Assert.That(csg.Elek.Eleme(new SulyozottEgeszGrafEl(2, 0, 0.0f)), Is.False);
// public void VezetElTeszt() //F2. // 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);
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2); // });
// Assert.IsFalse(csg.VezetEl(0, 1)); // }
// csg.UjEl(0, 1, 1.0f);
// Assert.IsTrue(csg.VezetEl(0, 1)); // [TestCase]
// Assert.IsFalse(csg.VezetEl(1, 0)); // public void VezetElTeszt()
// } // {
// // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(2);
// [TestMethod] // Assert.That(csg.VezetEl(0, 1), Is.False);
// public void SzomszedsagTeszt() //F2. // csg.UjEl(0, 1, 1.0f);
// { // Assert.Multiple(() =>
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3); // {
// csg.UjEl(0, 1, 1.0f); // Assert.That(csg.VezetEl(0, 1), Is.True);
// csg.UjEl(0, 2, 1.0f); // Assert.That(csg.VezetEl(1, 0), Is.False);
// csg.UjEl(1, 2, 1.0f); // });
// // }
// Halmaz<int> a_szomszedai = csg.Szomszedai(0);
// Halmaz<int> b_szomszedai = csg.Szomszedai(1); // [TestCase]
// Halmaz<int> c_szomszedai = csg.Szomszedai(2); // public void SzomszedsagTeszt()
// // {
// Assert.IsFalse(a_szomszedai.Eleme(0)); // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// Assert.IsTrue(a_szomszedai.Eleme(1)); // csg.UjEl(0, 1, 1.0f);
// Assert.IsTrue(a_szomszedai.Eleme(2)); // csg.UjEl(0, 2, 1.0f);
// // csg.UjEl(1, 2, 1.0f);
// Assert.IsFalse(b_szomszedai.Eleme(0));
// Assert.IsFalse(b_szomszedai.Eleme(1)); // Halmaz<int> a_szomszedai = csg.Szomszedai(0);
// Assert.IsTrue(b_szomszedai.Eleme(2)); // Halmaz<int> b_szomszedai = csg.Szomszedai(1);
// // Halmaz<int> c_szomszedai = csg.Szomszedai(2);
// Assert.IsFalse(c_szomszedai.Eleme(0));
// Assert.IsFalse(c_szomszedai.Eleme(1)); // Assert.Multiple(() =>
// Assert.IsFalse(c_szomszedai.Eleme(2)); // {
// } // Assert.That(a_szomszedai.Eleme(0), Is.False);
// // Assert.That(a_szomszedai.Eleme(1), Is.True);
// [TestMethod] // Assert.That(a_szomszedai.Eleme(2), Is.True);
// [ExpectedException(typeof(NincsElKivetel))]
// public void NemLetezoElTeszt() //F2. // Assert.That(b_szomszedai.Eleme(0), Is.False);
// { // Assert.That(b_szomszedai.Eleme(1), Is.False);
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3); // Assert.That(b_szomszedai.Eleme(2), Is.True);
// csg.UjEl(0, 1, 1.0f);
// csg.UjEl(0, 2, 1.0f); // Assert.That(c_szomszedai.Eleme(0), Is.False);
// csg.Suly(1, 0); // Assert.That(c_szomszedai.Eleme(1), Is.False);
// } // Assert.That(c_szomszedai.Eleme(2), Is.False);
// // });
// [TestMethod] // }
// public void ElSulyTeszt() //F2.
// { // [TestCase]
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3); // public void NemLetezoElTeszt()
// csg.UjEl(0, 1, 2.0f); // {
// csg.UjEl(0, 2, 3.0f); // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// float szum = 0.0f; // csg.UjEl(0, 1, 1.0f);
// csg.Elek.Bejar(x => szum += csg.Suly(x.Honnan, x.Hova)); // csg.UjEl(0, 2, 1.0f);
// Assert.AreEqual(5.0f, szum); // Assert.Throws<NincsElKivetel>(() => csg.Suly(1, 0));
// } // }
// }
// // [TestCase]
// [TestClass] // public void ElSulyTeszt()
// public class GrafUtkeresesTesztek // {
// { // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// [TestMethod] // csg.UjEl(0, 1, 2.0f);
// public void DijkstraKicsiGrafTeszt() //F3. // csg.UjEl(0, 2, 3.0f);
// { // float szum = 0.0f;
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3); // csg.Elek.Bejar(x => szum += csg.Suly(x.Honnan, x.Hova));
// csg.UjEl(0, 1, 10.0f); // Assert.That(szum, Is.EqualTo(5.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)); // [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Min Feszítőfa Tesztek")]
// Assert.AreEqual(20.0f, hossz.Kiolvas(2)); // public class GrafMinFeszitofaTesztek
// // {
// csg.UjEl(1, 2, 5.0f); // [TestCase]
// hossz = Utkereses.Dijkstra(csg, 0); // public void KisPrimTeszt()
// Assert.AreEqual(0.0f, hossz.Kiolvas(0)); // {
// Assert.AreEqual(10.0f, hossz.Kiolvas(1)); // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// Assert.AreEqual(15.0f, hossz.Kiolvas(2)); // csg.UjEl(0, 1, 10.0f);
// } // csg.UjEl(0, 2, 20.0f);
// // csg.UjEl(1, 2, 5.0f);
// [TestMethod] // Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
// public void DijkstraJegyzetGrafTeszt() //F3. // Assert.Multiple(() =>
// { // {
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(7); // Assert.That(elek.Kiolvas(1), Is.EqualTo(0));
// csg.UjEl(0, 1, 1.0f); // Assert.That(elek.Kiolvas(2), Is.EqualTo(1));
// csg.UjEl(0, 3, 2.0f); // });
// csg.UjEl(0, 4, 4.0f); // }
//
// csg.UjEl(1, 0, 1.0f); // [TestCase]
// csg.UjEl(1, 3, 2.0f); // public void NagyPrimTeszt()
// csg.UjEl(1, 2, 9.0f); // {
// // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
// csg.UjEl(2, 1, 9.0f); // csg.UjEl(0, 1, 5.0f);
// csg.UjEl(2, 3, 5.0f); // csg.UjEl(0, 3, 4.0f);
// csg.UjEl(2, 5, 1.0f);
// // csg.UjEl(1, 0, 5.0f);
// csg.UjEl(3, 0, 2.0f); // csg.UjEl(1, 3, 2.0f);
// csg.UjEl(3, 1, 2.0f); // csg.UjEl(1, 2, 1.0f);
// csg.UjEl(3, 2, 5.0f);
// csg.UjEl(3, 5, 3.0f); // csg.UjEl(2, 1, 1.0f);
// // csg.UjEl(2, 3, 3.0f);
// csg.UjEl(5, 2, 1.0f); // csg.UjEl(2, 4, 4.0f);
// csg.UjEl(5, 3, 3.0f);
// csg.UjEl(5, 6, 3.0f); // csg.UjEl(3, 0, 4.0f);
// // csg.UjEl(3, 1, 2.0f);
// csg.UjEl(6, 5, 3.0f); // csg.UjEl(3, 2, 3.0f);
// // csg.UjEl(3, 4, 1.0f);
// Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 1);
// Assert.AreEqual(1.0f, hossz.Kiolvas(0)); // csg.UjEl(4, 2, 4.0f);
// Assert.AreEqual(0.0f, hossz.Kiolvas(1)); // csg.UjEl(4, 3, 1.0f);
// Assert.AreEqual(6.0f, hossz.Kiolvas(2));
// Assert.AreEqual(2.0f, hossz.Kiolvas(3)); // Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0);
// Assert.AreEqual(5.0f, hossz.Kiolvas(4)); // float sum = 0.0f;
// Assert.AreEqual(5.0f, hossz.Kiolvas(5)); // csg.Csucsok.Bejar(x =>
// Assert.AreEqual(8.0f, hossz.Kiolvas(6)); // {
// } // if (x != 0)
// } // {
// // int p = elek.Kiolvas(x);
// [TestClass] // sum += csg.Suly(p, x);
// public class GrafMininmalisFeszitofaTesztek // }
// { // }
// [TestMethod] // );
// public void KisPrimTeszt() //F4.(a) // Assert.That(sum, Is.EqualTo(8.0f));
// { // }
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// csg.UjEl(0, 1, 10.0f); // [TestCase]
// csg.UjEl(0, 2, 20.0f); // public void KisKruskalTeszt()
// csg.UjEl(1, 2, 5.0f); // {
// Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0); // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// Assert.AreEqual(0, elek.Kiolvas(1)); // csg.UjEl(0, 1, 10.0f);
// Assert.AreEqual(1, elek.Kiolvas(2)); // csg.UjEl(0, 2, 20.0f);
// } // csg.UjEl(1, 2, 5.0f);
// // Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
// [TestMethod] // Assert.Multiple(() =>
// public void NagyPrimTeszt() //F4.(a) // {
// { // Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 10.0f)), Is.True);
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5); // Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 20.0f)), Is.False);
// csg.UjEl(0, 1, 5.0f); // Assert.That(elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 5.0f)), Is.True);
// csg.UjEl(0, 3, 4.0f); // });
// // }
// csg.UjEl(1, 0, 5.0f);
// csg.UjEl(1, 3, 2.0f); // [TestCase]
// csg.UjEl(1, 2, 1.0f); // public void NagyKruskalTeszt()
// // {
// csg.UjEl(2, 1, 1.0f); // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5);
// csg.UjEl(2, 3, 3.0f); // csg.UjEl(0, 1, 5.0f);
// csg.UjEl(2, 4, 4.0f); // csg.UjEl(0, 3, 4.0f);
//
// csg.UjEl(3, 0, 4.0f); // csg.UjEl(1, 0, 5.0f);
// csg.UjEl(3, 1, 2.0f); // csg.UjEl(1, 3, 2.0f);
// csg.UjEl(3, 2, 3.0f); // csg.UjEl(1, 2, 1.0f);
// csg.UjEl(3, 4, 1.0f);
// // csg.UjEl(2, 1, 1.0f);
// csg.UjEl(4, 2, 4.0f); // csg.UjEl(2, 3, 3.0f);
// csg.UjEl(4, 3, 1.0f); // csg.UjEl(2, 4, 4.0f);
//
// Szotar<int, int> elek = FeszitofaKereses.Prim(csg, 0); // csg.UjEl(3, 0, 4.0f);
// float sum = 0.0f; // csg.UjEl(3, 1, 2.0f);
// csg.Csucsok.Bejar(x => // csg.UjEl(3, 2, 3.0f);
// { // csg.UjEl(3, 4, 1.0f);
// if (x != 0)
// { // csg.UjEl(4, 2, 4.0f);
// int p = elek.Kiolvas(x); // csg.UjEl(4, 3, 1.0f);
// sum += csg.Suly(p, x);
// } // Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg);
// } // float sum = 0.0f;
// ); // elek.Bejar(x =>
// Assert.AreEqual(8.0f, sum); // {
// } // sum += x.Suly;
// // }
// [TestMethod] // );
// public void KisKruskalTeszt() //F4.(b) // Assert.That(sum, Is.EqualTo(8.0f));
// { // }
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3); // }
// csg.UjEl(0, 1, 10.0f);
// csg.UjEl(0, 2, 20.0f); // [TestFixture(Category = "Adatszerkezetek", TestName = "12 - Gráf Útkeresés Tesztek")]
// csg.UjEl(1, 2, 5.0f); // public class GrafUtkeresesTesztek
// Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg); // {
// Assert.IsTrue(elek.Eleme(new SulyozottEgeszGrafEl(0, 1, 10.0f))); // [TestCase]
// Assert.IsFalse(elek.Eleme(new SulyozottEgeszGrafEl(0, 2, 20.0f))); // public void DijkstraKicsiGrafTeszt()
// Assert.IsTrue(elek.Eleme(new SulyozottEgeszGrafEl(1, 2, 5.0f))); // {
// } // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(3);
// // csg.UjEl(0, 1, 10.0f);
// [TestMethod] // csg.UjEl(0, 2, 20.0f);
// public void NagyKruskalTeszt() //F4.(b) // Szotar<int, float> hossz = Utkereses.Dijkstra(csg, 0);
// { // Assert.Multiple(() =>
// CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(5); // {
// csg.UjEl(0, 1, 5.0f); // Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
// csg.UjEl(0, 3, 4.0f); // Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
// // Assert.That(hossz.Kiolvas(2), Is.EqualTo(20.0f));
// csg.UjEl(1, 0, 5.0f); // });
// csg.UjEl(1, 3, 2.0f);
// csg.UjEl(1, 2, 1.0f); // csg.UjEl(1, 2, 5.0f);
// // hossz = Utkereses.Dijkstra(csg, 0);
// csg.UjEl(2, 1, 1.0f); // Assert.Multiple(() =>
// csg.UjEl(2, 3, 3.0f); // {
// csg.UjEl(2, 4, 4.0f); // Assert.That(hossz.Kiolvas(0), Is.EqualTo(0.0f));
// // Assert.That(hossz.Kiolvas(1), Is.EqualTo(10.0f));
// csg.UjEl(3, 0, 4.0f); // Assert.That(hossz.Kiolvas(2), Is.EqualTo(15.0f));
// csg.UjEl(3, 1, 2.0f); // });
// csg.UjEl(3, 2, 3.0f); // }
// csg.UjEl(3, 4, 1.0f);
// // [TestCase]
// csg.UjEl(4, 2, 4.0f); // public void DijkstraJegyzetGrafTeszt()
// csg.UjEl(4, 3, 1.0f); // {
// // CsucsmatrixSulyozottEgeszGraf csg = new CsucsmatrixSulyozottEgeszGraf(7);
// Halmaz<SulyozottEgeszGrafEl> elek = FeszitofaKereses.Kruskal(csg); // csg.UjEl(0, 1, 1.0f);
// float sum = 0.0f; // csg.UjEl(0, 3, 2.0f);
// elek.Bejar(x => // csg.UjEl(0, 4, 4.0f);
// {
// sum += x.Suly; // csg.UjEl(1, 0, 1.0f);
// } // csg.UjEl(1, 3, 2.0f);
// ); // csg.UjEl(1, 2, 9.0f);
// Assert.AreEqual(8.0f, sum);
// } // 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> <PropertyGroup>
<TargetFramework>net8.0</TargetFramework> <TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings> <ImplicitUsings>disable</ImplicitUsings>
<Nullable>enable</Nullable> <Nullable>enable</Nullable>
<SatelliteResourceLanguages>en</SatelliteResourceLanguages>
<IsPackable>false</IsPackable> <IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject> <IsTestProject>true</IsTestProject>
<RootNamespace>OE.ALGA.Tesztek</RootNamespace>
</PropertyGroup> </PropertyGroup>
<ItemGroup> <ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" /> <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
<PackageReference Include="MSTest.TestAdapter" Version="3.0.4" /> <PackageReference Include="NUnit" Version="4.4.0" />
<PackageReference Include="MSTest.TestFramework" Version="3.0.4" /> <PackageReference Include="NUnit.Analyzers" Version="4.10.0">
<PackageReference Include="coverlet.collector" Version="6.0.0" /> <PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="NUnit3TestAdapter" Version="5.1.0" />
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ProjectReference Include="..\ALGA\ALGA.csproj" /> <ProjectReference Include="..\ALGA\ALGA.csproj" />
</ItemGroup> </ItemGroup>
<ItemGroup>
<Using Include="NUnit.Framework" />
</ItemGroup>
</Project> </Project>