#include "a_lolly_test.hpp"
#include "string.hpp"
#include "tm_ostream.hpp"

Include dependency graph for tm_ostream_test.cpp:

Functions
bool	test_same (tm_ostream &a, tm_ostream &b)

bool	test_same (tm_ostream &a, string b)

TEST_MEMORY_LEAK_INIT	TEST_CASE ("function is_writable")

	TEST_CASE ("function write and unbuffer")

	TEST_CASE ("function redirect")

	TEST_CASE ("operator <<")

	TEST_CASE ("cout/cerr")

Detailed Description

Copyright: GPLv3

A unitest for tm_ostream.

Author: Paradisuman

Date: 2023

Definition in file tm_ostream_test.cpp.

Function Documentation

◆ test_same() [1/2]

bool test_same	(	tm_ostream &	a,
		tm_ostream &	b )

Definition at line 13 of file tm_ostream_test.cpp.

                                         {
  string sa= a.unbuffer ();
  string sb= b.unbuffer ();
 
  return sa == sb;
}

◆ test_same() [2/2]

bool test_same	(	tm_ostream &	a,
		string	b )

Definition at line 21 of file tm_ostream_test.cpp.

                                    {
  string sa= a.unbuffer ();
 
  return sa == b;
}

◆ TEST_CASE() [1/5]

TEST_MEMORY_LEAK_INIT TEST_CASE ( "function is_writable" )

Definition at line 29 of file tm_ostream_test.cpp.

                                   {
  tm_ostream t;
  CHECK (t->is_writable () == true);
 
  t.buffer ();
  CHECK (t->is_writable () == true);
}

◆ TEST_CASE() [2/5]

TEST_CASE ( "function write and unbuffer" )

Definition at line 37 of file tm_ostream_test.cpp.

                                          {
  tm_ostream t;
 
  t.buffer ();
  t->write ("abc");
  CHECK (test_same (t, "abc"));
 
  t.buffer ();
  t->write ("abc");
  t->write ("1234");
  CHECK (test_same (t, "abc1234"));
}

◆ TEST_CASE() [3/5]

TEST_CASE ( "function redirect" )

Definition at line 50 of file tm_ostream_test.cpp.

                                {
  tm_ostream t;
 
  SUBCASE ("redirect itself") {
    auto tem= t;
    t.redirect (t);
    CHECK (t.rep == tem.rep);
  }
 
  SUBCASE ("redirect others") {
    tm_ostream t2;
    t.redirect (t2);
 
    CHECK (t.rep == t2.rep);
  }
}

◆ TEST_CASE() [4/5]

TEST_CASE ( "operator <<" )

Definition at line 67 of file tm_ostream_test.cpp.

                          {
  tm_ostream t1;
  t1.buffer ();
  tm_ostream t2;
  t2.buffer ();
 
  SUBCASE ("test bool") {
    t1 << true;
    t2 << false;
    CHECK (test_same (t1, "true"));
    CHECK (test_same (t2, "false"));
  }
 
  SUBCASE ("test char") {
    char val = 'A';
    char val2= '1';
    t1 << val;
    t2 << val2;
    CHECK (test_same (t1, "A"));
    CHECK (test_same (t2, "1"));
  }
 
  SUBCASE ("test short") {
    short val= 123;
    t1 << val;
    CHECK (test_same (t1, "123"));
 
    short val_neg= -123;
    t2 << val_neg;
    CHECK (test_same (t2, "-123"));
  }
 
  SUBCASE ("test float") {
    float val= 3.14f;
    t1 << val;
    CHECK (test_same (t1, "3.14"));
 
    float val_neg= -3.14f;
    t2 << val_neg;
    CHECK (test_same (t2, "-3.14"));
  }
 
  SUBCASE ("test double") {
    double val= 3.14159265;
    t1 << val;
    CHECK (test_same (t1, "3.14159"));
 
    double val_neg= -3.14159265;
    t2 << val_neg;
    CHECK (test_same (t2, "-3.14159"));
  }
 
  SUBCASE ("test int") {
    int val= 1000;
    t1 << val;
    CHECK (test_same (t1, "1000"));
 
    int val_neg= -1000;
    t2 << val_neg;
    CHECK (test_same (t2, "-1000"));
  }
 
  SUBCASE ("test unsigned int") {
    unsigned int val= 2000;
    t1 << val;
    CHECK (test_same (t1, "2000"));
  }
 
  SUBCASE ("test long") {
    long val= 3000000L;
    t1 << val;
    CHECK (test_same (t1, "3000000"));
 
    long val_neg= -3000000L;
    t2 << val_neg;
    CHECK (test_same (t2, "-3000000"));
  }
 
  SUBCASE ("test unsigned long") {
    unsigned long val= 4000000UL;
    t1 << val;
    CHECK (test_same (t1, "4000000"));
  }
 
  SUBCASE ("test long long int") {
    long long int val= 50000000000LL;
    t1 << val;
    CHECK (test_same (t1, "50000000000"));
 
    long long int val_neg= -50000000000LL;
    t2 << val_neg;
    CHECK (test_same (t2, "-50000000000"));
  }
 
  SUBCASE ("test unsigned long long int") {
    unsigned long long int val= 60000000000ULL;
    t1 << val;
    CHECK (test_same (t1, "60000000000"));
  }
 
  SUBCASE ("test long double") {
    long double val= 3.141592653589793238L;
    t1 << val;
    CHECK (test_same (t1, "3.14159"));
 
    long double val_neg= -3.141592653589793238L;
    t2 << val_neg;
    CHECK (test_same (t2, "-3.14159"));
  }
 
  SUBCASE ("test const char*") {
    const char* val= "Hello, world!";
    t1 << val;
    CHECK (test_same (t1, "Hello, world!"));
  }
}

◆ TEST_CASE() [5/5]

TEST_CASE ( "cout/cerr" )

Definition at line 184 of file tm_ostream_test.cpp.

                        {
  cout << "Lolly" << LF;
  cout << "棒棒糖" << LF;
  cerr << "Lolly" << LF;
  cerr << "棒棒糖" << LF;
}

Functions