/home/balazs/CLionProjects/prog2/hf_naptar/gtest_lite.h fájlreferencia
`#include "../../../../../usr/lib/gcc/x86_64-pc-linux-gnu/9.2.0/include/g++-v9/iostream"`
`#include "../../../../../usr/lib/gcc/x86_64-pc-linux-gnu/9.2.0/include/g++-v9/cassert"`
`#include "../../../../../usr/lib/gcc/x86_64-pc-linux-gnu/9.2.0/include/g++-v9/cmath"`
`#include "../../../../../usr/lib/gcc/x86_64-pc-linux-gnu/9.2.0/include/g++-v9/cstring"`
`#include "../../../../../usr/lib/gcc/x86_64-pc-linux-gnu/9.2.0/include/g++-v9/limits"`
`#include "../../../../../usr/lib/gcc/x86_64-pc-linux-gnu/9.2.0/include/g++-v9/string"`
`#include "../../../../../usr/lib/gcc/x86_64-pc-linux-gnu/9.2.0/include/g++-v9/fstream"`
A gtest_lite.h definíciós fájl függési gráfja:

Ugrás a fájl forráskódjához.

## Osztályok

struct | gtest_lite::Test

## Névterek

| gtest_lite
| gtest_lite: a keretrendszer függvényinek és objektumainak névtere

## Makródefiníciók

#define | TEST(C, N) { gtest_lite::test.begin(#C"."#N);
#define | END gtest_lite::test.end(); }
| Teszteset vége.
#define | SUCCEED() gtest_lite::test.tstatus(true, __FILE__, __LINE__)
| Sikeres teszt makrója.
#define | FAIL() gtest_lite::test.tstatus(false, __FILE__, __LINE__)
| Sikertelen teszt makrója.
#define | EXPECT_EQ(expected, actual) EXPECTCMP((expected) == (actual), expected, actual)
| Azonosságot elváró makró
#define | EXPECT_NE(expected, actual) EXPECTNE((expected) != (actual), expected, actual)
| Eltérést elváró makró
#define | EXPECT_TRUE(actual) EXPECTCMP(actual, "true", actual)
| Igaz értéket elváró makró
#define | EXPECT_FALSE(actual) EXPECTCMP(!(actual), "false", actual)
| Hamis értéket elváró makró
#define | EXPECT_DOUBLE_EQ(expected, actual) EXPECTCMP(gtest_lite::almostEQ(expected, actual), expected, actual)
| Valós számok azonosságát elváró makró
#define | EXPECT_STREQ(expected, actual)
| C stringek (const char *) azonosságát tesztelő makró Részletek...
#define | EXPECT_STRNE(expected, actual)
| C stringek (const char *) eltéréset tesztelő makró Részletek...
#define | EXPECT_THROW(statement, exception_type)
| Kivételt várunk. Részletek...
#define | EXPECT_THROW_THROW(statement, exception_type)
| Kivételt várunk és továbbdobjuk – ilyen nincs a gtest-ben. Részletek...
#define | EXPECT_NO_THROW(statement)
| Nem várunk kivételt. Részletek...
#define | CREATE_Has_(X)
#define | EXPECT(expr, msg) gtest_lite::test.expect(expr, __FILE__, __LINE__, #msg)
| EXPECT: makró, hogy könnyen lecserélhető legyen. Részletek...
#define | EXPECTEXP(expr, exp, act)
| EXPECTEXP: általános kifejezés kiértékelése. Részletek...
#define | EXPECTCMP(expr, exp, act)
| EXPECTCMP: összehasonlítás. Részletek...
#define | EXPECTNE(expr, exp, act)
| EXPECTNE: összehasonlítás. Részletek...
#define | EXPECTTHROW(statement, exp, act)
| EXPECTTHROW: kivételkezelés. Részletek...
#define | GTINIT(IS)
#define | GTEND(os)

## Függvények

void | hasMember (...)
| Segédfüggvény egy publikus adattag, vagy tagfüggvény létezésének tesztelésére fordítási időben.
bool | gtest_lite::almostEQ (double a, double b)

## Részletes leírás

Google gtest keretrendszerhez hasonló rendszer. Sz.I. 2015., 2016., 2017. (_Has_X)

A tesztelés legalapvetőbb funkcióit támogató függvények és makrók. Nem szálbiztos megvalósítás. Szabadon felhasználható, bővíthető.

Használati példa: Teszteljük az f(x)=2*x függvényt: int f(int x) { return 2*x; }

int main() { TEST(TeszEsetNeve, TesztNeve) EXPECT_EQ(0, f(0)); 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.

## Makródefiníciók dokumentációja

## CREATE_Has_

#define CREATE_Has_ | ( |  | X | ) |

Érték:
template<typename T> struct Has_##X { \
struct Fallback { int X; }; \
struct Derived : T, Fallback {}; \
template<typename C, C> struct ChT; \
template<typename D> static char (&f(ChT<int Fallback::*, &D::X>*))[1]; \
template<typename D> static char (&f(...))[2]; \
static bool const member = sizeof(f<Derived>(0)) == 2; \
};

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

## EXPECT

