scalt3.cpp

Go to the documentation of this file.

#include "scalt0.hpp"

#include <iostream>

#include <ql/utilities/tracing.hpp>

#include "scal0.hpp"

#include "eleve/src/typing3.hpp"
#include "eleve/src/typing1.hpp"

#include "types0.cpp"

BOOST_AUTO_TEST_SUITE (typing1)

BOOST_AUTO_TEST_CASE(tas3)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as3");

  using namespace eepgwde::detail;

  {
    std::string s("1");
    boost::any o(s);

    unsigned long ul = 0;
    unsigned long * p;
    BOOST_CHECK( (p = as(&ul, o)) );

    if (p)
      BOOST_TEST_MESSAGE( s << " " << ul << " " 
              << boost::any(ul).type().name());
  }

  {
    std::string s("1");
    boost::any o(s);

    Rate0 ul = 0;
    Rate0 * p;
    BOOST_CHECK( (p = as(&ul, o)) );

    if (p)
      BOOST_TEST_MESSAGE( s << " " << ul << " " 
              << boost::any(ul).type().name());
  }

  {
    std::string s("2009-11-12");
    boost::any o(s);

    posixdate ul;
    posixdate * p;
    BOOST_CHECK( (p = as(&ul, o)) );

    if (p)
      BOOST_TEST_MESSAGE( s << " " << ul << " " 
              << boost::any(ul).type().name());
  }

  {
    std::string s("11-12-2009");
    boost::any o(s);

    usdate ul;
    usdate * p;
    BOOST_CHECK( (p = as(&ul, o)) );

    if (p)
      BOOST_TEST_MESSAGE( s << " " << ul << " " 
              << boost::any(ul).type().name());
  }

}

  BOOST_AUTO_TEST_CASE(tas0)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as0");

  using namespace eepgwde::detail;

  int d;
  std::string s;
  if (as(&d, boost::any( (null0<int>())()) ) )
    s = boost::lexical_cast<std::string>(d);

  BOOST_TEST_MESSAGE( "int: " << d );
  BOOST_TEST_MESSAGE( "int: " << (null0<int>())() );
  BOOST_TEST_MESSAGE( "int: " << s);
  BOOST_CHECK( d == (null0<int>())() );
}

BOOST_AUTO_TEST_CASE(tas1)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as1");

  using namespace eepgwde::detail;

  double d;
  std::string s;
  if (as(&d, boost::any( (null0<double>())()) ) )
    s = boost::lexical_cast<std::string>(d);

  BOOST_TEST_MESSAGE( "double: " << d );
  BOOST_TEST_MESSAGE( "double: " << (null0<double>())() );
  BOOST_TEST_MESSAGE( "double: " << s);
  BOOST_CHECK( d == (null0<double>())() );
}

BOOST_AUTO_TEST_SUITE_END() 

#include <locale>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/gregorian/parsers.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/local_time/local_time.hpp>

BOOST_AUTO_TEST_SUITE (date0) 

using namespace boost::gregorian;
using namespace boost::local_time;
using namespace boost::posix_time;
using namespace std;

using namespace eepgwde::detail;

BOOST_AUTO_TEST_CASE(format0)
{
  BOOST_TEST_MESSAGE("eepgwde::boost::date");

  posixdate d( date(2004, Feb, 29) );
  time_duration td(12,34,56,789);
  stringstream ss;
  ss << d << ' ' << td;
  ptime pt(not_a_date_time);
  cerr << pt << endl; // "not-a-date-time"
  ss >> pt;
  cerr << pt << endl; // "2004-Feb-29 12:34:56.000789"
  ss.str("");
  ss << pt << " EDT-05EDT,M4.1.0,M10.5.0";
  local_date_time ldt(not_a_date_time);
  ss >> ldt;
  cerr << ldt << endl; // "2004-Feb-29 12:34:56.000789 EDT"

  local_time_facet* output_facet = new local_time_facet();
  local_time_input_facet* input_facet = new local_time_input_facet();
  ss.imbue(locale(locale::classic(), output_facet));
  ss.imbue(locale(ss.getloc(), input_facet));
  
  output_facet->format("%a %b %d, %H:%M %z");
  ss.str("");
  ss << ldt;
  cerr << ss.str() << endl; // "Sun Feb 29, 12:34 EDT"

  output_facet->format(local_time_facet::iso_time_format_specifier);
  ss.str("");
  ss << ldt;
  cerr << ss.str() << endl; // "20040229T123456.000789-0500"
 
  output_facet->format(local_time_facet::iso_time_format_extended_specifier);
  ss.str("");
  ss << ldt;
  cerr << ss.str() << endl; // "2004-02-29 12:34:56.000789-05:00"

}

