update gtest, mem, main

cc9ffe80 · Zoltan Karsa · 7f2601ad · cc9ffe80 · cc9ffe80 · cc9ffe80
Commit cc9ffe80 authored Jan 22, 2023 by Zoltan Karsa
Hide whitespace changes
Inline Side-by-side

Showing with 163 additions and 53 deletions

gtest_lite.h
+101 -10

memtrace.cpp
+11 -3

memtrace.h
+23 -3

vektorMain.cpp
+28 -37

No files found.
--- a/gtest_lite.h
+++ b/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
 *
 * 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
@@ -159,7 +205,7 @@ inline void hasMember(...) {}
 /// Segédsablon típuskonverzió futás közbeni ellenőrzésere
 template <typename F, typename T>
 struct _Is_Types {
-    template<typename D> static char (&f(D*))[1];
+    template<typename D> static char (&f(D))[1];
    template<typename D> static char (&f(...))[2];
    static bool const convertable = sizeof(f<T>(F())) == 1;
 };
@@ -174,6 +220,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;      \
@@ -243,6 +296,8 @@ public:
    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) {
@@ -311,6 +366,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 T1, typename T2>
@@ -323,6 +401,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 T1, typename T2>
 bool ne(T1 a, T2 b) { return a != b; }

--- a/memtrace.cpp
+++ b/memtrace.cpp
@@ -131,9 +131,9 @@ START_NAMESPACE
 		unsigned int s, o;
        if (can_len > 0)
-            fprintf(fp, "Dump (addr: %p kanari hossz: %d):\n", m+can_len, (int)can_len);
+            fprintf(fp, "Dump (addr: %p kanari hossz: %d):\n", (void*) (m+can_len), (int)can_len);
        else
-            fprintf(fp, "Dump: (addr: %p) \n", m);
+            fprintf(fp, "Dump: (addr: %p) \n", (void*) m);
 		size += 2*can_len;
 		for (s = 0; s < (size+15)/16; s++) {
 			fprintf(fp, "%04x:%c ", s*16, s*16 < can_len || s*16 >= size-can_len ? ' ' : '*');
@@ -167,7 +167,7 @@ START_NAMESPACE
        #endif
 		fprintf(fperror,"%s\n",msg);
 		if (p) {
-			fprintf(fperror, "\tPointer:\t%p", PU(p));
+			fprintf(fperror, "\tPointer:\t%p", (void*) PU(p));
 			if (size) fprintf(fperror," (%d byte)", (int)size);
 			fprintf(fperror,"\n");
 		}
@@ -487,7 +487,15 @@ void operator delete(void * p) THROW_NOTHING {
 void operator delete[](void * p) THROW_NOTHING {
 	memtrace::traced_delete(p,FDELETEARR);
 }
+#if __cplusplus >= 201402L
+void operator delete(void * p, size_t) THROW_NOTHING {
+	memtrace::traced_delete(p,FDELETE);
+}
+void operator delete[](void * p, size_t) THROW_NOTHING {
+	memtrace::traced_delete(p,FDELETEARR);
+}
+#endif
 /* Visual C++ 2012 miatt kell, mert háklis, hogy nincs megfelelő delete, bár senki sem használja */
 void operator delete(void * p, int, const char *) THROW_NOTHING {

--- a/memtrace.h
+++ b/memtrace.h
@@ -5,7 +5,7 @@ Keszitette: Peregi Tamas, BME IIT, 2011
 Kanari:     Szeberenyi Imre, 2013.,
 VS 2012:    Szeberényi Imre, 2015.,
 mem_dump:   2016.
-inclue-ok:  2017., 2018. 2019.
+inclue-ok:  2017., 2018., 2019., 2021.
 *********************************/
 #ifndef MEMTRACE_H
@@ -153,6 +153,17 @@ END_NAMESPACE
 	#include <map>
 	#include <algorithm>
 	#include <functional>
+	#include <memory>
+	#include <iomanip>
+	#include <locale>
+	#include <typeinfo>
+	#include <ostream>
+	#include <stdexcept>
+	#include <ctime>
+    #if __cplusplus >= 201103L
+        #include <iterator>
+        #include <regex>
+    #endif
 #endif
 #ifdef MEMTRACE_CPP
 	namespace std {
@@ -178,7 +189,7 @@ START_NAMESPACE
 	#define realloc(old,size) TRACEC(traced_realloc)(old,size,#size,__LINE__,__FILE__)
 	void * traced_realloc(void * old, size_t size, const char *size_txt, int line, const char * file);
-	void mem_dump(void const *mem, size_t size, FILE* fp);
+	void mem_dump(void const *mem, size_t size, FILE* fp = stdout);
 END_NAMESPACE
@@ -200,6 +211,12 @@ void * operator new[](size_t size) THROW_BADALLOC;
 void operator delete(void * p)  THROW_NOTHING;
 void operator delete[](void * p) THROW_NOTHING;
+#if __cplusplus >= 201402L
+// sized delete miatt: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3536.html
+void operator delete(void * p, size_t)  THROW_NOTHING;
+void operator delete[](void * p, size_t) THROW_NOTHING;
+#endif
 /* Visual C++ 2012 miatt kell, mert háklis, hogy nincs megfelelő delete, bár senki sem használja */
 void operator delete(void *p, int, const char *) THROW_NOTHING;
 void operator delete[](void *p, int, const char *) THROW_NOTHING;
@@ -215,5 +232,8 @@ void operator delete[](void *p, int, const char *) THROW_NOTHING;
 #endif /*MEMTRACE_CPP*/
 #endif /*FROM_MEMTRACE_CPP*/
-#endif /*MEMCHECK*/
+#else
+#pragma message ( "MEMTRACE NOT DEFINED" )
+#endif /*MEMTRACE*/
 #endif /*MEMTRACE_H*/
--- a/vektorMain.cpp
+++ b/vektorMain.cpp
@@ -133,7 +133,15 @@ void test_2() {
    Vektor v;
    cout << "v merete: "<< v.size() << endl;
    cout << "v[0] = " << v[0] << endl;
-    v[-1];  // szép kis kivételt generálunk, hogy megtudjuk a neptun kódját
+    TEST(Kivetelek, Caesar/MyCipher) {
+      try {
+        EXPECT_THROW_THROW(v[-1], const char* p);
+      } catch (const char *p) {
+        #ifdef CPORTA
+        EXPECT_ENVCASEEQ("ORG_ID", p);
+        #endif
+      }
+    } END
 }
 //
@@ -151,12 +159,18 @@ void test_3() {
        EXPECT_NO_THROW(v3[i]); // nem várunk kivételt
        EXPECT_EQ(2, v3[i]);    // minden eleme 2
      }
-      EXPECT_THROW(v3[6], const char *);  // túl nagy
+      try {
-      EXPECT_THROW(v3[7], const char *);  // ez is
+        EXPECT_THROW_THROW(v3[6], const char* p);
-      EXPECT_THROW(v3[-20], const char *); // túl kicsi
+      } catch (const char *p) { }
+      try {
-      // elengedünk egy kivételt a konstansra is a neptun miatt
+        EXPECT_THROW_THROW(v3[7], const char* p);
-      v3[-99];
+      } catch (const char *p) { }
+      try {
+        EXPECT_THROW_THROW(v3[-20], const char* p);
+      } catch (const char *p) { }
+      try {
+        EXPECT_THROW_THROW(v3[-99], const char* p);
+      } catch (const char *p) { }
    } END
 }
@@ -205,35 +219,12 @@ void test_4() {
 int main() {
 	// alapételmezett értékek tesztelése
-    try
+    GTINIT(std::cin);
-    {
-        Vektor v0;
+    test_1();
-        cout << "alapertelmezett ertekek: " << v0.size() << " " << v0[1] << endl;
+    test_2();
-    }
+    test_3();
-    catch (...)
-    {
+    GTEND(std::cerr);
-        cout << "alapertelmezett ertekkel valo letrehozas soran kivetel keletkezett." << endl;
-		return 1;
-    }
-    int testNr;
-    const char *prompt_txt = "Teszteset (1-4) (0: vege): ";
-    prompt(prompt_txt);
-    while (cin >> testNr && testNr != 0) {  // * 0-ig, vagy amíg tud számot olvasni
-        try {
-            switch (testNr) {
-                case 1: test_1(); break;
-                case 2: test_2(); break;
-                case 3: test_3(); break;
-                case 4: test_4(); break;
-            }
-            cout << endl;
-          } catch (const char *p) {
-            cout << p << endl << endl;
-        } catch (...) {
-            cout << "Baj van!" << endl;
-        }
-        prompt(prompt_txt);
-    }
    return 0;
 }