format-cout-test.cpp

Go to the documentation of this file.

/*
  FormatCOUT(Test)  -  validate automatic string conversion in output
 
   Copyright (C)
     2016,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
* *****************************************************************/
 
#include "lib/test/run.hpp"
 
#include "lib/p.hpp"
#include "lib/diff/gen-node.hpp"
 
#include "lib/meta/util.hpp"
#include "lib/meta/trait.hpp"
#include "lib/format-cout.hpp"
 
#include <string>
 
using lib::P;
using lib::makeP;
using lib::diff::GenNode;
 
using std::string;
 
 
namespace util {
namespace test {
 
  namespace { // test fixture
    
    class Reticent
      {
        uint neigh_ = 42;
      };
    
    
    using lib::meta::is_basically;
    using lib::meta::is_StringLike;
    using lib::meta::can_lexical2string;
    using lib::meta::can_convertToString;
    using lib::meta::use_StringConversion4Stream;
    
    template<typename T>
    using BasicallyString = is_basically<T, string>;
    template<typename T>
    using BasicallyCString = std::is_convertible<T, const char*>;
    
    
#define SHOW_CHECK(_EXPR_) cout << STRINGIFY(_EXPR_) << "\t : " << (_EXPR_::value? "Yes":"No") << endl;
#define ANALYSE(_TYPE_)                     \
        cout << "Type: " STRINGIFY(_TYPE_) " ......"<<endl;   \
        SHOW_CHECK (is_StringLike<_TYPE_>);   \
        SHOW_CHECK (BasicallyString<_TYPE_>);  \
        SHOW_CHECK (BasicallyCString<_TYPE_>);  \
        SHOW_CHECK (std::is_arithmetic<_TYPE_>); \
        SHOW_CHECK (can_lexical2string<_TYPE_>);  \
        SHOW_CHECK (can_convertToString<_TYPE_>);  \
        SHOW_CHECK (use_StringConversion4Stream<_TYPE_>);
    
    
    void
    showTraits()
      {
        using CharLit = decltype("literal");
        using CharPtr = const char*;
        using StringPtr = string *;
        using StringRef = string &;
        using StringRRef = string &&;
        using StrConstRef = string const&;
        using GenNodePtr  = GenNode*;
        using GenNodeRef  = GenNode&;
        using GenNodeRRef = GenNode&&;
        
        ANALYSE (int);
        ANALYSE (char);
        ANALYSE (double);
        ANALYSE (int64_t);
        ANALYSE (string);
        ANALYSE (StringPtr);
        ANALYSE (StringRef);
        ANALYSE (StringRRef);
        ANALYSE (StrConstRef);
        ANALYSE (CharLit);
        ANALYSE (CharPtr)
        ANALYSE (Reticent)
        ANALYSE (P<Reticent>)
        ANALYSE (GenNode)
        ANALYSE (GenNodePtr)
        ANALYSE (GenNodeRef)
        ANALYSE (GenNodeRRef)
        ANALYSE (P<GenNode>)
        cout << "───────────────────────────╼━━━━━━━━━━╾───────────────────────────"<<endl;
      }
  }//(end)fixture
  
  
  
  
  /***************************************************************************/
  class FormatCOUT_test
    : public Test
    {
      void
      run (Arg)
        {
          showTraits();
          
          auto silent = makeP<Reticent>();
          auto chatty = makeP<GenNode>("Hui", "Buh");
          
          cout << "smart-ptr, no string conv..." << silent <<endl;
          cout << "smart-ptr, custom conv......" << chatty <<endl;
          
          cout << "reference, no string conv..." << *silent      <<endl;
          cout << "reference, custom conv......" << *chatty      <<endl;
          cout << "pointer,   custom conv......" << chatty.get() <<endl;
          
          chatty.reset();
          cout << "smart-ptr, NULL pointee....." << chatty       <<endl;
          cout << "pointer,   NULL pointee....." << chatty.get() <<endl;
        }
    };
  
  LAUNCHER (FormatCOUT_test, "unit common");
  
  
}} // namespace util::test