void trier(date & dt, std::string & sdt) {
  cerr << sdt << endl;

  try {
    dt = from_simple_string(sdt);
    cerr << "simple: " << dt << endl;
  } catch (...) {
  }

  try {
    dt = from_us_string(sdt);
    cerr << "us: " << dt << endl;
  } catch (...) {
  }

  try {
    dt = from_uk_string(sdt);
    cerr << "uk: " << dt << endl;
  } catch (...) {
  }
}

BOOST_AUTO_TEST_CASE(format1)
{
  BOOST_TEST_MESSAGE("eepgwde::boost::format1");

  string sdt;
  date dt;

  sdt = "2002-1-25";
  trier(dt, sdt);

  sdt = "1/25/2002";
  trier(dt, sdt);

  sdt = "25-1-2002";
  trier(dt, sdt);
}

BOOST_AUTO_TEST_CASE(format2)
{
  BOOST_TEST_MESSAGE("eepgwde::boost::format2");

  string sdt;
  posixdate dt;
  boost::any o;

  sdt = "2002-11-12";
  o = boost::any(sdt);
  dt = * eepgwde::detail::as(&dt, o);
  cerr << sdt << " " << dt << endl;

  {
    // The C locale
    locale loc0 = locale();
    cerr << loc0.name() << endl;
  }

  {
    // Environment locale
    // Change to US time and date handling
    // Install it as the global
    // Check it has been set.
    locale loc0 = locale("");
    cerr << loc0.name() << endl;
    locale loc1 = locale("en_US");
    locale loc2 = locale(loc0, loc1, locale::time);
    cerr << loc2.name() << endl;
    locale::global(loc2);
    locale loc3;
    cerr << loc3.name() << endl;

    locale locA = locale(locale::classic(), locale(), locale::time);
    locale locB = locale(locale::classic(), locale("en_US"), locale::time);
    cerr << locA.name() << endl;
    cerr << locB.name() << endl;
    bool a = locA == locB;
    cerr << a << endl;
  }

  sdt = "11/12/2002";
  o = boost::any(sdt);
  cerr << sdt << " " << dt << endl;

  sdt = "11-12-2002";
  o = boost::any(sdt);
  cerr << sdt << " " << dt << endl;
}

BOOST_AUTO_TEST_CASE(locale0)
{
  BOOST_TEST_MESSAGE("eepgwde::boost::locale0");

  using namespace eepgwde::detail;

  Typing t0;
  try {
    const std::locale & ours0 = t0.get();
    BOOST_TEST_MESSAGE( ours0.name() );
  } catch (...) {
    BOOST_TEST_MESSAGE( "bad locale" );
  }

  t0.set(Typing::posix);
  BOOST_TEST_MESSAGE( locale().name() );
  const std::locale & ours1 = t0.get();
  BOOST_TEST_MESSAGE( ours1.name() );
}

BOOST_AUTO_TEST_SUITE_END() 


BOOST_AUTO_TEST_SUITE(date1)

