Skip to content

Prog2 / labor_peldak / lab_08

Go to a project
Commit bd70543d by Szeberényi Imre
Options

2021 update

parent 5e4881e2
Showing with 180 additions and 59 deletions
generikus1/generikus1_teszt.cpp
......@@ -6,18 +6,18 @@
*/
/**
* TESTLEVEL == 0 estén az előre elkészített Integer osztályt próbálja ki pár esetre.
* TESTLEVEL == 1 estén az Ön által elkészítendő Alaptípus osztálysablont próbálja ki.
* TESTLEVEL >= 2 esetén pedig egy egyszerű függvénysablont kell elkészítenie.
* ELKESZULT == 0 estén az előre elkészített Integer osztályt próbálja ki pár esetre.
* ELKESZULT == 1 estén az Ön által elkészítendő Alaptípus osztálysablont próbálja ki.
* ELKESZULT >= 2 esetén pedig egy egyszerű függvénysablont kell elkészítenie.
*/
#define TESTLEVEL 0
#define ELKESZULT 0
#include <iostream>
#include "integer.h"
#if TESTLEVEL > 0
#if ELKESZULT > 0
# include "alaptipus.hpp"
#endif // TESTLEVEL > 0
#endif // ELKESZULT > 0
/// Korábban használt makró, ami kiírja a paramétereit, majd változtatás nélkül kigenerálja azokat.
/// A kiírást egy tabulátorral kezdi és soremeléssel zárja.
......@@ -26,7 +26,7 @@
#define _(...) std::cout << "\t" << #__VA_ARGS__ << std::endl; __VA_ARGS__
/// Ebből a függvényből kell sablont készíteni TESTLEVEL >= 2 esetén (l. útmutató)
/// Ebből a függvényből kell sablont készíteni ELKESZULT >= 2 esetén (l. útmutató)
void kiir(Integer* first, Integer* last, std::ostream& os = std::cout) {
while (first != last)
os << *first++ << ' ';
......@@ -34,9 +34,9 @@ void kiir(Integer* first, Integer* last, std::ostream& os = std::cout) {
}
int main() {
#if TESTLEVEL >= 0
#if ELKESZULT >= 0
{ // blokk kezdete így a nevek lokálisak maradnak
std::cout << "\nTESTLEVEL >= 0\n";
std::cout << "\nELKESZULT >= 0\n";
/// Csak az Integer osztályt mutatja be.
/// Értse meg az osztály működését és használatát!
......@@ -65,12 +65,12 @@ _( Integer t[] = { 1, 2, 4, 8, 10} ; )
_( kiir(t, t+5); )
} // blokk vége
#endif // TESTLEVEL >= 0
#endif // ELKESZULT >= 0
#if TESTLEVEL >= 1
#if ELKESZULT >= 1
{ // blokk kezdete így a nevek lokálisak maradnak
std::cout << "\nTESTLEVEL >= 1\n";
std::cout << "\nELKESZULT >= 1\n";
/// Az Alaptípus sablont példányosítjuk double típusra.
_( Alaptipus<double> a; )
......@@ -81,13 +81,13 @@ _( std::cout << b / 10 << std::endl; )
_( Alaptipus<double> t[] = { 1.1, 2.2, 4.4, 8.8};)
#if TESTLEVEL >= 2
std::cout << "\nTESTLEVEL >= 2\n";
#if ELKESZULT >= 2
std::cout << "\nELKESZULT >= 2\n";
_( kiir(t, t+4); )
#endif // TESTLEVEL >= 2
#endif // ELKESZULT >= 2
} // blokk vége
#endif // TESTLEVEL >= 1
#endif // ELKESZULT >= 1
return 0;
}
......
halmaz/gtest_lite.h
......@@ -8,6 +8,8 @@
* Sz.I. 2015., 2016., 2017. (_Has_X)
* Sz.I. 2018 (template), ENDM, ENDMsg, nullptr_t
* Sz.I. 2019 singleton
* Sz.I. 2021 ASSERT.., STRCASE...
* Sz.I. 2021 EXPEXT_REGEXP, CREATE_Has_fn_, cmp w. NULL, EXPEXT_ param fix
*
* A tesztelés legalapvetőbb funkcióit támogató függvények és makrók.
* Nem szálbiztos megvalósítás.
......@@ -26,6 +28,14 @@
* ...
* END
* ...
* // Fatális hiba esetén a teszteset nem fut tovább. Ezek az ASSERT... makrók.
* // Nem lehet a kiírásukhoz további üzenetet fűzni. PL:
* TEST(TeszEsetNeve, TesztNeve)
* ASSERT_NO_THROW(f(0)); // itt nem lehet << "duma"
* EXPECT_EQ(4, f(2)) << "A függvény hibás eredményt adott" << std::endl;
* ...
* END
* ...
*
* A működés részleteinek megértése szorgalmi feladat.
*/
......@@ -35,10 +45,15 @@
#include <cmath>
#include <cstring>
#include <limits>
#include <cstdlib>
#include <string>
#include <fstream>
#if __cplusplus >= 201103L
# include <iterator>
# include <regex>
#endif
#ifdef MEMTRACE
#include "memtrace.h"
# include "memtrace.h"
#endif
// Két makró az egyes tesztek elé és mögé:
......@@ -50,19 +65,19 @@
/// a gtest keretrendszerbe.
/// @param C - teszteset neve (csak a gtest kompatibilitás miatt van külön neve az eseteknek)
/// @param N - teszt neve
#define TEST(C, N) { gtest_lite::test.begin(#C"."#N);
#define TEST(C, N) do { gtest_lite::test.begin(#C"."#N);
/// Teszteset vége.
#define END gtest_lite::test.end(); }
#define END gtest_lite::test.end(); } while (false);
/// Teszteset vége allokált blokkok számának összehasonlításával
/// Ez az ellenőrzés nem bomba biztos.
#define ENDM gtest_lite::test.end(true); }
#define ENDM gtest_lite::test.end(true); } while (false);
/// Teszteset vége allokált blokkok számának összehasonlításával
/// Ez az ellenőrzés nem bomba biztos.
/// Ha hiba van kiírja az üzenetet.
#define ENDMsg(t) gtest_lite::test.end(true) << t << std::endl; }
#define ENDMsg(t) gtest_lite::test.end(true) << t << std::endl; } while (false);
// Eredmények vizsgálatát segítő makrók.
// A paraméterek és a funkciók a gtest keretrendszerrel megegyeznek.
......@@ -70,11 +85,13 @@
/// Sikeres teszt makrója
#define SUCCEED() gtest_lite::test.expect(true, __FILE__, __LINE__, "SUCCEED()", true)
/// Sikertelen teszt makrója
/// Sikertelen teszt fatális hiba makrója
#define FAIL() gtest_lite::test.expect(false, __FILE__, __LINE__, "FAIL()", true)
/// Azonosságot elváró makró
/// Sikertelen teszt makrója
#define ADD_FAILURE() gtest_lite::test.expect(false, __FILE__, __LINE__, "ADD_FAILURE()", true)
/// Azonosságot elváró makró
#define EXPECT_EQ(expected, actual) gtest_lite::EXPECT_(expected, actual, gtest_lite::eq, __FILE__, __LINE__, "EXPECT_EQ(" #expected ", " #actual ")" )
/// Eltérést elváró makró
......@@ -110,6 +127,12 @@
/// C stringek (const char *) eltéréset tesztelő makró
#define EXPECT_STRNE(expected, actual) gtest_lite::EXPECTSTR(expected, actual, gtest_lite::nestr, __FILE__, __LINE__, "EXPECT_STRNE(" #expected ", " #actual ")", "etalon" )
/// C stringek (const char *) azonosságát tesztelő makró (kisbetű/nagybetű azonos)
#define EXPECT_STRCASEEQ(expected, actual) gtest_lite::EXPECTSTR(expected, actual, gtest_lite::eqstrcase, __FILE__, __LINE__, "EXPECT_STRCASEEQ(" #expected ", " #actual ")" )
/// C stringek (const char *) eltéréset tesztelő makró (kisbetű/nagybetű azonos)
#define EXPECT_STRCASENE(expected, actual) gtest_lite::EXPECTSTR(expected, actual, gtest_lite::nestrcase, __FILE__, __LINE__, "EXPECT_STRCASENE(" #expected ", " #actual ")", "etalon" )
/// Kivételt várunk
#define EXPECT_THROW(statement, exception_type) try { gtest_lite::test.tmp = false; statement; } \
catch (exception_type) { gtest_lite::test.tmp = true; } \
......@@ -126,16 +149,39 @@
catch (...) { gtest_lite::test.tmp = false; }\
EXPECTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")
/// Nem várunk kivételt gtest kompatibilitás miatt
/// Nem várunk kivételt
#define ASSERT_NO_THROW(statement) try { gtest_lite::test.tmp = true; statement; } \
catch (...) { gtest_lite::test.tmp = false; }\
EXPECTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")
ASSERTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")
/// Kivételt várunk és továbbdobjuk -- ilyen nincs a gtest-ben
#define EXPECT_THROW_THROW(statement, exception_type) try { gtest_lite::test.tmp = false; statement; } \
catch (exception_type) { gtest_lite::test.tmp = true; throw; } \
EXPECTTHROW(statement, "kivetelt dob.", "nem dobott '"#exception_type"' kivetelt.")
/// Környezeti változóhoz hasonlít -- ilyen nincs a gtest-ben
#define EXPECT_ENVEQ(expected, actual) gtest_lite::EXPECTSTR(std::getenv(expected), actual, gtest_lite::eqstr, __FILE__, __LINE__, "EXPECT_ENVEQ(" #expected ", " #actual ")" )
/// Környezeti változóhoz hasonlít -- ilyen nincs a gtest-ben (kisbetű/nagybetű azonos)
#define EXPECT_ENVCASEEQ(expected, actual) gtest_lite::EXPECTSTR(std::getenv(expected), actual, gtest_lite::eqstrcase, __FILE__, __LINE__, "EXPECT_ENVCASEEQ(" #expected ", " #actual ")" )
#if __cplusplus >= 201103L
/// Reguláris kifejezés illesztése
# define EXPECT_REGEXP(expected, actual, match, err) gtest_lite::EXPECTREGEXP(expected, actual, match, err, __FILE__, __LINE__, "EXPECT_REGEXP(" #expected ", " #actual ", " #match ")" )
#endif
////--------------------------------------------------------------------------------------------
/// ASSERT típusú ellenőrzések. CSak 1-2 van megvalósítva. Nem ostream& -val térnek vissza !!!
/// Kivételt várunk
/// Azonosságot elváró makró
#define ASSERT_EQ(expected, actual) gtest_lite::ASSERT_(expected, actual, gtest_lite::eq, "ASSER_EQ")
/// Nem várunk kivételt
#define ASSERT_NO_THROW(statement) try { gtest_lite::test.tmp = true; statement; } \
catch (...) { gtest_lite::test.tmp = false; }\
ASSERTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")
/// Segédmakró egy adattag, vagy tagfüggvény létezésének tesztelésére futási időben
/// Ötlet:
/// https://cpptalk.wordpress.com/2009/09/12/substitution-failure-is-not-an-error-2
......@@ -152,6 +198,14 @@ template<typename T> struct _Has_##X { \
static bool const member = sizeof(f<Derived>(0)) == 2; \
};
#define CREATE_Has_fn_(X, S) \
template<typename R, typename T> struct _Has_fn_##X##_##S { \
template<typename C, R (C::*f)() S> struct ChT; \
template<typename D> static char (&f(ChT<D, &D::X>*))[1]; \
template<typename D> static char (&f(...))[2]; \
static bool const fn = sizeof(f<T>(0)) == 1; \
};
/// Segédfüggvény egy publikus adattag, vagy tagfüggvény létezésének tesztelésére
/// fordítási időben
inline void hasMember(...) {}
......@@ -174,6 +228,13 @@ struct _Is_Types {
<< "** Az utasitas " << (act) \
<< "\n** Azt vartuk, hogy " << (exp) << std::endl
#define ASSERTTHROW(statement, exp, act) gtest_lite::test.expect(gtest_lite::test.tmp, __FILE__, __LINE__, #statement) \
<< "** Az utasitas " << (act) \
<< "\n** Azt vartuk, hogy " << (exp) << std::endl; if (!gtest_lite::test.status) { gtest_lite::test.end(); break; }
#define ASSERT_(expected, actual, fn, op) EXPECT_(expected, actual, fn, __FILE__, __LINE__, #op "(" #expected ", " #actual ")" ); \
if (!gtest_lite::test.status) { gtest_lite::test.end(); break; }
#ifdef CPORTA
#define GTINIT(is) \
int magic; \
......@@ -203,12 +264,13 @@ struct Test {
bool tmp; ///< temp a kivételkezeléshez;
std::string name; ///< éppen futó teszt neve
std::fstream null; ///< nyelő, ha nem kell kiírni semmit
std::ostream& os; ///< ide írunk
static Test& getTest() {
static Test instance;///< egyedüli (singleton) példány
return instance;
}
private: /// singleton minta miatt
Test() :sum(0), failed(0), status(false), null("/dev/null") {}
Test() :sum(0), failed(0), status(false), null("/dev/null"), os(std::cout) {}
Test(const Test&);
void operator=(const Test&);
public:
......@@ -218,9 +280,7 @@ public:
#ifdef MEMTRACE
ablocks = memtrace::allocated_blocks();
#endif
#ifndef CPORTA
std::cerr << "\n---> " << name << std::endl;
#endif // CPORTA
os << "\n---> " << name << std::endl;
++sum;
}
/// Teszt vége
......@@ -228,21 +288,24 @@ public:
#ifdef MEMTRACE
if (memchk && ablocks != memtrace::allocated_blocks()) {
status = false;
return std::cerr << "** Lehet, hogy nem szabaditott fel minden memoriat! **" << std::endl;
return os << "** Lehet, hogy nem szabaditott fel minden memoriat! **" << std::endl;
}
#endif
os << (status ? " SIKERES" : "** HIBAS ****") << "\t" << name << " <---" << std::endl;
#ifdef CPORTA
if (!status)
#endif // CPORTA
std::cerr << (status ? " SIKERES" : "** HIBAS ****") << "\t" << name << " <---" << std::endl;
#endif // CPORTA
if (!status)
return std::cerr;
return os;
else
return null;
}
bool fail() { return failed; }
bool astatus() { return status; }
/// Eredményt adminisztráló tagfüggvény True a jó eset.
std::ostream& expect(bool st, const char *file, int line, const char *expr, bool pr = false) {
if (!st) {
......@@ -254,17 +317,20 @@ public:
size_t i = str.rfind("\\");
if (i == std::string::npos) i = str.rfind("/");
if (i == std::string::npos) i = 0; else i++;
return std::cerr << "\n**** " << &file[i] << "(" << line << "): " << expr << " ****" << std::endl;
return os << "\n**** " << &file[i] << "(" << line << "): " << expr << " ****" << std::endl;
}
return null;
}
/// Destruktor
~Test() {
if (sum != 0) {
os << "\n==== TESZT VEGE ==== HIBAS/OSSZES: " << failed << "/" << sum << std::endl;
#ifdef CPORTA
if (failed)
if (failed)
std::cerr << "\n==== TESZT VEGE ==== HIBAS/OSSZES: " << failed << "/" << sum << std::endl;
#endif // CPORTA
std::cerr << "\n==== TESZT VEGE ==== HIBAS/OSSZES: " << failed << "/" << sum << std::endl;
}
}
};
......@@ -274,7 +340,7 @@ static Test& test = Test::getTest();
/// általános sablon a várt értékhez.
template <typename T1, typename T2>
std::ostream& EXPECT_(T1 exp, T2 act, bool (*pred)(T1, T2), const char *file, int line,
std::ostream& EXPECT_(T1 exp, T2 act, bool (*pred)(T1, T1), const char *file, int line,
const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
return test.expect(pred(exp, act), file, line, expr)
<< "** " << lhs << ": " << std::boolalpha << exp
......@@ -283,7 +349,7 @@ std::ostream& EXPECT_(T1 exp, T2 act, bool (*pred)(T1, T2), const char *file, in
/// pointerre specializált sablon a várt értékhez.
template <typename T1, typename T2>
std::ostream& EXPECT_(T1* exp, T2* act, bool (*pred)(T1*, T2*), const char *file, int line,
std::ostream& EXPECT_(T1* exp, T2* act, bool (*pred)(T1*, T1*), const char *file, int line,
const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
return test.expect(pred(exp, act), file, line, expr)
<< "** " << lhs << ": " << (void*) exp
......@@ -292,8 +358,16 @@ std::ostream& EXPECT_(T1* exp, T2* act, bool (*pred)(T1*, T2*), const char *file
#if __cplusplus >= 201103L
/// nullptr-re specializált sablon a várt értékhez.
template <typename T1>
std::ostream& EXPECT_(T1* exp, std::nullptr_t act, bool (*pred)(T1*, std::nullptr_t), const char *file, int line,
template <typename T>
std::ostream& EXPECT_(std::nullptr_t exp, T* act, bool (*pred)(T*, T*), const char *file, int line,
const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
return test.expect(pred(exp, act), file, line, expr)
<< "** " << lhs << ": " << (void*) exp
<< "\n** " << rhs << ": " << (void*) act << std::endl;
}
template <typename T>
std::ostream& EXPECT_(T* exp, std::nullptr_t act, bool (*pred)(T*, T*), const char *file, int line,
const char *expr, const char *lhs = "elvart", const char *rhs = "aktual") {
return test.expect(pred(exp, act), file, line, expr)
<< "** " << lhs << ": " << (void*) exp
......@@ -311,10 +385,33 @@ std::ostream& EXPECTSTR(const char *exp, const char *act, bool (*pred)(const cha
<< "\n** " << rhs << ": " << (act == NULL ? "NULL pointer" : std::string("\"") + act + std::string("\"")) << std::endl;
}
#if __cplusplus >= 201103L
/// regexp összehasonlításhoz.
template <typename E, typename S>
int count_regexp(E exp, S str) {
std::regex rexp(exp);
auto w_beg = std::sregex_iterator(str.begin(), str.end(), rexp);
auto w_end = std::sregex_iterator();
return std::distance(w_beg, w_end);
}
template <typename E, typename S>
std::ostream& EXPECTREGEXP(E exp, S str, int match, const char *err, const char *file, int line,
const char *expr, const char *lhs = "regexp", const char *rhs = "string",
const char *m = "elvart/illeszkedik") {
int cnt = count_regexp(exp, str);
if (match < 0) match = cnt;
return test.expect(cnt == match, file, line, expr)
<< "** " << lhs << ": " << std::string("\"") + exp + std::string("\"")
<< "\n** " << rhs << ": " << (err == NULL ? std::string("\"") + str + std::string("\"") : err)
<< "\n** " << m << ": " << match << "/" << cnt << std::endl;
}
#endif
/// segéd sablonok a relációkhoz.
/// azért nem STL (algorithm), mert csak a függvény lehet, hogy menjen a deduckció
template <typename T1, typename T2>
bool eq(T1 a, T2 b) { return a == b; }
template <typename T>
bool eq(T a, T b) { return a == b; }
inline
bool eqstr(const char *a, const char *b) {
......@@ -323,8 +420,21 @@ bool eqstr(const char *a, const char *b) {
return false;
}
template <typename T1, typename T2>
bool ne(T1 a, T2 b) { return a != b; }
inline
bool eqstrcase(const char *a, const char *b) {
if (a != NULL && b != NULL) {
while (toupper(*a) == toupper(*b) && *a != '\0') {
a++;
b++;
}
return *a == *b;
}
return false;
}
template <typename T>
bool ne(T a, T b) { return a != b; }
inline
bool nestr(const char *a, const char *b) {
......@@ -333,17 +443,17 @@ bool nestr(const char *a, const char *b) {
return false;
}
template <typename T1, typename T2>
bool le(T1 a, T2 b) { return a <= b; }
template <typename T>
bool le(T a, T b) { return a <= b; }
template <typename T1, typename T2>
bool lt(T1 a, T2 b) { return a < b; }
template <typename T>
bool lt(T a, T b) { return a < b; }
template <typename T1, typename T2>
bool ge(T1 a, T2 b) { return a >= b; }
template <typename T>
bool ge(T a, T b) { return a >= b; }
template <typename T1, typename T2>
bool gt(T1 a, T2 b) { return a > b; }
template <typename T>
bool gt(T a, T b) { return a > b; }
/// Segédsablon valós számok összehasonlításához
/// Nem bombabiztos, de nekünk most jó lesz
......@@ -365,6 +475,17 @@ bool almostEQ(T a, T b) {
return (aa - ba) < aa * eps;
}
/// Segédsablon ostream átirányításához
/// A destruktor visszaállít
class ostreamRedir {
std::ostream& src;
std::streambuf *const save;
public:
ostreamRedir(std::ostream& src, std::ostream& dst)
: src(src), save(src.rdbuf(dst.rdbuf())) {}
~ostreamRedir() { src.rdbuf(save); }
};
} // namespace gtest_lite
#endif // GTEST_LITE_H
halmaz/halmaz_teszt.cpp
......@@ -11,12 +11,12 @@
* ELKESZULT == 0 estén az Ön által készített Set sablon létezését teszteli.
* ELKESZULT == 1 esetén a Set működését teszteli néhány alaptípussal.
* ELKESZULT >= 2 esetén a Set sablont a Point osztállyal teszteli.
* TESZLEVEL >= 3 esetén az Ön által készített equal sablont teszteli
* TEZSLEVEL == 4 esetén az Ön által készített equal specializációját teszteli
(Point Y koordinátája nem vesz részt a hasonlításban)
* TEZSLEVEL == 5 esetén az Ön által módosított Set sablont teszteli, ami sablon paraméterként
kapja az összehasonlító függvényt, melynek alapértelmezett értéke az equal sablon
Feltételezi, hogy van a ponthoz Xequal függvény, vagy funktor.
* ELKESZULT >= 3 esetén az Ön által készített equal sablont teszteli
* ELKESZULT == 4 esetén az Ön által készített equal specializációját teszteli
* (Point Y koordinátája nem vesz részt a hasonlításban)
* ELKESZULT == 5 esetén az Ön által módosított Set sablont teszteli, ami sablon paraméterként
* kapja az összehasonlító függvényt, melynek alapértelmezett értéke az equal sablon
* Feltételezi, hogy van a ponthoz Xequal függvény, vagy funktor.
*/
......@@ -79,9 +79,9 @@ int main() {
EXPECT_TRUE(s0.isElement(1)) << "== Betettuk, de nincs benne! ==\n";
EXPECT_TRUE(s0.isElement(2)) << "== Betettuk, de nincs benne! ==\n";
EXPECT_FALSE(s0.isElement(0)) << "== Nem tettuk be, de benne van! ==\n";
EXPECT_EQ((size_t)2, s0.size()) << "== Nem jo meretet! ***\n";
EXPECT_EQ(2, s0.size()) << "== Nem jo meretet! ***\n";
s0.insert(1);
EXPECT_EQ((size_t)2, s0.size()) << "== Azonos elem utan nem jo a meretet! ==\n";
EXPECT_EQ(2, s0.size()) << "== Azonos elem utan nem jo a meretet! ==\n";
} ENDM
/// kivétel dobás tesztelése int-re
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or sign in to comment