friss gtest_lite

3c200618 · András Bodor · c698759b · 3c200618
Commit 3c200618 authored Jul 01, 2025 by András Bodor
Show whitespace changes
Inline Side-by-side

Showing with 187 additions and 37 deletions

Komplex/gtest_lite.h
+187 -37

No files found.
--- a/Komplex/gtest_lite.h
+++ b/Komplex/gtest_lite.h
 #ifndef GTEST_LITE_H
 #define GTEST_LITE_H
 /**
- * \file gtest_lite.h  (v2)
+ * \file gtest_lite.h  (v4/2022)
 *
 * Google gtest keretrendszerhez hasonló rendszer.
 * Sz.I. 2015., 2016., 2017. (_Has_X)
- * Sz.I. 2018 (template), ENDM, ENDMsg
+ * 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, EXPECT_ param fix
+ * V.B., Sz.I. 2022 almostEQ fix,
+ * Sz.I. 2022. EXPECT_THROW fix
+ * B.A.  2025. memtrace nélkül -Wunused-variable fix
 *
 * A tesztelés legalapvetőbb funkcióit támogató függvények és makrók.
 * Nem szálbiztos megvalósítás.
 *
- * Egyetlen fájlban kell megvalósítani minden tesztesetet!
- * Csak ebből include-olható a gtest_lite.h
- * Ezen korlátozás kiküszöböléséhez sigletonnal kellene rednesen megvalósítani.
-  a test osztályt!
 *
 * Szabadon felhasználható, bővíthető.
 *
@@ -29,6 +31,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.
 */
@@ -38,10 +48,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é:
@@ -53,19 +68,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.
@@ -73,11 +88,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ó
@@ -113,9 +130,15 @@
 /// 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; } \
+    catch (exception_type &e) { gtest_lite::test.tmp = true; } \
    catch (...) { } \
    EXPECTTHROW(statement, "kivetelt dob.", "nem dobott '"#exception_type"' kivetelt.")
@@ -129,17 +152,45 @@
    catch (...) { gtest_lite::test.tmp = false; }\
    EXPECTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")
+/// 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.")
 /// 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; } \
+    catch (exception_type &e) { 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
 /// Használat:
 /// CREATE_Has_(size)
-/// ... if (Has_size<std::string>::member)...
+/// ... if (_Has_size<std::string>::member)...
 #define CREATE_Has_(X) \
 template<typename T> struct _Has_##X {  \
    struct Fallback { int X; };         \
@@ -150,6 +201,18 @@ 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(...) {}
 /// Segédsablon típuskonverzió futás közbeni ellenőrzésere
 template <typename F, typename T>
 struct _Is_Types {
@@ -168,6 +231,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;      \
@@ -197,39 +267,49 @@ 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
-    Test() :sum(0), failed(0), status(false), null("/dev/null") {}
+    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"), os(std::cout) {}
+    Test(const Test&);
+    void operator=(const Test&);
+public:
    /// Teszt kezdete
    void begin(const char *n) {
        name = n; status = true;
 #ifdef MEMTRACE
        ablocks = memtrace::allocated_blocks();
 #endif
-#ifndef CPORTA
+        os << "\n---> " << name << std::endl;
-        std::cerr << "\n---> " << name << std::endl;
-#endif // CPORTA
        ++sum;
    }
    /// Teszt vége
    std::ostream& end(bool memchk = false) {
+        (void) memchk; // Elkerülni az unused-variable warningot, ha nincs memtrace
 #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) {
@@ -241,26 +321,30 @@ struct Test {
            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)
-#endif // CPORTA
                std::cerr << "\n==== TESZT VEGE ==== HIBAS/OSSZES: " << failed << "/" << sum << std::endl;
+#endif // CPORTA
+        }
    }
 };
-/// Egyetlen statikus példány. (singletonnal szebb lenne)
+/// A statikus referencia minden fordítási egységben keletkezik, de
-static Test test;
+/// mindegyik egyetlen példányra fog hivatkozni a singleton minta miatt
+static Test& test = Test::getTest();
 /// általános sablon a várt értékhez.
-template <typename T>
+template <typename T1, typename T2>
-std::ostream& EXPECT_(T exp, T act, bool (*pred)(T, T), 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
@@ -268,14 +352,33 @@ std::ostream& EXPECT_(T exp, T act, bool (*pred)(T, T), const char *file, int li
 }
 /// pointerre specializált sablon a várt értékhez.
+template <typename T1, typename T2>
+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
+        << "\n** " << rhs << ": " << (void*) act << std::endl;
+}
+#if __cplusplus >= 201103L
+/// nullptr-re specializált sablon a várt értékhez.
 template <typename T>
-std::ostream& EXPECT_(T* exp, T* act, bool (*pred)(T*, T*), const char *file, int line,
+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
+        << "\n** " << rhs << ": " << (void*) act << std::endl;
+}
+#endif
 /// stringek összehasonlításához.
 /// azért nem spec. mert a sima EQ-ra másként kell működnie.
 inline
@@ -286,6 +389,29 @@ 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 T>
@@ -298,6 +424,19 @@ bool eqstr(const char *a, const char *b) {
    return false;
 }
+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; }
@@ -328,18 +467,29 @@ template <typename T>
 bool almostEQ(T a, T  b) {
    // eps: ha a relatív, vagy abszolút hiba ettől kisebb, akkor elfogadjuk
    T eps = 10 * std::numeric_limits<T>::epsilon(); // 10-szer a legkisebb érték
-    if (a == b) return true;
+	T diff = fabs(a - b);
-    if (fabs(a - b) < eps)
+    if (diff < eps)
       return true;
-    double aa = fabs(a);
+    T aa = fabs(a);
-    double ba = fabs(b);
+    T ba = fabs(b);
    if (aa < ba) {
        aa = ba;
        ba = fabs(a);
    }
-    return (aa - ba) < aa * eps;
+    return diff < 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