// Demonstrates that it can handle an ISO-ish date an any time.

  BOOST_AUTO_TEST_CASE(tas2)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as2");

  using eepgwde::daemon::Q;
  using namespace eepgwde::detail;
  using boost::gregorian::date;

  Typing t0;
  try {
    const std::locale & ours0 = t0.get();
  } catch (...) {
    BOOST_TEST_MESSAGE( "bad locale" );
  }

  posixdate d;
  std::string s;

  s = "2009-11-12"; 
  {
    t0.set(Typing::posix);
    const std::locale & ours1 = t0.get();

    if (as(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
  }

  BOOST_TEST_MESSAGE( "date(date): " << d );
  BOOST_TEST_MESSAGE( "date: " << s);

  s = "2009-11-12"; 
  {
    t0.set(Typing::uk);
    const std::locale & ours1 = t0.get();

    if (as(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
  }

  BOOST_TEST_MESSAGE( "date(date): " << d );
  BOOST_TEST_MESSAGE( "date: " << s);

  s = "2009-11-12"; 
  {
    t0.set(Typing::us);
    const std::locale & ours1 = t0.get();

    if (as(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
  }

  BOOST_TEST_MESSAGE( "date(date): " << d );
  BOOST_TEST_MESSAGE( "date: " << s);
}

BOOST_AUTO_TEST_CASE(tas3)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::tas3");

  using eepgwde::daemon::Q;
  using namespace eepgwde::detail;
  using boost::gregorian::date;

  Typing t0;
  try {
    const std::locale & ours0 = t0.get();
  } catch (...) {
    BOOST_TEST_MESSAGE( "bad locale" );
  }

  boost::gregorian::date dt;
  std::string s;

  s = "2009-11-12"; 
  BOOST_TEST_MESSAGE( "date(in): " << s);
  {
    t0.set(Typing::posix);
    const std::locale & ours1 = t0.get();

    posixdate d;
    if (as(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
    dt = d;
  }
  BOOST_TEST_MESSAGE( "date(date): " << boost::gregorian::to_simple_string(dt) );
  BOOST_TEST_MESSAGE( "date(out): " << s);

  s = "12-11-2009"; 
  BOOST_TEST_MESSAGE( "date(in): " << s);
  {
    t0.set(Typing::uk);
    const std::locale & ours1 = t0.get();

    usdate d;
    if (as(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
    dt = d;
  }
  BOOST_TEST_MESSAGE( "date(date): " << dt );
  BOOST_TEST_MESSAGE( "date(out): " << s);

  s = "11-12-2009"; 
  BOOST_TEST_MESSAGE( "date(in): " << s);
  {
    t0.set(Typing::us);
    const std::locale & ours1 = t0.get();

    eudate d;
    if (as(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
    dt = d;
  }
  BOOST_TEST_MESSAGE( "date(date): " << dt );
  BOOST_TEST_MESSAGE( "date(out): " << s);
}

// Demonstrates that it can handle an ISO-ish date an any time.

BOOST_AUTO_TEST_CASE(tas4)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as4");
  
  using eepgwde::daemon::Q;
  using namespace eepgwde::detail;
  using boost::gregorian::date;

  usdate d;
  std::string s;

  s = "2009-11-12"; 
  s = "11-30-2009";
  BOOST_TEST_MESSAGE( "date(in): " << s);
  {
    if (as<usdate>(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
  }
  BOOST_TEST_MESSAGE( "date(date): " << d );
  BOOST_TEST_MESSAGE( "date(out): " << s);

  boost::any o(d);
  std::cerr << as(o) << std::endl;
}

BOOST_AUTO_TEST_CASE(tas5)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as5");
  
  using eepgwde::daemon::Q;
  using namespace eepgwde::detail;
  using boost::gregorian::date;

  eudate d;
  std::string s;

  s = "2009-11-12"; 
  s = "12-11-2009"; 
  BOOST_TEST_MESSAGE( "date(in): " << s);
  {
    if (as<eudate>(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
  }
  BOOST_TEST_MESSAGE( "date(date): " << d );
  BOOST_TEST_MESSAGE( "date(out): " << s);

  boost::any o(d);
  std::cerr << as(o) << std::endl;
}

BOOST_AUTO_TEST_CASE(tas6)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as6");
  
  using eepgwde::daemon::Q;
  using namespace eepgwde::detail;
  using boost::gregorian::date;

  eudate d;
  std::string s;

  s = "2009-11-12"; 
  s = "12-11-2009"; 
  BOOST_TEST_MESSAGE( "date(in): " << s);
  {
    if (as<eudate>(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
  }
  BOOST_TEST_MESSAGE( "date(date): " << d );
  BOOST_TEST_MESSAGE( "date(out): " << s);

  boost::any o(d);
  std::cerr << as(o) << std::endl;
}

BOOST_AUTO_TEST_CASE(tas7)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as7");
  
  using namespace eepgwde::detail;

  {
    // Demonstrates that only rate will be scaled.
    rate d;
    std::string s;

    s = "4.5";
    BOOST_TEST_MESSAGE( "rate(in): " << s);
    {
      if (as<rate>(&d, boost::any(s)))
    s = boost::lexical_cast<std::string>(d);
    }
    BOOST_TEST_MESSAGE( "rate(rate): " << d );
    BOOST_TEST_MESSAGE( "rate(out): " << s);

    boost::any o(d);
    std::cerr << as(o) << std::endl;
  }

  {
    // Demonstrates that double when passed in will not be scaled.
    double a = 0.045;
    double a0;
    std::string s;
    BOOST_TEST_MESSAGE( "rate(in): " << a);
    {
      if (as<double>(&a0, boost::any(a)))
    s = boost::lexical_cast<std::string>(a0);
    }
    BOOST_TEST_MESSAGE( "rate(double): " << a0);
    BOOST_TEST_MESSAGE( "rate(out): " << s);
    BOOST_CHECK( a == a0);

    boost::any o(a0);
    std::cerr << as(o) << std::endl;
  }
  
}

BOOST_AUTO_TEST_CASE(tas8)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::as8");
  
  using eepgwde::daemon::Q;
  using namespace eepgwde::detail;
  using boost::gregorian::date;

  bps d;
  std::string s;

  s = "450";
  BOOST_TEST_MESSAGE( "bps(in): " << s);
  {
    if (as<bps>(&d, boost::any(s)))
      s = boost::lexical_cast<std::string>(d);
  }
  BOOST_TEST_MESSAGE( "bps(bps): " << d );
  BOOST_TEST_MESSAGE( "bps(out): " << s);

  boost::any o(d);
  std::cerr << as(o) << std::endl;
}

BOOST_AUTO_TEST_SUITE_END()

BOOST_AUTO_TEST_SUITE(tzs)

BOOST_AUTO_TEST_CASE(tzs0)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::zs0");
  
  using namespace eepgwde::detail;
  using boost::gregorian::date;

  int d;
  std::string s;

  s = "450";
  BOOST_TEST_MESSAGE( "int(in): " << s);
  boost::any o(s);
  {
    as<int>(&d, o);
    s = boost::lexical_cast<std::string>(d);
  }
  BOOST_TEST_MESSAGE( "int(int): " << d );
  BOOST_TEST_MESSAGE( "int(out): " << s);

}

BOOST_AUTO_TEST_CASE(tzs1)
{
  BOOST_TEST_MESSAGE("eepgwde::detail::zs1");
  
  using namespace eepgwde::detail;
  using boost::gregorian::date;

  int d;
  std::string s;

  s = "450";
  BOOST_TEST_MESSAGE( "int(in): " << s);
  boost::any o(s);
  {
    d = renderer<int>(o, (null0<int>())(), 0);
    s = boost::lexical_cast<std::string>(d);
  }
  BOOST_TEST_MESSAGE( "int(int): " << d );
  BOOST_TEST_MESSAGE( "int(out): " << s);

}

BOOST_AUTO_TEST_SUITE_END()

---