#define EXPECT | ( |  | expr,
|  |  | msg
| ) |  | gtest_lite::test.expect(expr, __FILE__, __LINE__, #msg)

EXPECT: makró, hogy könnyen lecserélhető legyen.

Belső megvalósításhoz tartozó makrók, és osztályok.

## Nem célszerű közvetlenül használni, vagy módosítani

## EXPECT_NO_THROW

#define EXPECT_NO_THROW | ( |  | statement | ) |

Érték:
try { gtest_lite::test.tmp = true; statement; } \
catch (...) { gtest_lite::test.tmp = false; }\
EXPECTTHROW(statement, "nem dob kivetelt.", "kivetelt dobott.")

Nem várunk kivételt.

## EXPECT_STREQ

#define EXPECT_STREQ | ( |  | expected,
|  |  | actual
| ) |  |

Érték:
((actual != NULL) ? \
EXPECTCMP(strcmp(expected, actual) == 0, expected, actual) : \
EXPECT(false, "STR_EQ NULL pointert kapott!"))

C stringek (const char *) azonosságát tesztelő makró

## EXPECT_STRNE

#define EXPECT_STRNE | ( |  | expected,
|  |  | actual
| ) |  |

Érték:
((actual != NULL) ? \
EXPECTNE(strcmp(expected, actual) != 0, expected, actual) : \
EXPECT(false, "STR_EQ NULL pointert kapott!"))

C stringek (const char *) eltéréset tesztelő makró

## EXPECT_THROW

#define EXPECT_THROW | ( |  | statement,
|  |  | exception_type
| ) |  |

Érték:
try { gtest_lite::test.tmp = false; statement; } \
catch (exception_type) { gtest_lite::test.tmp = true; } \
catch (...) { } \
EXPECTTHROW(statement, "kivetelt dob.", "nem dobott '"#exception_type"' kivetelt.")

Kivételt várunk.

## EXPECT_THROW_THROW

#define EXPECT_THROW_THROW | ( |  | statement,
|  |  | exception_type
| ) |  |

Érték:
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.")

Kivételt várunk és továbbdobjuk – ilyen nincs a gtest-ben.

## EXPECTCMP

#define EXPECTCMP | ( |  | expr,
|  |  | exp,
|  |  | act
| ) |  |

Érték:
gtest_lite::test.expect(expr, __FILE__, __LINE__, #act) \
<< "**A(z) '"#act << "'kifejezes\n** erteke: " << std::boolalpha << (act) \
<< "\n** elvart: " << (exp) << std::endl

EXPECTCMP: összehasonlítás.

## EXPECTEXP

#define EXPECTEXP | ( |  | expr,
|  |  | exp,
|  |  | act
| ) |  |

Érték:
gtest_lite::test.expect(expr, __FILE__, __LINE__, #expr) \
<< "**A(z) '"#act << "'kifejezes\n** erteke: " << std::boolalpha << (act) \
<< "\n** elvart: " << (exp) << std::endl

EXPECTEXP: általános kifejezés kiértékelése.

## EXPECTNE

#define EXPECTNE | ( |  | expr,
|  |  | exp,
|  |  | act
| ) |  |

Érték:
gtest_lite::test.expect(expr, __FILE__, __LINE__, #act) \
<< "**A(z) '"#act << "'kifejezes\n** erteke: " << std::boolalpha << (act) \
<< "\n** elvart, hogy nem: " << (exp) << std::endl

EXPECTNE: összehasonlítás.

## EXPECTTHROW

#define EXPECTTHROW | ( |  | statement,
|  |  | exp,
|  |  | act
| ) |  |

Érték:
gtest_lite::test.expect(gtest_lite::test.tmp, __FILE__, __LINE__, #statement) \
<< "**Az utasitas " << (act) \
<< "\n**Azt vartuk, hogy " << (exp) << std::endl

EXPECTTHROW: kivételkezelés.

## TEST

#define TEST | ( |  | C,
|  |  | N
| ) |  | { gtest_lite::test.begin(#C"."#N);

Teszt kezdete. A makró paraméterezése hasonlít a gtest paraméterezéséhez. Így az itt elkészített testek könnyen átemelhetők a gtest keretrendszerbe.

Paraméterek

  C | - teszteset neve (csak a gtest kompatibilitás miatt van külön neve az eseteknek)
  N | - teszt neve

gtest_lite::Test::tmp
bool tmp
temp a kivételkezeléshez;
Definition: gtest_lite.h:172
EXPECT
#define EXPECT(expr, msg)
EXPECT: makró, hogy könnyen lecserélhető legyen.
Definition: gtest_lite.h:125
gtest_lite::Test::expect
std::ostream & expect(bool st, const char *file, int line, const char *expr)
Eredményt adminisztráló tagfüggvény True a jó eset.
Definition: gtest_lite.h:196
EXPECTNE
#define EXPECTNE(expr, exp, act)
EXPECTNE: összehasonlítás.
Definition: gtest_lite.h:138
EXPECTCMP
#define EXPECTCMP(expr, exp, act)
EXPECTCMP: összehasonlítás.
Definition: gtest_lite.h:133