boost_tuple 0.1.0

// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

// For more information, see http://www.boost.org

// -- io_test.cpp -----------------------------------------------
//
// Testing the I/O facilities of tuples

#define _CRT_SECURE_NO_WARNINGS // std::tmpnam

#include "boost/tuple/tuple_io.hpp"
#include "boost/tuple/tuple_comparison.hpp"

#include "boost/core/lightweight_test.hpp"

#include <fstream>
#include <iterator>
#include <algorithm>
#include <string>
#include <iomanip>
#include <cstdio>

#if defined BOOST_NO_STRINGSTREAM
#include <strstream>
#else
#include <sstream>
#endif

#define BOOST_CHECK BOOST_TEST

using namespace boost;

#if defined BOOST_NO_STRINGSTREAM
typedef std::ostrstream useThisOStringStream;
typedef std::istrstream useThisIStringStream;
#else
typedef std::ostringstream useThisOStringStream;
typedef std::istringstream useThisIStringStream;
#endif

int main() {
   using boost::tuples::set_close;
   using boost::tuples::set_open;
   using boost::tuples::set_delimiter;
   
  useThisOStringStream os1;

  // Set format [a, b, c] for os1
  os1 << set_open('[');
  os1 << set_close(']');
  os1 << set_delimiter(',');
  os1 << make_tuple(1, 2, 3);
  BOOST_CHECK (os1.str() == std::string("[1,2,3]") );

  {
  useThisOStringStream os2;
  // Set format (a:b:c) for os2; 
  os2 << set_open('(');
  os2 << set_close(')');
  os2 << set_delimiter(':');
#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  os2 << make_tuple("TUPU", "HUPU", "LUPU", 4.5);
  BOOST_CHECK (os2.str() == std::string("(TUPU:HUPU:LUPU:4.5)") );
#endif
  }

  // The format is still [a, b, c] for os1
  os1 << make_tuple(1, 2, 3);
  BOOST_CHECK (os1.str() == std::string("[1,2,3][1,2,3]") );

  // check empty tuple.
  useThisOStringStream os3;
  os3 << make_tuple();
  BOOST_CHECK (os3.str() == std::string("()") );
  os3 << set_open('[');
  os3 << set_close(']');
  os3 << make_tuple();
  BOOST_CHECK (os3.str() == std::string("()[]") );
  
  // check width
  useThisOStringStream os4;
  os4 << std::setw(10) << make_tuple(1, 2, 3);
  BOOST_CHECK (os4.str() == std::string("   (1 2 3)") );

  std::string fn = std::tmpnam( 0 );

  std::ofstream tmp( fn.c_str() );

#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  tmp << make_tuple("One", "Two", 3);
#endif   
  tmp << set_delimiter(':');
  tmp << make_tuple(1000, 2000, 3000) << std::endl;

  tmp.close();
  
  // When teading tuples from a stream, manipulators must be set correctly:
  std::ifstream tmp3( fn.c_str() );
  tuple<std::string, std::string, int> j;

#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
  tmp3 >> j; 
  BOOST_CHECK (tmp3.good() ); 
#endif
   
  tmp3 >> set_delimiter(':');
  tuple<int, int, int> i;
  tmp3 >> i; 
  BOOST_CHECK (tmp3.good() ); 
   
  tmp3.close(); 

  std::remove( fn.c_str() );

  // reading tuple<int, int, int> in format (a b c); 
  useThisIStringStream is1("(100 200 300)"); 
   
  tuple<int, int, int> ti1; 
  BOOST_CHECK(bool(is1 >> ti1));
  BOOST_CHECK(ti1 == make_tuple(100, 200, 300));

  useThisIStringStream is2("()");
  tuple<> ti2;
  BOOST_CHECK(bool(is2 >> ti2));
  useThisIStringStream is3("[]");
  is3 >> set_open('[');
  is3 >> set_close(']');
  BOOST_CHECK(bool(is3 >> ti2));

  // Make sure that whitespace between elements
  // is skipped.
  useThisIStringStream is4("(100 200 300)"); 
   
  BOOST_CHECK(bool(is4 >> std::noskipws >> ti1));
  BOOST_CHECK(ti1 == make_tuple(100, 200, 300));

  // Note that strings are problematic:
  // writing a tuple on a stream and reading it back doesn't work in
  // general. If this is wanted, some kind of a parseable string class
  // should be used.
  
  return boost::report_errors();
}