Adding upstream version 16.2.11+ds.upstream/16.2.11+dsupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

70 files changed, 11301 insertions, 0 deletions

diff --git a/src/boost/libs/date_time/test/Jamfile.v2 b/src/boost/libs/date_time/test/Jamfile.v2
new file mode 100644
index 000000000..74da9b90a
--- /dev/null
+++ b/src/boost/libs/date_time/test/Jamfile.v2
@@ -0,0 +1,168 @@
+import os ;
+import path ;
+import regex ;
+import testing ;
+
+local DATE_TIME_DYNAMIC_PROPERTIES = <define>BOOST_ALL_DYN_LINK <runtime-link>shared <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG <define>BOOST_ALL_NO_LIB ;
+local DATE_TIME_PROPERTIES = <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+  # FIXME 
+  #std::locale-support 
+  <define>BOOST_ALL_NO_LIB ;
+
+# core stuff
+run testint_adapter.cpp ;
+run testtime_resolution_traits.cpp ;
+run testwrapping_int.cpp ;
+run testconstrained_value.cpp ;
+run testgregorian_calendar.cpp ;
+run testgeneric_period.cpp ;
+# the library dependence below is just to test that the
+# stub library will build, it's completely uneeded not that
+# date-time is all inline
+run testmisc.cpp
+    ../build//boost_date_time/<link>static
+    : : : <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+    : testmisc_std_cfg ;
+
+###  gregorian
+
+run gregorian/testdate.cpp ;
+run gregorian/testdate_duration.cpp ;
+run gregorian/testdate_facet_new.cpp ;
+run gregorian/testdate_input_facet.cpp ;
+run gregorian/testdate_iterator.cpp ;
+
+run gregorian/testgenerators.cpp ;
+run gregorian/testgreg_cal.cpp ;
+run gregorian/testgreg_day.cpp ;
+run gregorian/testgreg_durations.cpp ;
+run gregorian/testgreg_month.cpp ;
+run gregorian/testgreg_year.cpp ;
+run gregorian/testformatters.cpp ;
+run gregorian/testparse_date.cpp ;
+run gregorian/testperiod.cpp ;
+
+run gregorian/testgreg_serialize.cpp
+     ../../serialization/build//boost_serialization
+     : : : <define>DATE_TIME_XML_SERIALIZE
+     : testgreg_serialize_xml ;
+
+run gregorian/testgreg_serialize.cpp
+    ../../serialization/build//boost_serialization
+    : : :
+    : testgreg_serialize ;
+
+run posix_time/testfiletime_functions.cpp ;
+run posix_time/testlocal_adjustor.cpp ;
+run posix_time/testc_local_adjustor.cpp ;
+run posix_time/testclock.cpp ;
+run posix_time/testdst_rules.cpp ;
+run posix_time/testduration.cpp ;
+run posix_time/testiterator.cpp ;
+run posix_time/testparse_time.cpp ;
+run posix_time/testtime_period.cpp ;
+run posix_time/testtime.cpp ;
+run posix_time/testmicrosec_time_clock.cpp ;
+run posix_time/testgreg_duration_operators.cpp ;
+run posix_time/testtime_facet.cpp ;
+run posix_time/testtime_input_facet.cpp 
+    : : : <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+    : testtime_input_facet ;
+
+run posix_time/testtime_formatters.cpp
+    : : : <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+    : testtime_formatters ;
+
+# text archive tests
+run posix_time/testtime_serialize.cpp
+    ../../serialization/build//boost_serialization
+    : : :
+    : testtime_serialize ;
+
+run posix_time/testtime_serialize.cpp
+    ../../serialization/build//boost_serialization
+    : : : <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+    : testtime_serialize_std_config ;
+
+# xml archive tests
+run posix_time/testtime_serialize.cpp
+    ../../serialization/build//boost_serialization
+    : : :  <define>DATE_TIME_XML_SERIALIZE <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+    : testtime_serialize_xml_std_config ;
+
+run posix_time/testtime_serialize.cpp
+    ../../serialization/build//boost_serialization
+    : : : <define>DATE_TIME_XML_SERIALIZE
+    : testtime_serialize_xml ;
+
+# versioning tests
+run posix_time/testtime_serialize_versioning.cpp
+    ../../serialization/build//boost_serialization
+    : : testtime_serialize_versioning_prev 
+    : <define>BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+    : testtime_serialize_versioning_curr ;
+
+run posix_time/testtime_serialize_versioning.cpp
+    ../../serialization/build//boost_serialization
+    : : :  <define>BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION=0
+    : testtime_serialize_versioning_prev ;
+
+
+
+
+compile-fail posix_time/compile_fail/hours_special_value.cpp ;
+compile-fail posix_time/compile_fail/minutes_special_value.cpp ;
+compile-fail posix_time/compile_fail/seconds_special_value.cpp ;
+compile-fail posix_time/compile_fail/millisec_special_value.cpp ;
+
+run local_time/testdst_transition_day_rule.cpp ;
+run local_time/testcustom_time_zone.cpp ;
+run local_time/testposix_time_zone.cpp ;
+run local_time/testwcustom_time_zone.cpp ;
+run local_time/testwposix_time_zone.cpp ;
+run local_time/testlocal_time.cpp ;
+run local_time/testlocal_time_iterator.cpp ;
+run local_time/testlocal_time_period.cpp ;
+
+run local_time/testtz_database.cpp 
+     : : ../data/date_time_zonespec.csv local_time/poorly_formed_zonespec.csv
+     :  ;
+run local_time/testlocal_time_facet.cpp
+    : : ../data/date_time_zonespec.csv : ;
+run local_time/testclocks.cpp ;
+
+
+#todo
+#if ! [ os.environ UBSAN_OPTIONS ]
+#{
+#  local DATE_TIME_PROPERTIES = <define>BOOST_ALL_NO_LIB  <define>USE_DATE_TIME_PRE_1_33_FACET_IO
+#    # FIXME
+#    # std::locale-support toolset::require-boost-spirit-support 
+#    ;
+
+# Iterate over all public headers and generate a self-contained header test to check for any missing includes
+# and basic syntax errors.
+if ! [ os.environ BOOST_DATE_TIME_TEST_WITHOUT_SELF_CONTAINED_HEADER_TESTS ]
+{
+    local headers_path = [ path.make $(BOOST_ROOT)/libs/date_time/include/boost ] ;
+    for file in [ path.glob-tree $(headers_path) : *.hpp ]
+    {
+        local rel_file = [ path.relative-to $(headers_path) $(file) ] ;
+        # Note: The test name starts with '~' in order to group these tests in the test report table, preferably at the end.
+        #       All '/' are replaced with '-' because apparently test scripts have a problem with test names containing slashes.
+        local test_name = [ regex.replace ~hdr/$(rel_file) "/" "-" ] ;
+        #ECHO $(rel_file) ;
+        compile self_contained_header.cpp : <define>"BOOST_DATE_TIME_TEST_HEADER=$(rel_file)" <dependency>$(file) : $(test_name) ;
+    }
+}
+
+
+# Copyright (c) 2000-2020
+# CrystalClear Software, Inc.
+# Subject to the Boost Software License, Version 1.0. 
+# (See accompanying file LICENSE_1_0.txt or 
+# http://www.boost.org/LICENSE_1_0.txt)
+
+
+
+
diff --git a/src/boost/libs/date_time/test/gregorian/testcurrent_day.cpp b/src/boost/libs/date_time/test/gregorian/testcurrent_day.cpp
new file mode 100644
index 000000000..e89e32df4
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testcurrent_day.cpp
@@ -0,0 +1,37 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include <iostream>
+
+int
+main() 
+{
+
+  boost::gregorian::date d1(boost::gregorian::day_clock::local_day());
+  std::cout << "Check the printed date by hand: "
+            <<  boost::gregorian::to_iso_string(d1) << std::endl;
+
+  using namespace boost::gregorian;
+  date::ymd_type ymd = day_clock::local_day_ymd();
+  std::cout << ymd.year << "-" 
+            << ymd.month.as_long_string() << "-"
+            << ymd.day << std::endl;
+
+  date d2(day_clock::universal_day());
+  std::cout << "Getting UTC date: "
+            <<  to_iso_string(d2) << std::endl;
+
+  date::ymd_type ymd2 = day_clock::universal_day_ymd();
+  std::cout << ymd2.year << "-" 
+            << ymd2.month.as_long_string() << "-"
+            << ymd2.day << std::endl;
+
+  return 0;
+
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testdate.cpp b/src/boost/libs/date_time/test/gregorian/testdate.cpp
new file mode 100644
index 000000000..e8b957ed9
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testdate.cpp
@@ -0,0 +1,319 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include <boost/cstdint.hpp>
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+#include <sstream>
+
+void test_yearlimit(int yr, bool allowed)
+{
+    std::stringstream sdesc;
+    sdesc << "should" << (allowed ? "" : " not") << " be able to make a date in year " << yr;
+
+    try {
+        boost::gregorian::date chkyr(yr, 1, 1);
+        check(sdesc.str(), allowed);
+    }
+    catch (std::out_of_range&) { check(sdesc.str(), !allowed); }
+}
+
+int
+main()
+{
+
+  using namespace boost::gregorian;
+
+  //various constructors
+#if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
+  date def;
+  check("Default constructor", def == date(not_a_date_time));
+#endif
+  
+  date d1(1900,1,1);
+  date d2 = date(2000,1,1);
+  date d3(d2);
+  check("Copy constructor", d3 == d2);
+  date d4(2000,12,31);
+  date d4a(2000,Dec,31);
+  //d4a.print(std::cout); std::cout << std::endl;
+  check("month_rep constructor",   d4 == d4a);
+  //std::cout << d3 << std::endl;
+  //retrieval functions
+  check_equal("1900-01-01 day is 01",     d1.day(),   1);
+  check_equal("1900-01-01 month is 01",   d1.month(), 1);
+  check_equal("1900-01-01 year is 1900",  d1.year(),  1900);
+  check_equal("2000-12-31 day is 31",     d4.day(),   31);
+  check_equal("2000-12-31 month is 12",   d4.month(), 12);
+  check_equal("2000-12-31 year is 2000",  d4.year(),  2000);
+  //operator<
+  check("1900-01-01 is less than 2000-01-01",          d1 < d2);
+  check("2000-01-01 is NOT less than 2000-01-01",      !(d1 < d1));
+  //operator<=
+  check("2000-01-01 is less equal than 2000-01-01",    d1 <= d1);
+  //operator>
+  check("2000-01-01 is greater than 1900-01-01",       d2 > d1);
+  check("2000-01-01 is NOT greater than 2000-01-01",   !(d1 < d1));
+  //operator>=
+  check("2000-01-01 is greater equal than 2000-01-01", d1 >= d1);
+  //operator!=
+  check("2000-01-01 is NOT equal to 1900-01-01",       d2 != d1);
+  //operator==
+  check_equal("2000-01-01 is equal 2000-01-01",        d3,   d2);
+  check("2000-01-01 is greater equal 2000-01-01",      d3 >= d2);
+  check("2000-01-01 is greater equal 2000-01-01",      d3 <= d2);
+
+  date::ymd_type ymd = d1.year_month_day();
+  check_equal("ymd year",  ymd.year,  1900);
+  check_equal("ymd month", ymd.month, 1);
+  check_equal("ymd day",   ymd.day,   1);
+
+  //The max function will not compile with Borland 5.5
+  //Complains about must specialize basic_data<limits> ???
+//   std::cout << "Max date is " << (date::max)() << std::endl;
+//   //std::cout << "Max date is " << (basic_date< date_limits<unsigned int,1900> >::max)() << std::endl;
+//   //std::cout << "Max date is " << (date_limits<unsigned int, 1900>::max)() << std::endl;
+
+  const date answers[] = {date(1900,Jan,1),date(1900,Jan,4),date(1900,Jan,7),
+                          date(1900,Jan,10),date(1900,Jan,13)};
+  date_duration off(3);
+  date d5(1900,1,1);
+  for (int i=0; i < 5; ++i) {
+    //std::cout << d5 << "  ";
+    check(" addition ", d5 == answers[i]);
+    d5 = d5 + off;
+  }
+  std::cout << std::endl;
+
+   const date answers1[] = {date(2000,2,26),date(2000,2,28),date(2000,Mar,1)};
+   date d8(2000,Feb,26);
+   for (int j=0; j < 3; ++j) {
+     //std::cout << d8 << "  ";
+     check(" more addition ", d8 == answers1[j]);
+     d8 = d8 + days(2);
+   }
+   // std::cout << std::endl;
+
+  date d6(2000,2,28);
+  date d7(2000,3,1);
+  date_duration twoDays(2);
+  date_duration negtwoDays(-2);
+  date_duration zeroDays(0);
+  check_equal("2000-03-01 - 2000-02-28 == 2 days",   twoDays,     (d7-d6));
+  check_equal("2000-02-28 - 2000-03-01 == - 2 days", negtwoDays,  (d6-d7));
+  check_equal("2000-02-28 - 2000-02-28 == 0 days",   zeroDays,    (d6-d6));
+  check_equal("2000-02-28 + 2 days == 2000-03-01 ",  d6 + twoDays, d7);
+  check_equal("2000-03-01 - 2 days == 2000-02-28 ",  d7 - twoDays, d6);
+  check_equal("Add duration to date", date(1999,1,1) + date_duration(365), date(2000,1,1));
+  check_equal("Add zero days", date(1999,1,1) + zeroDays, date(1999,1,1));
+  //can't do this...
+  //check("Add date to duration", date_duration(365) + date(1999,1,1) == date(2000,1,1));
+
+  {
+    date d(2003,Oct,31);
+    date_duration dd(55);
+    d += dd;
+    check("date += date_duration", d == date(2003,Dec,25));
+    d -= dd;
+    check("date -= date_duration", d == date(2003,Oct,31));
+    /* special_values is more thoroughly tested later,
+     * this is just a test of += & -= with special values */
+    d += date_duration(pos_infin);
+    check("date += inf_dur", d == date(pos_infin));
+    d -= dd;
+    check("inf_date -= dur", d == date(pos_infin));
+  }
+  {
+    date d(2003,Oct,31);
+    date_duration dd1(pos_infin), dd2(neg_infin), dd3(not_a_date_time);
+    check_equal("date + inf_dur", d + dd1, date(pos_infin));
+    check_equal("date + inf_dur", d + dd2, date(neg_infin));
+    check_equal("date + nan_dur", d + dd3, date(not_a_date_time));
+    check_equal("date - inf_dur", d - dd1, date(neg_infin));
+    check_equal("date - inf_dur", d - dd2, date(pos_infin));
+    check_equal("date - nan_dur", d - dd3, date(not_a_date_time));
+    check_equal("inf_date + inf_dur", date(pos_infin) + dd1, date(pos_infin));
+    check_equal("inf_date - inf_dur", date(pos_infin) - dd1, date(not_a_date_time));
+    check_equal("inf_date + inf_dur", date(neg_infin) + dd1, date(not_a_date_time));
+    check_equal("inf_date - inf_dur", date(neg_infin) - dd1, date(neg_infin));
+  }
+
+
+  try {
+    date d9(2000, Jan, 32);
+    check("day out of range", false);
+    //never reached if working -- but stops compiler warnings :-)
+    std::cout << "Oops: " << to_iso_string(d9) << std::endl;
+  }
+  catch (bad_day_of_month&) {
+    check("day out of range", true);
+  }
+  try {
+    date d9(2000, Jan, 0);
+    check("day out of range", false);
+    //never reached if working -- but stops compiler warnings :-)
+    std::cout << "Oops: " << to_iso_string(d9) << std::endl;
+  }
+  catch (bad_day_of_month&) {
+    check("day out of range", true);
+  }
+
+  try {
+    date d20(2000, Feb, 31);
+    check("day out of range", false);
+    //never reached if working -- but stops compiler warnings :-)
+    std::cout << "Oops: " << to_iso_string(d20) << std::endl;
+  }
+  catch (bad_day_of_month&) {
+    check("day out of range", true);
+  }
+
+  //more subtle -- one day past in a leap year
+  try {
+    date d21(2000, Feb, 30);
+    check("day out of range", false);
+    //never reached if working -- but stops compiler warnings :-)
+    std::cout << "Oops: " << to_iso_string(d21) << std::endl;
+  }
+  catch (bad_day_of_month&) {
+    check("day out of range", true);
+  }
+
+  //more subtle -- one day past in a leap year
+  try {
+    date d22(2000, Feb, 29);
+    check("last day of month ok", true);
+    std::cout << to_iso_string(d22) << std::endl; //stop compiler warning
+  }
+  catch (bad_day_of_month&) {
+    check("last day of month -- oops bad exception", false);
+  }
+
+  //Not a leap year -- now Feb 29 is bad
+  try {
+    date d23(1999, Feb, 29);
+    check("day out of range", false);
+    //never reached if working -- but stops compiler warnings :-)
+    std::cout << "Oops: " << to_iso_string(d23) << std::endl;
+  }
+  catch (bad_day_of_month&) {
+    check("day out of range", true);
+  }
+
+  //check out some special values
+  check("check not a date - false",           !d7.is_not_a_date());
+  check("check positive infinity - false",    !d7.is_pos_infinity());
+  check("check negative infinity - false",    !d7.is_neg_infinity());
+
+  date d10(neg_infin);
+  check("check negative infinity - true",     d10.is_infinity());
+  d10 = d10 + twoDays; //still neg infinity
+  check("check negative infinity - true",     d10.is_neg_infinity());
+
+  date d11(pos_infin);
+  check("check positive infinity - true",     d11.is_infinity());
+  d11 = d11 + twoDays;
+  check("check positive infinity add - true", d11.is_pos_infinity());
+
+  date d12(not_a_date_time);
+  check("check not a date",                   d12.is_not_a_date());
+  check("check infinity compare   ",          d10 != d11);
+  check("check infinity compare   ",          d10 < d11);
+  check("check infinity nad compare   ",      d12 != d11);
+  date d13(max_date_time);
+  check("check infinity - max compare   ",      d13 < d11);
+  check_equal("max date_time value   ",       d13, date(9999,Dec, 31));
+  std::cout << to_simple_string(d13) << std::endl;
+  date d14(min_date_time);
+  check("check infinity - min compare   ",      d14 > d10);
+  std::cout << to_simple_string(d14) << std::endl;
+  check_equal("min date_time value   ",      d14, date(1400,Jan, 1));
+
+
+  date d15(1400,1,1);
+  std::cout << d15.day_of_week().as_long_string() << std::endl;
+  check("check infinity - min compare   ",      d10 < d15);
+
+  // most of this testing is in the gregorian_calendar tests
+  std::cout << d15.julian_day() << std::endl;
+  check_equal("check julian day   ", d15.julian_day(), 
+      static_cast<boost::uint32_t>(2232400));
+  check_equal("check modjulian day   ", d15.modjulian_day(), -167601);
+  date d16(2004,2,29);
+  check_equal("check julian day   ", d16.julian_day(), 
+      static_cast<boost::uint32_t>(2453065));
+  check_equal("check modjulian day   ", d16.modjulian_day(), 
+      static_cast<boost::uint32_t>(53064));
+
+  // most of this testing is in the gregorian_calendar tests
+  date d31(2000, Jun, 1);
+  check_equal("check iso week number   ", d31.week_number(), 22);
+  date d32(2000, Aug, 1);
+  check_equal("check iso week number   ", d32.week_number(), 31);
+  date d33(2000, Oct, 1);
+  check_equal("check iso week number   ", d33.week_number(), 39);
+  date d34(2000, Dec, 1);
+  check_equal("check iso week number   ", d34.week_number(), 48);
+  date d35(2000, Dec, 24);
+  check_equal("check iso week number   ", d35.week_number(), 51);
+  date d36(2000, Dec, 25);
+  check_equal("check iso week number   ", d36.week_number(), 52);
+  date d37(2000, Dec, 31);
+  check_equal("check iso week number   ", d37.week_number(), 52);
+  date d38(2001, Jan, 1);
+  check_equal("check iso week number   ", d38.week_number(), 1);
+
+  try {
+    int dayofyear1 = d38.day_of_year();
+    check_equal("check day of year number", dayofyear1, 1);
+    check_equal("check day of year number", d37.day_of_year(), 366);
+    date d39(2001,Dec,31);
+    check_equal("check day of year number", d39.day_of_year(), 365);
+    date d40(2000,Feb,29);
+    check_equal("check day of year number", d40.day_of_year(), 60);
+    date d41(1400,Jan,1);
+    check_equal("check day of year number", d41.day_of_year(), 1);
+    date d42(1400,Jan,1);
+    check_equal("check day of year number", d42.day_of_year(), 1);
+    date d43(2002,Nov,17);
+    check_equal("check day of year number", d43.day_of_year(), 321);
+  }
+  catch(std::exception& e) {
+    std::cout << e.what() << std::endl;
+    check("check day of year number", false);
+  }
+
+  //converts to date and back -- should get same result
+  check_equal("tm conversion functions 2000-1-1", date_from_tm(to_tm(d2)), d2);
+  check_equal("tm conversion functions 1900-1-1", date_from_tm(to_tm(d1)), d1);
+  check_equal("tm conversion functions min date 1400-1-1 ", date_from_tm(to_tm(d14)), d14);
+  check_equal("tm conversion functions max date 9999-12-31", date_from_tm(to_tm(d13)), d13);
+
+  try{
+    date d(neg_infin);
+    tm d_tm = to_tm(d);
+    check("Exception not thrown (special_value to_tm)", false);
+    std::cout << d_tm.tm_sec << std::endl; //does nothing useful but stops compiler from complaining about unused d_tm
+  }catch(std::out_of_range&){
+    check("Caught expected exception (special_value to_tm)", true);
+  }catch(...){
+    check("Caught un-expected exception (special_value to_tm)", false);
+  }
+
+  // trac-13159
+  test_yearlimit(    0, false);
+  test_yearlimit( 1399, false);
+  test_yearlimit( 1400,  true);
+  test_yearlimit( 1401,  true);
+  test_yearlimit( 9999,  true);
+  test_yearlimit(10000, false);
+  test_yearlimit(10001, false);
+
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testdate_duration.cpp b/src/boost/libs/date_time/test/gregorian/testdate_duration.cpp
new file mode 100644
index 000000000..12bee2dbb
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testdate_duration.cpp
@@ -0,0 +1,77 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+
+
+void test_date_duration()
+{
+  using namespace boost::gregorian;
+  
+  date_duration threeDays(3);
+  date_duration twoDays(2);
+  //date_duration zeroDays(0);
+  check("Self equal case",       threeDays == threeDays);
+  check("Not equal case",        !(threeDays == twoDays));
+  check("Less case succeed",     twoDays < threeDays);
+  check("Not less case",         !(threeDays < twoDays));
+  check("Not less case - equal", !(threeDays < threeDays));
+  check("Greater than ",         !(threeDays > threeDays));
+  check("Greater equal ",        threeDays >= threeDays);
+  check("Greater equal - false", !(twoDays >= threeDays));
+  check("add", twoDays + threeDays == date_duration(5));
+  date_duration fiveDays = threeDays;
+  fiveDays += twoDays;
+  check("add", fiveDays == date_duration(5));
+  date_duration tenDays = fiveDays;
+  tenDays += date_duration(5);
+  check("add", tenDays.days() == 10);
+  
+  date_duration derivedOneDay = threeDays - twoDays;
+  check("Subtraction - neg result", twoDays - threeDays == date_duration(-1));
+  date_duration oneDay(1);
+  check("Subtraction",           oneDay == derivedOneDay);
+  date_duration fiveDaysDerived = tenDays;
+  fiveDaysDerived -= fiveDays;
+  check("Subtraction",           fiveDaysDerived == fiveDays);
+
+  oneDay = twoDays / 2;
+  check("Division",           oneDay.days() == 1);
+  date_duration oneDayDivide = threeDays / 2;
+  check("Division",           oneDayDivide.days() == 1);
+  date_duration hundred(100);
+  hundred /= -10;
+  check("Division",           hundred.days() == -10 && hundred.is_negative());
+
+  date_duration pos_dur(123);
+  date_duration neg_dur(-pos_dur);
+  check("unary-", neg_dur.days() == -123);
+  
+  // special values tests
+  date_duration pi_dur(pos_infin);
+  date_duration ni_dur(neg_infin);
+  date_duration nd_dur(not_a_date_time);
+  check("pos_inf + neg_inf",  (pi_dur + ni_dur) == nd_dur);
+  //check("inf * integer",    (pi_dur * 2) == pi_dur); // not implemented
+  check("neg_inf / integer",  (ni_dur / 3) == ni_dur);
+  check("inf + dur",          (pi_dur + hundred) == pi_dur);
+  check("unary-",              date_duration(-pi_dur) == ni_dur);
+ 
+//   date_duration dd(1);
+//   dd++;
+//   check("Increment",             dd == twoDays);
+
+}
+
+int main() {
+  test_date_duration();
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testdate_facet_new.cpp b/src/boost/libs/date_time/test/gregorian/testdate_facet_new.cpp
new file mode 100644
index 000000000..9c6dafbe2
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testdate_facet_new.cpp
@@ -0,0 +1,388 @@
+
+
+/* Copyright (c) 2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "boost/date_time/date_facet.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+#include <sstream>
+
+
+template<class temporal_type, typename charT>
+inline
+void
+teststreaming(std::string testname,
+              temporal_type value,
+              std::basic_string<charT> expected_result,
+              const std::locale& locale = std::locale::classic())
+{
+  std::basic_stringstream<charT> ss;
+  ss.imbue(locale);
+  ss << value;
+  check_equal(testname, ss.str(), expected_result);
+}
+
+
+// collections for adding to facet
+const char* const month_short_names[]={"*jan*","*feb*","*mar*",
+                                       "*apr*","*may*","*jun*",
+                                       "*jul*","*aug*","*sep*",
+                                       "*oct*","*nov*","*dec*"};
+
+const char* const month_long_names[]={"**January**","**February**","**March**",
+                                      "**April**","**May**","**June**",
+                                      "**July**","**August**","**September**",
+                                      "**October**","**November**","**December**"};
+
+const char* const weekday_short_names[]={"day1", "day2","day3","day4",
+                                         "day5","day6","day7"};
+
+const char* const weekday_long_names[]= {"Sun-0", "Mon-1", "Tue-2", 
+                                         "Wed-3", "Thu-4", 
+                                         "Fri-5", "Sat-6"};
+
+std::vector<std::basic_string<char> > short_weekday_names;
+std::vector<std::basic_string<char> > long_weekday_names;
+std::vector<std::basic_string<char> > short_month_names;
+std::vector<std::basic_string<char> > long_month_names;
+
+#if !defined(BOOST_NO_STD_WSTRING)
+// collections of test results
+const std::wstring full_months[]={L"January",L"February",L"March",
+                                  L"April",L"May",L"June",
+                                  L"July",L"August",L"September",
+                                  L"October",L"November",L"December"};
+const std::wstring short_months[]={L"Jan",L"Feb",L"Mar",
+                                   L"Apr",L"May",L"Jun",
+                                   L"Jul",L"Aug",L"Sep",
+                                   L"Oct",L"Nov",L"Dec"};
+
+const std::wstring full_weekdays[]= {L"Sunday", L"Monday",L"Tuesday", 
+                                     L"Wednesday", L"Thursday", 
+                                     L"Friday", L"Saturday"};
+const std::wstring short_weekdays[]= {L"Sun", L"Mon",L"Tue", 
+                                      L"Wed", L"Thu", 
+                                      L"Fri", L"Sat"};
+
+//const whcar_t const 
+#endif // BOOST_NO_STD_WSTRING
+
+int main() {
+  using namespace boost::gregorian;
+
+  std::copy(&month_short_names[0],
+            &month_short_names[12],
+            std::back_inserter(short_month_names));
+
+  std::copy(&month_long_names[0],
+            &month_long_names[12],
+            std::back_inserter(long_month_names));
+
+  std::copy(&weekday_short_names[0],
+            &weekday_short_names[7],
+            std::back_inserter(short_weekday_names));
+
+  std::copy(&weekday_long_names[0],
+            &weekday_long_names[7],
+            std::back_inserter(long_weekday_names));
+
+  {
+    std::stringstream ss;
+    date d(2004,Oct,31);
+    date_period dp(d, d + days(7));
+    ss << d;
+    check("to_string & default formats match",
+        to_simple_string(d) == ss.str());
+    ss.str("");
+    ss << dp;
+    check("to_string & default formats match",
+        to_simple_string(dp) == ss.str());
+  }
+
+  {
+    date d(2004,Oct, 13);
+    date_period dp(d, d + days(7));
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->format(date_facet::standard_format_specifier);
+      std::cout.imbue(std::locale(std::locale::classic(), datefacet));
+      teststreaming("default classic date", d, std::string("10/13/04"),
+                    std::locale(std::locale::classic(), datefacet));
+      std::cout << "default classic date output: " << d << std::endl;
+
+    }
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->format(date_facet::standard_format_specifier);
+      teststreaming("default classic date period", dp, 
+                    std::string("[10/13/04/10/19/04]"),
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->format("%Y-%d-%b %a");
+      teststreaming("custom date facet date period", dp, 
+                    std::string("[2004-13-Oct Wed/2004-19-Oct Tue]"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->set_iso_format();
+      teststreaming("custom date facet date", d, 
+                    std::string("20041013"), 
+                    std::locale(std::locale::classic(), datefacet));
+
+    }
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->set_iso_format();
+      teststreaming("custom date facet date period", dp, 
+                    std::string("[20041013/20041019]"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->set_iso_extended_format();
+      teststreaming("custom date facet date", d, 
+                    std::string("2004-10-13"), 
+                    std::locale(std::locale::classic(), datefacet));
+
+    }
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->set_iso_extended_format();
+      teststreaming("custom date facet date period", dp, 
+                    std::string("[2004-10-13/2004-10-19]"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->set_iso_extended_format();
+      period_formatter pf(period_formatter::AS_OPEN_RANGE, " / ", "[ ", " )", " ]");
+      datefacet->period_formatter(pf);
+      teststreaming("custom date facet date period - open range custom delimeters", dp, 
+                    std::string("[ 2004-10-13 / 2004-10-20 )"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+    // trac-11142: actually test delimiter_strings(...)
+    {
+        date_facet* datefacet = new date_facet();
+        datefacet->set_iso_extended_format();
+        period_formatter pf(period_formatter::AS_OPEN_RANGE, " / ", "[ ", " )", " ]");
+        pf.delimiter_strings(" to ", "from ", " inclusive", " exclusive");
+        datefacet->period_formatter(pf);
+        teststreaming("custom date facet date period - delimiter_strings", dp,
+            std::string("from 2004-10-13 to 2004-10-20 inclusive"),
+            std::locale(std::locale::classic(), datefacet));
+    }
+
+    {
+      date_facet* datefacet = new date_facet("%A %b %d, %Y");
+      datefacet->short_month_names(short_month_names);
+      teststreaming("custom date facet -- custom short month names", d, 
+                    std::string("Wednesday *oct* 13, 2004"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+    {
+      date_facet* datefacet = new date_facet("%B %A %d, %Y");
+      datefacet->long_month_names(long_month_names);
+      teststreaming("custom date facet -- custom long month names", d, 
+                    std::string("**October** Wednesday 13, 2004"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+    {
+      date_facet* datefacet = new date_facet("%a - %b %d, %Y");
+      datefacet->short_weekday_names(short_weekday_names);
+      std::cout.imbue(std::locale(std::locale::classic(), datefacet));
+      std::cout << d << std::endl;
+      teststreaming("custom date facet -- custom short weekday names", d, 
+                    std::string("day4 - Oct 13, 2004"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+    {
+      date_facet* datefacet = new date_facet("%b %d, %Y ++ %A");
+      datefacet->long_weekday_names(long_weekday_names);
+      teststreaming("custom date facet -- custom short weekday names", d, 
+                    std::string("Oct 13, 2004 ++ Wed-3"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+    {//date
+      date_facet* datefacet = new date_facet("%Y-%b-%d %%d");
+      teststreaming("Literal '%' in date format", d, 
+                    std::string("2004-Oct-13 %d"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+    {
+      date_facet* datefacet = new date_facet("%Y-%b-%d %%%d");
+      teststreaming("Multiple literal '%'s in date format", d, 
+                    std::string("2004-Oct-13 %13"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+    {
+      date d1(2004,Oct, 13);
+      date_facet* datefacet = new date_facet("%d%m%y");
+      teststreaming("Single digit year and %y", d1,
+                    std::string("131004"),
+                    std::locale(std::locale::classic(), datefacet));
+    }
+    {//month
+      date_facet* datefacet = new date_facet();
+      datefacet->month_format("%b %%b");
+      teststreaming("Literal '%' in month format", d.month(), 
+                    std::string("Oct %b"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->month_format("%b %%%b");
+      teststreaming("Multiple literal '%'s in month format", d.month(), 
+                    std::string("Oct %Oct"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+    {//weekday
+      date_facet* datefacet = new date_facet();
+      datefacet->weekday_format("%a %%a");
+      teststreaming("Literal '%' in weekday format", d.day_of_week(), 
+                    std::string("Wed %a"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+    {
+      date_facet* datefacet = new date_facet();
+      datefacet->weekday_format("%a %%%a");
+      teststreaming("Multiple literal '%'s in weekday format", d.day_of_week(), 
+                    std::string("Wed %Wed"), 
+                    std::locale(std::locale::classic(), datefacet));
+    }
+
+
+
+    date d_not_date(not_a_date_time);
+    teststreaming("special value, no special facet", d_not_date, std::string("not-a-date-time"));
+
+
+//       std::cout.imbue(std::locale(std::locale::classic(), datefacet));
+//       std::cout << d << std::endl;
+
+
+  }
+
+  // date_generator tests
+  {
+    partial_date pd(31,Oct);
+    teststreaming("partial date", pd, std::string("31 Oct"));
+    first_kday_of_month fkd(Tuesday, Sep);
+    teststreaming("first kday", fkd, std::string("first Tue of Sep"));
+    nth_kday_of_month nkd2(nth_kday_of_month::second, Tuesday, Sep);
+    teststreaming("nth kday", nkd2, std::string("second Tue of Sep"));
+    nth_kday_of_month nkd3(nth_kday_of_month::third, Tuesday, Sep);
+    teststreaming("nth kday", nkd3, std::string("third Tue of Sep"));
+    nth_kday_of_month nkd4(nth_kday_of_month::fourth, Tuesday, Sep);
+    teststreaming("nth kday", nkd4, std::string("fourth Tue of Sep"));
+    nth_kday_of_month nkd5(nth_kday_of_month::fifth, Tuesday, Sep);
+    teststreaming("nth kday", nkd5, std::string("fifth Tue of Sep"));
+    last_kday_of_month lkd(Tuesday, Sep);
+    teststreaming("last kday", lkd, std::string("last Tue of Sep"));
+    first_kday_before fkb(Wednesday);
+    teststreaming("First before", fkb, std::string("Wed before"));
+    first_kday_after fka(Thursday);
+    teststreaming("First after", fka, std::string("Thu after"));
+  }
+
+#if !defined(BOOST_NO_STD_WSTRING) 
+    date d(2004,Oct, 13);
+    date_period dp(d, d + days(7));
+    date d_not_date(not_a_date_time);
+    
+    teststreaming("special value, no special facet wide", d_not_date, 
+                  std::wstring(L"not-a-date-time"));
+  {
+    wdate_facet* wdatefacet = new wdate_facet();
+    wdatefacet->format(wdate_facet::standard_format_specifier);
+    teststreaming("widestream default classic date", d, 
+                  std::wstring(L"10/13/04"),
+                  std::locale(std::locale::classic(), wdatefacet));
+  }
+  {
+    wdate_facet* wdatefacet = new wdate_facet();
+    wdatefacet->format(wdate_facet::standard_format_specifier);
+    teststreaming("widestream default classic date period", dp, 
+                  std::wstring(L"[10/13/04/10/19/04]"),
+                  std::locale(std::locale::classic(), wdatefacet));
+  }
+  {
+    wdate_facet* wdatefacet = new wdate_facet();
+    wdatefacet->format(L"%Y-%d-%b %a");
+    teststreaming("widestream custom date facet", d, 
+                  std::wstring(L"2004-13-Oct Wed"), 
+                  std::locale(std::locale::classic(), wdatefacet));
+  }
+  {
+    wdate_facet* wdatefacet = new wdate_facet();
+    wdatefacet->format(L"%Y-%d-%b %a");
+    teststreaming("widestream custom date facet date period", dp, 
+                  std::wstring(L"[2004-13-Oct Wed/2004-19-Oct Tue]"), 
+                  std::locale(std::locale::classic(), wdatefacet));
+  }
+  {
+    wdate_facet* wdatefacet = new wdate_facet();
+    wdatefacet->set_iso_extended_format();
+    wperiod_formatter pf(wperiod_formatter::AS_OPEN_RANGE, L" / ", L"[ ", L" )", L" ]");
+    wdatefacet->period_formatter(pf);
+    teststreaming("custom date facet date period - open range custom delimeters", dp, 
+                  std::wstring(L"[ 2004-10-13 / 2004-10-20 )"), 
+                  std::locale(std::locale::classic(), wdatefacet));
+  }
+  /************* small gregorian types tests *************/ 
+  wdate_facet* small_types_facet = new wdate_facet();
+  std::locale loc = std::locale(std::locale::classic(), small_types_facet);
+
+  // greg_year test
+  greg_year gy(2004);
+  teststreaming("greg_year", gy, std::string("2004"));
+
+  // greg_month tests
+  {
+    for(greg_month::value_type i = 0; i < 12; ++i) {
+      greg_month m(i+1); // month numbers 1-12
+      teststreaming("greg_month short", m, short_months[i], loc);
+    }
+    small_types_facet->month_format(L"%B"); // full name
+    for(greg_month::value_type i = 0; i < 12; ++i) {
+      greg_month m(i+1); // month numbers 1-12
+      teststreaming("greg_month full", m, full_months[i], loc);
+    }
+  }
+
+  // greg_weekday tests
+  {
+    for(greg_weekday::value_type i = 0; i < 7; ++i) {
+      greg_weekday gw(i); // weekday numbers 0-6
+      teststreaming("greg_weekday short", gw, short_weekdays[i], loc);
+    }
+    small_types_facet->weekday_format(L"%A"); // full name
+    for(greg_weekday::value_type i = 0; i < 7; ++i) {
+      greg_weekday gw(i); // weekday numbers 0-6
+      teststreaming("greg_weekday full", gw, full_weekdays[i], loc);
+    }
+  }
+#endif // BOOST_NO_STD_WSTRING
+
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testdate_input_facet.cpp b/src/boost/libs/date_time/test/gregorian/testdate_input_facet.cpp
new file mode 100644
index 000000000..d0b9c19cc
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testdate_input_facet.cpp
@@ -0,0 +1,582 @@
+/* Copyright (c) 2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#ifndef USE_DATE_TIME_PRE_1_33_FACET_IO
+// for tests that are expected to fail and throw exceptions
+template<class temporal_type, class exception_type>
+bool failure_test(temporal_type component,
+                  const std::string& input,
+                  exception_type const& /*except*/,
+                  boost::gregorian::date_input_facet* facet)
+{
+  using namespace boost::gregorian;
+  bool result = false;
+  std::istringstream iss(input);
+  iss.exceptions(std::ios_base::failbit); // turn on exceptions
+  iss.imbue(std::locale(std::locale::classic(), facet));
+  try {
+    iss >> component;
+  }
+  catch(exception_type& e) {
+    std::cout << "Expected exception caught: \"" 
+              << e.what() << "\"" << std::endl;
+    result = iss.fail(); // failbit must be set to pass test
+  }
+  catch(...) {
+    result = false;
+  }
+
+  return result;
+}
+
+// for tests that are expected to fail quietly
+template<class temporal_type>
+bool failure_test(temporal_type component,
+                  const std::string& input,
+                  boost::gregorian::date_input_facet* facet)
+{
+  using namespace boost::gregorian;
+  std::istringstream iss(input);
+  /* leave exceptions turned off
+   * iss.exceptions(std::ios_base::failbit); */
+  iss.imbue(std::locale(std::locale::classic(), facet));
+  try {
+    iss >> component;
+  }
+  catch(...) {
+    std::cout << "Caught unexpected exception" << std::endl;
+    return false;
+  }
+
+  return iss.fail(); // failbit must be set to pass test
+}
+
+#endif
+
+
+
+int main(){
+#ifndef  USE_DATE_TIME_PRE_1_33_FACET_IO
+  using namespace boost::gregorian;
+
+  {
+    // verify no extra character are consumed
+    greg_month m(1);
+    std::stringstream ss("Mar.");
+    std::istreambuf_iterator<char> sitr(ss), str_end;
+
+    date_input_facet f;
+    f.get(sitr, str_end, ss, m);
+    check("No extra characters consumed", m == greg_month(Mar) && *sitr == '.');
+  }
+ 
+  // set up initial objects
+  date d(not_a_date_time);
+  days dd(not_a_date_time);
+  greg_month m(1);
+  greg_weekday gw(0);
+  greg_day gd(1);
+  greg_year gy(2000);
+  // exceptions for failure_tests
+  std::ios_base::failure e_failure("default");
+  bad_month e_bad_month;
+  bad_year e_bad_year;
+  bad_day_of_month e_bad_day_of_month;
+  bad_weekday e_bad_weekday;
+  bad_day_of_year e_bad_day_of_year;
+
+  // default format tests: date, days, month, weekday, day, year
+  std::istringstream iss("2005-Jan-15 21 Feb Tue 4 2002");
+  iss >> d;
+  check_equal("Default format date", d, date(2005,Jan,15));
+  iss >> dd;
+  check_equal("Default (only) format positive days", dd, days(21));
+  iss >> m;
+  check_equal("Default format month", m, greg_month(2));
+  iss >> gw;
+  check_equal("Default format weekday", gw, greg_weekday(2));
+  iss >> gd;
+  check_equal("Default (only) format day of month", gd, greg_day(4));
+  iss >> gy;
+  check_equal("Default format year", gy, greg_year(2002));
+  // failure tests
+  check("Input Misspelled in year (date) w/exceptions", 
+      failure_test(d, "205-Jan-15", e_bad_year, new date_input_facet()));
+  check("Input Misspelled in year (date) no-exceptions", 
+      failure_test(d, "205-Jan-15", new date_input_facet()));
+  check("Input Misspelled in month (date) w/exceptions", 
+      failure_test(d, "2005-Jsn-15", e_bad_month, new date_input_facet()));
+  check("Input Misspelled in month (date) no-exceptions", 
+      failure_test(d, "2005-Jsn-15", new date_input_facet()));
+  check("Input Misspelled in day (date) w/exceptions", 
+      failure_test(d, "2005-Jan-51", e_bad_day_of_month, new date_input_facet()));
+  check("Input Misspelled in day (date) no-exceptions", 
+      failure_test(d, "2005-Jan-51", new date_input_facet()));
+  check("Input Misspelled greg_weekday w/exceptions", 
+      failure_test(gw, "San", e_bad_weekday, new date_input_facet()));
+  check("Input Misspelled greg_weekday no-exceptions", 
+      failure_test(gw, "San", new date_input_facet()));
+  check("Input Misspelled month w/exceptions", 
+      failure_test(m, "Jsn", e_bad_month, new date_input_facet()));
+  check("Input Misspelled month no-exceptions", 
+      failure_test(m, "Jsn", new date_input_facet()));
+  check("Bad Input greg_day w/exceptions", 
+      failure_test(gd, "Sun", e_bad_day_of_month, new date_input_facet()));
+  check("Bad Input greg_day no-exceptions", 
+      failure_test(gd, "Sun", new date_input_facet()));
+  check("Input Misspelled greg_year w/exceptions", 
+      failure_test(gy, "205", e_bad_year, new date_input_facet()));
+  check("Input Misspelled greg_year no-exceptions", 
+      failure_test(gy, "205", new date_input_facet()));
+
+  // change to full length names, iso date format, and 2 digit year
+  date_input_facet* facet = new date_input_facet();
+  facet->set_iso_format();
+  facet->month_format("%B");
+  facet->weekday_format("%A");
+  facet->year_format("%y");
+  iss.str("20050115 -55 February Tuesday 02");
+  iss.imbue(std::locale(std::locale::classic(), facet));
+
+  iss >> d;
+  check_equal("ISO format date", d, date(2005,Jan,15));
+  iss >> dd;
+  check_equal("Default (only) format negative days", dd, days(-55));
+  iss >> m;
+  check_equal("Full format month", m, greg_month(2));
+  iss >> gw;
+  check_equal("Full format weekday", gw, greg_weekday(2));
+  iss >> gy;
+  check_equal("2 digit format year", gy, greg_year(2002));
+
+  date_input_facet* f1 = new date_input_facet();
+  date_input_facet* f2 = new date_input_facet();
+  f1->set_iso_format();
+  f2->set_iso_format();
+  check("Missing digit(s) in ISO string", failure_test(d,"2005071", f1));
+  check("Missing digit(s) in ISO string", 
+        failure_test(d,"2005071", e_bad_day_of_month, f2));
+
+  { // literal % in format tests
+    date dx(not_a_date_time);
+    greg_month mx(1);
+    greg_weekday gwx(0);
+    greg_year y(1400);
+    date_input_facet* f = new date_input_facet("%%d %Y-%b-%d");
+    std::stringstream ss;
+    ss.imbue(std::locale(ss.getloc(), f));
+
+    ss.str("%d 2005-Jun-14");
+    ss >> dx;
+    check_equal("Literal '%' in date format", dx, date(2005,Jun,14));
+    f->format("%%%d %Y-%b-%d");
+    ss.str("%14 2005-Jun-14");
+    ss >> dx;
+    check_equal("Multiple literal '%'s in date format", dx, date(2005,Jun,14));
+
+    f->month_format("%%b %b");
+    ss.str("%b Jun");
+    ss >> mx;
+    check_equal("Literal '%' in month format", mx, greg_month(6));
+    f->month_format("%%%b");
+    ss.str("%Jun");
+    ss >> mx;
+    check_equal("Multiple literal '%'s in month format", mx, greg_month(6));
+
+    f->weekday_format("%%a %a");
+    ss.str("%a Tue");
+    ss >> gwx;
+    check_equal("Literal '%' in weekday format", gwx, greg_weekday(2));
+    f->weekday_format("%%%a");
+    ss.str("%Tue");
+    ss >> gwx;
+    check_equal("Multiple literal '%'s in weekday format", gwx, greg_weekday(2));
+
+    f->year_format("%%Y %Y");
+    ss.str("%Y 2005");
+    ss >> y;
+    check_equal("Literal '%' in year format", y, greg_year(2005));
+    f->year_format("%%%Y");
+    ss.str("%2005");
+    ss >> y;
+    check_equal("Multiple literal '%'s in year format", y, greg_year(2005));
+
+    f->year_format("%Y%");
+    ss.str("2005%");
+    ss >> y;
+    check_equal("Trailing'%'s in year format", y, greg_year(2005));
+  }
+
+  // All days, month, weekday, day, and year formats have been tested
+  // begin testing other date formats
+  facet->set_iso_extended_format();
+  iss.str("2005-01-15");
+  iss >> d;
+  check_equal("ISO Extended format date", d, date(2005,Jan,15));
+
+  facet->format("%B %d, %Y");
+  iss.str("March 15, 2006");
+  iss >> d;
+  check_equal("Custom date format: \"%B %d, %Y\" => 'March 15, 2006'",
+      d, date(2006,Mar,15));
+
+  facet->format("%Y-%j"); // Ordinal format ISO8601(2000 sect 5.2.2.1 extended)
+  iss.str("2006-074");
+  iss >> d;
+  check_equal("Custom date format: \"%Y-%j\" => '2006-074'",
+      d, date(2006,Mar,15));
+  check("Bad input Custom date format: \"%Y-%j\" => '2006-74' (w/exceptions)",
+      failure_test(d, "2006-74", e_bad_day_of_year, facet));
+  check("Bad input Custom date format: \"%Y-%j\" => '2006-74' (no exceptions)",
+      failure_test(d, "2006-74", facet));
+
+  // date_period tests
+
+  // A date_period is constructed with an open range. So the periods
+  // [2000-07--04/2000-07-25) <-- open range
+  // And
+  // [2000-07--04/2000-07-24] <-- closed range
+  // Are equal
+  date begin(2002, Jul, 4);
+  days len(21);
+  date_period dp(date(2000,Jan,1), days(1));
+  iss.str("[2002-07-04/2002-07-24]");
+  facet->set_iso_extended_format();
+  iss >> dp;
+  check_equal("Default period (closed range)", dp, date_period(begin,len));
+  {
+    std::stringstream ss;
+    date dx(not_a_date_time);
+    date d2 = day_clock::local_day();
+    date d3(neg_infin);
+    date d4(pos_infin);
+    date_period dpx(d2, dx); // date/nadt
+    date_period dp2(dx, dx); // nadt/nadt
+    date_period dp3(d3, d4);
+    ss << dpx;
+    ss >> dp2;
+    check_equal("Special values period (reversibility test)", dpx, dp2);
+    ss.str("[-infinity/+infinity]");
+    ss >> dp2;
+    check_equal("Special values period (infinities)", dp3, dp2);
+  }
+
+
+  // open range
+  period_parser pp(period_parser::AS_OPEN_RANGE);
+  iss.str("[2002-07-04/2002-07-25)");
+  facet->period_parser(pp);
+  iss >> dp;
+  check_equal("Open range period", dp, date_period(begin,len));
+  // custom period delimiters
+  pp.delimiter_strings(" to ", "from ", " exclusive", " inclusive");
+  iss.str("from 2002-07-04 to 2002-07-25 exclusive");
+  facet->period_parser(pp);
+  iss >> dp;
+  check_equal("Open range period - custom delimiters", dp, date_period(begin,len));
+  pp.range_option(period_parser::AS_CLOSED_RANGE);
+  iss.str("from 2002-07-04 to 2002-07-24 inclusive");
+  facet->period_parser(pp);
+  iss >> dp;
+  check_equal("Closed range period - custom delimiters", dp, date_period(begin,len));
+
+
+  // date_generator tests
+
+  // date_generators use formats contained in the 
+  // date_input_facet for weekdays and months
+  // reset month & weekday formats to defaults
+  facet->month_format("%b");
+  facet->weekday_format("%a");
+
+  partial_date pd(1,Jan);
+  nth_kday_of_month nkd(nth_kday_of_month::first, Sunday, Jan);
+  first_kday_of_month fkd(Sunday, Jan);
+  last_kday_of_month lkd(Sunday, Jan);
+  first_kday_before fkb(Sunday);
+  first_kday_after fka(Sunday);
+  // using default date_generator_parser "nth_strings"
+  iss.str("29 Feb");
+  iss >> pd;
+  // Feb-29 is a valid date_generator, get_date() will fail in a non-leap year
+  check_equal("Default strings, partial_date",
+      pd.get_date(2004), date(2004,Feb,29));
+  iss.str("second Mon of Mar");
+  iss >> nkd; 
+  check_equal("Default strings, nth_day_of_the_week_in_month",
+      nkd.get_date(2004), date(2004,Mar,8));
+  iss.str("first Tue of Apr");
+  iss >> fkd;
+  check_equal("Default strings, first_day_of_the_week_in_month",
+      fkd.get_date(2004), date(2004,Apr,6));
+  iss.str("last Wed of May");
+  iss >> lkd;
+  check_equal("Default strings, last_day_of_the_week_in_month",
+      lkd.get_date(2004), date(2004,May,26));
+  iss.str("Thu before");
+  iss >> fkb;
+  check_equal("Default strings, first_day_of_the_week_before",
+      fkb.get_date(date(2004,Feb,8)), date(2004,Feb,5));
+  iss.str("Fri after");
+  iss >> fka;
+  check_equal("Default strings, first_day_of_the_week_after",
+      fka.get_date(date(2004,Feb,1)), date(2004,Feb,6));
+  // failure tests
+  check("Incorrect elements (date_generator) w/exceptions", // after/before type mixup
+      failure_test(fkb, "Fri after", e_failure, new date_input_facet()));
+  check("Incorrect elements (date_generator) no exceptions", // after/before type mixup
+      failure_test(fkb, "Fri after", new date_input_facet()));
+  check("Incorrect elements (date_generator) w/exceptions", // first/last type mixup
+      failure_test(lkd, "first Tue of Apr", e_failure, new date_input_facet()));
+  check("Incorrect elements (date_generator) no exceptions", // first/last type mixup
+      failure_test(lkd, "first Tue of Apr", new date_input_facet()));
+  check("Incorrect elements (date_generator) w/exceptions", // 'in' is wrong
+      failure_test(nkd, "second Mon in Mar", e_failure, new date_input_facet()));
+  check("Incorrect elements (date_generator) no exceptions", // 'in' is wrong
+      failure_test(nkd, "second Mon in Mar", new date_input_facet()));
+
+  // date_generators - custom element strings
+  facet->date_gen_element_strings("1st","2nd","3rd","4th","5th","final","prior to","past","in");
+  iss.str("3rd Sat in Jul");
+  iss >> nkd;
+  check_equal("Custom strings, nth_day_of_the_week_in_month",
+      nkd.get_date(2004), date(2004,Jul,17));
+  iss.str("1st Wed in May");
+  iss >> fkd;
+  check_equal("Custom strings, first_day_of_the_week_in_month",
+      fkd.get_date(2004), date(2004,May,5));
+  iss.str("final Tue in Apr");
+  iss >> lkd;
+  check_equal("Custom strings, last_day_of_the_week_in_month",
+      lkd.get_date(2004), date(2004,Apr,27));
+  iss.str("Fri prior to");
+  iss >> fkb;
+  check_equal("Custom strings, first_day_of_the_week_before",
+      fkb.get_date(date(2004,Feb,8)), date(2004,Feb,6));
+  iss.str("Thu past");
+  iss >> fka;
+  check_equal("Custom strings, first_day_of_the_week_after",
+      fka.get_date(date(2004,Feb,1)), date(2004,Feb,5));
+
+  // date_generators - special case with empty element string
+  /* Doesn't work. Empty string returns -1 from string_parse_tree 
+   * because it attempts to match the next set of characters in the 
+   * stream to the wrong element. Ex. It attempts to match "Mar" to 
+   * the 'of' element in the test below.
+   *
+  facet->date_gen_element_strings("1st","2nd","3rd","4th","5th","final","prior to","past",""); // the 'of' string is an empty string
+  iss.str("final Mon Mar");
+  iss >> lkd;
+  check_equal("Special case, empty element string",
+      lkd.get_date(2005), date(2005,Mar,28));
+      */
+
+
+  // special values tests (date and days only)
+  iss.str("minimum-date-time +infinity");
+  iss >> d;
+  iss >> dd;
+  check_equal("Special values, default strings, min_date_time date",
+      d, date(min_date_time));
+  check_equal("Special values, default strings, pos_infin days",
+      dd, days(pos_infin));
+  iss.str("-infinity maximum-date-time");
+  iss >> d;
+  iss >> dd;
+  check_equal("Special values, default strings, neg_infin date",
+      d, date(neg_infin));
+  check_equal("Special values, default strings, max_date_time days",
+      dd, days(max_date_time));
+  iss.str("not-a-date-time");
+  iss >> d;
+  check_equal("Special values, default strings, not_a_date_time date",
+      d, date(not_a_date_time));
+
+  // in addition check that special_value_from_string also works correctly for other special values
+  check_equal("Special values, default strings, not_special test",
+      special_value_from_string("not_special"), not_special);
+  check_equal("Special values, default strings, junk test",
+      special_value_from_string("junk"), not_special);
+
+  // special values custom, strings
+  special_values_parser svp("NADT", "MINF", "INF", "MINDT", "MAXDT");
+  facet->special_values_parser(svp);
+  iss.str("MINDT INF");
+  iss >> d;
+  iss >> dd;
+  check_equal("Special values, custom strings, min_date_time date",
+      d, date(min_date_time));
+  check_equal("Special values, custom strings, pos_infin days",
+      dd, days(pos_infin));
+  iss.str("MINF MAXDT");
+  iss >> d;
+  iss >> dd;
+  check_equal("Special values, custom strings, neg_infin date",
+      d, date(neg_infin));
+  check_equal("Special values, custom strings, max_date_time days",
+      dd, days(max_date_time));
+  iss.str("NADT");
+  iss >> dd;
+  check_equal("Special values, custom strings, not_a_date_time days",
+      dd, days(not_a_date_time));
+  // failure test
+  check("Misspelled input, special_value date w/exceptions",
+      failure_test(d, "NSDT", e_bad_year, new date_input_facet()));
+  check("Misspelled input, special_value date no exceptions",
+      failure_test(d, "NSDT", new date_input_facet()));
+  check("Misspelled input, special_value days w/exceptions",
+      failure_test(dd, "NSDT", e_failure, new date_input_facet()));
+  check("Misspelled input, special_value days no exceptions",
+      failure_test(dd, "NSDT", new date_input_facet()));
+
+  {
+    // German names. Please excuse any errors, I don't speak German and
+    // had to rely on an on-line translation service.
+    // These tests check one of each (at least) from all sets of custom strings
+
+    // create a custom format_date_parser
+    std::string m_a[] = {"Jan","Feb","Mar","Apr","Mai",
+                         "Jun","Jul","Aug","Sep","Okt","Nov","Dez"};
+    std::string m_f[] = {"Januar","Februar","Marz","April",
+                         "Mai","Juni","Juli","August",
+                         "September","Oktober","November","Dezember"};
+    std::string w_a[] = {"Son", "Mon", "Die","Mit", "Don", "Fre", "Sam"};
+    std::string w_f[] = {"Sonntag", "Montag", "Dienstag","Mittwoch",
+                         "Donnerstag", "Freitag", "Samstag"};
+    typedef boost::date_time::format_date_parser<date, char> date_parser;
+    date_parser::input_collection_type months_abbrev;
+    date_parser::input_collection_type months_full;
+    date_parser::input_collection_type wkdays_abbrev;
+    date_parser::input_collection_type wkdays_full;
+    months_abbrev.assign(m_a, m_a+12);
+    months_full.assign(m_f, m_f+12);
+    wkdays_abbrev.assign(w_a, w_a+7);
+    wkdays_full.assign(w_f, w_f+7);
+    date_parser d_parser("%B %d %Y",
+                         months_abbrev, months_full,
+                         wkdays_abbrev, wkdays_full);
+
+    // create a special_values parser
+    special_values_parser sv_parser("NichtDatumzeit",
+                                    "Negativ Unendlichkeit",
+                                    "Positiv Unendlichkeit",
+                                    "Wenigstes Datum",
+                                    "Maximales Datum");
+
+    // create a period_parser
+    period_parser p_parser; // default will do
+    // create date_generator_parser
+    typedef boost::date_time::date_generator_parser<date,char> date_gen_parser;
+    date_gen_parser dg_parser("Zuerst","Zweitens","Dritt","Viert",
+                              "F\xC3\xBCnft","Letzt","Vor","Nach","Von");
+
+    // create the date_input_facet
+    date_input_facet* de_facet =
+      new date_input_facet("%B %d %Y",
+                           d_parser,
+                           sv_parser,
+                           p_parser,
+                           dg_parser);
+    std::istringstream iss2;
+    iss2.imbue(std::locale(std::locale::classic(), de_facet));
+    // June 06 2005, Dec, minimum date, Tues
+    iss2.str("Juni 06 2005 Dez Wenigstes Datum Die");
+    iss2 >> d;
+    iss2 >> m;
+    check_equal("German names: date", d, date(2005, Jun, 6));
+    check_equal("German names: month", m, greg_month(Dec));
+    iss2 >> d;
+    iss2 >> gw;
+    check_equal("German names: special value date", d, date(min_date_time));
+    check_equal("German names: short weekday", gw, greg_weekday(Tuesday));
+    de_facet->weekday_format("%A"); // long weekday
+    // Tuesday, Second Tuesday of Mar
+    iss2.str("Dienstag Zweitens Dienstag von Mar");
+    iss2 >> gw;
+    iss2 >> nkd;
+    check_equal("German names: long weekday", gw, greg_weekday(Tuesday));
+    check_equal("German names, nth_day_of_the_week_in_month",
+        nkd.get_date(2005), date(2005,Mar,8));
+    // Tuesday after
+    iss2.str("Dienstag Nach");
+    iss2 >> fka;
+    check_equal("German names, first_day_of_the_week_after",
+        fka.get_date(date(2005,Apr,5)), date(2005,Apr,12));
+  }
+
+  {
+    // test name replacement functions
+
+    // collections for adding to facet
+    const char* const month_short_names[]={"*jan*","*feb*","*mar*",
+                                           "*apr*","*may*","*jun*",
+                                           "*jul*","*aug*","*sep*",
+                                           "*oct*","*nov*","*dec*"};
+    const char* const month_long_names[]={"**January**","**February**","**March**",
+                                          "**April**","**May**","**June**",
+                                          "**July**","**August**","**September**",
+                                          "**October**","**November**","**December**"};
+    const char* const weekday_short_names[]={"day1", "day2","day3","day4",
+                                             "day5","day6","day7"};
+    const char* const weekday_long_names[]= {"Sun-0", "Mon-1", "Tue-2",
+                                             "Wed-3", "Thu-4",
+                                             "Fri-5", "Sat-6"};
+
+    std::vector<std::basic_string<char> > short_weekday_names;
+    std::vector<std::basic_string<char> > long_weekday_names;
+    std::vector<std::basic_string<char> > short_month_names;
+    std::vector<std::basic_string<char> > long_month_names;
+
+    std::copy(&weekday_short_names[0],
+              &weekday_short_names[7],
+              std::back_inserter(short_weekday_names));
+    std::copy(&weekday_long_names[0],
+              &weekday_long_names[7],
+              std::back_inserter(long_weekday_names));
+    std::copy(&month_short_names[0],
+              &month_short_names[12],
+              std::back_inserter(short_month_names));
+    std::copy(&month_long_names[0],
+              &month_long_names[12],
+              std::back_inserter(long_month_names));
+
+    date dx(not_a_date_time);
+    date_input_facet* facetx = new date_input_facet();
+    std::stringstream ss;
+    ss.imbue(std::locale(std::locale::classic(), facetx));
+    facetx->short_month_names(short_month_names);
+    facetx->short_weekday_names(short_weekday_names);
+    facetx->long_month_names(long_month_names);
+    facetx->long_weekday_names(long_weekday_names);
+    facetx->format("%a %b %d, %Y");
+    ss.str("day7 *apr* 23, 2005");
+    ss >> dx;
+    check_equal("Short custom names, set via accessor function", dx.day_of_week(), greg_weekday(6));
+    check_equal("Short custom names, set via accessor function", dx.month(), greg_month(4));
+    ss.str("");
+    ss.str("Sun-0 **April** 24, 2005");
+    facetx->format("%A %B %d, %Y");
+    ss >> dx;
+    check_equal("Long custom names, set via accessor function", dx.day_of_week(), greg_weekday(0));
+    check_equal("Long custom names, set via accessor function", dx.month(), greg_month(4));
+
+  }
+#else
+    check("This test is a nop for platforms with USE_DATE_TIME_PRE_1_33_FACET_IO",
+          true);
+#endif
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testdate_iterator.cpp b/src/boost/libs/date_time/test/gregorian/testdate_iterator.cpp
new file mode 100644
index 000000000..f82e3d22f
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testdate_iterator.cpp
@@ -0,0 +1,367 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+
+
+void test_month_decrement_iterator(const boost::gregorian::date *Answers, int array_len){
+  using namespace boost::gregorian;
+  typedef boost::date_time::month_functor<date> mfg;
+    
+  boost::date_time::date_itr<mfg, date> ditr(Answers[array_len-1]);
+  int i = array_len-1;
+  std::cout << "month iter decrement test..." << std::endl;
+  try { 
+    for (; ditr > Answers[0] - date_duration(1); --ditr) {
+      check("month iterator: " + to_iso_string(*ditr), Answers[i] == *ditr);
+      i--;
+    }
+    check("month iterator iteration count", i == -1);
+  }
+  catch(std::exception& e) 
+  {
+    check("month iterator: exception failure", false);      
+    std::cout << e.what() << std::endl;
+  }
+}
+
+void test_base_iterator(boost::gregorian::date end,
+                        boost::gregorian::date_iterator& di,
+                        std::string& data)
+{
+  using namespace boost::gregorian;
+  for (; di < end; ++di) {
+    data += to_iso_string(*di) + " ";
+  }
+}
+
+int
+main() 
+{
+  using namespace boost::gregorian;
+
+  day_iterator di(date(2002,Jan,1));
+  std::string data;
+  test_base_iterator(date(2002,Jan,3),di,data);
+  month_iterator di2(date(2002,Jan,3));
+  test_base_iterator(date(2002,Mar,1),di2,data);
+  std::string result("20020101 20020102 20020103 20020203 ");
+  check("base iterator", data == result); 
+  std::cout << data << std::endl;
+
+
+  typedef boost::date_time::day_functor<date> dfg;
+  
+  {
+    const date DayAnswers[] = {date(2000,Jan,20),date(2000,Jan,22),date(2000,Jan,24)};
+    boost::date_time::date_itr<dfg,date> ditr(date(2000,Jan,20),2);
+    int i=0;
+    for (; ditr < date(2000,Jan,25); ++ditr) {
+      //std::cout << *ditr << " ";
+      check("day iterator -- 2 days", DayAnswers[i] == *ditr);
+      i++;
+    }
+    check("day iterator -- 2 days", i == 3); // check the number of iterations
+    // decrement
+    i = 2;
+    --ditr;
+    for (; ditr > date(2000,Jan,19); --ditr) {
+      //std::cout << *ditr << " ";
+      check("day iterator decrement -- 2 days", DayAnswers[i] == *ditr);
+      i--;
+    }
+    check("day iterator decrement -- 2 days", i == -1); // check the number of iterations
+  }
+
+  typedef boost::date_time::week_functor<date> wfg;
+  {
+    const date WeekAnswers[] = {date(2000,Jan,20),date(2000,Jan,27),date(2000,Feb,3)};
+    boost::date_time::date_itr<wfg, date> ditr(date(2000,Jan,20));
+    int i=0;
+    for (; ditr < date(2000,Feb,6); ++ditr) {
+      //std::cout << *ditr << " ";
+      check("week iterator", WeekAnswers[i] == *ditr);
+      i++;
+    }
+    check("week iterator", i == 3);
+    // decrement
+    i=2;
+    --ditr;
+    for (; ditr > date(2000,Jan,19); --ditr) {
+      //std::cout << *ditr << " ";
+      check("week iterator", WeekAnswers[i] == *ditr);
+      i--;
+    }
+    check("week iterator", i == -1);
+  }
+
+  {
+    const date WeekAnswers[] = {date(2000,Jan,20),date(2000,Feb,3)};
+    boost::date_time::date_itr<wfg, date> ditr(date(2000,Jan,20),2);
+    int i=0;
+    for (; ditr < date(2000,Feb,6); ++ditr) {
+      //std::cout << *ditr << " ";
+      check("week iterator", WeekAnswers[i] == *ditr);
+      i++;
+    }
+    check("week iterator", i == 2);
+    // decrement
+    i=1;
+    --ditr;
+    for (; ditr > date(2000,Jan,19); --ditr) {
+      //std::cout << *ditr << " ";
+      check("week iterator", WeekAnswers[i] == *ditr);
+      i--;
+    }
+    check("week iterator", i == -1);
+  }
+
+  {
+    const date WeekAnswers[] = {date(2000,Jan,20),date(2000,Feb,3), date(2000,Feb,17)};
+    boost::date_time::date_itr<wfg, date> ditr(date(2000,Jan,20),2);
+    int i=0;
+    for (; ditr < date(2000,Feb,20); ++ditr) {
+      //std::cout << *ditr << " ";
+      check("week iterator -- 2 weeks", WeekAnswers[i] == *ditr);
+      i++;
+    }
+    check("week iterator -- 2 weeks", i == 3);
+    // decrement
+    i=2;
+    --ditr;
+    for (; ditr > date(2000,Jan,19); --ditr) {
+      //std::cout << *ditr << " ";
+      check("week iterator -- 2 weeks", WeekAnswers[i] == *ditr);
+      i--;
+    }
+    check("week iterator -- 2 weeks", i == -1);
+  }
+
+  typedef boost::date_time::month_functor<date> mfg;
+  {
+    const date MonthAnswers[] = {
+      date(2000,Jan,1),date(2000,Feb,1),date(2000,Mar,1),date(2000,Apr,1),
+      date(2000,May,1),date(2000,Jun,1),date(2000,Jul,1),date(2000,Aug,1),
+      date(2000,Sep,1),date(2000,Oct,1),date(2000,Nov,1),date(2000,Dec,1),
+      date(2001,Jan,1)
+    };
+    test_month_decrement_iterator(MonthAnswers, 13);
+    
+    boost::date_time::date_itr<mfg, date> ditr(date(2000,Jan,1));
+    int i = 0;
+    try { 
+      for (; ditr < date(2001,Jan,2); ++ditr) {
+        check("month iterator: " + to_iso_string(*ditr), MonthAnswers[i] == *ditr);
+        i++;
+      }
+      check("month iterator iteration count", i == 13);
+    }
+    catch(std::exception& e) 
+    {
+      check("month iterator: exception failure", false);      
+      std::cout << e.what() << std::endl;
+    }
+  }
+
+  {
+    const date MonthAnswers[] = {
+      date(2000,Jan,31),date(2000,Feb,29),date(2000,Mar,31),date(2000,Apr,30),
+      date(2000,May,31),date(2000,Jun,30),date(2000,Jul,31),date(2000,Aug,31),
+      date(2000,Sep,30),date(2000,Oct,31),date(2000,Nov,30),date(2000,Dec,31),
+      date(2001,Jan,31)
+    };
+    test_month_decrement_iterator(MonthAnswers, 13);
+    
+    boost::date_time::date_itr<mfg, date> ditr(date(2000,Jan,31));
+    int i = 0;
+    try { 
+      for (; ditr < date(2001,Feb,1); ++ditr) {
+        //      std::cout << *ditr << " ";
+        check("last day of month iterator: " + to_iso_string(*ditr), 
+              MonthAnswers[i] == *ditr);
+        //check("last day of month iterator", MonthAnswers[i] == *ditr);
+        i++;
+      }
+      check("last day of month iterator", i == 13);
+    }
+    catch(std::exception& e) 
+    {
+      check("last day of month iterator: exception failure", false);      
+      std::cout << e.what() << std::endl;
+    }
+  }
+
+  {
+    const date MonthAnswers[] = {
+      date(2000,Feb,29),date(2000,Mar,31),date(2000,Apr,30),
+      date(2000,May,31),date(2000,Jun,30),date(2000,Jul,31),date(2000,Aug,31),
+      date(2000,Sep,30),date(2000,Oct,31),date(2000,Nov,30),date(2000,Dec,31),
+      date(2001,Jan,31),date(2001,Feb,28)
+    };
+    test_month_decrement_iterator(MonthAnswers, 13);
+    
+    boost::date_time::date_itr<mfg, date> ditr(date(2000,Feb,29));
+    int i = 0;
+    try { 
+      for (; ditr < date(2001,Mar,1); ++ditr) {
+        //      std::cout << *ditr << " ";
+        check("last day of month iterator2: " + to_iso_string(*ditr), 
+              MonthAnswers[i] == *ditr);
+        //check("last day of month iterator", MonthAnswers[i] == *ditr);
+        i++;
+      }
+      check("last day of month iterator2", i == 13);
+    }
+    catch(std::exception& e) 
+    {
+      check("last day of month iterator: exception failure", false);      
+      std::cout << e.what() << std::endl;
+    }
+  }
+
+  { // running a span of 5 years to verify snap to end doesn't occur at next leap year
+    const date MonthAnswers[] = {
+      date(2000,Feb,28),date(2000,Mar,28),date(2000,Apr,28),date(2000,May,28),
+      date(2000,Jun,28),date(2000,Jul,28),date(2000,Aug,28),date(2000,Sep,28),
+      date(2000,Oct,28),date(2000,Nov,28),date(2000,Dec,28),date(2001,Jan,28),
+      date(2001,Feb,28),date(2001,Mar,28),date(2001,Apr,28),date(2001,May,28),
+      date(2001,Jun,28),date(2001,Jul,28),date(2001,Aug,28),date(2001,Sep,28),
+      date(2001,Oct,28),date(2001,Nov,28),date(2001,Dec,28),date(2002,Jan,28),
+      date(2002,Feb,28),date(2002,Mar,28),date(2002,Apr,28),date(2002,May,28),
+      date(2002,Jun,28),date(2002,Jul,28),date(2002,Aug,28),date(2002,Sep,28),
+      date(2002,Oct,28),date(2002,Nov,28),date(2002,Dec,28),date(2003,Jan,28),
+      date(2003,Feb,28),date(2003,Mar,28),date(2003,Apr,28),date(2003,May,28),
+      date(2003,Jun,28),date(2003,Jul,28),date(2003,Aug,28),date(2003,Sep,28),
+      date(2003,Oct,28),date(2003,Nov,28),date(2003,Dec,28),date(2004,Jan,28),
+      date(2004,Feb,28),date(2004,Mar,28),date(2004,Apr,28),date(2004,May,28),
+      date(2004,Jun,28),date(2004,Jul,28),date(2004,Aug,28),date(2004,Sep,28),
+      date(2004,Oct,28),date(2004,Nov,28),date(2004,Dec,28),date(2005,Jan,28),
+    };
+    test_month_decrement_iterator(MonthAnswers, 60);
+    
+    boost::date_time::date_itr<mfg, date> ditr(date(2000,Feb,28));
+    int i = 0;
+    try { 
+      for (; ditr < date(2005,Feb,1); ++ditr) {
+        //      std::cout << *ditr << " ";
+        check("last day of month iterator3: " + to_iso_string(*ditr), 
+              MonthAnswers[i] == *ditr);
+        //check("last day of month iterator", MonthAnswers[i] == *ditr);
+        i++;
+      }
+      check("last day of month iterator3", i == 60);
+    }
+    catch(std::exception& e) 
+    {
+      check("last day of month iterator: exception failure", false);      
+      std::cout << e.what() << std::endl;
+    }
+  }
+
+  typedef boost::date_time::year_functor<date> yfg;
+  {
+    const date YearAnswers[] = {
+      date(2000,Jan,1),date(2001,Jan,1),date(2002,Jan,1),date(2003,Jan,1),
+      date(2004,Jan,1),date(2005,Jan,1),date(2006,Jan,1),date(2007,Jan,1),
+      date(2008,Jan,1),date(2009,Jan,1),date(2010,Jan,1)
+    };
+    
+    boost::date_time::date_itr<yfg, date> d3(date(2000,Jan,1));
+    int i = 0;
+    for (; d3 < date(2010,Jan,2); ++d3) {
+      //std::cout << *d3 << " ";
+      check("year iterator: " + to_iso_string(*d3), YearAnswers[i] == *d3);
+      i++;
+    }
+    std::cout << "Decrementing...." << std::endl;
+    i = 10;
+    --d3;
+    for (; d3 > date(1999,Dec,31); --d3) {
+      //std::cout << *d3 << " ";
+      check("year iterator: " + to_iso_string(*d3), YearAnswers[i] == *d3);
+      i--;
+    }
+ }
+  { // WON'T snap top end of month
+    const date YearAnswers[] = {
+      date(2000,Feb,28),date(2001,Feb,28),date(2002,Feb,28),date(2003,Feb,28),
+      date(2004,Feb,28),date(2005,Feb,28),date(2006,Feb,28),date(2007,Feb,28),
+      date(2008,Feb,28),date(2009,Feb,28),date(2010,Feb,28)
+    };
+    
+    boost::date_time::date_itr<yfg, date> d3(date(2000,Feb,28));
+    int i = 0;
+    for (; d3 < date(2010,Mar,1); ++d3) {
+      //std::cout << *d3 << " ";
+      check("year iterator: " + to_iso_string(*d3), YearAnswers[i] == *d3);
+      i++;
+    }
+    std::cout << "Decrementing...." << std::endl;
+    i = 10;
+    --d3;
+    for (; d3 > date(2000,Feb,27); --d3) {
+      //std::cout << *d3 << " ";
+      check("year iterator: " + to_iso_string(*d3), YearAnswers[i] == *d3);
+      i--;
+    }
+ }
+  {// WILL snap top end of month
+    const date YearAnswers[] = {
+      date(2000,Feb,29),date(2001,Feb,28),date(2002,Feb,28),date(2003,Feb,28),
+      date(2004,Feb,29),date(2005,Feb,28),date(2006,Feb,28),date(2007,Feb,28),
+      date(2008,Feb,29),date(2009,Feb,28),date(2010,Feb,28)
+    };
+    
+    boost::date_time::date_itr<yfg, date> d3(date(2000,Feb,29));
+    int i = 0;
+    for (; d3 < date(2010,Mar,1); ++d3) {
+      //std::cout << *d3 << " ";
+      check("year iterator: " + to_iso_string(*d3), YearAnswers[i] == *d3);
+      i++;
+    }
+    std::cout << "Decrementing...." << std::endl;
+    i = 10;
+    --d3;
+    for (; d3 > date(2000,Feb,27); --d3) {
+      //std::cout << *d3 << " ";
+      check("year iterator: " + to_iso_string(*d3), YearAnswers[i] == *d3);
+      i--;
+    }
+ }
+
+  {
+    std::cout << "Increment by 2 years...." << std::endl;
+    const date YearAnswers[] = {
+      date(2000,Jan,1),date(2002,Jan,1),
+      date(2004,Jan,1),date(2006,Jan,1),
+      date(2008,Jan,1),date(2010,Jan,1)
+    };
+    
+    boost::date_time::date_itr<yfg, date> d3(date(2000,Jan,1),2);
+    int i = 0;
+    for (; d3 < date(2010,Jan,2); ++d3) {
+      //std::cout << *d3 << " ";
+      check("year iterator: " + to_iso_string(*d3), YearAnswers[i] == *d3);
+      i++;
+    }
+    // decrement
+    std::cout << "Decrementing...." << std::endl;
+    i = 5;
+    --d3;
+    for (; d3 > date(1999,Dec,31); --d3) {
+      //std::cout << *d3 << " ";
+      check("year iterator: " + to_iso_string(*d3), YearAnswers[i] == *d3);
+      i--;
+    }
+  }
+
+
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testfacet.cpp b/src/boost/libs/date_time/test/gregorian/testfacet.cpp
new file mode 100644
index 000000000..82a7253db
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testfacet.cpp
@@ -0,0 +1,342 @@
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst 
+ */
+
+#include <sstream>
+#include <iostream>
+#include <fstream>
+
+#include "boost/date_time/gregorian/greg_month.hpp"
+#include "boost/date_time/gregorian/greg_facet.hpp"
+#include "boost/date_time/date_format_simple.hpp"
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+
+#ifndef BOOST_DATE_TIME_NO_LOCALE
+
+    const char* const de_short_month_names[]={"Jan","Feb","Mar","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez", "NAM"};
+
+    const char* const de_long_month_names[]={"Januar","Februar","Marz","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember","NichtDerMonat"};
+    const char* const de_special_value_names[]={"NichtDatumzeit","-unbegrenztheit", "+unbegrenztheit"};
+
+const char* const de_short_weekday_names[]={"Son", "Mon", "Die","Mit", "Don", "Fre", "Sam"};
+
+    const char* const de_long_weekday_names[]={"Sonntag", "Montag", "Dienstag","Mittwoch", "Donnerstag", "Freitag", "Samstag"};
+
+#endif 
+
+/** Not used for now
+    const char* const es_short_month_names[]={"Ene","Feb","Mar","Abr","Pue","Jun","Jul","Ago","Sep","Oct","Nov","Dic", "NAM"};
+
+    const char* const es_long_month_names[]={"Enero","Febrero","Marcha","Abril","Pueda","Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre","NoAMes"};
+    const char* const es_special_value_names[]={"NoUnRatoDeLaFacha","-infinito", "+infinito"};
+**/
+int
+main()
+{
+//   std::locale native("");
+//   std::cout << "native: " << native.name() << std::endl;
+//#ifndef BOOST_NO_STD_LOCALE
+#ifndef BOOST_DATE_TIME_NO_LOCALE
+
+  using namespace boost::gregorian;
+
+  typedef greg_facet_config facet_config;
+  typedef boost::date_time::all_date_names_put<facet_config> date_facet;
+  typedef boost::date_time::date_names_put<facet_config> date_facet_base;
+  typedef boost::date_time::ostream_month_formatter<date_facet_base> month_formatter;
+
+  {
+    // special_values tests
+    std::stringstream ss;
+    date_facet_base* f = new date_facet_base();
+    std::locale loc(std::locale::classic(), f);
+    ss.imbue(loc);
+    date d(not_a_date_time);
+    ss << d;
+    check("Special value, stream out nadt" , ss.str() == std::string("not-a-date-time"));
+    ss.str("");
+    d = date(neg_infin);
+    ss << d;
+    check("Special value, stream out neg_infin" , ss.str() == std::string("-infinity"));
+    ss.str("");
+    d = date(pos_infin);
+    ss << d;
+    check("Special value, stream out pos_infin" , ss.str() == std::string("+infinity"));
+  }
+
+  date_facet gdnp(de_short_month_names, de_long_month_names, 
+                  de_special_value_names, de_long_weekday_names,
+                  de_long_weekday_names, 
+                  '.', 
+                  boost::date_time::ymd_order_dmy);
+
+  std::stringstream ss;
+  std::ostreambuf_iterator<char> coi(ss);
+  gdnp.put_month_short(coi, Oct);
+  check("check german short month: " + ss.str(), 
+        ss.str() == std::string("Okt"));
+
+  ss.str(""); //reset string stream 
+  greg_month mo(Oct);
+  month_formatter::format_month(mo, ss, gdnp);
+  check("check german short month: " + ss.str(), 
+        ss.str() == std::string("Okt"));
+  ss.str(""); //reset string stream 
+//   month_formatter::format_month(mo, ss, gdnp);
+//   check("check german long month: " + ss.str(), 
+//         ss.str() == std::string("Oktober"));
+
+
+  greg_year_month_day ymd(2002,Oct,1);
+  typedef boost::date_time::ostream_ymd_formatter<greg_year_month_day, date_facet_base> ymd_formatter;
+  ss.str(""); //reset string stream 
+  ymd_formatter::ymd_put(ymd, ss, gdnp);
+  check("check ymd: " + ss.str(), 
+        ss.str() == std::string("01.Okt.2002"));
+
+
+  typedef boost::date_time::ostream_date_formatter<date, date_facet_base> datef;
+
+  std::stringstream os;
+  date d1(2002, Oct, 1);
+  datef::date_put(d1, os, gdnp);
+  check("ostream low level check string:"+os.str(), 
+        os.str() == std::string("01.Okt.2002"));
+
+//   //Locale tests
+  std::locale global;
+  std::cout << "global: " << global.name() << std::endl;
+
+  // put a facet into a locale
+  //check for a facet p319
+  check("no registered facet here",
+        !std::has_facet<date_facet>(global));
+
+  std::locale global2(global, 
+                      new date_facet(de_short_month_names, 
+                                     de_long_month_names,
+                                     de_special_value_names,
+                                     de_long_weekday_names,
+                                     de_long_weekday_names));
+
+  check("facet registered here",
+        std::has_facet<boost::date_time::date_names_put<facet_config> >(global2));
+
+  std::stringstream os2;
+  os2.imbue(global2); 
+  datef::date_put(d1, os2);
+  check("check string imbued ostream: "+os2.str(), 
+        os2.str() == std::string("2002-Okt-01"));
+
+  date infin(pos_infin);
+  os2.str(""); //clear stream
+  datef::date_put(infin, os2);
+  check("check string imbued ostream: "+os2.str(), 
+        os2.str() == std::string("+unbegrenztheit"));
+
+  os2.str(""); //clear stream
+  os2 << infin;
+  check("check string imbued ostream: "+os2.str(), 
+        os2.str() == std::string("+unbegrenztheit"));
+
+
+  date nadt(not_a_date_time);
+  os2.str(""); //clear stream
+  datef::date_put(nadt, os2);
+  check("check string imbued ostream: "+os2.str(), 
+        os2.str() == std::string("NichtDatumzeit"));
+  
+
+  std::stringstream os3;
+  os3 << d1;
+  check("check any old ostream: "+os3.str(), 
+        os3.str() == std::string("2002-Oct-01"));
+
+  std::ofstream f("test_facet_file.out");
+  f << d1 << std::endl;
+  
+//   // date formatter that takes locale and gets facet from locale
+  std::locale german_dates1(global, 
+                            new date_facet(de_short_month_names, 
+                                           de_long_month_names,
+                                           de_special_value_names,
+                                           de_short_weekday_names,
+                                           de_long_weekday_names,
+                                           '.',
+                                           boost::date_time::ymd_order_dmy,
+                                           boost::date_time::month_as_integer));
+
+  os3.imbue(german_dates1); 
+  os3.str("");
+  os3 << d1;
+  check("check date order: "+os3.str(), 
+        os3.str() == std::string("01.10.2002"));
+
+  std::locale german_dates2(global, 
+                            new date_facet(de_short_month_names, 
+                                           de_long_month_names,
+                                           de_special_value_names,
+                                           de_short_weekday_names,
+                                           de_long_weekday_names,
+                                           ' ',
+                                           boost::date_time::ymd_order_iso,
+                                           boost::date_time::month_as_short_string));
+
+  os3.imbue(german_dates2); 
+  os3.str("");
+  os3 << d1;
+  check("check date order: "+os3.str(), 
+        os3.str() == std::string("2002 Okt 01"));
+
+  std::locale german_dates3(global, 
+                            new date_facet(de_short_month_names, 
+                                           de_long_month_names,
+                                           de_special_value_names,
+                                           de_short_weekday_names,
+                                           de_long_weekday_names,
+                                           ' ',
+                                           boost::date_time::ymd_order_us,
+                                           boost::date_time::month_as_long_string));
+
+  os3.imbue(german_dates3); 
+  os3.str("");
+  os3 << d1;
+  check("check date order: "+os3.str(), 
+        os3.str() == std::string("Oktober 01 2002"));
+
+  date_period dp(d1, date_duration(3));
+  os3.str("");
+  os3 << dp;
+  check("check date period: "+os3.str(), 
+        os3.str() == std::string("[Oktober 01 2002/Oktober 03 2002]"));
+
+
+  /*******************************************************************/
+  /* Streaming operations for date durations                         */
+  /*******************************************************************/
+
+  date_duration dur(26);
+  std::stringstream ss2;
+  ss2 << dur;
+  check("date_duration stream out", ss2.str() == std::string("26"));
+
+  dur = date_duration(boost::date_time::pos_infin);
+  ss2.str("");
+  ss2 << dur;
+  check("date_duration stream out", ss2.str() == std::string("+infinity"));
+
+  /*******************************************************************/
+  /* Streaming operations for date generator functions               */
+  /*******************************************************************/
+
+  partial_date pd(26, Jun);
+  //std::stringstream ss2;
+  ss2.str("");
+  ss2 << pd;
+  check("partial date stream out", ss2.str() == std::string("26 Jun"));
+
+  ss2.str("");
+  nth_kday_of_month nkm(nth_kday_of_month::second, Friday, Sep);
+  ss2 << nkm;
+  check("nth kday of month", ss2.str() == std::string("second Fri of Sep"));
+
+  ss2.str("");
+  first_kday_of_month fkm(Saturday, May);
+  ss2 << fkm;
+  check("first kday of month", ss2.str() == std::string("first Sat of May"));
+
+  ss2.str("");
+  last_kday_of_month lkm(Monday, Aug);
+  ss2 << lkm;
+  check("last kday of month", ss2.str() == std::string("last Mon of Aug"));
+
+  ss2.str("");
+  first_kday_after  fka(Thursday);//fkb.get_date(d)
+  ss2 << fka;
+  check("first kday after", ss2.str() == std::string("Thu after"));
+
+  ss2.str("");
+  first_kday_before fkb(Tuesday); // same ^
+  ss2 << fkb;
+  check("first kday after", ss2.str() == std::string("Tue before"));
+
+  std::cout << pd << '\n'
+            << nkm << '\n'
+            << fkm << '\n'
+            << lkm << '\n'
+            << fka << '\n'
+            << fkb << '\n'
+            << std::endl;
+  
+  /*******************************************************************/
+  /* Input Streaming for greg_month                                  */
+  /*******************************************************************/
+  {
+    std::stringstream ss1("January");
+    std::stringstream ss2m("dec"); // misspelled
+    std::stringstream german("Okt");
+    german.imbue(global2);
+    greg_month m(3);
+    ss1 >> m;
+    check("Stream in month", m == greg_month(Jan));
+#ifndef BOOST_NO_STD_WSTRING
+    std::wstringstream ws1(L"Dec");
+    ws1 >> m;
+    check("Wide Stream in month", m == greg_month(Dec));
+#else
+    check("Wide Stream in not supported by this compiler", false);
+#endif // BOOST_NO_STD_WSTRING
+    german >> m;
+    check("Stream in German month", m == greg_month(Oct));
+    try{
+      ss2m >> m; // misspelled
+      check("Bad month exception NOT thrown (misspelled name)", false);
+    }catch(bad_month&){
+      check("Bad month exception caught (misspelled name)", true);
+    }catch(...){
+      check("Bad month exception NOT caught (misspelled name)", false);
+    }
+  }
+  /*******************************************************************/
+  /* Input Streaming for greg_weekday                                */
+  /*******************************************************************/
+  {
+    std::stringstream ss1("Sun");
+    std::stringstream ss2w("Wensday"); // misspelled
+    std::stringstream german("Mittwoch"); // Wednesday
+    german.imbue(global2);
+    greg_weekday wd(Friday); //something not Sunday...
+    ss1 >> wd;
+    check("Stream in weekday", wd == greg_weekday(Sunday));
+#ifndef BOOST_NO_STD_WSTRING
+    std::wstringstream ws1(L"Saturday");
+    ws1 >> wd;
+    check("Wide Stream in weekday", wd == greg_weekday(Saturday));
+#else
+    check("Wide Stream in not supported by this compiler", false);
+#endif // BOOST_NO_STD_WSTRING
+    german >> wd;
+    check("Stream in German weekday", wd == greg_weekday(Wednesday));
+    try{
+      ss2w >> wd;
+      check("Bad weekday exception NOT thrown (misspelled name)", false);
+    }catch(bad_weekday&){
+      check("Bad weekday exception caught (misspelled name)", true);
+    }catch(...){
+      check("Bad weekday exception NOT caught (misspelled name)", false);
+    }
+  }
+
+#else
+  check("No tests executed - Locales not supported by this compiler", false);
+
+#endif //BOOST_DATE_TIME_NO_LOCALE
+
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testformat_date_parser.cpp b/src/boost/libs/date_time/test/gregorian/testformat_date_parser.cpp
new file mode 100644
index 000000000..f29ab4ed2
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testformat_date_parser.cpp
@@ -0,0 +1,363 @@
+
+/* Copyright (c) 2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland
+ */
+
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+#include "boost/date_time/format_date_parser.hpp"
+#include <sstream>
+#include <algorithm>
+#include <iostream>
+
+const wchar_t* const wmonth_short_names[]={L"Jan",L"Feb",L"Mar",
+                                          L"Apr",L"May",L"Jun",
+                                          L"Jul",L"Aug",L"Sep",
+                                          L"Oct",L"Nov",L"Dec"};
+
+const char* const month_short_names[]={"Jan","Feb","Mar",
+                                       "Apr","May","Jun",
+                                       "Jul","Aug","Sep",
+                                       "Oct","Nov","Dec"};
+
+const char* const month_long_names[]={"January","February","March",
+                                      "April","May","June",
+                                      "July","August","September",
+                                      "October","November","December"};
+
+const wchar_t* const wmonth_long_names[]={L"January",L"February",L"March",
+                                          L"April",L"May",L"June",
+                                          L"July",L"August",L"September",
+                                          L"October",L"Novomber",L"December"};
+
+const wchar_t* const wweek_short_names[]= {L"Sun", L"Mon", L"Tue", L"Wed",
+                                           L"Thu", L"Fri", L"Sat"};
+
+const char* const week_short_names[]={"Sun", "Mon","Tue","Wed",
+                                      "Thu","Fri","Sat"};
+
+const wchar_t* const wweek_long_names[]= {L"Sunday", L"Monday", L"Tuesday", 
+                                          L"Wednesday", L"Thursday", 
+                                          L"Friday", L"Saturday"};
+
+const char* const week_long_names[]= {"Sunday", "Monday", "Tuesday", 
+                                      "Wednesday", "Thursday", 
+                                      "Friday", "Saturday"};
+
+
+
+
+std::vector<std::basic_string<char> > short_month_names;
+std::vector<std::basic_string<wchar_t> > wshort_month_names;
+std::vector<std::basic_string<char> > long_month_names;
+std::vector<std::basic_string<wchar_t> > wlong_month_names;
+std::vector<std::basic_string<char> > short_week_names;
+std::vector<std::basic_string<wchar_t> > wshort_week_names;
+std::vector<std::basic_string<char> > long_week_names;
+std::vector<std::basic_string<wchar_t> > wlong_week_names;
+
+
+using namespace boost::gregorian;
+
+void
+wtest_format(const std::basic_string<wchar_t>& format,
+             const std::basic_string<wchar_t>& value,
+             const std::string& testname,
+             boost::gregorian::date expected_res)
+{
+  typedef boost::date_time::format_date_parser<date, wchar_t> parser_type;
+  typedef std::basic_string<wchar_t> string_type;
+  typedef std::istreambuf_iterator<wchar_t> iter_type;
+  try {
+    //    string_type format(format);
+    std::basic_stringstream<wchar_t> ws;
+    ws << value;
+    iter_type sitr(ws);
+    iter_type stream_end;
+
+    parser_type p(format, wshort_month_names, wlong_month_names,
+                  wshort_week_names, wlong_week_names);
+    date d = p.parse_date(sitr, stream_end, format);
+    check_equal(testname, d, expected_res);
+  }
+  catch(std::exception& e) {
+    std::cout << "Got an exception: " << e.what() << std::endl;
+    check(testname, false);
+  }
+}
+
+
+void
+test_format(const std::basic_string<char>& format,
+            const std::basic_string<char>& value,
+            const std::string& testname,
+            boost::gregorian::date expected_res)
+{
+  typedef boost::date_time::format_date_parser<date, char> parser_type;
+  typedef std::basic_string<char> string_type;
+  typedef std::istreambuf_iterator<char> iter_type;
+  try {
+    string_type format(format);
+    std::basic_stringstream<char> ws;
+    ws << value; 
+    iter_type sitr(ws);
+    iter_type stream_end;
+
+    parser_type pt(format, short_month_names, long_month_names,
+                   short_week_names, long_week_names);
+    date d = pt.parse_date(sitr, stream_end, format);
+    check_equal(testname, d, expected_res);
+  }
+  catch(std::exception& e) {
+    std::cout << "Got an exception: " << e.what() << std::endl;
+    check(testname, false);
+  }
+}
+
+
+template<typename charT>
+void
+test_format2(boost::date_time::format_date_parser<date, charT>& parser,
+             const charT* const format,
+             const charT* const value,
+             const std::string& testname,
+             boost::gregorian::date expected_res)
+{
+  try {
+    date d = parser.parse_date(value, format);
+    check_equal(testname, d == expected_res);
+  }
+  catch(std::exception& e) {
+    std::cout << "Got an exception: " << e.what() << std::endl;
+    check(testname, false);
+  }
+}
+
+int
+main()
+{
+  std::copy(&wmonth_short_names[0], 
+            &wmonth_short_names[12],
+            std::back_inserter(wshort_month_names));
+
+  std::copy(&month_short_names[0], 
+            &month_short_names[12],
+            std::back_inserter(short_month_names));
+
+  std::copy(&month_long_names[0], 
+            &month_long_names[12],
+            std::back_inserter(long_month_names));
+
+  std::copy(&wmonth_long_names[0], 
+            &wmonth_long_names[12],
+            std::back_inserter(wlong_month_names));
+
+
+  std::copy(&wweek_short_names[0], 
+            &wweek_short_names[7],
+            std::back_inserter(wshort_week_names));
+
+  std::copy(&week_short_names[0], 
+            &week_short_names[7],
+            std::back_inserter(short_week_names));
+
+  std::copy(&wweek_long_names[0], 
+            &wweek_long_names[7],
+            std::back_inserter(wlong_week_names));
+
+  std::copy(&week_long_names[0], 
+            &week_long_names[7],
+            std::back_inserter(long_week_names));
+
+  
+  wtest_format(L"1%%23%Y %m %d", L"1232004 12 31 other stuff...",
+               "wide and weird", date(2004,12,31));
+
+  wtest_format(L"%Y-%m-%d", L"2004-12-31",
+               "%Y-%m-%d wide", date(2004,12,31));
+
+  wtest_format(L"%Y day %j", L"2004 day 001",
+               "%Y day %j wide", date(2004,1,1));
+
+  test_format("%m/%d/%y", "10/31/04",
+              "%m/%d/%y", date(2004,10,31));
+
+
+  wtest_format(L"%Y/%m/%d", L"2004-12-31",
+               "%Y/%m/%d wide 2004-12-31 input", date(2004,12,31));
+
+  test_format("%Y.%d.%m", "2004.31.1",
+              "%Y.%d.%m var length", date(2004,Jan,31));
+
+  test_format("%d.%m.%Y", "1.1.2004",
+              "%d.%m.%Y var length month and day", date(2004,1,1));
+
+  test_format("%Y.%m.%d", "2004.1.31",
+              "%Y.%m.%d var length month", date(2004,Jan,31));
+
+  test_format("%Y.%b.%d", "2004.Jan.1",
+              "%Y.%b.%d var length month", date(2004,Jan,1));
+
+  test_format("%Y%m%d", "20041231",
+              "%Y%m%d undelimited", date(2004,12,31));
+
+  test_format("%Y/%d/%b", "2004/01/Jan",
+              "%Y/%d/%b month at end", date(2004,1,1));
+
+  test_format("%Y/%b/%d", "2004/Jan/01",
+              "%Y/%b/%d named month jan", date(2004,1,1));
+
+  test_format("%Y/%b/%d", "2004/Dec/20",
+              "%Y/%b/%d named month dec", date(2004,12,20));
+
+  wtest_format(L"%Y/%b/%d", L"2004-Jul-31",
+               "%Y/%b/%d wide 2004-Jul-31 input", date(2004,7,31));
+
+  wtest_format(L"%B %d, %Y", L"March 15, 2004",
+               "%B %d, %Y", date(2004,3,15));
+
+  wtest_format(L"%a %B %d, %Y", L"Sun March 15, 2004",
+               "%a %B %d, %Y", date(2004,3,15));
+
+  wtest_format(L"%A %B %d, %Y", L"Sunday March 15, 2004",
+               "%A %B %d, %Y", date(2004,3,15));
+
+  // bad format case...
+
+  {
+    try {
+      std::wstring format(L"%Y-%d");
+      std::wstringstream ws;
+      ws << L"2004-12-31";
+      std::istreambuf_iterator<wchar_t> sitr(ws);
+      std::istreambuf_iterator<wchar_t> stream_end;
+
+      boost::date_time::format_date_parser<date,wchar_t> pt(format, 
+                                                            wshort_month_names,
+                                                            wlong_month_names,
+                                                            wshort_week_names,
+                                                            wlong_week_names);
+      date d = pt.parse_date(sitr, stream_end);
+      check("Bad format spec test", false);
+    }
+    catch(std::exception& e) {
+      std::cout << "Got an expected exception: " << e.what() << std::endl;
+      check("Bad format spec test -- pass", true);
+
+    }
+  }
+
+  {
+    //some interesting month names 
+    const char* const roman_months[]={"I","II","III",
+                                      "IV","V","VI",
+                                      "VII","VIII","IX",
+                                      "X","XI","XII"};
+    std::vector<std::basic_string<char> > roman_month_names;
+    std::copy(&roman_months[0], 
+              &roman_months[12],
+              std::back_inserter(roman_month_names));
+
+    std::string format("%Y.%b.%d");
+
+    boost::date_time::format_date_parser<date,char> parser(format, 
+                                                           roman_month_names,
+                                                           long_month_names,
+                                                           short_week_names,
+                                                           long_week_names);
+
+
+    test_format2(parser, "%Y.%b.%d", "2004-I-1",
+                 "roman I", date(2004,Jan,1));
+    test_format2(parser, "%Y.%b.%d", "2004-II-01",
+                 "roman II", date(2004,Feb,1));
+    test_format2(parser, "%Y.%b.%d", "2004-III-01",
+                 "roman III", date(2004,Mar,1));
+    test_format2(parser, "%Y.%b.%d", "2004-IV-01",
+                 "roman IV", date(2004,Apr,1));
+    test_format2(parser, "%Y.%b.%d", "2004-V-01",
+                 "roman V", date(2004,May,1));
+    test_format2(parser, "%Y.%b.%d", "2004-VI-01",
+                 "roman VI", date(2004,Jun,1));
+    test_format2(parser, "%Y.%b.%d", "2004-VII-01",
+                 "roman VII", date(2004,Jul,1));
+    test_format2(parser, "%Y.%b.%d", "2004-VIII-01",
+                 "roman VIII", date(2004,Aug,1));
+    test_format2(parser, "%Y.%b.%d", "2004-IX-01",
+                 "roman IX", date(2004,Sep,1));
+    test_format2(parser, "%Y.%b.%d", "2004-X-01",
+                 "roman X", date(2004,Oct,1));
+    test_format2(parser, "%Y.%b.%d", "2004-XI-01",
+                 "roman XI", date(2004,Nov,1));
+    test_format2(parser, "%Y.%b.%d", "2004 XII 1",
+                 "roman XII", date(2004,Dec,1));
+
+  }
+
+  { 
+    //alternate constructor that takes month/weekday strings
+    //from a locale
+    std::string format("%Y %m %d");
+    boost::date_time::format_date_parser<date,char> parser(format, 
+                                                           std::locale::classic());
+    test_format2(parser, "%a %Y.%b.%d", "Sun 2004 Jan 1",
+                 "strings from locale", date(2004,Jan,1));
+    test_format2(parser, "%a %Y.%b.%d", "Mon 2004 Feb 1",
+                 "strings from locale", date(2004,Feb,1));
+    test_format2(parser, "%a %Y.%b.%d", "Tue 2004 Mar 1",
+                 "strings from locale", date(2004,Mar,1));
+    test_format2(parser, "%a %Y.%b.%d", "Wed 2004 Apr 1",
+                 "strings from locale", date(2004,Apr,1));
+    test_format2(parser, "%a %Y.%b.%d", "thu 2004 May 1",
+                 "strings from locale", date(2004,May,1));
+    test_format2(parser, "%a %Y.%b.%d", "fri 2004 Jun 1",
+                 "strings from locale", date(2004,Jun,1));
+    test_format2(parser, "%a %Y.%b.%d", "sat 2004 Jul 1",
+                 "strings from locale", date(2004,Jul,1));
+    test_format2(parser, "%Y.%b.%d", "2004 Aug 1",
+                 "strings from locale", date(2004,Aug,1));
+    test_format2(parser, "%Y.%b.%d", "2004 Sep 1",
+                 "strings from locale", date(2004,Sep,1));
+    test_format2(parser, "%Y.%b.%d", "2004 Sep 1",
+                 "strings from locale", date(2004,Sep,1));
+    test_format2(parser, "%Y.%b.%d", "2004 Oct 1",
+                 "strings from locale", date(2004,Oct,1));
+    test_format2(parser, "%Y.%b.%d", "2004 Nov 1",
+                 "strings from locale", date(2004,Nov,1));
+    test_format2(parser, "%Y.%b.%d", "2004 Dec 1",
+                 "strings from locale", date(2004,Dec,1));
+
+    test_format2(parser, "%A %B %d, %Y", "Sunday January 1, 2004",
+                 "long strings from locale", date(2004,Jan,1));
+    test_format2(parser, "%A %B %d, %Y", "Monday February 29, 2004",
+                 "long strings from locale", date(2004,Feb,29));
+    test_format2(parser, "%A %B %d, %Y", "Tuesday March 1, 2004",
+                 "long strings from locale", date(2004,Mar,1));
+    test_format2(parser, "%A %B %d, %Y", "Wednesday APRIL 1, 2004",
+                 "long strings from locale", date(2004,Apr,1));
+    test_format2(parser, "%A %B %d, %Y", "thursday may 15, 2004",
+                 "long strings from locale", date(2004,May,15));
+    test_format2(parser, "%A %B %d, %Y", "friday june 15, 2004",
+                 "long strings from locale", date(2004,Jun,15));
+    test_format2(parser, "%A %B %d, %Y", "saturday july 30, 2004",
+                 "long strings from locale", date(2004,Jul,30));
+    test_format2(parser, "%A %B %d, %Y", "thursday auguST 15, 2004",
+                 "long strings from locale", date(2004,Aug,15));
+    test_format2(parser, "%A %B %d, %Y", "thursday september 1, 2004",
+                 "long strings from locale", date(2004,Sep,1));
+    test_format2(parser, "%A %B %d, %Y", "thursday october 1, 2004",
+                 "long strings from locale", date(2004,Oct,1));
+    test_format2(parser, "%A %B %d, %Y", "thursday november 1, 2004",
+                 "long strings from locale", date(2004,Nov,1));
+    test_format2(parser, "%A %B %d, %Y", "thursday december 31, 2004",
+                 "long strings from locale", date(2004,Dec,31));
+
+  }
+
+  return printTestStats();
+
+}
diff --git a/src/boost/libs/date_time/test/gregorian/testformatters.cpp b/src/boost/libs/date_time/test/gregorian/testformatters.cpp
new file mode 100644
index 000000000..80d778c1f
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testformatters.cpp
@@ -0,0 +1,62 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+
+int
+main() 
+{
+
+  boost::gregorian::date d1(2002,01,02);
+  std::string ds1 = boost::gregorian::to_simple_string(d1);
+  check("check string:     " + ds1, ds1 == "2002-Jan-02");
+ 
+  std::string ids1(boost::gregorian::to_iso_string(d1));
+  //  std::cout << boost::gregorian::to_iso_string(d1) << std::endl;
+  check("check iso normal: " + ids1, ids1 == "20020102");
+
+  std::string sds1 = boost::gregorian::to_sql_string(d1);
+  check("check sql string: "+sds1, sds1 == "2002-01-02");
+
+  boost::gregorian::date d2(2001,12,30);
+  std::string ds2 = boost::gregorian::to_simple_string(d2);
+  check("check string:     "+ds2, ds2 == "2001-Dec-30");
+  std::string ids2 = boost::gregorian::to_iso_extended_string(d2);
+  check("check iso extended string: "+ids2, ids2 == "2001-12-30");
+
+  using namespace boost::gregorian;
+  date d3(neg_infin);
+  std::cout  << "|" << to_simple_string(d3) << "|" << std::endl;
+  check("check negative infinity",     
+        (to_simple_string(d3) == std::string("-infinity")));
+  date d4(pos_infin);
+  check("check positive infinity",     
+        (to_simple_string(d4) == std::string("+infinity")));
+  date d5(not_a_date_time);
+  std::cout << to_simple_string(d5) << "|" << std::endl;
+  check("check not a date",     
+        (to_simple_string(d5) == std::string("not-a-date-time")));
+
+  date_period p1(date(2000,Jan,1), date(2001,Jan,1));
+  check("check period format",     
+        (to_simple_string(p1) == std::string("[2000-Jan-01/2000-Dec-31]")));
+  date_period p2(date(2000,Jan,1), date(pos_infin));
+  check("check period format",     
+        (to_simple_string(p2) == std::string("[2000-Jan-01/+infinity]")));
+  std::cout << to_simple_string(p2) << std::endl;
+
+  
+
+  //  TODO enhance wchar support 
+//   std::wstringstream wss;
+//   wss << d3 << std::endl;
+//   std::wcout << d3;
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testgenerators.cpp b/src/boost/libs/date_time/test/gregorian/testgenerators.cpp
new file mode 100644
index 000000000..b58c1c343
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testgenerators.cpp
@@ -0,0 +1,175 @@
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst 
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+#include <string>
+#include <sstream>
+
+int
+main() 
+{
+
+  using namespace boost::gregorian;
+
+  partial_date pd1(1,Jan);
+  date d = pd1.get_date(2000);
+  check("Partial date to_string()", pd1.to_string() == std::string("0"));
+  check("Partial date getdate",     date(2000,1,1) == d);
+  d = pd1.get_date(2001);
+  check("Partial date getdate",     date(2001,1,1) == d);
+  partial_date pd2(1,Feb);
+  check("Partial date to_string()", pd2.to_string() == std::string("31"));
+  check("Partial date operator==",  pd1 == pd1);
+  check("Partial date operator==",  !(pd1 == pd2));
+  check("Partial date operator==",  !(pd2 == pd1));
+  check("Partial date operator<",   !(pd1 < pd1));
+  check("Partial date operator<",    pd1 < pd2);
+  check("Partial date operator<",   !(pd2 < pd1));
+
+  typedef last_day_of_the_week_in_month lastkday;
+
+  //Find last Sunday in Feb
+  lastkday lsif(Sunday, Feb);
+  std::cout << lsif.get_date(2002) << std::endl; //24th
+  check("Last kday",     date(2002,Feb,24) == lsif.get_date(2002));
+  check("Last kday to_string()", lsif.to_string() == std::string("M2.5.0"));
+  lastkday ltif(Thursday, Feb);
+  check("Last kday",     date(2002,Feb,28) == ltif.get_date(2002));
+  check("Last kday to_string()", ltif.to_string() == std::string("M2.5.4"));
+  lastkday lfif(Friday, Feb);
+  check("Last kday",     date(2002,Feb,22) == lfif.get_date(2002));
+  check("Last kday to_string()", lfif.to_string() == std::string("M2.5.5"));
+
+  typedef first_day_of_the_week_in_month firstkday;
+
+  firstkday fsif(Sunday, Feb);
+  std::cout << fsif.get_date(2002) << std::endl; //24th
+  check("First kday",     date(2002,Feb,3) == fsif.get_date(2002));
+  check("First kday to_string()", fsif.to_string() == std::string("M2.1.0"));
+  firstkday ftif(Thursday, Feb);
+  check("First kday",     date(2002,Feb,7) == ftif.get_date(2002));
+  check("First kday to_string()", ftif.to_string() == std::string("M2.1.4"));
+  firstkday ffif(Friday, Feb);
+  check("First kday",     date(2002,Feb,1) == ffif.get_date(2002));
+  check("First kday to_string()", ffif.to_string() == std::string("M2.1.5"));
+  
+  typedef first_day_of_the_week_after firstkdayafter;
+  firstkdayafter fkaf(Monday);
+  std::cout << fkaf.get_date(date(2002,Feb,1)) << std::endl; //feb 4
+  check("kday after",date(2002,Feb,4) == fkaf.get_date(date(2002,Feb,1)));
+  firstkdayafter fkaf2(Thursday);
+  check("kday after",date(2002,Feb,7) == fkaf2.get_date(date(2002,Feb,1)));
+  check("kday after",date(2002,Feb,28)== fkaf2.get_date(date(2002,Feb,21)));
+
+  typedef first_day_of_the_week_before firstkdaybefore;
+  firstkdaybefore fkbf(Monday);
+  std::cout << fkaf.get_date(date(2002,Feb,10))
+            << std::endl; //feb 4
+  check("kday before",date(2002,Feb,4) == fkbf.get_date(date(2002,Feb,10)));
+  firstkdaybefore fkbf2(Thursday);
+  check("kday before",date(2002,Jan,31) == fkbf2.get_date(date(2002,Feb,1)));
+  check("kday before",date(2002,Feb,7)== fkbf2.get_date(date(2002,Feb,14)));
+
+  typedef nth_day_of_the_week_in_month nthkdayofmonth;
+  nthkdayofmonth nkd1(nthkdayofmonth::third, Sunday, Jul);
+  check("nth_kday 1", date(1969, Jul, 20) == nkd1.get_date(1969));
+  check("Nth kday to_string()", nkd1.to_string() == std::string("M7.3.0"));
+  nthkdayofmonth nkd2(nthkdayofmonth::second, Monday, Dec);
+  check("nth_kday 2", date(1980, Dec, 8) == nkd2.get_date(1980));
+  check("Nth kday to_string()", nkd2.to_string() == std::string("M12.2.1"));
+  nthkdayofmonth nkd3(nthkdayofmonth::fifth, Wednesday, Jan);
+  check("nth_kday fifth wed jan 2003 2003-Jan-29", 
+        date(2003, Jan, 29) == nkd3.get_date(2003));
+  check("Nth kday to_string()", nkd3.to_string() == std::string("M1.5.3"));
+  nthkdayofmonth nkd4(nthkdayofmonth::fifth, Monday, Jan);
+  check("nth_kday fifth mon jan 2003 (actaully 4th) 2003-Jan-27", 
+        date(2003, Jan, 27) == nkd4.get_date(2003));
+  check("Nth kday to_string()", nkd4.to_string() == std::string("M1.5.1"));
+
+  // greg date_generator functions tests
+  {
+    date sunday(2003,Feb,2),tuesday(2003,Feb,4);
+    date friday(2003,Feb,7),saturday(2003,Feb,8);
+    greg_weekday sat(Saturday), tue(Tuesday), fri(Friday), sund(Sunday);
+    
+    check("Days until weekday" , days_until_weekday(saturday, sund) == days(1));
+    check("Days until weekday" , days_until_weekday(friday, tue) == days(4));
+    check("Days until weekday" , days_until_weekday(tuesday, fri) == days(3));
+    check("Days until weekday" , days_until_weekday(sunday, sat) == days(6));
+    check("Days until weekday" , days_until_weekday(sunday, sund) == days(0));
+    check("Days until weekday" , days_until_weekday(tuesday, tue) == days(0));
+    
+    check("Days before weekday" , days_before_weekday(saturday, sund) == days(6));
+    check("Days before weekday" , days_before_weekday(friday, tue) == days(3));
+    check("Days before weekday" , days_before_weekday(tuesday, fri) == days(4));
+    check("Days before weekday" , days_before_weekday(sunday, sat) == days(1));
+    check("Days before weekday" , days_before_weekday(sunday, sund) == days(0));
+    check("Days before weekday" , days_before_weekday(tuesday, tue) == days(0));
+
+    check("Date of next weekday", next_weekday(saturday, sund)== date(2003,Feb,9));
+    check("Date of next weekday", next_weekday(friday, tue) == date(2003,Feb,11));
+    check("Date of next weekday", next_weekday(tuesday, fri) == date(2003,Feb,7));
+    check("Date of next weekday", next_weekday(sunday, sat) == date(2003,Feb,8));
+    check("Date of next weekday", next_weekday(sunday, sund) == sunday);
+    check("Date of next weekday", next_weekday(tuesday, tue) == tuesday);
+    
+    check("Date of previous weekday", previous_weekday(saturday, sund)== date(2003,Feb,2));
+    check("Date of previous weekday", previous_weekday(friday, tue) == date(2003,Feb,4));
+    check("Date of previous weekday", previous_weekday(tuesday, fri) == date(2003,Jan,31));
+    check("Date of previous weekday", previous_weekday(sunday, sat) == date(2003,Feb,1));
+    check("Date of previous weekday", previous_weekday(sunday, sund) == sunday);
+    check("Date of previous weekday", previous_weekday(tuesday, tue) == tuesday);
+  
+  }
+#ifndef BOOST_DATE_TIME_NO_LOCALE
+#if !defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
+  //TODO: this is temporary condition -- don't force a failure...
+  //  check("no streaming implemented for new facet", false);
+#else
+  // streaming tests...
+  std::stringstream ss("");
+  std::string s("");
+  
+  ss.str("");
+  ss << pd1;
+  s = "01 Jan";
+  check("streaming partial_date", ss.str() == s);
+  std::cout << ss.str() << std::endl;
+  
+  ss.str("");
+  ss << lsif;
+  s = "last Sun of Feb";
+  check("streaming last_kday_of_month", ss.str() == s);
+  
+  ss.str("");
+  ss << fsif;
+  s = "first Sun of Feb";
+  check("streaming first_kday_of_month", ss.str() == s);
+  
+  ss.str("");
+  ss << fkaf;
+  s = "Mon after";
+  check("streaming first_kday_after", ss.str() == s);
+  
+  ss.str("");
+  ss << fkbf;
+  s = "Mon before";
+  check("streaming first_kday_before", ss.str() == s);
+  
+  ss.str("");
+  ss << nkd1;
+  s = "third Sun of Jul";
+  check("streaming nth_kday", ss.str() == s);
+#endif // USE_DATE_TIME_PRE_1_33_FACET_IO 
+#endif // NO_LOCAL
+  
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testgreg_cal.cpp b/src/boost/libs/date_time/test/gregorian/testgreg_cal.cpp
new file mode 100644
index 000000000..43558a20c
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testgreg_cal.cpp
@@ -0,0 +1,135 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/gregorian/greg_calendar.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+
+
+void
+test_greg_calendar()
+{
+  using namespace boost::gregorian;
+  check("Day of week 2000-09-24 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,24))==0);
+  check("Day of week 2000-09-25 == 1 (Mon)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,25))==1);
+  check("Day of week 2000-09-26 == 2 (Tue)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,26))==2);
+  check("Day of week 2000-09-27 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,27))==3);
+  check("Day of week 2000-09-28 == 4 (Thu)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,28))==4);
+  check("Day of week 2000-09-29 == 5 (Fri)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,29))==5);
+  check("Day of week 2000-09-30 == 6 (Sat)", gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,30))==6);
+  //see calendar FAQ 2.2 for reference
+  check("Day of week 1953-08-02 == 0 (Sun)", gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,2))==0);
+  check("Day of week 1953-08-03 == 1 (Mon)", gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,3))==1);
+  check("Day of week 1953-08-04 == 2 (Tue)", gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,4))==2);
+  check("Day of week 1953-08-05 == 3 (Wed)", gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,5))==3);
+  check("Day of week 1953-08-06 == 4 (Thu)", gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,6))==4);
+  check("Day of week 1953-08-07 == 5 (Fri)", gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,7))==5);
+  check("Day of week 1953-08-08 == 6 (Sat)", gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,8))==6);
+  check("Day of week 2001-08-31 == 5 (Fri)", gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2001,8,31))==5);
+  
+  //Checked against Caledrical Calc M. Edition p 396 and www site
+  check("Day of week 1400-01-01 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1400,1,1))==3);
+  check("Day of week 1436-02-03 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1436,2,3))==3);
+  check("Day of week 1492-04-9 == 6 (Sat)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1492,4,9))==6);
+  check("Day of week 1560-03-5 == 6 (Sat)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1560,3,5))==6);
+  check("Day of week 1716-07-24 == 5 (Fri)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1716,7,24))==5);
+  check("Day of week 1768-06-19 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1768,6,19))==0);
+  check("Day of week 1839-03-27 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1839,3,27))==3);
+  check("Day of week 1819-08-02 == 1 (Mon)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1819,8,2))==1);
+  check("Day of week 1903-04-19 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1903,4,19))==0);
+  check("Day of week 1929-08-25 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1929,8,25))==0);
+  check("Day of week 2038-11-10 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2038,11,10))==3);
+  check("Day of week 2094-07-18 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2094,7,18))==0);
+  //verified against website applet
+  check("Day of week 3002-07-10 == 6 (Sat)",
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(3002,7,10))==6);
+  //verified against website applet
+  check("Day of week 4002-07-10 == 3 (Wed)",
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(4002,7,10))==3);
+  //verified against website applet
+  check("Day of week 5002-07-10 == 6 (Sat)",
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(5002,7,10))==6);
+
+  check("1404 is a leap year", gregorian_calendar::is_leap_year(1404));
+  check("2000 is a leap year", gregorian_calendar::is_leap_year(2000));
+  check("2004 is a leap year", gregorian_calendar::is_leap_year(2004));
+  check("2400 is a leap year", gregorian_calendar::is_leap_year(2400));
+  check("4000 is a leap year", gregorian_calendar::is_leap_year(4000));
+  check("1400 is NOT a leap year", !gregorian_calendar::is_leap_year(1400));
+  check("1900 is NOT a leap year", !gregorian_calendar::is_leap_year(1900));
+  check("2100 is NOT a leap year", !gregorian_calendar::is_leap_year(2100));
+  check("1999 is NOT a leap year", !gregorian_calendar::is_leap_year(1999));
+  check("5000 is NOT a leap year", !gregorian_calendar::is_leap_year(5000));
+
+
+  unsigned long jday1 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(2000,1,1));
+  unsigned long jday2 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(2001,1,1));
+//   unsigned short year, month, day;
+//   //2451545 is 2000-1-1
+  check("ToDayNumber 2000-1-1 is day 2451545", jday1 == 2451545);
+  check("ToDayNumber 2001-1-1 is day 2451911", jday2 == 2451911);
+  gregorian_calendar::ymd_type ymd = gregorian_calendar::from_day_number(jday1);
+  check("from_day_number test 2000-1-1",  (ymd.year==2000)&&
+                                          (ymd.month==1) &&
+                                          (ymd.day==1) );
+
+  unsigned long jday3 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(1999,1,1));
+  check("366 days between 2000-1-1 and 2001-1-1", (jday2-jday1) == 366);
+  check("731 days between 1999-1-1 and 2001-1-1 ",(jday2-jday3) == 731);
+
+  unsigned long jday4 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(2000,2,28));
+  unsigned long jday5 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(2000,3,1));
+  check("2 days between 2000-2-28 and 2000-3-1 ",(jday5-jday4) == 2);
+
+  check("31 days in month Jan 2000", gregorian_calendar::end_of_month_day(2000,1) == 31);
+  check("29 days in month Feb 2000", gregorian_calendar::end_of_month_day(2000,2) == 29);
+  check("28 days in month Feb 1999", gregorian_calendar::end_of_month_day(1999,2) == 28);
+  check("28 days in month Feb 2001", gregorian_calendar::end_of_month_day(2001,2) == 28);
+  check("31 days in month Mar 2000", gregorian_calendar::end_of_month_day(2000,3) == 31);
+  check("30 days in month Apr 2000", gregorian_calendar::end_of_month_day(2000,4) == 30);
+  check("31 days in month May 2000", gregorian_calendar::end_of_month_day(2000,5) == 31);
+  check("30 days in month Jun 2000", gregorian_calendar::end_of_month_day(2000,6) == 30);
+  check("31 days in month Jul 2000", gregorian_calendar::end_of_month_day(2000,7) == 31);
+  check("31 days in month Aug 2000", gregorian_calendar::end_of_month_day(2000,8) == 31);
+  check("30 days in month Sep 2000", gregorian_calendar::end_of_month_day(2000,9) == 30);
+  check("31 days in month Oct 2000", gregorian_calendar::end_of_month_day(2000,10) == 31);
+  check("30 days in month Nov 2000", gregorian_calendar::end_of_month_day(2000,11) == 30);
+  check("31 days in month Dec 2000", gregorian_calendar::end_of_month_day(2000,12) == 31);
+
+
+//   unsigned long jday0 = date_limits<>::dayNumber(gregorian_calendar::ymd_type(1900,1,1));
+//   std::cout << "Day 0: " << jday0 << std::endl;
+
+  std::cout << gregorian_calendar::epoch().year << std::endl;
+}
+
+
+int
+main() 
+{
+  test_greg_calendar();
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testgreg_day.cpp b/src/boost/libs/date_time/test/gregorian/testgreg_day.cpp
new file mode 100644
index 000000000..1cb5c4470
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testgreg_day.cpp
@@ -0,0 +1,91 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/gregorian/greg_day.hpp"
+#include "boost/date_time/gregorian/greg_weekday.hpp"
+#include "boost/date_time/gregorian/greg_day_of_year.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+
+
+void 
+test_day() 
+{
+  using namespace boost::gregorian;
+  greg_day d1(1);
+  check("Basic test", d1 == 1);
+  try {
+    greg_day bad(0);
+    check("Bad day creation", false); //oh oh, fail
+    //unreachable
+    std::cout << "Shouldn't reach here: " << bad << std::endl;
+  }
+  catch(std::exception &) {
+    check("Bad day creation", true); //good
+    
+  }
+  try {
+    greg_day bad(32);
+    check("Bad day creation2", false); //oh oh, fail
+    //unreachable
+    std::cout << "Shouldn't reach here: " << bad << std::endl;
+  }
+  catch(std::exception&) {
+    check("Bad day creation2", true); //good
+    
+  }
+  check("traits min day", (greg_day::min)() == 1);
+  check("traits max day", (greg_day::max)() == 31);
+
+  greg_weekday sunday(0);
+  greg_weekday monday(1);
+
+  check("Weekday 0 short name == Sun", 
+        sunday.as_short_string() == std::string("Sun"));
+  check("Weekday 1 short name == Mon", 
+        monday.as_short_string() == std::string("Mon"));
+  check("Weekday 2 short name == Tue", 
+        greg_weekday(2).as_short_string() == std::string("Tue"));
+  check("Weekday 3 short name == Wed", 
+        greg_weekday(3).as_short_string() == std::string("Wed"));
+  check("Weekday 4 short name == Thu", 
+        greg_weekday(4).as_short_string() == std::string("Thu"));
+  check("Weekday 5 short name == Fri", 
+        greg_weekday(5).as_short_string() == std::string("Fri"));
+  check("Weekday 6 short name == Sat", 
+        greg_weekday(6).as_short_string() == std::string("Sat"));
+  try {
+    greg_weekday bad(7);
+    check("Bad weekday creation", false); //oh oh, fail
+    //unreachable
+    std::cout << "Shouldn't reach here: " << bad << std::endl;
+  }
+  catch(bad_weekday&) {
+    check("Bad weekday creation", true); //good
+    
+  }
+
+   try {
+     greg_day_of_year_rep bad(367);
+     check("Bad day of year", false); //oh oh, fail
+    //unreachable
+    std::cout << "Shouldn't reach here: " << bad << std::endl;
+
+   }
+   catch(bad_day_of_year&) {
+     check("Bad day of year", true); //good
+  }
+  
+}
+
+int
+main() 
+{
+  test_day();
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testgreg_durations.cpp b/src/boost/libs/date_time/test/gregorian/testgreg_durations.cpp
new file mode 100644
index 000000000..53c3c0420
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testgreg_durations.cpp
@@ -0,0 +1,241 @@
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+
+
+int main(){
+
+#if !defined(BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES)
+  // do not set this test to return fail - 
+  // this is not necessarily a compiler problem
+  check("Optional gregorian types not selected - no tests run", true);
+#else
+
+  using namespace boost::gregorian;
+      
+
+  /*** months ***/
+  {
+    months m1(5), m2(3), m3(1);
+    check("months & months addable", months(8) == m1 + m2);
+    m1 += m2;
+    check("months & months addable", months(8) == m1);
+    check("months & months subtractable", months(-5) == m2 - m1);
+    m2 -= m1;
+    check("months & months subtractable", months(-5) == m2);
+    {
+      // adding and subtracting negative values
+      date d1(2005, Jan, 1);
+      date d2(2005, Feb, 1);
+      check("add neg months (year wrap under)",
+          d1 + months(-1) == date(2004,Dec,1));
+      check("add neg months (no year wrap under)",
+          d2 + months(-1) == date(2005,Jan,1));
+      check("add neg months (year wrap under)",
+          d2 + months(-2) == date(2004,Dec,1));
+      check("add neg months (year wrap under)",
+          d2 + months(-12) == date(2004,Feb,1));
+      check("add neg months (year wrap under)",
+          d2 + months(-13) == date(2004,Jan,1));
+      check("add neg months (year wrap under)",
+          d2 + months(-14) == date(2003,Dec,1));
+      date d3(2005, Dec, 1);
+      date d4(2005, Nov, 1);
+      check("subtract neg months (year wrap over)",
+          d3 - months(-1) == date(2006,Jan,1));
+      check("subtract neg months (no year wrap over)",
+          d4 - months(-1) == date(2005,Dec,1));
+      check("subtract neg months (year wrap over)",
+          d4 - months(-2) == date(2006,Jan,1));
+      check("subtract neg months (year wrap over)",
+          d4 - months(-12) == date(2006,Nov,1));
+      check("subtract neg months (year wrap over)",
+          d4 - months(-13) == date(2006,Dec,1));
+      check("subtract neg months (year wrap over)",
+          d4 - months(-14) == date(2007,Jan,1));
+    }
+    {
+      months m1x(5), m3x(10);
+      check("months & int multipliable", months(15) == m1x * 3);
+      m1x *= 3;
+      check("months & int multipliable", months(15) == m1x);
+      //check("int * months", months(12) == 4 * m2x);
+      check("months & int dividable", months(3) == m3x / 3);
+      m3x /= 3;
+      check("months & int dividable", months(3) == m3x);
+    }
+    {
+      months m(-5), m_pos(pos_infin), m_neg(neg_infin), m_nadt(not_a_date_time);
+      check("months add special_values", m + m_pos == m_pos);
+      check("months add special_values", m + m_neg == m_neg);
+      check("months add special_values", m_pos + m_neg == m_nadt);
+      check("months add special_values", m_neg + m_neg == m_neg);
+      check("months subtract special_values", m - m_pos == m_neg);
+      check("months subtract special_values", m - m_neg == m_pos);
+      check("months subtract special_values", m_pos - m_neg == m_pos);
+      check("months special_values & int multipliable", m_pos * -1 == m_neg);
+      check("months special_values & int multipliable", m_pos * 0 == m_nadt);
+      check("months special_values & int dividable", m_neg / 3 == m_neg);
+    }
+
+    years y1(2), y2(4);
+    check("months & years addable", months(25) == m3 + y1);
+    m3 += y1;
+    check("months & years addable", months(25) == m3);
+    check("months & years subtractable", months(-23) == m3 - y2);
+    m3 -= y2;
+    check("months & years subtractable", months(-23) == m3);
+
+    {
+      date d(2001, Oct, 31);
+      check("date + months", date(2002, Feb, 28) == d + months(4));
+      d += months(4);
+      check("date += months", date(2002, Feb, 28) == d);
+    }
+    {
+      date d(2001, Oct, 31);
+      check("date - months", date(2001, Apr, 30) == d - months(6));
+      d -= months(6);
+      check("date -= months", date(2001, Apr, 30) == d);
+    }
+  }
+
+  /*** years ***/
+  {
+    years y1(2), y2(4), y3(1);
+    check("years & years addable", years(3) == y3 + y1);
+    y3 += y1;
+    check("years & years addable", years(3) == y3);
+    check("years & years subtractable", years(-1) == y3 - y2);
+    y3 -= y2;
+    check("years & years subtractable", years(-1) == y3);
+    {
+      years y1x(5), y3x(10);
+      check("years & int multipliable", years(15) == y1x * 3);
+      y1x *= 3;
+      check("years & int multipliable", years(15) == y1x);
+      //check("int * years", years(12) == 4 * y2x);
+      check("years & int dividable", years(3) == y3x / 3);
+      y3x /= 3;
+      check("years & int dividable", years(3) == y3x);
+    }
+    {
+      years m(15), y_pos(pos_infin), y_neg(neg_infin), y_nadt(not_a_date_time);
+      check("years add special_values", m + y_pos == y_pos);
+      check("years add special_values", m + y_neg == y_neg);
+      check("years add special_values", y_pos + y_neg == y_nadt);
+      check("years add special_values", y_neg + y_neg == y_neg);
+      check("years subtract special_values", m - y_pos == y_neg);
+      check("years subtract special_values", m - y_neg == y_pos);
+      check("years subtract special_values", y_pos - y_neg == y_pos);
+      check("years special_values & int multipliable", y_pos * -1 == y_neg);
+      check("years special_values & int multipliable", y_pos * 0 == y_nadt);
+      check("years special_values & int dividable", y_neg / 3 == y_neg);
+    }
+    
+    months m1(5), m2(3);
+    check("years & months addable", months(51) == y2 + m2);
+    check("years & months subtractable", months(43) == y2 - m1);
+
+    {
+      date d(2001, Feb, 28); // not a leap year
+      check("date + years", date(2004, Feb, 29) == d + years(3));
+      d += years(3);
+      check("date += years", date(2004, Feb, 29) == d);
+    }
+    {
+      date d(2000, Feb, 29);
+      check("date - years", date(1994, Feb, 28) == d - years(6));
+      d -= years(6);
+      check("date -= years", date(1994, Feb, 28) == d);
+    }
+
+    try {
+      date d1(1400, 6, 1);
+      const date d2 = d1 + years(8599);
+      check("date + many years != overflow", d2 == date(9999, 6, 1));
+    }
+    catch (...) {
+      check("date + many years != overflow", false);
+    }
+
+    try {
+      date d1(9999, 1, 1);
+      const date d2 = d1 - years(8599);
+      check("date - many years != overflow", d2 == date(1400, 1, 1));
+    }
+    catch (...) {
+      check("date - many years != overflow", false);
+    }
+
+  }
+  
+  /*** weeks ***/
+  // shouldn't need many tests, it is nothing more than a date_duration
+  // so all date_duration tests should prove this class
+  {
+    weeks w1(2), w2(4), w3(1), pi(pos_infin);
+    check("add special_values", weeks(pos_infin) == w1 + pi);
+    check("weeks & weeks addable", weeks(3) == w3 + w1);
+    w3 += w1;
+    check("weeks & weeks addable", weeks(3) == w3);
+    check("weeks & weeks subtractable", weeks(-1) == w3 - w2);
+    w3 -= w2;
+    check("weeks & weeks subtractable", weeks(-1) == w3);
+    {
+      days d(10);
+      check("days + weeks", days(31) == d + weeks(3));
+      d += weeks(3);
+      check("days += weeks", days(31) == d);
+    }
+    {
+      days d(10);
+      check("days - weeks", days(-32) == d - weeks(6));
+      d -= weeks(6);
+      check("days -= weeks", days(-32) == d);
+    }
+    {
+      date d(2001, Feb, 28);
+      check("date + weeks", date(2001, Mar, 21) == d + weeks(3));
+      d += weeks(3);
+      check("date += weeks", date(2001, Mar, 21) == d);
+    }
+    {
+      date d(2001, Feb, 28);
+      check("date - weeks", date(2001, Jan, 17) == d - weeks(6));
+      d -= weeks(6);
+      check("date -= weeks", date(2001, Jan, 17) == d);
+    }
+  }
+
+  {
+    date d(2000, Oct, 31);
+    date d2 = d + months(4) + years(2);
+    date d3 = d + years(2) + months(4);
+    check("date + years + months", date(2003,Feb,28) == d2);
+    check("date + years + months", date(2003,Feb,28) == d3);
+    months m = years(2) + months(4) - months(4) - years(2);
+    check("sanity check", m.number_of_months() == 0);
+  }
+  /*{
+    date d(2001, Mar, 31);
+    date d1 = (d - months(1)) + months(1); //Mar 28, right? WRONG
+    // Mar31 - 1 month is Feb28 (last day of month) so Feb28 + 1 month
+    // will be Mar31 (last day of month)
+    check("date + 1 months - 1 months", date(2001,Mar,28) == d1);
+    std::cout << d1 << std::endl;
+    //date d2 = (d - months(1)) + d; //compile error, right?  RIGHT 
+    //weeks w1 = weeks(1) + months(1); //compiler error, right?  RIGHT 
+  }*/
+
+#endif // BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
+  
+  return printTestStats();
+  
+}
diff --git a/src/boost/libs/date_time/test/gregorian/testgreg_month.cpp b/src/boost/libs/date_time/test/gregorian/testgreg_month.cpp
new file mode 100644
index 000000000..3e5db8fa9
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testgreg_month.cpp
@@ -0,0 +1,67 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/gregorian/greg_month.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+
+
+void 
+test_month() 
+{
+  using namespace boost::gregorian;
+  greg_month m1(Jan), m2(Feb), m3(Mar), m4(Apr), m5(May), m6(Jun);
+  greg_month m7(Jul), m8(Aug), m9(Sep), m10(Oct), m11(Nov),m12(Dec);
+  check("January  as_number", m1.as_number() == 1);
+  check("December as_number", m12.as_number() == 12);
+  check("Jan as Short String",  m1.as_short_string()  == std::string("Jan"));
+  check("Feb as Short String",  m2.as_short_string()  == std::string("Feb"));
+  check("Mar as Short String",  m3.as_short_string()  == std::string("Mar"));
+  check("Apr as Short String",  m4.as_short_string()  == std::string("Apr"));
+  check("May as Short String",  m5.as_short_string()  == std::string("May"));
+  check("Jun as Short String",  m6.as_short_string()  == std::string("Jun"));
+  check("Jul as Short String",  m7.as_short_string()  == std::string("Jul"));
+  check("Aug as Short String",  m8.as_short_string()  == std::string("Aug"));
+  check("Sep as Short String",  m9.as_short_string()  == std::string("Sep"));
+  check("Oct as Short String",  m10.as_short_string() == std::string("Oct"));
+  check("Nov as Short String",  m11.as_short_string() == std::string("Nov"));
+  check("Dec as Short String",  m12.as_short_string() == std::string("Dec"));
+  check("Jan as Long String",  m1.as_long_string()  == std::string("January"));
+  check("Feb as Long String",  m2.as_long_string()  == std::string("February"));
+  check("Mar as Long String",  m3.as_long_string()  == std::string("March"));
+  check("Apr as Long String",  m4.as_long_string()  == std::string("April"));
+  check("May as Long String",  m5.as_long_string()  == std::string("May"));
+  check("Jun as Long String",  m6.as_long_string()  == std::string("June"));
+  check("Jul as Long String",  m7.as_long_string()  == std::string("July"));
+  check("Aug as Long String",  m8.as_long_string()  == std::string("August"));
+  check("Sep as Long String",  m9.as_long_string()  == std::string("September"));
+  check("Oct as Long String",  m10.as_long_string() == std::string("October"));
+  check("Nov as Long String",  m11.as_long_string() == std::string("November"));
+  check("Dec as Long String",  m12.as_long_string() == std::string("December"));
+  //month m(5);
+
+  //TODO can this support NAM? or check exception
+  //  greg_month sm0(0);
+  greg_month sm1(1);
+  greg_month sm12(12);
+  //check("check not a month value", sm0.as_short_string() == "NAM");
+  check("short construction -- 1", 
+        sm1.as_short_string() == std::string("Jan"));
+  check("short construction -- 12", 
+        sm12.as_short_string() == std::string("Dec"));
+  check("month traits min", (greg_month::min)() == 1);
+  check("month traits max", (greg_month::max)() == 12);
+
+}
+
+int
+main() 
+{
+  test_month();
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testgreg_serialize.cpp b/src/boost/libs/date_time/test/gregorian/testgreg_serialize.cpp
new file mode 100644
index 000000000..e1b608b40
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testgreg_serialize.cpp
@@ -0,0 +1,190 @@
+/* Copyright (c) 2002-2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+ 
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include <boost/date_time/gregorian/greg_serialize.hpp>
+#include "../testfrmwk.hpp"
+#include <sstream>
+
+using namespace boost;
+using namespace gregorian;
+
+template<class archive_type, class temporal_type>
+void save_to(archive_type& ar, const temporal_type& tt)
+{
+  ar << tt;
+}
+
+int main(){
+  date d(2002,Feb,12);
+  date sv_d1(not_a_date_time);
+  date sv_d2(pos_infin);
+  date_duration dd(11);
+  date_duration sv_dd(neg_infin);
+  date_period dp(d,dd);
+  greg_year gy(1959);
+  greg_month gm(Feb);
+  greg_day gd(14);
+  greg_weekday gwd(Friday);
+  partial_date pd(26,Jul);
+  nth_kday_of_month nkd(nth_kday_of_month::second,Tuesday,Mar);
+  first_kday_of_month fkd(Saturday,Apr);
+  last_kday_of_month lkd(Saturday,Apr);
+  first_kday_before fkdb(Thursday);
+  first_kday_after fkda(Thursday);
+
+  std::ostringstream oss;
+
+  {
+
+  // NOTE: DATE_TIME_XML_SERIALIZE is only used in testing and is
+  // defined in the testing Jamfile
+#if defined(DATE_TIME_XML_SERIALIZE)
+  std::cout << "Running xml archive tests" << std::endl;
+  archive::xml_oarchive oa(oss);
+#else
+  std::cout << "Running text archive tests" << std::endl;
+  archive::text_oarchive oa(oss);
+#endif
+
+  // load up the archive
+  try{
+#if defined(DATE_TIME_XML_SERIALIZE)
+    save_to(oa, BOOST_SERIALIZATION_NVP(d));
+    save_to(oa, BOOST_SERIALIZATION_NVP(sv_d1));
+    save_to(oa, BOOST_SERIALIZATION_NVP(sv_d2));
+    save_to(oa, BOOST_SERIALIZATION_NVP(dd));
+    save_to(oa, BOOST_SERIALIZATION_NVP(sv_dd));
+    save_to(oa, BOOST_SERIALIZATION_NVP(dp));
+    save_to(oa, BOOST_SERIALIZATION_NVP(gy));
+    save_to(oa, BOOST_SERIALIZATION_NVP(gm));
+    save_to(oa, BOOST_SERIALIZATION_NVP(gd));
+    save_to(oa, BOOST_SERIALIZATION_NVP(gwd));
+    save_to(oa, BOOST_SERIALIZATION_NVP(pd));
+    save_to(oa, BOOST_SERIALIZATION_NVP(nkd));
+    save_to(oa, BOOST_SERIALIZATION_NVP(fkd));
+    save_to(oa, BOOST_SERIALIZATION_NVP(lkd));
+    save_to(oa, BOOST_SERIALIZATION_NVP(fkdb));
+    save_to(oa, BOOST_SERIALIZATION_NVP(fkda));
+#else
+    save_to(oa, d);
+    save_to(oa, sv_d1);
+    save_to(oa, sv_d2);
+    save_to(oa, dd);
+    save_to(oa, sv_dd);
+    save_to(oa, dp);
+    save_to(oa, gy);
+    save_to(oa, gm);
+    save_to(oa, gd);
+    save_to(oa, gwd);
+    save_to(oa, pd);
+    save_to(oa, nkd);
+    save_to(oa, fkd);
+    save_to(oa, lkd);
+    save_to(oa, fkdb);
+    save_to(oa, fkda);
+#endif
+  }catch(archive::archive_exception& ae){
+    std::string s(ae.what());
+    check("Error writing to archive: " + s + "\nWritten data: \"" + oss.str() + "\"", false);
+    return printTestStats();
+  }
+  }
+
+  // read from the archive
+  date d2(not_a_date_time);
+  date sv_d3(min_date_time);
+  date sv_d4(min_date_time);
+  date_duration dd2(not_a_date_time);
+  date_duration sv_dd2(0);
+  date_period dp2(date(2000,Jan,1),date_duration(1));
+  greg_year gy2(1960);
+  greg_month gm2(Jan);
+  greg_day gd2(1);
+  greg_weekday gwd2(Monday);
+  partial_date pd2(1);
+  nth_kday_of_month nkd2(nth_kday_of_month::first,Monday,Jan);
+  first_kday_of_month fkd2(Monday,Jan);
+  last_kday_of_month lkd2(Monday,Jan);
+  first_kday_before fkdb2(Monday);
+  first_kday_after fkda2(Monday);
+
+  {
+  std::istringstream iss(oss.str());
+#if defined(DATE_TIME_XML_SERIALIZE)
+  archive::xml_iarchive ia(iss);
+#else
+  archive::text_iarchive ia(iss);
+#endif
+
+  try{
+#if defined(DATE_TIME_XML_SERIALIZE)
+    ia >> BOOST_SERIALIZATION_NVP(d2);
+    ia >> BOOST_SERIALIZATION_NVP(sv_d3);
+    ia >> BOOST_SERIALIZATION_NVP(sv_d4);
+    ia >> BOOST_SERIALIZATION_NVP(dd2);
+    ia >> BOOST_SERIALIZATION_NVP(sv_dd2);
+    ia >> BOOST_SERIALIZATION_NVP(dp2);
+    ia >> BOOST_SERIALIZATION_NVP(gy2);
+    ia >> BOOST_SERIALIZATION_NVP(gm2);
+    ia >> BOOST_SERIALIZATION_NVP(gd2);
+    ia >> BOOST_SERIALIZATION_NVP(gwd2);
+    ia >> BOOST_SERIALIZATION_NVP(pd2);
+    ia >> BOOST_SERIALIZATION_NVP(nkd2);
+    ia >> BOOST_SERIALIZATION_NVP(fkd2);
+    ia >> BOOST_SERIALIZATION_NVP(lkd2);
+    ia >> BOOST_SERIALIZATION_NVP(fkdb2);
+    ia >> BOOST_SERIALIZATION_NVP(fkda2);
+#else
+    ia >> d2;
+    ia >> sv_d3;
+    ia >> sv_d4;
+    ia >> dd2;
+    ia >> sv_dd2;
+    ia >> dp2;
+    ia >> gy2;
+    ia >> gm2;
+    ia >> gd2;
+    ia >> gwd2;
+    ia >> pd2;
+    ia >> nkd2;
+    ia >> fkd2;
+    ia >> lkd2;
+    ia >> fkdb2;
+    ia >> fkda2;
+#endif
+  }catch(archive::archive_exception& ae){
+    std::string s(ae.what());
+    check("Error reading from archive: " + s + "\nWritten data: \"" + oss.str() + "\"", false);
+    return printTestStats();
+  }
+  }
+  
+  check("date", d == d2);
+  check("special_value date (nadt)", sv_d1 == sv_d3);
+  check("special_value date (pos_infin)", sv_d2 == sv_d4);
+  check("date_duration", dd == dd2);
+  check("special_value date_duration (neg_infin)", sv_dd == sv_dd2);
+  check("date_period", dp == dp2);
+  check("greg_year", gy == gy2);
+  check("greg_month", gm == gm2);
+  check("greg_day", gd == gd2);
+  check("greg_weekday", gwd == gwd2);
+  check("date_generator: partial_date", pd == pd2);
+  check("date_generator: nth_kday_of_month", nkd.get_date(2002) == nkd2.get_date(2002)); // no operator== for nth_kday_of_week - yet
+  check("date_generator: first_kday_of_month", fkd.get_date(2002) == fkd2.get_date(2002)); // no operator== for first_kday_of_week - yet
+  check("date_generator: last_kday_of_month", lkd.get_date(2002) == lkd2.get_date(2002)); // no operator== for last_kday_of_week - yet
+  check("date_generator: first_kday_before", fkdb.get_date(d) == fkdb2.get_date(d)); // no operator== for first_kday_before - yet
+  check("date_generator: first_kday_after", fkda.get_date(d) == fkda2.get_date(d)); // no operator== for first_kday_after - yet
+
+  return printTestStats();
+}
diff --git a/src/boost/libs/date_time/test/gregorian/testgreg_wstream.cpp b/src/boost/libs/date_time/test/gregorian/testgreg_wstream.cpp
new file mode 100644
index 000000000..08173fc8c
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testgreg_wstream.cpp
@@ -0,0 +1,178 @@
+/* Copyright (c) 2003-2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Bart Garst
+ * $Date$
+ */
+#include <iostream>
+#include <sstream>
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include "../testfrmwk.hpp"
+
+using namespace boost::gregorian;
+
+int main(){
+#if defined(BOOST_NO_STD_WSTRING) || \
+    defined(BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS)
+  check("No wstring/wstream support for this compiler", false);
+#else
+  std::wstring res, ws;
+  std::wstringstream wss;
+  /* date_period is used because almost all the date-type objects 
+   * that have the operator<< can be easily accessed from it.
+   * Those are: date, greg_month, greg_day_of_week,
+   * date_period, date_duration (also date_generators) */
+  date_period dp(date(2003,Aug,21), date(2004,May,27));
+ 
+  
+  // date
+  wss << dp.begin();
+  res = L"2003-Aug-21";
+  check("date operator<<", wss.str() == res);
+  wss.str(L"");
+  ws = to_simple_wstring(dp.begin());
+  check("date to_simple_string", ws == res);
+  ws = to_iso_wstring(dp.begin());
+  res = L"20030821";
+  check("date to_iso_string", ws == res);
+  ws = to_iso_extended_wstring(dp.begin());
+  res = L"2003-08-21";
+  check("date to_iso_extended_string", ws == res);
+  ws = to_sql_wstring(dp.begin());
+  check("date to_sql_string", ws == res);
+  wss.str(L"");
+#ifndef BOOST_NO_STD_ITERATOR_TRAITS
+  { 
+    res = L"2003-Aug-21";
+    std::wstringstream wss2(L"2003-Aug-21");
+    date testdate(not_a_date_time);
+    wss2 >> testdate;
+    check("date operator>>", to_simple_wstring(testdate) == res);
+  }
+#else
+  check("no date operator>> for this compiler", false);
+#endif
+  
+  // greg_month
+  wss << dp.begin().month();
+  res = L"08";
+  check("greg_month", wss.str() == res);
+  wss.str(L"");
+  ws = dp.begin().month().as_short_wstring();
+  res = L"Aug";
+  check("greg_month as_short_wstring", ws == res);
+  ws = dp.begin().month().as_long_wstring();
+  res = L"August";
+  check("greg_month as_long_wstring", ws == res);
+  /*{ 
+    std::wstringstream wss2(L"August");
+    greg_month testmonth(not_a_date_time);
+    wss2 >> testmonth;
+    check("greg_month operator>>", to_simple_wstring(testmonth) == res);
+  }*/
+  
+  // greg_day_of_week
+  wss << dp.begin().day_of_week();
+  res = L"Thu";
+  check("greg_day_of_week", wss.str() == res);
+  wss.str(L"");
+  ws = dp.begin().day_of_week().as_short_wstring();
+  check("greg_day_of_week as_short_wstring", ws == res);
+  ws = dp.begin().day_of_week().as_long_wstring();
+  res = L"Thursday";
+  check("greg_day_of_week as_long_wstring", ws == res);
+  /*{ 
+    std::wstringstream wss2(L"Thu");
+    greg_day_of_week testday(not_a_date_time);
+    wss2 >> testday;
+    check("greg_day_of_week operator>>", to_simple_wstring(testday) == res);
+  }*/
+  
+  // date_period
+  wss << dp;
+  res = L"[2003-Aug-21/2004-May-26]";
+  check("date_period", wss.str() == res);
+  wss.str(L"");
+  ws = to_simple_wstring(dp);
+  check("date_period to_simple_string", ws == res);
+  res = L"20030821/20040526";
+  ws = to_iso_wstring(dp);
+  check("date_period to_iso_string", ws == res);
+  { 
+    std::wstringstream wss2(L"[2003-Aug-21/2004-May-27]");
+    res = L"[2003-Aug-21/2004-May-26]";
+    // following line gives an ambiguous overload of op>>
+    //date_period testperiod(date(not_a_date_time),date_duration(not_a_date_time));
+    date_period testperiod(date(2003,Aug,21), date(2004,May,27));
+    wss2 >> testperiod;
+    check("date_period operator>>", to_simple_wstring(testperiod) == res);
+  }
+  
+  // date_duration
+  wss << dp.length();
+  res = L"280";
+  check("date_duration", wss.str() == res);
+  wss.str(L"");
+  { 
+    std::wstringstream wss2(L"280");
+    date_duration testduration(not_a_date_time);
+    wss2 >> testduration;
+    check("date_duration operator>>", testduration.days() == 280);
+  }
+
+  // special values
+  date sv_d(neg_infin);
+  date_duration sv_dd(pos_infin);
+  //date_period sv_dp(sv_d,sv_dd);
+  // sv-date
+  wss << sv_d;
+  res = L"-infinity";
+  check("date operator<< special value", wss.str() == res);
+  wss.str(L"");
+  ws = to_simple_wstring(sv_d);
+  check("date to_simple_string special value", ws == res);
+  // sv-date_duration
+  wss << sv_dd;
+  res = L"+infinity";
+  check("date_duration operator<< special value", wss.str() == res);
+  wss.str(L"");
+  // sv-date_period
+  /*
+   * works - just gives unexpected results:
+   *[-infinity/not-a-date-time]
+  wss << sv_dp;
+  res = L"[2003-Aug-21/2004-May-26]";
+  check("date_period", wss.str() == res);
+  std::wcout << wss.str() << std::endl;
+  wss.str(L"");
+  */
+
+  // date_generators
+  first_day_of_the_week_after fka(Monday);
+  wss << fka;
+  res = L"Mon after";
+  check("first_kday_after", wss.str() == res);
+  wss.str(L"");
+  
+  first_day_of_the_week_before fkb(Monday);
+  wss << fkb;
+  res = L"Mon before";
+  check("first_kday_before", wss.str() == res);
+  wss.str(L"");
+  
+  first_day_of_the_week_in_month fkom(Monday,Jan);
+  wss << fkom;
+  res = L"first Mon of Jan";
+  check("first_kday_of_month", wss.str() == res);
+  wss.str(L"");
+  
+  last_day_of_the_week_in_month lkom(Monday,Jan);
+  wss << lkom;
+  res = L"last Mon of Jan";
+  check("last_kday_of_month", wss.str() == res);
+  wss.str(L"");
+
+#endif
+  return printTestStats();
+}
diff --git a/src/boost/libs/date_time/test/gregorian/testgreg_year.cpp b/src/boost/libs/date_time/test/gregorian/testgreg_year.cpp
new file mode 100644
index 000000000..2f2f3a4d1
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testgreg_year.cpp
@@ -0,0 +1,45 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/gregorian/greg_year.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+#include <sstream>
+
+void test_yearlimit(int yr, bool allowed)
+{
+    std::stringstream sdesc;
+    sdesc << "should" << (allowed ? "" : " not") << " be able to make a year " << yr;
+
+    try {
+        boost::gregorian::greg_year chkyr(yr);
+        check(sdesc.str(), allowed);
+        if (allowed) {
+            check_equal("year operator ==", chkyr, yr);
+        }
+    }
+    catch (std::out_of_range&) { check(sdesc.str(), !allowed); }
+}
+
+int
+main() 
+{
+  // trac-13159 better limit testing
+  test_yearlimit(    0, false);
+  test_yearlimit( 1399, false);
+  test_yearlimit( 1400,  true);
+  test_yearlimit( 1401,  true);
+  test_yearlimit( 9999,  true);
+  test_yearlimit(10000, false);
+  test_yearlimit(10001, false);
+
+  check("traits min year", (boost::gregorian::greg_year::min)() == 1400);
+  check("traits max year", (boost::gregorian::greg_year::max)() == 9999);
+
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testparse_date.cpp b/src/boost/libs/date_time/test/gregorian/testparse_date.cpp
new file mode 100644
index 000000000..a28280a38
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testparse_date.cpp
@@ -0,0 +1,368 @@
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst 
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+#include "boost/lexical_cast.hpp"
+#include <iostream>
+#include <string>
+
+// missing or misspelled parts of date string tests
+// 'output_str' will be overwritten with what() from caught exception
+bool failure_tests(std::string date_spec, 
+                   std::string& output_str)
+{
+  using namespace boost::gregorian;
+  bool result = false;
+  date d(not_a_date_time);
+  try {
+    d = from_simple_string(date_spec);
+  }
+  catch(bad_year& by){ // ex: "205-Jan-15"
+    result = true;
+    output_str = by.what();
+  }
+  catch(bad_month& bm){ // ex: "2005-Jsn-15"
+    result = true;
+    output_str = bm.what();
+  }
+  catch(bad_day_of_month& bd){ // ex: "2005-Jan-51"
+    result = true;
+    output_str = bd.what();
+  }
+  catch(...){
+    // test failed - unexpected exception, leave result set to false
+  }
+  return result;
+}
+
+int
+main() 
+{
+
+
+// Examples from 8601
+// Full date
+// Extended CCYY-MM-DD
+  std::string s("2001-10-5");
+
+  //This one aborts gcc2.95.3 on mandrake 8.1 linux with
+  //bad lexical cast?
+  try {
+    boost::gregorian::date d(boost::gregorian::from_string(s));
+    check("check year",  d.year()  == 2001);
+    check("check month", d.month() == 10);
+    check("check day",   d.day()   == 5);
+  }
+  catch(std::exception& e) {
+    check("parse 2001-10-5",  false);
+    std::cout << "Fail: " << e.what() << std::endl;
+  }
+
+  {
+    using namespace boost::gregorian;
+    // date objects from strings & strings to date objects
+    date d(2000, 2, 29);
+    date d2 = from_string("2000-2-29");
+    check("2000-2-29", d2 == d);
+    date d3 = from_string("2000-FEB-29");
+    check("2000-FEB-29 (uppercase)", d3 == d);
+    date d4 = from_string("2000-february-29");
+    check("2000-february-29 (lowercase)", d4 == d);
+    date d5 = from_string(to_simple_string(d));
+    check("date to string to date", d5 == d);
+    date d6 = from_string(to_iso_extended_string(d));
+    check("date to string to date", d6 == d);
+    date d7 = from_us_string("Feb-29-2000");
+    check("date from month-day-year string", d7 == d);
+    date d8 = from_uk_string("29-Feb-2000");
+    check("date from day-month-year string", d8 == d);
+    {
+      std::string sn("20050229"); // no Feb-29 in 2005
+      date dn(not_a_date_time);
+      try {
+        dn = date_from_iso_string(sn);
+        check("Expected exception not thrown: from ISO string (bad_day_of_month)", false);
+        std::cout << date_from_iso_string(sn) << std::endl;
+      }
+      catch(bad_day_of_month&) {
+        check("Caught expected exception: bad_day_of_month ", true);
+      }
+      catch(...) {
+        check("Caught unexpected exception", false);
+      }
+/* not currently passing due to a bug in boost::offset_separator (reported 2005-Aug-02)
+      sn = "2005022"; // missing a digit
+      try {
+        d = date_from_iso_string(sn);
+        check("Expected exception not thrown: from ISO string (missing digit)", false);
+        std::cout << date_from_iso_string(sn) << std::endl;
+      }
+      catch(bad_day_of_month& e) {
+        check("Caught expected exception: bad_day_of_month ", true);
+      }
+      catch(...) {
+        check("Caught unexpected exception", false);
+      }
+  */      
+      sn = "20050228"; // now it's correct
+      dn = date_from_iso_string(sn);
+      check("from ISO string", date(2005,Feb,28) == dn);
+    }
+    
+    date d9 = from_us_string(__DATE__);
+    std::cout << "Today's date: " << to_simple_string(d9) << std::endl;
+    date d10 = from_us_string("Feb 29, 2000");
+    std::cout << "With comma: " << to_simple_string(d10) << std::endl;
+    check("american date with comma: Feb 29, 2000 ", d10 == d);
+
+    date d11 = from_us_string("feb 29 2000");
+    check("american date with comma: feb 29 2000 ", d11 == d);
+
+    // test for missing or misspelled date spec components
+    std::string output_str("unexpected exception caught");
+    check("Year misspelled/out of range: " + output_str,
+        failure_tests("205-Jan-15", output_str));
+    output_str = "unexpected exception caught";
+    check("Month misspelled: " + output_str,
+        failure_tests("2005-Jsn-15", output_str));
+    output_str = "unexpected exception caught";
+    check("Day out of range: " + output_str,
+        failure_tests("2005-Jan-55", output_str));
+    output_str = "unexpected exception caught";
+    check("Missing month and day: " + output_str,
+        failure_tests("2005", output_str));
+    output_str = "unexpected exception caught";
+    check("Missing day: " + output_str,
+        failure_tests("2005-Jan", output_str));
+
+
+#if defined(BOOST_DATE_TIME_NO_LOCALE) || defined(BOOST_NO_STD_ITERATOR_TRAITS) || !defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
+
+    //TODO -- all these PRE_1_33 exclusions need to be removed.  In the meantime, don't make
+    //this stuff fail.
+#if defined(USE_DATE_TIME_PRE_1_33_FACET_IO)
+    check("input streaming for date not available", false); // force a failure
+#endif
+#else
+    {
+      std::stringstream ss("2000-2-29");
+      ss >> d2;
+      check("2000-2-29 stream-in", d2 == d);
+    }
+    { 
+      std::stringstream ss("2000-FEB-29");
+      ss >> d2;
+      //std::cout << d2 << std::endl;
+      check("2000-FEB-29 stream-in (uppercase)", d2 == d);
+    }
+    {
+      std::stringstream ss("2000-february-29");
+      ss >> d2;
+      check("2000-february-29 stream-in (lowercase)", d2 == d);
+    }
+    // the removed (3) tests require a stream manipulator for date_order
+    // and date_separator (not yet implemented)
+    /*{
+      std::stringstream ss("Feb-29-2000");
+      ss >> d2;
+      check("date from month-day-year string stream-in", d2 == d);
+    }
+    {
+      std::stringstream ss("29-Feb-2000");
+      ss >> d2;
+      check("date from day-month-year string stream-in", d2 == d);
+    }
+    {
+      std::stringstream ss("Feb 29, 2000");
+      ss >> d2;
+      check("american date with comma: Feb 29, 2000 stream-in", d2 == d);
+    }*/
+#endif //BOOST_DATE_TIME_NO_LOCALE
+
+
+
+    // check proper range
+    d = date(2001, 1, 1);
+    d2 = from_string("2001-Jan-1");
+    d3 = from_string("2001-January-1");
+    check("January", d == d2);
+    check("January", d == d3);
+    d = date(2001, 12, 1);
+    d2 = from_string("2001-Dec-1");
+    d3 = from_string("2001-December-1");
+    check("December", d == d2);
+    check("December", d == d3);
+#if defined(BOOST_NO_STD_ITERATOR_TRAITS)
+    check("date from stream not available: no std iterator traits", false);
+#else
+    // from stream
+    d = date(2000, 10, 31);
+    std::stringstream ss("");
+    ss << "2000-Oct-31 is Halloween 2k!";
+    std::istream_iterator<std::string> iter(ss), eos;
+    check("from stream - stringstream", d == from_stream(iter, eos));
+#if !(defined(BOOST_NO_STD_WSTRING)) 
+#if !(defined(BOOST_DATE_TIME_NO_WISTREAM_ITERATOR))
+    std::wstringstream ws;
+    ws << "2000-Oct-31 is Halloween 2k!";
+    std::istream_iterator<std::wstring, wchar_t> witer(ws), weos;
+    check("from stream - wstringstream", d == from_stream(witer, weos));
+#endif // NO_WSTREAM_ITERATOR
+#endif // BOOST_NO_WSTRING
+    char d2_string[] = {"2000-10-31 is Halloween 2k!"};
+    char* end = d2_string + sizeof(d2_string) - 1;
+    check("from stream - char[]", d == from_stream(d2_string, end));
+
+    std::string s1_string("2000-Oct-31 is Halloween 2k!");
+    std::string::iterator s1_start = s1_string.begin();
+    std::string::iterator s1_end = s1_string.end();
+    check("from stream - string", d == from_stream(s1_start, s1_end));
+#ifndef BOOST_NO_STD_WSTRING
+    std::wstring w1_string(boost::lexical_cast<std::wstring>("2000-Oct-31 is Halloween 2k!"));
+    std::wstring::iterator w1_start = w1_string.begin();
+    std::wstring::iterator w1_end = w1_string.end();
+    check("from stream - wstring", d == from_stream(w1_start, w1_end));
+#endif // BOOST_NO_STD_WSTRING 
+#endif // BOOST_NO_STD_ITERATOR_TRAITS
+    /* date objects from strings & strings to date objects
+     * with misspelled months */
+    try {
+      date bd = from_string("2002-Jull-4");
+      std::cout << "Shouldn't be reached." << 
+        boost::gregorian::to_simple_string(bd) << std::endl;
+    }
+    catch(boost::gregorian::bad_month&){
+      check("bad spelling 'Jull'", true);
+    }
+    catch(std::exception& e){
+      check("bad spelling", false);
+      std::cout << "Fail: " << e.what() << std::endl;
+    }
+  }
+
+  
+  try {
+    std::string s2("2001-12-41"); //oops should be 31
+    boost::gregorian::date bad_day(boost::gregorian::from_string(s2)); //won't construct
+    check("check bad day", false);
+    //The line below won't execute, but make the compiler think
+    //we are using bad day....
+    std::cout << "Oh oh, this shouldn't be reached: "
+              << boost::gregorian::to_iso_string(bad_day) << std::endl;
+
+  }
+  catch(boost::gregorian::bad_day_of_month&) { //expected
+    check("check bad day", true);
+  }
+  catch(std::exception& e) {
+    //oops wrong exception
+    check("check bad day",  false);
+    std::cout << "Fail: " << e.what() << std::endl;
+  }
+
+  try {
+    std::string s2("2001-02-29"); //oops should be 28
+    boost::gregorian::date bad_day(boost::gregorian::from_string(s2)); //won't construct
+    check("check bad leap year", false);
+    //The line below won't execute, but make the compiler think
+    //we are using bad day....
+    std::cout << "Oh oh, this shouldn't be reached: "
+              << boost::gregorian::to_iso_string(bad_day) << std::endl;
+
+  }
+  catch(boost::gregorian::bad_day_of_month&) { //expected
+    check("check bad leap year", true);
+  }
+  catch(std::exception& e) {
+    //oops wrong exception
+    check("check bad leap year",  false);
+    std::cout << "Fail: " << e.what() << std::endl;
+  }
+
+  try {
+    std::string s2("2001-14-1"); //oops should be <= 12
+    boost::gregorian::date bad_month(boost::date_time::parse_date<boost::gregorian::date>(s2));
+    check("check bad month", false); //fail the test
+    //The line below won't execute, but make the compiler think
+    //we are using bad day....
+    std::cout << "Oh oh, this shouldn't be reached: "
+              << boost::gregorian::to_iso_string(bad_month) << std::endl;
+
+  }
+  catch(boost::gregorian::bad_month&) { //expected
+    check("check bad month", true);
+  }
+  catch(std::exception& e) {
+    //oops wrong exception
+    check("check bad month",  false);
+    std::cout << "Fail: " << e.what() << std::endl;
+  }
+
+  //This one aborts gcc2.95.3 on mandrake 8.1 linux with
+  //bad lexical cast?
+  try {
+    //Example of ISO Standard -- CCYYMMDD
+    using namespace boost::gregorian;
+    std::string ud("20011009"); //2001-Oct-09
+    date d1(boost::gregorian::from_undelimited_string(ud));
+    //  std::cout << to_string(d1) << std::endl;
+    check("undelimited date string", d1 == date(2001,Oct,9));
+    
+  
+    std::string ad("2001/10/09");
+    date d2(boost::date_time::parse_date<date>(ad));
+    check("check american date",  d2  == date(2001,Oct,9));
+  }
+  catch(std::exception& e) {
+    check("more parsing",  false);
+    std::cout << "Fail: " << e.what() << std::endl;
+  }
+
+  using namespace boost::gregorian;
+  std::string s2("2003-07-28");
+  date d2(from_string(s2));
+  check("check date", d2.month() == 7 &&
+                      d2.year() == 2003 &&
+                      d2.day() == 28);
+//   std::string s1("2001-Oct-5");
+//   gregorian::date d1(parse_date<gregorian::date>(s1));
+//    check("check month", d1.month() == 10);
+  
+
+  //Check that the from_string and to_string can be reversed
+  date d10(2003, 10, 19);
+  std::string d10s = to_simple_string(d10);
+  date d11 = from_simple_string(d10s);
+  check("to from string inversion", d10 == d11);
+
+  try {
+    using namespace boost::gregorian;
+    std::string ud(""); //empty string error sf bug# 1155556
+    date d1(from_simple_string(ud));
+    check("empty string",  false); //should never reach this piont
+    (void)d1;
+  }
+  catch(std::exception& e) {
+    check(std::string("empty string parse (exception expected): ") + e.what(),  true);
+  }
+  
+
+//Calendar Week + Day Number
+// CCYYWwwDThhmmss
+// 1986W105T
+// week == 10 day=5
+// see page 5
+
+
+//Duration rep
+//CCYYMMDDThhmmss/PnYnMnDTnHnMnS
+
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/gregorian/testperiod.cpp b/src/boost/libs/date_time/test/gregorian/testperiod.cpp
new file mode 100644
index 000000000..bca235276
--- /dev/null
+++ b/src/boost/libs/date_time/test/gregorian/testperiod.cpp
@@ -0,0 +1,153 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+
+int main() 
+{
+  using namespace boost::gregorian;
+  date d1(2000,Jan,1),d2(2000,Jan,4);
+  date d3 = d2;
+  check("assignment", d3 == d2);
+  date_period p1(d1,d2);
+  date_period p2(d1,date_duration(3));
+  check("construction and ==", p1 == p2);
+  check("begin",  p1.begin()  == d1);
+  check("last",   p1.last()   == d2-date_duration(1) );
+  check("end",    p1.end()    == d2);
+  check("length", p2.length() == date_duration(3));
+  check("contains begin", p1.contains(d1));
+  check("contains last", !p1.contains(d2));
+  date_period p3(date(2000,Jan,4),date(2000,Feb,1));
+  check("operator== not equal case", !(p1 == p3));
+  check("less than order", p1 < p3);
+  check("greater than order", p3 > p1);
+  check("not equal", p3 != p1);
+  check("intersects with myself", p1.intersects(p1));
+  check("not intersects", !(p1.intersects(p3)));
+  check("not intersects", !(p3.intersects(p1)));
+  date_period p4(date(1999,Dec,1), d2);
+  check("intersects", p1.intersects(p4));
+  check("intersects", p4.intersects(p1));
+  date_period p5(date(1999,Dec,1), date(2000,Dec,31));
+  check("intersects", p1.intersects(p5));
+  check("intersects", p5.intersects(p1));
+  date_period p6(date(2000,Jan,1),date(2000,Dec,31));
+  check("contains period", p5.contains(p6));
+  check("contains period equal", p6.contains(p6));
+  check("not contains period", !p6.contains(p5));
+  
+  //shift test
+  date_duration fourDays(4);
+  p1.shift(fourDays); //from 2000-Jan-01--2000-Jan-04
+  date_period shifted(date(2000,Jan,5),date(2000,Jan,8));
+  //   std::cout << to_string(p1.begin()) <<"--" 
+  //             << to_string(p1.last()) << std::endl;
+  check("shift", p1 == shifted);
+
+  //expand the date period  
+  date_period p10(date(2000,Jan,5),date(2000,Jan,8));
+  p10.expand(days(2)); //from 2000-Jan-01--2000-Jan-04
+  check("expand", p10 == date_period(date(2000,Jan,3),date(2000,Jan,10)));
+
+  //intersection tests
+  date_period i1(date(2000,Jan,5), date(2000,Jan,10));
+  date_period i2(date(2000,Jan,1), date(2000,Jan,7));
+  date_period r1(date(2000,Jan,5), date(2000,Jan,7));
+  //case 1    [5 -10) intersect [1-7) ->  [5-7)
+  std::cout << i1.intersection(i2) << std::endl;
+  check("intersect case1", i1.intersection(i2) == r1);
+  check("intersect case1", i2.intersection(i1) == r1);
+  //case 2    [5 -10) intersect [1-15) -> [5-10)
+  date_period i3(date(2000,Jan,1), date(2000,Jan,15));
+  check("intersect case2", i1.intersection(i3) == i1);
+  check("intersect case2", i3.intersection(i1) == i1);
+  //case 3    [5-10) intersect [7-15)  -> [7-10)
+  date_period i4(date(2000,Jan,7), date(2000,Jan,10));
+  date_period r2(date(2000,Jan,7), date(2000,Jan,10));
+  check("intersect case3", i1.intersection(i4) == r2);
+  check("intersect case3", i4.intersection(i1) == r2);
+  //case 4    [5-10) intersect [6-9)  -> [6-9)
+  date_period i5(date(2000,Jan,6), date(2000,Jan,9));
+  check("intersect case4", i1.intersection(i5) == i5);
+  check("intersect case4", i5.intersection(i1) == i5);
+  //case 5 no intersection [1-7) intersect [7-10)
+  check("no intersection", i2.intersection(i4).is_null());
+
+  //case 1    [5 -10) merge [1-7) ->  [1-10)
+  date_period r3(date(2000,Jan,1), date(2000,Jan,10));
+  //  std::cout << to_iso_string(i1.merge(i2).begin()) << "/" << to_iso_string(i1.merge(i2).last()) << std::endl;
+  check("[5 -10) merge [1-7)  -> [1-10)", i1.merge(i2) == r3);
+  check("[1 -7)  merge [7-10) ->  null",  i2.merge(i4).is_null());
+  date_period r4(date(2000,Jan,5), date(2000,Jan,10));
+  check("[5 -10) merge [6-9)  -> [5-10)", i1.merge(i5) == r4);
+
+  check("[5-10) span [1-7)  -> [1-10)", i1.span(i2) == r3);
+  check("[1-7)  span [7-10) -> [1-10)", i2.span(i4) == r3);
+  check("[7-10)  span [1-7) -> [1-10)", i4.span(i2) == r3);
+  check("[1-15)  span [1-7) -> [1-15)", i3.span(i2) == i3);
+
+  date_period i6(date(2000,Jan,1), date(2000,Jan,2));
+  check("[1-2)  span [7-10) -> [1-10)", i6.span(i4) == r3);
+  check("[7-10)  span [1-2) -> [1-10)", i4.span(i6) == r3);
+  
+
+  date bf_start(2000,Jan,5);
+  date bf_end(2000,Jan,10);
+  date bf_before(2000,Jan,4); //is before the period
+  date bf_after(2000,Jan,11);  //is really after
+  date bf_during(2000, Jan, 7);
+  date_period bfp1(bf_start, bf_end);  //[2000-Jan-5 - 2000-Jan10)
+  
+  check("is before -- start boundary", !bfp1.is_before(bf_start));
+  check("is before -- end boundary", bfp1.is_before(bf_end));
+  check("is before -- last boundary", !bfp1.is_before(bfp1.last()));
+  check("is before -- false", !bfp1.is_before(bf_before));
+  check("is before -- false", !bfp1.is_before(bf_during));
+  check("is before -- true",  bfp1.is_before(bf_after));
+
+  check("is after -- start boundary", !bfp1.is_after(bf_start));
+  check("is after -- end boundary", !bfp1.is_after(bf_end));
+  check("is after -- last boundary", !bfp1.is_after(bfp1.last()));
+  check("is after -- true",   bfp1.is_after(bf_before));
+  check("is after -- false", !bfp1.is_after(bf_during));
+  check("is after -- false", !bfp1.is_after(bf_after));
+
+  //adjacent tests
+  /*
+          [5-----10)            adj1
+     [1----5)                   adj2
+             [7-----12)         adj3
+                     [12----15) adj4
+     [1-3)                      adj5
+             [7-9)              adj6
+  */  
+  date_period adj1(date(2000,Jan,5), date(2000,Jan,10));
+  date_period adj2(date(2000,Jan,1), date(2000,Jan,5));
+  date_period adj3(date(2000,Jan,7), date(2000,Jan,12));
+  date_period adj4(date(2000,Jan,12), date(2000,Jan,15));
+  date_period adj5(date(2000,Jan,1),  date(2000,Jan,3));
+  date_period adj6(date(2000,Jan,7),  date(2000,Jan,9));
+  
+  check("is adjacent -- adj1-->adj2", adj1.is_adjacent(adj2));
+  check("is adjacent -- adj2-->adj1", adj2.is_adjacent(adj1));
+  check("is adjacent -- adj1-->adj3", !adj1.is_adjacent(adj3));
+  check("is adjacent -- adj3-->adj1", !adj3.is_adjacent(adj1));
+  check("is adjacent -- adj1-->adj4", !adj1.is_adjacent(adj4));
+  check("is adjacent -- adj4-->adj1", !adj4.is_adjacent(adj1));
+  check("is adjacent -- adj1-->adj5", !adj1.is_adjacent(adj5));
+  check("is adjacent -- adj5-->adj1", !adj5.is_adjacent(adj1));
+  check("is adjacent -- adj1-->adj6", !adj1.is_adjacent(adj6));
+  check("is adjacent -- adj6-->adj1", !adj6.is_adjacent(adj1));
+  
+  printTestStats();
+
+  return 0;
+}
+
diff --git a/src/boost/libs/date_time/test/local_time/README.poorly_formed_zonespec b/src/boost/libs/date_time/test/local_time/README.poorly_formed_zonespec
new file mode 100644
index 000000000..b417cc8a6
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/README.poorly_formed_zonespec
@@ -0,0 +1,4 @@
+The file "poorly_formed_zonespec.csv" is only used for testing.
+
+This file has the wrong number of fields in it and should not be used for
+any other prupose.
diff --git a/src/boost/libs/date_time/test/local_time/poorly_formed_zonespec.csv b/src/boost/libs/date_time/test/local_time/poorly_formed_zonespec.csv
new file mode 100644
index 000000000..d5eb87149
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/poorly_formed_zonespec.csv
@@ -0,0 +1,2 @@
+"ID","STD ABBR","STD NAME","DST ABBR","DST NAME","GMT offset","DST adjustment","DST Start Date rule","Start time","DST End date rule","End time"
+"Unique/Zone_name","GMT","","+00:00:00"
diff --git a/src/boost/libs/date_time/test/local_time/testclocks.cpp b/src/boost/libs/date_time/test/local_time/testclocks.cpp
new file mode 100644
index 000000000..6744631e2
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testclocks.cpp
@@ -0,0 +1,40 @@
+/* Copyright (c) 2003-2004 CrystalClear Software, Inc.
+ * Subject to the Boost Software License, Version 1.0. 
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/local_time/local_time.hpp"
+#include <iostream>
+
+// The actual clocks are tested in posix_time/testclock.cpp. 
+// These tests are to verify that the time zone is applied correctly
+
+int
+main()
+{
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+  using namespace boost::local_time;
+
+
+  boost::shared_ptr<time_zone> az_tz(new posix_time_zone("MST-07"));
+  boost::shared_ptr<time_zone> ny_tz(new posix_time_zone("EST-05EDT,M4.1.0,M10.5.0"));
+
+  ptime tl = second_clock::local_time();
+  std::cout << tl << std::endl;
+  local_date_time ldt1 = local_sec_clock::local_time(az_tz);
+  std::cout << ldt1.to_string() << std::endl;
+  local_date_time ldt2 = local_sec_clock::local_time(ny_tz);
+  std::cout << ldt2.to_string() << std::endl;
+  
+  tl = microsec_clock::local_time();
+  std::cout << tl << std::endl;
+  local_date_time ldt3 = local_microsec_clock::local_time(az_tz);
+  std::cout << ldt3.to_string() << std::endl;
+  local_date_time ldt4 = local_microsec_clock::local_time(ny_tz);
+  std::cout << ldt4.to_string() << std::endl;
+
+   return 0;
+}
diff --git a/src/boost/libs/date_time/test/local_time/testcustom_time_zone.cpp b/src/boost/libs/date_time/test/local_time/testcustom_time_zone.cpp
new file mode 100644
index 000000000..c45965e55
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testcustom_time_zone.cpp
@@ -0,0 +1,88 @@
+/* Copyright (c) 2003-2005 CrystalClear Software, Inc.
+ * Subject to the Boost Software License, Version 1.0. 
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/local_time/local_time.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+
+int
+main()
+{
+
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+  using namespace boost::local_time;
+
+
+  boost::shared_ptr<dst_calc_rule> 
+    rule1(new partial_date_dst_rule(partial_date(30,Apr),
+                                    partial_date(30,Oct)));
+  
+  boost::shared_ptr<dst_calc_rule> 
+    rule2(new first_last_dst_rule(first_last_dst_rule::start_rule(Sunday,Apr),
+                                  first_last_dst_rule::end_rule(Sunday,Oct)));
+  boost::shared_ptr<dst_calc_rule> 
+    rule3(new last_last_dst_rule(last_last_dst_rule::start_rule(Sunday,Mar),
+                                 last_last_dst_rule::end_rule(Sunday,Oct)));
+  boost::shared_ptr<dst_calc_rule> rule4; // no daylight savings
+  
+  time_zone_names pst("Pacific Standard Time",
+                      "PST", 
+                      "Pacific Daylight Time" ,
+                      "PDT");
+  time_zone_names mst("Mountain Standard Time",
+                      "MST", 
+                      "" ,
+                      "");
+  
+  dst_adjustment_offsets of(hours(1), hours(2), hours(2));
+  dst_adjustment_offsets of2(hours(0), hours(0), hours(0)); // no daylight savings
+
+  time_zone_ptr tz1(new custom_time_zone(pst, hours(-8), of, rule1));
+  time_zone_ptr tz2(new custom_time_zone(pst, hours(-8), of, rule2));
+  time_zone_ptr tz3(new custom_time_zone(pst, hours(-8), of, rule3));
+  time_zone_ptr tz4(new custom_time_zone(mst, hours(-7), of2, rule4));
+
+  check("out string", 
+        tz1->dst_zone_abbrev() == std::string("PDT"));
+  check("out string", 
+        tz1->std_zone_abbrev() == std::string("PST"));
+  check("out string", 
+        tz1->std_zone_name() == std::string("Pacific Standard Time"));
+  check("out string", 
+        tz1->dst_zone_name() == std::string("Pacific Daylight Time"));
+
+  check("dst offset", tz1->dst_offset() == hours(1));
+  check("base offset", tz1->base_utc_offset() == hours(-8));
+  check("has dst", tz1->has_dst());
+
+  check("dst start time", 
+        tz1->dst_local_start_time(2003) == ptime(date(2003,Apr,30),hours(2)));
+  check("dst end time", 
+        tz1->dst_local_end_time(2003) == ptime(date(2003,Oct,30),hours(2)));
+
+  check("tz1 to posix string", 
+       tz1->to_posix_string() == std::string("PST-08PDT+01,120/02:00,303/02:00"));
+  check("tz2 to posix string", 
+       tz2->to_posix_string() == std::string("PST-08PDT+01,M4.1.0/02:00,M10.5.0/02:00"));
+  check("tz3 to posix string", 
+        tz3->to_posix_string() == std::string("PST-08PDT+01,M3.5.0/02:00,M10.5.0/02:00"));
+  check("tz4 to posix string", 
+        tz4->to_posix_string() == std::string("MST-07"));
+
+  // test start/end for non-dst zone
+  check("has dst in non-dst zone", !tz4->has_dst());
+  check("dst start in non-dst zone", 
+        tz4->dst_local_start_time(2005) == ptime(not_a_date_time));
+  check("dst end in non-dst zone",
+        tz4->dst_local_end_time(2005) == ptime(not_a_date_time));
+
+
+  return printTestStats();
+}
+
+
diff --git a/src/boost/libs/date_time/test/local_time/testdst_transition_day_rule.cpp b/src/boost/libs/date_time/test/local_time/testdst_transition_day_rule.cpp
new file mode 100644
index 000000000..d3ca19afa
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testdst_transition_day_rule.cpp
@@ -0,0 +1,65 @@
+/* Copyright (c) 2003-2004 CrystalClear Software, Inc.
+ * Subject to the Boost Software License, Version 1.0. 
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "boost/date_time/local_time/dst_transition_day_rules.hpp"
+#include "boost/shared_ptr.hpp"
+#include "../testfrmwk.hpp"
+
+
+
+// see http://www.timeanddate.com/time/aboutdst.html for some info
+// also 
+int
+main() 
+{
+  //  using namespace boost::posix_time;
+  using namespace boost::local_time;
+  using namespace boost::gregorian;
+
+  boost::shared_ptr<dst_calc_rule> 
+    rule1(new partial_date_dst_rule(partial_date(30,Apr),
+                                    partial_date(30,Oct)));
+
+  check("partial date rule", rule1->start_day(2001) == date(2001, Apr, 30));
+  check("partial date rule", rule1->end_day(2001) == date(2001, Oct, 30));
+    
+  boost::shared_ptr<dst_calc_rule> 
+    rule2(new first_last_dst_rule(first_last_dst_rule::start_rule(Sunday,Apr),
+                                  first_last_dst_rule::end_rule(Sunday,Oct)));
+
+  check("first last rule", rule2->start_day(2001) == date(2001, Apr, 1));
+  check("first last rule", rule2->end_day(2001) == date(2001, Oct, 28));
+
+  boost::shared_ptr<dst_calc_rule> 
+    rule3(new last_last_dst_rule(last_last_dst_rule::start_rule(Sunday,Mar),
+                                 last_last_dst_rule::end_rule(Sunday,Oct)));
+
+  check("last last rule", rule3->start_day(2001) == date(2001, Mar, 25));
+  check("last last rule", rule3->end_day(2001) == date(2001, Oct, 28));
+  
+  typedef nth_kday_of_month nkday;
+  boost::shared_ptr<dst_calc_rule> 
+    rule4(new nth_last_dst_rule(nth_last_dst_rule::start_rule(nkday::first,Sunday,Mar),
+                                nth_last_dst_rule::end_rule(Sunday,Oct)));
+  
+  check("nth Last rule", rule4->start_day(2001) == date(2001, Mar, 4));
+  check("nth Last rule", rule4->end_day(2001) == date(2001, Oct, 28));
+    
+  boost::shared_ptr<dst_calc_rule> 
+    rule5(new nth_kday_dst_rule(nth_kday_dst_rule::start_rule(nkday::first,Sunday,Mar),
+                                nth_kday_dst_rule::end_rule(nkday::fourth,Sunday,Oct)));
+  
+  check("nth_kday rule", rule5->start_day(2001) == date(2001, Mar, 4));
+  check("nth_kday rule", rule5->end_day(2001) == date(2001, Oct, 28));
+  
+
+
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/local_time/testlocal_time.cpp b/src/boost/libs/date_time/test/local_time/testlocal_time.cpp
new file mode 100644
index 000000000..058090fc0
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testlocal_time.cpp
@@ -0,0 +1,370 @@
+/* Copyright (c) 2003-2005 CrystalClear Software, Inc.
+ * Subject to the Boost Software License, Version 1.0. 
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+
+#include "boost/date_time/local_time/custom_time_zone.hpp"
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/date_time/local_time/local_time.hpp"
+// #include "boost/date_time/local_time/posix_time_zone.hpp"
+#include "../testfrmwk.hpp"
+//#include "boost/date_time/c_time.hpp"
+#include <iostream>
+
+#include <sstream>
+// function eases testing
+std::string tm_out(const tm& ptr){
+  std::stringstream ss;
+
+  ss 
+    << ptr.tm_wday << ' ' << ptr.tm_yday << ' '
+    << std::setw(2) << std::setfill('0') << ptr.tm_mon + 1 << '/'
+    << std::setw(2) << std::setfill('0') << ptr.tm_mday << '/'
+    << std::setw(2) << std::setfill('0') << ptr.tm_year + 1900 << ' '
+    << std::setw(2) << std::setfill('0') << ptr.tm_hour << ':'
+    << std::setw(2) << std::setfill('0') << ptr.tm_min << ':'
+    << std::setw(2) << std::setfill('0') << ptr.tm_sec << ' ';
+  if(ptr.tm_isdst >= 0){
+    ss << (ptr.tm_isdst ? "DST" : "STD");
+  }
+  else{
+    ss << "DST/STD unknown";
+  }
+  return ss.str();
+}
+
+int
+main()
+{
+
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+  using namespace boost::local_time;
+
+  // since local_date_time inherits it's math operations from time, the 
+  // tests here only show that the operations work. The thorough testing
+  // of these operations is done in the posix_time tests
+
+  try {
+    time_zone_ptr az_tz(new posix_time_zone("MST-07"));
+    time_zone_ptr ny_tz(new posix_time_zone("EST-05EDT,M4.1.0,M10.5.0"));
+    // EST & EST for sydney is correct, according to zoneinfo files
+    time_zone_ptr sydney(new posix_time_zone("EST+10EST,M10.5.0,M3.5.0/03:00"));
+    time_zone_ptr null_tz;
+    date d(2003, 12, 20);
+    hours h(12);
+    ptime t(d,h);
+    local_date_time az_time(t, az_tz); // ptime constructor is a UTC time
+    
+    check("Zone abbreviation", az_time.zone()->std_zone_abbrev() == std::string("MST"));
+    check("base offset", az_time.zone()->base_utc_offset() == hours(-7));
+    check("zone has dst", az_time.zone()->has_dst() == false);
+    check("is_dst check", az_time.is_dst() == false);
+    check("to_string: " + az_time.to_string(), 
+          az_time.to_string() == "2003-Dec-20 05:00:00 MST");
+   
+
+    
+    std::cout << "\nChecking copy construction" << std::endl;
+    local_date_time az_time2(az_time); //copy constructor
+    // Now test the copy
+    check("is_dst check", az_time2.is_dst() == false);
+    check("to_string: " + az_time2.to_string(), 
+          az_time2.to_string() == "2003-Dec-20 05:00:00 MST");
+    check("zone has dst", az_time2.zone()->has_dst() == false);
+    check("base offset", az_time2.zone()->base_utc_offset() == hours(-7));
+    
+
+    std::cout << "\nChecking special_value construction" << std::endl;
+    // since local_date_time inherits its special value operatorations 
+    // from time, we only need to show here that they work as thorough 
+    // testing is done in the posix_time tests
+    ptime svpt(not_a_date_time);
+    local_date_time sv_time(svpt, ny_tz);
+    check("is special_value", sv_time.is_not_a_date_time());
+    check("to_string: " + sv_time.to_string(), 
+          sv_time.to_string() == "not-a-date-time");
+    check("is_dst", sv_time.is_dst() == false);
+    local_date_time sv_time2(pos_infin);
+    check("is special_value", sv_time2.is_pos_infinity());
+    check("to_string: " + sv_time2.to_string(), 
+          sv_time2.to_string() == "+infinity");
+    check("is_dst", sv_time2.is_dst() == false);
+    sv_time2 += days(12); // add a duration to a special value
+    check("Add a duration to a special value", sv_time2.is_pos_infinity());
+
+    local_date_time sv_time3(max_date_time, ny_tz);
+#ifdef BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+    check("max_date_time to_string: " + sv_time3.to_string(), 
+          sv_time3.to_string() == "9999-Dec-31 18:59:59.999999999 EST");
+#else
+    check("max_date_time to_string: " + sv_time3.to_string(), 
+          sv_time3.to_string() == "9999-Dec-31 18:59:59.999999 EST");
+#endif
+
+    try {
+      local_date_time sv_time4(min_date_time);
+      check("min_date_time to_string: " + sv_time4.to_string(), 
+            sv_time4.to_string() == "1400-Jan-01 00:00:00 UTC");
+    }
+    catch (std::exception& e) {
+      check("min_date_time to_string -- exception" , false);
+      std::cout << "Exception is : " << e.what() << std::endl;
+    }
+
+/** todo  -- this will cause an out of range when min_date is adjusted for ny_tz
+    local_date_time sv_time5(min_date_time, ny_tz);
+    std::cout << sv_time5.to_string() << std::endl;
+**/
+
+    std::cout << "\nChecking calc_options construction" << std::endl;
+    { // invalid NADT
+      date dx(2004, Apr, 4);
+      time_duration td(2,30,0); // invalid local time in ny_tz
+      local_date_time calcop(dx, td, ny_tz, local_date_time::NOT_DATE_TIME_ON_ERROR);
+      check("is NADT", calcop.is_not_a_date_time());
+    }
+    { // invalid exception
+      date dx(2004, Apr, 4);
+      time_duration td(2,30,0); // invalid local time in ny_tz
+      try{
+        local_date_time calcop(dx, td, ny_tz, local_date_time::EXCEPTION_ON_ERROR);
+        check("Did not catch expected exception", false);
+      }catch(time_label_invalid& /*i*/){
+        check("Caught expected exception", true);
+      }catch(...){
+        check("Caught unexpected exception", false);
+      }
+    }
+    { // ambig NADT
+      date dx(2004, Oct, 31);
+      time_duration td(1,30,0); // ambig local time in ny_tz
+      local_date_time calcop(dx, td, ny_tz, local_date_time::NOT_DATE_TIME_ON_ERROR);
+      check("is NADT", calcop.is_not_a_date_time());
+    }
+    { // ambig exception
+      date dx(2004, Oct, 31);
+      time_duration td(1,30,0); // ambig local time in ny_tz
+      try{
+        local_date_time calcop(dx, td, ny_tz, local_date_time::EXCEPTION_ON_ERROR);
+        check("Did not catch expected exception", false);
+      }catch(ambiguous_result& /*a*/){
+        check("Caught expected exception", true);
+      }catch(...){
+        check("Caught unexpected exception", false);
+      }
+    }
+
+    
+    //Now construct with a date and time
+    std::cout << "\nChecking construct with date and time_duration" << std::endl;
+    local_date_time az_time3(d, h, az_tz, false);
+    check("Zone abbreviation", az_time3.zone()->std_zone_abbrev() == std::string("MST"));
+    check("base offset", az_time3.zone()->base_utc_offset() == hours(-7));
+    check("base offset", az_time3.zone()->has_dst() == false);
+    check("is_dst check", az_time3.is_dst() == false);
+    check("to_string: " + az_time3.to_string(), 
+          az_time3.to_string() == "2003-Dec-20 12:00:00 MST");
+    
+    // construct with a null tz
+    //local_date_time null_tz_time(d, h, null_tz, false);
+    local_date_time null_tz_time(d, h, null_tz, true);
+    // TODO: how to handle calls to null_tz_time.zone()->...
+    check("is_dst check", null_tz_time.is_dst() == false);
+    check("to_string: " + null_tz_time.to_string(), 
+          null_tz_time.to_string() == "2003-Dec-20 12:00:00 UTC");
+    
+    //Now construct with a date and time - invalid parameters
+    try{
+      local_date_time blt(d, h, ny_tz, true);
+      check("Did not catch expected exception (dst_not_valid)", false);
+    }catch(dst_not_valid& e){
+      check(std::string("Caught expected exception (dst_not_valid) ") + e.what(), true);
+    }catch(std::exception& e){
+      check(std::string("Caught unexpected exception ") + e.what(), false);
+    }
+    try{
+      local_date_time blt(date(2004,Apr,4), time_duration(2,30,0), ny_tz, true);
+      check("Did not catch expected exception (Invalid_Time_Label)", false);
+    }catch(time_label_invalid& e){
+      check(std::string("Caught expected exception (Invalid_Time_Label) ") + e.what(), true);
+    }catch(std::exception& e){
+      check(std::string("Caught unexpected exception ") + e.what(), false);
+    }
+    
+    
+    // thorough is_dst() tests, tests againts null_tz and non dst tz are
+    // done where those local times were tested
+    {
+      date dx(2004,Apr,4);
+      time_duration td(1,15,0); // local
+      local_date_time lt1(dx,td,ny_tz,false);
+      local_date_time lt2(ptime(dx,time_duration(6,15,0)), ny_tz);
+      check("are local_times equal", lt1.utc_time() == lt2.utc_time());
+      check("is_dst - transition in 1", lt1.is_dst() == false);
+      check("is_dst - transition in 2", lt2.is_dst() == false);
+      lt1 += hours(1);
+      lt2 += hours(1);
+      check("is_dst - transition in 1", lt1.is_dst() == true);
+      check("is_dst - transition in 2", lt2.is_dst() == true);
+    }
+    {
+      date dx(2004,Oct,31);
+      time_duration td(1,15,0); // local
+      local_date_time lt1(dx,td,ny_tz,true);
+      /*try{
+        //local_date_time lt1(dx,td,ny_tz,false);
+        local_date_time lt1(dx,td,ny_tz,true);
+        std::cout << "no exception thrown" << std::endl;
+      }catch(time_label_invalid& e){
+        std::cout << "caught: " << e.what() << std::endl;
+      }*/
+      local_date_time lt2(ptime(dx,time_duration(5,15,0)), ny_tz);
+      check("are local_times equal", lt1.utc_time() == lt2.utc_time());
+      check("is_dst - transition out 1", lt1.is_dst() == true);
+      check("is_dst - transition out 2", lt2.is_dst() == true);
+      lt1 += hours(1);
+      lt2 += hours(1);
+      check("is_dst - transition out 1", lt1.is_dst() == false);
+      check("is_dst - transition out 2", lt2.is_dst() == false);
+    }
+    { // southern hemisphere 
+      date dx(2004,Oct,31);
+      time_duration td(1,15,0); // local
+      local_date_time lt1(dx,td,sydney,false);
+      check("is_dst - transition in (sydney)", lt1.is_dst() == false);
+      lt1 += hours(1);
+      check("is_dst - transition in (sydney)", lt1.is_dst() == true);
+    }
+    {
+      date dx(2004,Mar,28);
+      time_duration td(2,15,0); // local; sydney has a weird trans time
+      local_date_time lt1(dx,td,sydney,true);
+      check("is_dst - transition out (sydney)", lt1.is_dst() == true);
+      lt1 += hours(1);
+      check("is_dst - transition out (sydney)", lt1.is_dst() == false);
+    }
+
+
+    
+    std::cout << "\nTest conversion of time zone from Arizona to New York" << std::endl;
+    local_date_time ny_time = az_time.local_time_in(ny_tz);
+    check("Zone abbreviation", ny_time.zone()->std_zone_abbrev() == std::string("EST"));
+    check("base offset", ny_time.zone()->base_utc_offset() == hours(-5));
+    check("base offset", ny_time.zone()->has_dst() == true);
+    check("to_string: " + ny_time.to_string(), 
+          ny_time.to_string() == "2003-Dec-20 07:00:00 EST");
+    ny_time += hours(3);
+    check("to_string after add 3 hours: " + ny_time.to_string(), 
+          ny_time.to_string() == "2003-Dec-20 10:00:00 EST");
+    ny_time += days(3);
+    check("to_string after add 3 days: " + ny_time.to_string(), 
+          ny_time.to_string() == "2003-Dec-23 10:00:00 EST");
+    
+  
+    { // test comparisons & math operations
+      date dx(2003, Aug, 28);
+      ptime sv_pt(pos_infin);
+      local_date_time sv_lt(sv_pt, ny_tz);
+      ptime utc_pt(dx, hours(12));
+      // all 4 of the following local times happen at the same instant
+      // so they are all equal
+      local_date_time utc_lt(utc_pt, null_tz);           // noon in utc
+      local_date_time az_lt(dx, hours(5), az_tz, false);  // 5am local std
+      local_date_time ny_lt(dx, hours(8), ny_tz, true);   // 8am local dst
+      local_date_time au_lt(dx, hours(22), sydney, false);// 10pm local std
+
+      check("local_date_time to tm",
+          std::string("4 239 08/28/2003 05:00:00 STD") == tm_out(to_tm(az_lt)));
+      check("local_date_time to tm",
+          std::string("4 239 08/28/2003 08:00:00 DST") == tm_out(to_tm(ny_lt)));
+      check("local_date_time to tm",
+          std::string("4 239 08/28/2003 22:00:00 STD") == tm_out(to_tm(au_lt)));
+
+      try{
+        local_date_time ldt(not_a_date_time);
+        tm ldt_tm = to_tm(ldt);
+        check("Exception not thrown (special_value to_tm)", false);
+        //does nothing useful but stops compiler from complaining about unused ldt_tm
+        std::cout << ldt_tm.tm_sec << std::endl; 
+      }catch(std::out_of_range&){
+        check("Caught expected exception (special_value to_tm)", true);
+      }catch(...){
+        check("Caught un-expected exception (special_value to_tm)", false);
+      }
+      // check that all are equal to sv_pt
+      check("local == utc", az_lt == utc_lt); 
+      check("local == utc", ny_lt == utc_lt); 
+      check("local == utc", au_lt == utc_lt); 
+      check("local <= utc", au_lt <= utc_lt); 
+      check("local >= utc", au_lt >= utc_lt); 
+      check("local == local", az_lt == ny_lt); 
+      check("local < local", az_lt < ny_lt+seconds(1)); 
+      check("local > local", az_lt+seconds(1) >  ny_lt); 
+      check("local <= local", az_lt <= ny_lt); 
+      check("local >= local", az_lt >=  ny_lt); 
+      check("local != local", az_lt+seconds(1) !=  ny_lt); 
+      
+      au_lt += hours(1);
+      check("local != after +=", au_lt != utc_lt); 
+      check("local <= after +=", utc_lt <= au_lt);  
+      check("local >= after +=", au_lt >= utc_lt); 
+      check("local < after +=", utc_lt < au_lt); 
+      check("local > after +=", au_lt > utc_lt);
+      au_lt -= hours(1);
+      check("local == utc after -=", au_lt == utc_lt); 
+
+      check("local + days", 
+          (az_lt + days(2)).to_string() == "2003-Aug-30 05:00:00 MST");
+      check("local - days", 
+          (az_lt - days(2)).to_string() == "2003-Aug-26 05:00:00 MST");
+      check("local += days", 
+          (az_lt += days(2)).to_string() == "2003-Aug-30 05:00:00 MST");
+      check("local -= days", 
+          (az_lt -= days(2)).to_string() == "2003-Aug-28 05:00:00 MST");
+      check("local + time_duration", 
+          (az_lt + hours(2)).to_string() == "2003-Aug-28 07:00:00 MST");
+      check("local - time_duration", 
+          (az_lt - hours(2)).to_string() == "2003-Aug-28 03:00:00 MST");
+      // special_values is more thoroughly tested in posix_time
+      check("pos_infinity > local", sv_lt > au_lt); 
+      local_date_time sv_lt2(sv_lt + days(2));
+      check("pos_infin + duration == pos_infin", sv_lt2 == sv_lt);
+   
+#if defined(BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES)
+      months m(2);
+      years y(2);
+      check("Local + months", 
+          (az_lt + m).to_string() == "2003-Oct-28 05:00:00 MST");
+      az_lt += m;
+      check("Local += months", 
+          az_lt.to_string() == "2003-Oct-28 05:00:00 MST");
+      check("Local - months", 
+          (az_lt - m).to_string() == "2003-Aug-28 05:00:00 MST");
+      az_lt -= m;
+      check("Local -= months", 
+          az_lt.to_string() == "2003-Aug-28 05:00:00 MST");
+      check("Local + years", 
+          (az_lt + y).to_string() == "2005-Aug-28 05:00:00 MST");
+      az_lt += y;
+      check("Local += years", 
+          az_lt.to_string() == "2005-Aug-28 05:00:00 MST");
+      check("Local - years", 
+          (az_lt - y).to_string() == "2003-Aug-28 05:00:00 MST");
+      az_lt -= y;
+      check("Local -= years", 
+          az_lt.to_string() == "2003-Aug-28 05:00:00 MST");
+      
+#endif // BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
+    }
+  }
+  catch(std::exception& e) {
+    check(std::string("test failed due to exception: ") + e.what(), false);
+  }
+
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/local_time/testlocal_time_facet.cpp b/src/boost/libs/date_time/test/local_time/testlocal_time_facet.cpp
new file mode 100644
index 000000000..2046ac156
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testlocal_time_facet.cpp
@@ -0,0 +1,188 @@
+
+/* Copyright (c) 2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include <iostream>
+#include <sstream>
+#include <boost/shared_ptr.hpp>
+#include "boost/date_time/local_time/local_time.hpp"
+#include "../testfrmwk.hpp"
+
+
+template<class temporal_type, typename charT>
+inline
+void
+teststreaming(std::string const& testname,
+              temporal_type value,
+              std::basic_string<charT> const& expected_result,
+              const std::locale& locale)
+{
+  std::basic_stringstream<charT> ss;
+  ss.imbue(locale);
+  ss << value;
+
+  if (!check(testname, ss.str() == expected_result))
+#if !defined(BOOST_NO_STD_WSTRING)
+    std::wcout << L"Expected: \"" << expected_result.c_str() << L"\"\nGot:      \"" << ss.str().c_str() << L"\"" << std::endl;
+#else
+    std::cout << "Expected: \"" << expected_result.c_str() << "\"\nGot:      \"" << ss.str().c_str() << L"\"" << std::endl;
+#endif
+}
+
+int main(int /* argc */, char const* argv[]){
+  /* use the tz_database for the time zones. 
+   * Chicago, Denver, Los_Angeles, New_Tork, and Phoenix 
+   * have all had full names added */
+  using namespace boost;
+  using namespace boost::local_time;
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+
+  tz_database time_zones;
+
+  try {
+    // first try to find the data file from the test dir
+    time_zones.load_from_file(argv[1]);
+  }
+  catch(const data_not_accessible&) {
+    check("Cannot locate data file - aborting.", false);
+    return printTestStats();
+  }
+
+  time_zone_ptr utc;
+  time_zone_ptr chicago = time_zones.time_zone_from_region("America/Chicago");
+  time_zone_ptr denver = time_zones.time_zone_from_region("America/Denver");
+  time_zone_ptr la = time_zones.time_zone_from_region("America/Los_Angeles");
+  time_zone_ptr nyc = time_zones.time_zone_from_region("America/New_York");
+  time_zone_ptr phx = time_zones.time_zone_from_region("America/Phoenix");
+  // sydney does not have full time zone names in the tz_database
+  time_zone_ptr sydney = time_zones.time_zone_from_region("Australia/Sydney");
+
+  ptime a_time(date(2004,Dec,15), hours(12));
+  ptime b_time(date(2004,Aug,15), hours(12));
+  local_date_time ldt1(a_time, utc);
+  local_date_time ldt2(b_time, chicago);
+  local_date_time ldt3(a_time, denver);
+  local_date_time ldt4(b_time, la);
+  local_date_time ldt5(a_time, nyc);
+  local_date_time ldt6(b_time, phx);
+
+  local_time_period ltp1(ldt1, hours(10) + minutes(24) + seconds(5));
+  local_time_period ltp2(ldt4, hours(15) + minutes(20) + seconds(41));
+
+  typedef boost::date_time::time_facet<local_date_time, char> ldt_facet;
+  //ldt_facet* timefacet = new ldt_facet("%c %Z"); // full name
+  ldt_facet* timefacet = new ldt_facet("%a %b %d %H:%M:%S %Y %Z"); // full name
+  std::locale loc1(std::locale::classic(), timefacet);
+  
+  typedef boost::date_time::time_facet<ptime, char> pt_facet;
+  //pt_facet* ptimefacet1 = new pt_facet("%c %Z"); // show that zone is ignored
+  pt_facet* ptimefacet1 = new pt_facet("%a %b %d %H:%M:%S %Y %Z"); // show that zone is ignored
+  std::locale loc2(std::locale::classic(), ptimefacet1);
+
+
+  std::cout << "\nFull time zone names tests" << std::endl;
+  teststreaming("ptime with %Z flag\n", a_time, std::string("Wed Dec 15 12:00:00 2004") , loc2);
+  
+  teststreaming("UTC local_date_time", ldt1, std::string("Wed Dec 15 12:00:00 2004 Coordinated Universal Time"), loc1);
+  teststreaming("Chicago in summer", ldt2, std::string("Sun Aug 15 07:00:00 2004 Central Daylight Time") , loc1);
+  teststreaming("Denver in winter", ldt3, std::string("Wed Dec 15 05:00:00 2004 Mountain Standard Time"), loc1);
+  teststreaming("Los Angeles in summer", ldt4, std::string("Sun Aug 15 05:00:00 2004 Pacific Daylight Time"), loc1);
+  teststreaming("New York in winter", ldt5, std::string("Wed Dec 15 07:00:00 2004 Eastern Standard Time"), loc1);
+  teststreaming("Phoenix in Summer", ldt6, std::string("Sun Aug 15 05:00:00 2004 Mountain Standard Time"), loc1);
+
+  teststreaming("UTC local_time_period", ltp1, std::string("[Wed Dec 15 12:00:00 2004 Coordinated Universal Time/Wed Dec 15 22:24:04 2004 Coordinated Universal Time]"), loc1);
+  teststreaming("LA local_time_period", ltp2, std::string("[Sun Aug 15 05:00:00 2004 Pacific Daylight Time/Sun Aug 15 20:20:40 2004 Pacific Daylight Time]"), loc1);
+
+  //ptimefacet1->format("%c %z"); // show that zone abbrev is ignored
+  ptimefacet1->format("%a %b %d %H:%M:%S %Y %z"); // show that zone abbrev is ignored
+  std::cout << "\nTime zone abbreviation tests" << std::endl;
+  teststreaming("ptime with %z flag\n", a_time, std::string("Wed Dec 15 12:00:00 2004") , loc2);
+
+  // using standard format
+  //timefacet->format("%c %z"); // abbreviated zone
+  timefacet->format("%a %b %d %H:%M:%S %Y %z"); // abbreviated zone
+  teststreaming("UTC local_date_time", ldt1, std::string("Wed Dec 15 12:00:00 2004 UTC"), loc1);
+  teststreaming("Chicago in summer", ldt2, std::string("Sun Aug 15 07:00:00 2004 CDT") , loc1);
+  teststreaming("Denver in winter", ldt3, std::string("Wed Dec 15 05:00:00 2004 MST"), loc1);
+  teststreaming("Los Angeles in summer", ldt4, std::string("Sun Aug 15 05:00:00 2004 PDT"), loc1);
+  teststreaming("New York in winter", ldt5, std::string("Wed Dec 15 07:00:00 2004 EST"), loc1);
+  teststreaming("Phoenix in Summer", ldt6, std::string("Sun Aug 15 05:00:00 2004 MST"), loc1);
+
+  // iso format
+  // show that zone offset is ignored
+  ptimefacet1->format(pt_facet::iso_time_format_specifier); 
+  std::cout << "\nLocal time iso format tests" << std::endl;
+  teststreaming("ptime with iso format\n", a_time, 
+                std::string("20041215T120000") , loc2);
+
+  timefacet->format(ldt_facet::iso_time_format_specifier);
+  teststreaming("UTC local_date_time", ldt1, 
+                std::string("20041215T120000Z"), loc1);
+  teststreaming("Chicago in summer", ldt2, 
+                std::string("20040815T070000-0500") , loc1);
+  teststreaming("Denver in winter", ldt3, 
+                std::string("20041215T050000-0700"), loc1);
+  teststreaming("Los Angeles in summer", ldt4, 
+                std::string("20040815T050000-0700"), loc1);
+  teststreaming("New York in winter", ldt5, 
+                std::string("20041215T070000-0500"), loc1);
+  teststreaming("Phoenix in Summer", ldt6, 
+                std::string("20040815T050000-0700"), loc1);
+  teststreaming("Sydney in December", ldt1.local_time_in(sydney), 
+                std::string("20041215T230000+1100"), loc1);
+  
+  // iso extended format
+  // show that zone offset is ignored
+  ptimefacet1->format(pt_facet::iso_time_format_extended_specifier); 
+  std::cout << "\nLocal time iso_extended tests" << std::endl;
+  teststreaming("ptime with iso extended format\n", a_time, 
+                std::string("2004-12-15 12:00:00") , loc2);
+
+  timefacet->format(ldt_facet::iso_time_format_extended_specifier);
+  teststreaming("UTC local_date_time", ldt1, 
+                std::string("2004-12-15 12:00:00Z"), loc1);
+  teststreaming("Chicago in summer", ldt2, 
+                std::string("2004-08-15 07:00:00-05:00") , loc1);
+  teststreaming("Denver in winter", ldt3, 
+                std::string("2004-12-15 05:00:00-07:00"), loc1);
+  teststreaming("Los Angeles in summer", ldt4, 
+                std::string("2004-08-15 05:00:00-07:00"), loc1);
+  teststreaming("New York in winter", ldt5, 
+                std::string("2004-12-15 07:00:00-05:00"), loc1);
+  teststreaming("Phoenix in Summer", ldt6, 
+                std::string("2004-08-15 05:00:00-07:00"), loc1);
+  teststreaming("Sydney in December", ldt1.local_time_in(sydney), 
+                std::string("2004-12-15 23:00:00+11:00"), loc1);
+
+#if !defined(BOOST_NO_STD_WSTRING)
+
+  typedef boost::date_time::time_facet<local_date_time, wchar_t> wldt_facet;
+  //wldt_facet* wtimefacet = new wldt_facet(L"%c %Z"); // full name
+  wldt_facet* wtimefacet = new wldt_facet(L"%a %b %d %H:%M:%S %Y %Z"); // full name
+  std::locale loc3(std::locale::classic(), wtimefacet);
+  
+  /* Again, wide stream tests are more thoroughly done in the 
+   * time_facet tests. Here we just need to show that they work */
+  std::cout << "\nFull time zone names tests - wide stream" << std::endl;
+  teststreaming("UTC local_date_time", ldt1, std::wstring(L"Wed Dec 15 12:00:00 2004 Coordinated Universal Time"), loc3);
+  teststreaming("Chicago in summer", ldt2, std::wstring(L"Sun Aug 15 07:00:00 2004 Central Daylight Time") , loc3);
+ 
+  teststreaming("UTC local_time_period", ltp1, std::wstring(L"[Wed Dec 15 12:00:00 2004 Coordinated Universal Time/Wed Dec 15 22:24:04 2004 Coordinated Universal Time]"), loc3);
+  teststreaming("LA local_time_period", ltp2, std::wstring(L"[Sun Aug 15 05:00:00 2004 Pacific Daylight Time/Sun Aug 15 20:20:40 2004 Pacific Daylight Time]"), loc3);
+
+  //wtimefacet->format(L"%c %z"); // abbrev
+  wtimefacet->format(L"%a %b %d %H:%M:%S %Y %z"); // abbrev
+  std::cout << "\nAbbreviated time zone names tests - wide stream" << std::endl;
+  teststreaming("UTC local_date_time", ldt1, std::wstring(L"Wed Dec 15 12:00:00 2004 UTC"), loc3);
+  teststreaming("Phoenix in Summer", ldt6, std::wstring(L"Sun Aug 15 05:00:00 2004 MST"), loc3);
+
+#endif // BOOST_NO_STD_WSTRING
+  
+  return printTestStats();
+}
diff --git a/src/boost/libs/date_time/test/local_time/testlocal_time_input_facet.cpp b/src/boost/libs/date_time/test/local_time/testlocal_time_input_facet.cpp
new file mode 100644
index 000000000..7622e5676
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testlocal_time_input_facet.cpp
@@ -0,0 +1,239 @@
+/* Copyright (c) 2005 CrystalClear Software, Inc.
+ * Subject to the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/local_time/local_time.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+#include <sstream>
+#include <string>
+
+// for tests that are expected to fail and throw exceptions
+template<class temporal_type, class exception_type>
+bool failure_test(temporal_type component,
+                  const std::string& input,
+                  exception_type const& /*except*/,
+                  boost::local_time::local_time_input_facet* facet)
+{
+  using namespace boost::local_time;
+  bool result = false;
+  std::istringstream iss(input);
+  iss.exceptions(std::ios_base::failbit); // turn on exceptions
+  iss.imbue(std::locale(std::locale::classic(), facet));
+  try {
+    iss >> component;
+  }
+  catch(exception_type& e) {
+    std::cout << "Expected exception caught: \"" 
+              << e.what() << "\"" << std::endl;
+    result = iss.fail(); // failbit must be set to pass test
+  }
+  catch(...) {
+    result = false;
+  }
+
+  return result;
+}
+
+// for tests that are expected to fail quietly
+template<class temporal_type>
+bool failure_test(temporal_type component,
+                  const std::string& input,
+                  boost::local_time::local_time_input_facet* facet)
+{
+  using namespace boost::local_time;
+  std::istringstream iss(input);
+  /* leave exceptions turned off
+   * iss.exceptions(std::ios_base::failbit); */
+  iss.imbue(std::locale(std::locale::classic(), facet));
+  try {
+    iss >> component;
+  }
+  catch(...) {
+    std::cout << "Caught unexpected exception" << std::endl;
+    return false;
+  }
+
+  return iss.fail(); // failbit must be set to pass test
+}
+
+int main() {
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+  using namespace boost::local_time;
+  time_zone_ptr null_zone;
+  local_date_time ldt1(not_a_date_time, null_zone);
+
+  // verify wide stream works, thorough tests done in narrow stream
+#if !defined(BOOST_NO_STD_WSTRING)
+  {
+    std::wstringstream ws;
+    ws.str(L"2005-Feb-15 12:15:00 EST-05EDT,M4.1.0,M10.5.0");
+    ws >> ldt1;
+    check("Wide stream, Eastern US, daylight savings, winter, minimal input",
+          ldt1.local_time() == ptime(date(2005,2,15), time_duration(12,15,0)));
+    check("Wide stream, Eastern US, daylight savings, winter, minimal input",
+          ldt1.utc_time() == ptime(date(2005,2,15), time_duration(17,15,0)));
+    check("Wide stream, Eastern US, daylight savings, winter, minimal input", !ldt1.is_dst());
+    ws.str(L"");
+    wlocal_time_input_facet* wfacet = new wlocal_time_input_facet(L"%m/%d/%y %ZP");
+    std::locale loc(std::locale::classic(), wfacet);
+    ws.imbue(loc);
+    ws.str(L"10/31/04 PST-08PDT,M4.1.0,M10.5.0"); // midnight on end transition day, still in dst
+    ws >> ldt1;
+    std::wcout << ldt1.local_time() << std::endl;
+    check("Wide stream, Eastern US, daylight savings, winter, custom format",
+          ldt1.local_time() == ptime(date(2004,10,31), time_duration(0,0,0)));
+    check("Wide stream, Eastern US, daylight savings, winter, custom format",
+          ldt1.utc_time() == ptime(date(2004,10,31), time_duration(7,0,0)));
+    check("Wide stream, Eastern US, daylight savings, winter, custom format", ldt1.is_dst());
+  }
+#endif // BOOST_NO_STD_WSTRING
+
+  std::stringstream ss;
+  ss.str("2005-Feb-25 12:15:00 EST-05EDT,M4.1.0,M10.5.0");
+  ss >> ldt1;
+  check("Eastern US, daylight savings, winter, minimal input",
+        ldt1.local_time() == ptime(date(2005,2,25), time_duration(12,15,0)));
+  check("Eastern US, daylight savings, winter, minimal input",
+        ldt1.utc_time() == ptime(date(2005,2,25), time_duration(17,15,0)));
+  check("Eastern US, daylight savings, winter, minimal input", !ldt1.is_dst());
+  ss.str("");
+  
+  ss.str("2005-Aug-25 12:15:00 EST-05EDT,M4.1.0,M10.5.0");
+  ss >> ldt1;
+  check("Eastern US, daylight savings, summer, minimal input",
+        ldt1.local_time() == ptime(date(2005,8,25), time_duration(12,15,0)));
+  check("Eastern US, daylight savings, summer, minimal input",
+        ldt1.utc_time() == ptime(date(2005,8,25), time_duration(16,15,0)));
+  check("Eastern US, daylight savings, summer, minimal input", ldt1.is_dst());
+  ss.str("");
+  
+  ss.str("2005-Apr-03 01:15:00 EST-05EDT,M4.1.0,M10.5.0");
+  ss >> ldt1;
+  check("Eastern US, daylight savings, transition point", !ldt1.is_dst());
+  ldt1 += hours(1);
+  check("Eastern US, daylight savings, transition point", ldt1.is_dst());
+  ss.str("");
+  ss.str("2005-Apr-03 01:15:00 EST-05EDT,93,303");
+  ss >> ldt1;
+  check("Eastern US, daylight savings, transition point", !ldt1.is_dst());
+  ldt1 += hours(1);
+  check("Eastern US, daylight savings, transition point", ldt1.is_dst());
+  ss.str("");
+  
+  ss.str("2005-Oct-30 00:15:00 EST-05EDT,M4.1.0,M10.5.0");
+  ss >> ldt1;
+  check("Eastern US, daylight savings, transition point", ldt1.is_dst());
+  ldt1 += hours(1);
+  check("Eastern US, daylight savings, transition point", ldt1.is_dst());
+  ldt1 += hours(1);
+  check("Eastern US, daylight savings, transition point", !ldt1.is_dst());
+  ss.str("");
+  ss.str("2005-Oct-30 00:15:00 EST-05EDT,93,303");
+  ss >> ldt1;
+  check("Eastern US, daylight savings, transition point", ldt1.is_dst());
+  ldt1 += hours(1);
+  check("Eastern US, daylight savings, transition point", ldt1.is_dst());
+  ldt1 += hours(1);
+  check("Eastern US, daylight savings, transition point", !ldt1.is_dst());
+  ss.str("");
+  
+  ss.str("2005-Aug-25 12:15:00 MST-07");
+  ss >> ldt1;
+  check("Mountain US, no daylight savings",
+        ldt1.local_time() == ptime(date(2005,8,25), time_duration(12,15,0)));
+  check("Mountain US, no daylight savings",
+        ldt1.utc_time() == ptime(date(2005,8,25), time_duration(19,15,0)));
+  check("Mountain US, no daylight savings", !ldt1.is_dst());
+  ss.str("");
+
+  // insure input & output formats match
+  local_time_facet* out_facet = 
+    new local_time_facet(local_time_input_facet::default_time_input_format);
+  std::locale loc(std::locale::classic(), out_facet);
+  ss.imbue(loc);
+  time_zone_ptr syd_tz(new posix_time_zone("EST+10EST,M10.5.0,M3.5.0/03:00"));
+  ptime pt(date(2005,6,12), hours(0));
+  local_date_time ldt2(pt, syd_tz);
+  ss << ldt2;
+  ss >> ldt1;
+  check("Output as input makes match", ldt1 == ldt2);
+  check("Output as input makes match", 
+      ldt1.zone()->dst_local_start_time(2004) == ldt2.zone()->dst_local_start_time(2004));
+  ss.str("");
+  
+  time_zone_ptr f_tz(new posix_time_zone("FST+03FDT,90,300"));
+  ldt2 = local_date_time(ptime(date(2005,6,12), hours(0)), f_tz);
+  ss << ldt2;
+  ss >> ldt1;
+  check("Output as input makes match", ldt1 == ldt2);
+  check("Output as input makes match", 
+      ldt1.zone()->dst_local_start_time(2004) == ldt2.zone()->dst_local_start_time(2004));
+  ss.str("");
+
+  // missing input & wrong format tests
+  ss.str("2005-Oct-30 00:15:00");
+  ss >> ldt1;
+  check("Missing time_zone spec makes UTC", ldt1.zone_as_posix_string() == std::string("UTC+00"));
+  check("Missing time_zone spec makes UTC", ldt1.utc_time() == ldt1.local_time());
+  ss.str("");
+  {
+    std::istringstream iss("2005-Aug-25 12:15:00 MST-07");
+    local_time_input_facet* f = new local_time_input_facet("%Y-%b-%d %H:%M:%S %z");
+    std::locale locx(std::locale::classic(), f);
+    iss.imbue(locx);
+    iss >> ldt1;
+    check("Wrong format flag makes UTC", ldt1.zone_as_posix_string() == std::string("UTC+00"));
+    check("Wrong format flag makes UTC", ldt1.utc_time() == ldt1.local_time());
+  }
+  
+ 
+  // failure tests: (posix_time_zone) bad_offset, bad_adjustment, 
+  // (local_date_time) ambiguous_result, time_label_invalid, 
+  // time/date failures already tested
+  ambiguous_result amb_ex("default");
+  time_label_invalid inv_ex("default");
+  check("Failure test ambiguous time label (w/exceptions)", 
+        failure_test(ldt1,
+                     "2005-Oct-30 01:15:00 EST-05EDT,M4.1.0,M10.5.0",
+                     amb_ex, 
+                     new local_time_input_facet()));
+  check("Failure test ambiguous time label (no exceptions)", 
+        failure_test(ldt1,
+                     "2005-Oct-30 01:15:00 EST-05EDT,M4.1.0,M10.5.0",
+                     new local_time_input_facet()));
+  check("Failure test ambiguous time label (w/exceptions)", 
+        failure_test(ldt1,
+                     "2005-Oct-30 01:15:00 EST-05EDT,93,303",
+                     amb_ex, 
+                     new local_time_input_facet()));
+  check("Failure test ambiguous time label (no exceptions)", 
+        failure_test(ldt1,
+                     "2005-Oct-30 01:15:00 EST-05EDT,93,303",
+                     new local_time_input_facet()));
+  check("Failure test invalid time label (w/exceptions)", 
+        failure_test(ldt1,
+                     "2005-Apr-03 02:15:00 EST-05EDT,M4.1.0,M10.5.0",
+                     inv_ex, 
+                     new local_time_input_facet()));
+  check("Failure test invalid time label (no exceptions)", 
+        failure_test(ldt1,
+                     "2005-Apr-03 02:15:00 EST-05EDT,M4.1.0,M10.5.0",
+                     new local_time_input_facet()));
+  check("Failure test invalid time label (w/exceptions)", 
+        failure_test(ldt1,
+                     "2005-Apr-03 02:15:00 EST-05EDT,93,303",
+                     inv_ex, 
+                     new local_time_input_facet()));
+  check("Failure test invalid time label (no exceptions)", 
+        failure_test(ldt1,
+                     "2005-Apr-03 02:15:00 EST-05EDT,93,303",
+                     new local_time_input_facet()));
+
+
+  return printTestStats();
+}
diff --git a/src/boost/libs/date_time/test/local_time/testlocal_time_iterator.cpp b/src/boost/libs/date_time/test/local_time/testlocal_time_iterator.cpp
new file mode 100644
index 000000000..670b572f4
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testlocal_time_iterator.cpp
@@ -0,0 +1,95 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include <iostream>
+#include "boost/date_time/local_time/local_time.hpp"
+#include "../testfrmwk.hpp"
+// #if defined(BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS)
+// #include "boost/date_time/gregorian/formatters_limited.hpp"
+// #else
+// #include "boost/date_time/gregorian/formatters.hpp"
+// #endif
+
+using namespace boost::posix_time;
+using namespace boost::gregorian;
+using namespace boost::local_time;
+
+void iterate_backward(const local_date_time *answers, 
+                      int ary_len, 
+                      const time_duration& td)
+{
+  int i = ary_len -1;
+  local_date_time end = answers[i];
+  local_time_iterator titr(end,td);
+  
+  std::cout << "counting down by previous duration..." << std::endl;
+  for (; titr >= answers[0]; --titr) {
+    std::cout << *titr << std::endl;
+    check("iterating backward", answers[i] == *titr);
+    --i;
+  }
+  check("iterating backward count", i == -1); // check the number of iterations
+  std::cout << std::endl;
+}
+
+int
+main() 
+{
+
+  time_zone_ptr ny_tz(new posix_time_zone("EST-05EDT,M4.1.0,M10.5.0"));
+
+  //set up a time right on the dst boundary -- iterator will 
+  //jump forward an hour at the boundary
+  date d(2005,Apr,3);
+  time_duration dst_offset(1,59,59);
+  local_date_time start(d, dst_offset, ny_tz, false);
+
+  const local_date_time answer1[] = 
+    { 
+      local_date_time(d,dst_offset, ny_tz, false), 
+      local_date_time(d,hours(3), ny_tz, true),
+      local_date_time(d,hours(3)+seconds(1), ny_tz, true), 
+      local_date_time(d,hours(3)+seconds(2), ny_tz, true)
+    };
+
+  int i=0;
+  local_time_iterator titr(start,seconds(1)); 
+  local_date_time end = start + seconds(4);
+  for (; titr < end; ++titr) {
+    std::cout << (*titr) << std::endl;
+    check("iterator -- 1 sec", answer1[i] == *titr);
+    i++;
+  }
+  check("iterator -- 1 sec -- num iterations", i == 4); // check the number of iterations
+
+  iterate_backward(answer1, 4, seconds(1));
+
+  //iterate by hours
+  const local_date_time answer2[] = 
+    { local_date_time(d,dst_offset, ny_tz, false), 
+      local_date_time(d,dst_offset+hours(2), ny_tz, true),
+      local_date_time(d,dst_offset+hours(3), ny_tz, true), 
+      local_date_time(d,dst_offset+hours(4), ny_tz, true)
+    };
+   i=0;
+   local_time_iterator titr2(start,hours(1)); 
+   local_date_time end2 = start + hours(4);
+   for (; titr2 < end2; ++titr2) {
+     std::cout << *titr2 << std::endl;
+     check("iterator -- 1 hour", answer2[i] == *titr2);
+     i++;
+   }
+   check("iterator -- 1 hour -- num iterations", i == 4); 
+
+   iterate_backward(answer2, 4, hours(1));
+
+
+ 
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/local_time/testlocal_time_period.cpp b/src/boost/libs/date_time/test/local_time/testlocal_time_period.cpp
new file mode 100644
index 000000000..64c8f7564
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testlocal_time_period.cpp
@@ -0,0 +1,82 @@
+/* Copyright (c) 2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/local_time/local_time.hpp"
+#include "../testfrmwk.hpp"
+
+int main() 
+{
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+  using namespace boost::local_time;
+  date d1(2001,Jan, 1);
+  
+  time_zone_ptr az_tz(new posix_time_zone("MST-07"));
+
+  local_date_time t1 (d1,hours(2), az_tz, false);//2001-Jan-1 02:00:00
+
+  local_date_time t2 (d1,hours(3), az_tz, false);//2001-Jan-1 03:00:00
+  local_time_period p1(t1,t2); //2001-Jan-1 02:59:59
+  local_time_period p2(p1);
+  check("copy construct & ==", p1 == p2);
+  local_time_period p3 = p2;
+  check("assignment", p3 == p2);
+  local_time_period p4(t1,hours(1));
+
+  check("length", p4.length() == hours(1));
+
+//   std::cout << to_simple_string(t1) << std::endl;
+//   std::cout << to_simple_string(p4) << std::endl;
+//   std::cout << to_simple_string(p1) << std::endl;
+  check("construction and ==", p1 == p4);
+  check("begin", p1.begin() == t1);
+  check("last",  p1.end()   == t2);
+  check("end",   p1.last()  == t2-time_duration::unit());
+  
+//   std::cout << to_simple_string(p1) << std::endl;
+//   //  check("last",  p1.()  == t2);
+  check("contains begin", p1.contains(t1));
+  check("contains end-not", !p1.contains(t2));
+  check("contains last",  p1.contains(t2-seconds(1)));
+  local_date_time t3(date(2001,Jan,1),hours(4), az_tz, false);
+  local_time_period p5(t2,t3);
+  check("check contains", !p1.contains(p5.begin()));
+  check("check contains", !p5.contains(p1.begin()));
+  check("operator== not equal case", !(p1 == p5));
+  check("less than order", p1 < p5);
+  check("greater than order", p5 > p1);
+  check("not equal", p5 != p1);
+  check("intersects with myself", p1.intersects(p1));
+  check("not intersects", !(p1.intersects(p5)));
+  check("not intersects", !(p5.intersects(p1)));
+
+  local_time_period p6(p5);
+  p6.shift(minutes(30));
+//   std::cout << to_simple_string(p5) << std::endl;
+//   std::cout << to_simple_string(p6) << std::endl;
+  check("shifted intersects",    p5.intersects(p6));
+  check("shifted intersects",    p6.intersects(p5));
+  check("contains begin",        p5.contains(p6.begin()));
+  p6.shift(minutes(30));
+//   std::cout << to_simple_string(p5) << std::endl;
+//   std::cout << to_simple_string(p6) << std::endl;
+  check("shifted !intersects",    !p5.intersects(p6));
+  check("shifted !intersects",    !p6.intersects(p5));
+  p6.shift(minutes(-30));
+//   std::cout << to_simple_string(p5) << std::endl;
+//   std::cout << to_simple_string(p6) << std::endl;
+  local_time_period p7 = p5.intersection(p6);
+//   std::cout << to_simple_string(p7) << std::endl;
+  check("shifted intersection",    
+        p7 == local_time_period(local_date_time(d1,time_duration(3,30,0), az_tz, false),
+                                local_date_time(d1,time_duration(4,0,0), az_tz, false)));
+  
+  
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/local_time/testposix_time_zone.cpp b/src/boost/libs/date_time/test/local_time/testposix_time_zone.cpp
new file mode 100644
index 000000000..7bf971e87
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testposix_time_zone.cpp
@@ -0,0 +1,221 @@
+/* Copyright (c) 2003-2004 CrystalClear Software, Inc.
+ * Subject to the Boost Software License, Version 1.0. 
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+//#include "boost/date_time/local_time/time_zone.hpp"
+#include "../testfrmwk.hpp"
+
+#include "boost/date_time/local_time/posix_time_zone.hpp"
+
+#include <string>
+#include <iostream>
+
+int main(){
+  using namespace boost::local_time;
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+  std::string specs[] = {"MST-07", "MST-07:00:00","EST-05EDT,M4.1.0,M10.5.0", "EST-05:00:00EDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00","PST-08PDT,J46/1:30,J310","PST-08PDT,45,310/0:30:00"};
+
+  posix_time_zone nyc1(specs[2]);
+  posix_time_zone nyc2(specs[3]);
+  time_duration td = hours(-5);
+
+  check("Has DST", nyc1.has_dst() && nyc2.has_dst());
+  check("UTC offset", nyc1.base_utc_offset() == td);
+  check("UTC offsets match", nyc1.base_utc_offset() == nyc2.base_utc_offset());
+  check("Abbrevs", nyc1.std_zone_abbrev() == std::string("EST"));
+  check("Abbrevs", nyc2.std_zone_abbrev() == std::string("EST"));
+  check("Abbrevs", nyc1.dst_zone_abbrev() == std::string("EDT"));
+  check("Abbrevs", nyc2.dst_zone_abbrev() == std::string("EDT"));
+  // names not available for posix_time_zone, abbrevs used in their place
+  check("Names", nyc1.std_zone_name() == std::string("EST"));
+  check("Names", nyc2.std_zone_name() == std::string("EST"));
+  check("Names", nyc1.dst_zone_name() == std::string("EDT"));
+  check("Names", nyc2.dst_zone_name() == std::string("EDT"));
+  td = hours(1);
+  check("dst offset", nyc1.dst_offset() == td);
+  check("dst offsets match", nyc1.dst_offset() == nyc2.dst_offset());
+  check("dst start", nyc1.dst_local_start_time(2003) == 
+      ptime(date(2003,Apr,6),time_duration(2,0,0)));
+  check("dst starts match", nyc1.dst_local_start_time(2003) == 
+      nyc2.dst_local_start_time(2003)); 
+  check("dst end", nyc1.dst_local_end_time(2003) == 
+      ptime(date(2003,Oct,26),time_duration(2,0,0)));
+  check("dst ends match", nyc1.dst_local_end_time(2003) == 
+      nyc2.dst_local_end_time(2003)); 
+  check("to posix string", 
+        nyc1.to_posix_string() == std::string("EST-05EDT+01,M4.1.0/02:00,M10.5.0/02:00"));
+  check("to posix string", 
+        nyc2.to_posix_string() == std::string("EST-05EDT+01,M4.1.0/02:00,M10.5.0/02:00"));
+  
+
+  posix_time_zone az1(specs[0]);
+  posix_time_zone az2(specs[1]);
+  td = hours(-7);
+
+  check("Has DST", !az1.has_dst() && !az2.has_dst());
+  check("UTC offset", az1.base_utc_offset() == td);
+  check("UTC offsets match", az1.base_utc_offset() == az2.base_utc_offset());
+  check("dst start in non-dst zone", 
+        az1.dst_local_start_time(2005) == ptime(not_a_date_time));
+  check("dst end in non-dst zone", 
+        az2.dst_local_end_time(2005) == ptime(not_a_date_time));
+  check("Abbrevs", az1.std_zone_abbrev() == std::string("MST"));
+  check("Abbrevs", az2.std_zone_abbrev() == std::string("MST"));
+  // non-dst zones default to empty strings for dst names & abbrevs
+  check("Abbrevs", az1.dst_zone_abbrev() == std::string(""));
+  check("Abbrevs", az2.dst_zone_abbrev() == std::string(""));
+  check("Names", az1.std_zone_name() == std::string("MST"));
+  check("Names", az2.std_zone_name() == std::string("MST"));
+  check("Names", az1.dst_zone_name() == std::string(""));
+  check("Names", az2.dst_zone_name() == std::string(""));
+  check("to posix string", 
+        az1.to_posix_string() == std::string("MST-07"));
+  check("to posix string", 
+        az2.to_posix_string() == std::string("MST-07"));
+ 
+
+  // bizzar time zone spec to fully test parsing
+  std::cout << "\nFictitious time zone" << std::endl;
+  posix_time_zone bz("BST+11:21:15BDT-00:28,M2.2.4/03:15:42,M11.5.2/01:08:53");
+  check("hast dst", bz.has_dst());
+  check("UTC offset", bz.base_utc_offset() == time_duration(11,21,15));
+  check("Abbrev", bz.std_zone_abbrev() == std::string("BST"));
+  check("Abbrev", bz.dst_zone_abbrev() == std::string("BDT"));
+  check("dst offset", bz.dst_offset() == time_duration(0,-28,0));
+  check("dst start", bz.dst_local_start_time(1962) ==
+      ptime(date(1962,Feb,8),time_duration(3,15,42)));
+  check("dst end", bz.dst_local_end_time(1962) ==
+      ptime(date(1962,Nov,27),time_duration(1,8,53)));
+  
+  // only checking start & end rules w/ 'J' notation
+  std::cout << "\n'J' notation Start/End rule tests..." << std::endl;
+  posix_time_zone la1(specs[4]); // "PST-08PDT,J124,J310"
+  //posix_time_zone la1("PST-08PDT,J1,J365");// Jan1/Dec31 
+  check("dst start", la1.dst_local_start_time(2003) == 
+      ptime(date(2003,Feb,15),time_duration(1,30,0)));
+  check("dst end", la1.dst_local_end_time(2003) == 
+      ptime(date(2003,Nov,6),time_duration(2,0,0)));
+  /* NOTE: la1 was created from a 'J' notation string but to_posix_string
+   * returns an 'n' notation string. The difference between the two 
+   * is Feb-29 is always counted in an 'n' notation string and numbering 
+   * starts at zero ('J' notation starts at one). 
+   * Every possible date spec that can be written in 'J' notation can also
+   * be written in 'n' notation. The reverse is not true so 'n' notation 
+   * is used as the output for to_posix_string(). */
+  check("to posix string", 
+        la1.to_posix_string() == std::string("PST-08PDT+01,45/01:30,310/02:00"));
+  
+  // only checking start & end rules w/ 'n' notation
+  std::cout << "\n'n' notation Start/End rule tests..." << std::endl;
+  posix_time_zone la2(specs[5]); // "PST-08PDT,124,310"
+  //posix_time_zone la2("PST-08PDT,0,365");// Jan1/Dec31 
+  check("dst start", la2.dst_local_start_time(2003) == 
+      ptime(date(2003,Feb,15),time_duration(2,0,0)));
+  check("dst end", la2.dst_local_end_time(2003) == 
+      ptime(date(2003,Nov,6),time_duration(0,30,0)));
+  check("to posix string", 
+        la2.to_posix_string() == std::string("PST-08PDT+01,45/02:00,310/00:30"));
+
+  // bad posix time zone strings tests
+  std::cout << "\nInvalid time zone string tests..." << std::endl;
+  try {
+    posix_time_zone badz("EST-13");
+    check("Exception not thrown: bad UTC offset", false);
+  }catch(bad_offset& boff){
+    std::string msg(boff.what());
+    check("Exception caught: "+msg , true);
+  }
+  try {
+    posix_time_zone badz("EST-5EDT24:00:01,J124/1:30,J310");
+    check("Exception not thrown: bad DST adjust", false);
+  }catch(bad_adjustment& badj){
+    std::string msg(badj.what());
+    check("Exception caught: "+msg , true);
+  }
+  try {
+    posix_time_zone badz("EST-5EDT01:00:00,J124/-1:30,J310");
+    check("Exception not thrown: bad DST start/end offset", false);
+  }catch(bad_offset& boff){
+    std::string msg(boff.what());
+    check("Exception caught: "+msg , true);
+  }
+  try {
+    posix_time_zone badz("EST-5EDT01:00:00,J124/1:30,J370");
+    check("Exception not thrown: invalid date spec", false);
+  }catch(boost::gregorian::bad_day_of_month& boff){
+    std::string msg(boff.what());
+    check("Exception caught: "+msg , true);
+  }catch(boost::gregorian::bad_month& boff){
+    std::string msg(boff.what());
+    check("Exception caught: "+msg , true);
+  }catch(...){
+    check("Unexpected exception caught: ", false);
+  }
+
+  std::cout << "\nTest some Central Europe specs" << std::endl;
+
+  //Test a timezone spec on the positive side of the UTC line.
+  //This is the time for central europe which is one hour in front of UTC
+  //Note these Summer time transition rules aren't actually correct.
+  posix_time_zone cet_tz("CET+01:00:00EDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00");
+  check("Has DST", cet_tz.has_dst());
+  check("UTC offset", cet_tz.base_utc_offset() == hours(1));
+  check("Abbrevs", cet_tz.std_zone_abbrev() == std::string("CET"));
+//   check("Abbrevs", nyc2.std_zone_abbrev() == std::string("EST"));
+
+  std::cout << "\nTest some Central Austrialia UTC+8:30" << std::endl;
+
+  //Test a timezone spec on the positive side of the UTC line.
+  //This is the time for central europe which is one hour in front of UTC
+  //Note these Summer time transition rules aren't actually correct.
+  posix_time_zone caus_tz("CAS+08:30:00CDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00");
+  check("Has DST", caus_tz.has_dst());
+  check("UTC offset", caus_tz.base_utc_offset() == hours(8)+minutes(30));
+  check("Abbrevs", caus_tz.std_zone_abbrev() == std::string("CAS"));
+//   check("Abbrevs", nyc2.std_zone_abbrev() == std::string("EST"));
+
+  {
+    /**** first/last of month Julian & non-Julian tests ****/
+    // Mar-01 & Oct-31, count begins at 1
+    std::string spec("FST+3FDT,J60,J304"); 
+    posix_time_zone fl_1(spec);
+    check("Julian First/last of month", fl_1.dst_local_start_time(2003) == 
+        ptime(date(2003,Mar,1),hours(2)));
+    check("Julian First/last of month", fl_1.dst_local_end_time(2003) == 
+        ptime(date(2003,Oct,31),hours(2)));
+    check("Julian First/last of month", fl_1.dst_local_start_time(2004) == 
+        ptime(date(2004,Mar,1),hours(2)));
+    check("Julian First/last of month", fl_1.dst_local_end_time(2004) == 
+        ptime(date(2004,Oct,31),hours(2)));
+    
+    // Mar-01 & Oct-31 Non-leap year, count begins at 0
+    spec = "FST+3FDT,59,304"; // "304" is not a mistake here, see posix_time_zone docs
+    posix_time_zone fl_2(spec);
+    try{
+      check("Non-Julian First/last of month", fl_2.dst_local_start_time(2003) ==
+          ptime(date(2003,Mar,1),hours(2)));
+    }catch(std::exception&){
+      check("Expected exception caught for Non-Julian day of 59, in non-leap year (Feb-29)", true);
+    }
+    check("Non-Julian First/last of month", fl_2.dst_local_end_time(2003) == 
+        ptime(date(2003,Oct,31),hours(2)));
+    
+    // Mar-01 & Oct-31 leap year, count begins at 0
+    spec = "FST+3FDT,60,304"; 
+    posix_time_zone fl_3(spec);
+    check("Non-Julian First/last of month", fl_3.dst_local_start_time(2004) ==
+        ptime(date(2004,Mar,1),hours(2)));
+    check("Non-Julian First/last of month", fl_3.dst_local_end_time(2004) ==
+        ptime(date(2004,Oct,31),hours(2)));
+  }
+
+  printTestStats();
+  return 0;
+}
+
diff --git a/src/boost/libs/date_time/test/local_time/testtz_database.cpp b/src/boost/libs/date_time/test/local_time/testtz_database.cpp
new file mode 100644
index 000000000..add2943b3
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testtz_database.cpp
@@ -0,0 +1,116 @@
+/* Copyright (c) 2003-2005 CrystalClear Software, Inc.
+ * Subject to the Boost Software License, Version 1.0. 
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+
+#include "../testfrmwk.hpp"
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/date_time/local_time/custom_time_zone.hpp"
+#include "boost/date_time/local_time/local_time_types.hpp"
+#include "boost/date_time/local_time/tz_database.hpp"
+#include "boost/date_time/local_time/posix_time_zone.hpp"
+#include <iostream>
+
+bool run_bad_field_count_test(char const* fn);
+
+int main(int /* argc */, char const* argv[]){
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+  using namespace boost::local_time;
+
+  /* NOTE: The testlocal_time_facet tests required full names 
+   * be added to some of the date_time_zonespec.csv entries. The 
+   * tests here also use those full names. Those entries are:
+   * Chicago, Denver, Los_Angeles, New_York, and Phoenix
+   * have all had full names added */
+ 
+  // run the exception tests first
+  try{
+    tz_database tz_db;
+    tz_db.load_from_file("missing_file.csv"); // file does not exist
+  }catch(data_not_accessible&){
+    check("Caught Missing data file exception", true);
+  }catch(...){
+    check("Caught first unexpected exception", false);
+  }
+  check("Caught Bad field count exception", run_bad_field_count_test(argv[2]));
+
+  tz_database tz_db;
+  try {
+    tz_db.load_from_file(argv[1]);
+  }catch(...) {
+    check("Cannot locate data file - aborting.", false);
+    return printTestStats();
+  }
+    
+  time_zone_ptr bad_tz = tz_db.time_zone_from_region("Invalid/name");
+  check("Expected null pointer return", bad_tz == time_zone_ptr()); 
+
+  time_zone_ptr nyc_test = tz_db.time_zone_from_region("America/New_York");
+  check("nyc Valid pointer", nyc_test != time_zone_ptr() ); 
+  check("nyc Abbreviations",nyc_test->std_zone_abbrev() == std::string("EST")); 
+  check("nyc Full Name", nyc_test->std_zone_name() == std::string("Eastern Standard Time")); 
+  check("nyc Abbreviations",nyc_test->dst_zone_abbrev() == std::string("EDT")); 
+  //std::cout << nyc_test->std_zone_name() << std::endl;
+  check("nyc Full Name", nyc_test->dst_zone_name() == std::string("Eastern Daylight Time")); 
+  check("nyc GMT Offset", nyc_test->base_utc_offset() == hours(-5));
+  check("nyc DST Offset", nyc_test->dst_offset() == hours(1));
+  //std::cout << nyc_test->dst_local_start_time(2004) << std::endl;
+  check("nyc dst start",  nyc_test->dst_local_start_time(2007) == ptime(date(2007, Mar, 11), hours(2)));
+  check("nyc dst end", nyc_test->dst_local_end_time(2007) == ptime(date(2007, Nov, 4), hours(2)));
+  check("nyc has dst", nyc_test->has_dst());
+  
+  time_zone_ptr phx_test = tz_db.time_zone_from_region("America/Phoenix");
+  check("az Valid pointer", phx_test != time_zone_ptr() ); 
+  check("az Abbreviations",phx_test->std_zone_abbrev() == std::string("MST"));  
+  check("az Full Name", phx_test->std_zone_name() == std::string("Mountain Standard Time"));  
+  check("az Abbreviations", phx_test->dst_zone_abbrev() == std::string(""));  
+  check("az Full Name", phx_test->dst_zone_name() == std::string(""));  
+  check("az GMT Offset", phx_test->base_utc_offset() == hours(-7));
+  check("az DST Offset", phx_test->dst_offset() == hours(0));
+  //std::cout << phx_test->dst_local_start_time(2004) << std::endl;
+  check("az has dst", phx_test->has_dst() == false);
+
+  //Now add and retrieve a Posix tz spec from the database
+  time_zone_ptr eastern(new posix_time_zone("EST-05:00:00EDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00"));
+  tz_db.add_record("United States/Eastern", eastern);
+  time_zone_ptr eastern_test = tz_db.time_zone_from_region("United States/Eastern");
+  check("eastern Valid pointer", eastern_test != time_zone_ptr() );
+  check("eastern Abbreviations", 
+      eastern_test->std_zone_abbrev() == std::string("EST"));  
+  check("eastern Abbreviations", 
+      eastern_test->std_zone_name() == std::string("EST"));  
+  check("eastern Abbreviations", 
+      eastern_test->dst_zone_abbrev() == std::string("EDT"));  
+  check("eastern Abbreviations", 
+      eastern_test->dst_zone_name() == std::string("EDT"));  
+  check("eastern GMT Offset", eastern_test->base_utc_offset() == hours(-5));
+  check("eastern dst start",  eastern_test->dst_local_start_time(2004) == ptime(date(2004, Apr, 4), hours(2)));
+  check("eastern dst end", eastern_test->dst_local_end_time(2004) == ptime(date(2004, Oct, 31), hours(2)));
+  check("eastern  has dst", eastern_test->has_dst() == true);
+
+
+  return printTestStats();
+}
+
+/* This test only checks to make sure the bad_field_count exception
+ * is properly thrown. It does not pay any attention to any other 
+ * exception, those are tested elsewhere. */
+bool run_bad_field_count_test(char const* fn)
+{
+  using namespace boost::local_time;
+  bool caught_bfc = false;
+  tz_database other_db;
+  try{
+    other_db.load_from_file(fn);
+  }catch(bad_field_count&){
+    caught_bfc = true;
+  }catch(...) {
+    // do nothing (file not found)
+  }
+  return caught_bfc;
+}
diff --git a/src/boost/libs/date_time/test/local_time/testwcustom_time_zone.cpp b/src/boost/libs/date_time/test/local_time/testwcustom_time_zone.cpp
new file mode 100644
index 000000000..ad25ac31d
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testwcustom_time_zone.cpp
@@ -0,0 +1,89 @@
+/* Copyright (c) 2003-2005 CrystalClear Software, Inc.
+ * Subject to the Boost Software License, Version 1.0. 
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/local_time/local_time.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+
+int
+main()
+{
+
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+  using namespace boost::local_time;
+
+  typedef custom_time_zone_base<wchar_t> wcustom_time_zone;
+
+  boost::shared_ptr<dst_calc_rule> 
+    rule1(new partial_date_dst_rule(partial_date(30,Apr),
+                                    partial_date(30,Oct)));
+  
+  boost::shared_ptr<dst_calc_rule> 
+    rule2(new first_last_dst_rule(first_last_dst_rule::start_rule(Sunday,Apr),
+                                  first_last_dst_rule::end_rule(Sunday,Oct)));
+  boost::shared_ptr<dst_calc_rule> 
+    rule3(new last_last_dst_rule(last_last_dst_rule::start_rule(Sunday,Mar),
+                                 last_last_dst_rule::end_rule(Sunday,Oct)));
+  boost::shared_ptr<dst_calc_rule> rule4; // no daylight savings
+  
+  wtime_zone_names pst(L"Pacific Standard Time",
+                      L"PST", 
+                      L"Pacific Daylight Time" ,
+                      L"PDT");
+  wtime_zone_names mst(L"Mountain Standard Time",
+                      L"MST", 
+                      L"" ,
+                      L"");
+  
+  dst_adjustment_offsets of(hours(1), hours(2), hours(2));
+  dst_adjustment_offsets of2(hours(0), hours(0), hours(0)); // no daylight savings
+
+  wtime_zone_ptr tz1(new wcustom_time_zone(pst, hours(-8), of, rule1));
+  wtime_zone_ptr tz2(new wcustom_time_zone(pst, hours(-8), of, rule2));
+  wtime_zone_ptr tz3(new wcustom_time_zone(pst, hours(-8), of, rule3));
+  wtime_zone_ptr tz4(new wcustom_time_zone(mst, hours(-7), of2, rule4));
+
+  check("out string", 
+        tz1->dst_zone_abbrev() == std::wstring(L"PDT"));
+  check("out string", 
+        tz1->std_zone_abbrev() == std::wstring(L"PST"));
+  check("out string", 
+        tz1->std_zone_name() == std::wstring(L"Pacific Standard Time"));
+  check("out string", 
+        tz1->dst_zone_name() == std::wstring(L"Pacific Daylight Time"));
+
+  check("dst offset", tz1->dst_offset() == hours(1));
+  check("base offset", tz1->base_utc_offset() == hours(-8));
+  check("has dst", tz1->has_dst());
+
+  check("dst start time", 
+        tz1->dst_local_start_time(2003) == ptime(date(2003,Apr,30),hours(2)));
+  check("dst end time", 
+        tz1->dst_local_end_time(2003) == ptime(date(2003,Oct,30),hours(2)));
+
+  check("tz1 to posix string", 
+       tz1->to_posix_string() == std::wstring(L"PST-08PDT+01,120/02:00,303/02:00"));
+  check("tz2 to posix string", 
+       tz2->to_posix_string() == std::wstring(L"PST-08PDT+01,M4.1.0/02:00,M10.5.0/02:00"));
+  check("tz3 to posix string", 
+        tz3->to_posix_string() == std::wstring(L"PST-08PDT+01,M3.5.0/02:00,M10.5.0/02:00"));
+  check("tz4 to posix string", 
+        tz4->to_posix_string() == std::wstring(L"MST-07"));
+
+  // test start/end for non-dst zone
+  check("has dst in non-dst zone", !tz4->has_dst());
+  check("dst start in non-dst zone", 
+        tz4->dst_local_start_time(2005) == ptime(not_a_date_time));
+  check("dst end in non-dst zone",
+        tz4->dst_local_end_time(2005) == ptime(not_a_date_time));
+
+
+  return printTestStats();
+}
+
+
diff --git a/src/boost/libs/date_time/test/local_time/testwposix_time_zone.cpp b/src/boost/libs/date_time/test/local_time/testwposix_time_zone.cpp
new file mode 100644
index 000000000..2bd11cbd6
--- /dev/null
+++ b/src/boost/libs/date_time/test/local_time/testwposix_time_zone.cpp
@@ -0,0 +1,224 @@
+/* Copyright (c) 2003-2004 CrystalClear Software, Inc.
+ * Subject to the Boost Software License, Version 1.0. 
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+//#include "boost/date_time/local_time/time_zone.hpp"
+#include "../testfrmwk.hpp"
+
+#include "boost/date_time/local_time/posix_time_zone.hpp"
+
+#include <string>
+#include <iostream>
+
+int main(){
+  using namespace boost::local_time;
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+
+  typedef posix_time_zone_base<wchar_t> w_posix_time_zone;
+  
+  std::wstring specs[] = {L"MST-07", L"MST-07:00:00",L"EST-05EDT,M4.1.0,M10.5.0", L"EST-05:00:00EDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00",L"PST-08PDT,J46/1:30,J310",L"PST-08PDT,45,310/0:30:00"};
+
+  w_posix_time_zone nyc1(specs[2]);
+  w_posix_time_zone nyc2(specs[3]);
+  time_duration td = hours(-5);
+
+  check("Has DST", nyc1.has_dst() && nyc2.has_dst());
+  check("UTC offset", nyc1.base_utc_offset() == td);
+  check("UTC offsets match", nyc1.base_utc_offset() == nyc2.base_utc_offset());
+  check("Abbrevs", nyc1.std_zone_abbrev() == std::wstring(L"EST"));
+  check("Abbrevs", nyc2.std_zone_abbrev() == std::wstring(L"EST"));
+  check("Abbrevs", nyc1.dst_zone_abbrev() == std::wstring(L"EDT"));
+  check("Abbrevs", nyc2.dst_zone_abbrev() == std::wstring(L"EDT"));
+  // names not available for w_posix_time_zone, abbrevs used in their place
+  check("Names", nyc1.std_zone_name() == std::wstring(L"EST"));
+  check("Names", nyc2.std_zone_name() == std::wstring(L"EST"));
+  check("Names", nyc1.dst_zone_name() == std::wstring(L"EDT"));
+  check("Names", nyc2.dst_zone_name() == std::wstring(L"EDT"));
+  td = hours(1);
+  check("dst offset", nyc1.dst_offset() == td);
+  check("dst offsets match", nyc1.dst_offset() == nyc2.dst_offset());
+  check("dst start", nyc1.dst_local_start_time(2003) == 
+      ptime(date(2003,Apr,6),time_duration(2,0,0)));
+  check("dst starts match", nyc1.dst_local_start_time(2003) == 
+      nyc2.dst_local_start_time(2003)); 
+  check("dst end", nyc1.dst_local_end_time(2003) == 
+      ptime(date(2003,Oct,26),time_duration(2,0,0)));
+  check("dst ends match", nyc1.dst_local_end_time(2003) == 
+      nyc2.dst_local_end_time(2003)); 
+  check("to posix string", 
+        nyc1.to_posix_string() == std::wstring(L"EST-05EDT+01,M4.1.0/02:00,M10.5.0/02:00"));
+  check("to posix string", 
+        nyc2.to_posix_string() == std::wstring(L"EST-05EDT+01,M4.1.0/02:00,M10.5.0/02:00"));
+  
+
+  w_posix_time_zone az1(specs[0]);
+  w_posix_time_zone az2(specs[1]);
+  td = hours(-7);
+
+  check("Has DST", !az1.has_dst() && !az2.has_dst());
+  check("UTC offset", az1.base_utc_offset() == td);
+  check("UTC offsets match", az1.base_utc_offset() == az2.base_utc_offset());
+  check("dst start in non-dst zone", 
+        az1.dst_local_start_time(2005) == ptime(not_a_date_time));
+  check("dst end in non-dst zone", 
+        az2.dst_local_end_time(2005) == ptime(not_a_date_time));
+  check("Abbrevs", az1.std_zone_abbrev() == std::wstring(L"MST"));
+  check("Abbrevs", az2.std_zone_abbrev() == std::wstring(L"MST"));
+  // non-dst zones default to empty strings for dst names & abbrevs
+  check("Abbrevs", az1.dst_zone_abbrev() == std::wstring(L""));
+  check("Abbrevs", az2.dst_zone_abbrev() == std::wstring(L""));
+  check("Names", az1.std_zone_name() == std::wstring(L"MST"));
+  check("Names", az2.std_zone_name() == std::wstring(L"MST"));
+  check("Names", az1.dst_zone_name() == std::wstring(L""));
+  check("Names", az2.dst_zone_name() == std::wstring(L""));
+  check("to posix string", 
+        az1.to_posix_string() == std::wstring(L"MST-07"));
+  check("to posix string", 
+        az2.to_posix_string() == std::wstring(L"MST-07"));
+ 
+
+  // bizzar time zone spec to fully test parsing
+  std::cout << "\nFictitious time zone" << std::endl;
+  w_posix_time_zone bz(L"BST+11:21:15BDT-00:28,M2.2.4/03:15:42,M11.5.2/01:08:53");
+  check("hast dst", bz.has_dst());
+  check("UTC offset", bz.base_utc_offset() == time_duration(11,21,15));
+  check("Abbrev", bz.std_zone_abbrev() == std::wstring(L"BST"));
+  check("Abbrev", bz.dst_zone_abbrev() == std::wstring(L"BDT"));
+  check("dst offset", bz.dst_offset() == time_duration(0,-28,0));
+  check("dst start", bz.dst_local_start_time(1962) ==
+      ptime(date(1962,Feb,8),time_duration(3,15,42)));
+  check("dst end", bz.dst_local_end_time(1962) ==
+      ptime(date(1962,Nov,27),time_duration(1,8,53)));
+  
+  // only checking start & end rules w/ 'J' notation
+  std::cout << "\n'J' notation Start/End rule tests..." << std::endl;
+  w_posix_time_zone la1(specs[4]); // "PST-08PDT,J124,J310"
+  //w_posix_time_zone la1("PST-08PDT,J1,J365");// Jan1/Dec31 
+  check("dst start", la1.dst_local_start_time(2003) == 
+      ptime(date(2003,Feb,15),time_duration(1,30,0)));
+  check("dst end", la1.dst_local_end_time(2003) == 
+      ptime(date(2003,Nov,6),time_duration(2,0,0)));
+  /* NOTE: la1 was created from a 'J' notation string but to_posix_string
+   * returns an 'n' notation string. The difference between the two 
+   * is Feb-29 is always counted in an 'n' notation string and numbering 
+   * starts at zero ('J' notation starts at one). 
+   * Every possible date spec that can be written in 'J' notation can also
+   * be written in 'n' notation. The reverse is not true so 'n' notation 
+   * is used as the output for to_posix_string(). */
+  check("to posix string", 
+        la1.to_posix_string() == std::wstring(L"PST-08PDT+01,45/01:30,310/02:00"));
+  
+  // only checking start & end rules w/ 'n' notation
+  std::cout << "\n'n' notation Start/End rule tests..." << std::endl;
+  w_posix_time_zone la2(specs[5]); // "PST-08PDT,124,310"
+  //w_posix_time_zone la2("PST-08PDT,0,365");// Jan1/Dec31 
+  check("dst start", la2.dst_local_start_time(2003) == 
+      ptime(date(2003,Feb,15),time_duration(2,0,0)));
+  check("dst end", la2.dst_local_end_time(2003) == 
+      ptime(date(2003,Nov,6),time_duration(0,30,0)));
+  check("to posix string", 
+        la2.to_posix_string() == std::wstring(L"PST-08PDT+01,45/02:00,310/00:30"));
+
+  // bad posix time zone strings tests
+  std::cout << "\nInvalid time zone string tests..." << std::endl;
+  try {
+    w_posix_time_zone badz(L"EST-13");
+    check("Exception not thrown: bad UTC offset", false);
+  }catch(bad_offset& boff){
+    std::string msg(boff.what());
+    check("Exception caught: "+msg , true);
+  }
+  try {
+    w_posix_time_zone badz(L"EST-5EDT24:00:01,J124/1:30,J310");
+    check("Exception not thrown: bad DST adjust", false);
+  }catch(bad_adjustment& badj){
+    std::string msg(badj.what());
+    check("Exception caught: "+msg , true);
+  }
+  try {
+    w_posix_time_zone badz(L"EST-5EDT01:00:00,J124/-1:30,J310");
+    check("Exception not thrown: bad DST start/end offset", false);
+  }catch(bad_offset& boff){
+    std::string msg(boff.what());
+    check("Exception caught: "+msg , true);
+  }
+  try {
+    w_posix_time_zone badz(L"EST-5EDT01:00:00,J124/1:30,J370");
+    check("Exception not thrown: invalid date spec", false);
+  }catch(boost::gregorian::bad_day_of_month& boff){
+    std::string msg(boff.what());
+    check("Exception caught: "+msg , true);
+  }catch(boost::gregorian::bad_month& boff){
+    std::string msg(boff.what());
+    check("Exception caught: "+msg , true);
+  }catch(...){
+    check("Unexpected exception caught: ", false);
+  }
+
+  std::cout << "\nTest some Central Europe specs" << std::endl;
+
+  //Test a timezone spec on the positive side of the UTC line.
+  //This is the time for central europe which is one hour in front of UTC
+  //Note these Summer time transition rules aren't actually correct.
+  w_posix_time_zone cet_tz(L"CET+01:00:00EDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00");
+  check("Has DST", cet_tz.has_dst());
+  check("UTC offset", cet_tz.base_utc_offset() == hours(1));
+  check("Abbrevs", cet_tz.std_zone_abbrev() == std::wstring(L"CET"));
+//   check("Abbrevs", nyc2.std_zone_abbrev() == std::wstring("EST"));
+
+  std::cout << "\nTest some Central Austrialia UTC+8:30" << std::endl;
+
+  //Test a timezone spec on the positive side of the UTC line.
+  //This is the time for central europe which is one hour in front of UTC
+  //Note these Summer time transition rules aren't actually correct.
+  w_posix_time_zone caus_tz(L"CAS+08:30:00CDT+01:00:00,M4.1.0/02:00:00,M10.5.0/02:00:00");
+  check("Has DST", caus_tz.has_dst());
+  check("UTC offset", caus_tz.base_utc_offset() == hours(8)+minutes(30));
+  check("Abbrevs", caus_tz.std_zone_abbrev() == std::wstring(L"CAS"));
+//   check("Abbrevs", nyc2.std_zone_abbrev() == std::wstring("EST"));
+
+  {
+    /**** first/last of month Julian & non-Julian tests ****/
+    // Mar-01 & Oct-31, count begins at 1
+    std::wstring spec(L"FST+3FDT,J60,J304"); 
+    w_posix_time_zone fl_1(spec);
+    check("Julian First/last of month", fl_1.dst_local_start_time(2003) == 
+        ptime(date(2003,Mar,1),hours(2)));
+    check("Julian First/last of month", fl_1.dst_local_end_time(2003) == 
+        ptime(date(2003,Oct,31),hours(2)));
+    check("Julian First/last of month", fl_1.dst_local_start_time(2004) == 
+        ptime(date(2004,Mar,1),hours(2)));
+    check("Julian First/last of month", fl_1.dst_local_end_time(2004) == 
+        ptime(date(2004,Oct,31),hours(2)));
+    
+    // Mar-01 & Oct-31 Non-leap year, count begins at 0
+    spec = L"FST+3FDT,59,304"; // "304" is not a mistake here, see posix_time_zone docs
+    w_posix_time_zone fl_2(spec);
+    try{
+      check("Non-Julian First/last of month", fl_2.dst_local_start_time(2003) ==
+          ptime(date(2003,Mar,1),hours(2)));
+    }catch(std::exception&){
+      check("Expected exception caught for Non-Julian day of 59, in non-leap year (Feb-29)", true);
+    }
+    check("Non-Julian First/last of month", fl_2.dst_local_end_time(2003) == 
+        ptime(date(2003,Oct,31),hours(2)));
+    
+    // Mar-01 & Oct-31 leap year, count begins at 0
+    spec = L"FST+3FDT,60,304"; 
+    w_posix_time_zone fl_3(spec);
+    check("Non-Julian First/last of month", fl_3.dst_local_start_time(2004) ==
+        ptime(date(2004,Mar,1),hours(2)));
+    check("Non-Julian First/last of month", fl_3.dst_local_end_time(2004) ==
+        ptime(date(2004,Oct,31),hours(2)));
+  }
+
+  printTestStats();
+  return 0;
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/compile_fail/hours_special_value.cpp b/src/boost/libs/date_time/test/posix_time/compile_fail/hours_special_value.cpp
new file mode 100644
index 000000000..c2d001df7
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/compile_fail/hours_special_value.cpp
@@ -0,0 +1,19 @@
+//
+// Copyright (c) 2017 James E. King III
+// Use, modification and distribution is subject to the
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <boost/date_time/special_defs.hpp>
+
+int main()
+{
+    using boost::date_time::pos_infin;
+    using boost::posix_time::hours;
+    boost::ignore_unused(hours(static_cast<boost::int64_t>(pos_infin))); // compiles: it's an integral
+    boost::ignore_unused(hours(pos_infin));                              // won't compile: not an integral
+    return 1;                                                            // return an error if we actually compile
+}
diff --git a/src/boost/libs/date_time/test/posix_time/compile_fail/millisec_special_value.cpp b/src/boost/libs/date_time/test/posix_time/compile_fail/millisec_special_value.cpp
new file mode 100644
index 000000000..a8d18cc59
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/compile_fail/millisec_special_value.cpp
@@ -0,0 +1,19 @@
+//
+// Copyright (c) 2017 James E. King III
+// Use, modification and distribution is subject to the
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <boost/date_time/special_defs.hpp>
+
+int main()
+{
+    using boost::date_time::pos_infin;
+    using boost::posix_time::millisec;
+    boost::ignore_unused(millisec(static_cast<boost::int64_t>(pos_infin))); // compiles: it's a number
+    boost::ignore_unused(millisec(pos_infin));                              // won't compile: not an integral
+    return 1;                                                               // return an error if we actually run for some reason
+}
diff --git a/src/boost/libs/date_time/test/posix_time/compile_fail/minutes_special_value.cpp b/src/boost/libs/date_time/test/posix_time/compile_fail/minutes_special_value.cpp
new file mode 100644
index 000000000..f99b722f7
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/compile_fail/minutes_special_value.cpp
@@ -0,0 +1,19 @@
+//
+// Copyright (c) 2017 James E. King III
+// Use, modification and distribution is subject to the
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <boost/date_time/special_defs.hpp>
+
+int main()
+{
+    using boost::date_time::pos_infin;
+    using boost::posix_time::minutes;
+    boost::ignore_unused(minutes(static_cast<boost::int64_t>(pos_infin))); // compiles: it's an integral
+    boost::ignore_unused(minutes(pos_infin));                              // won't compile: not an integral
+    return 1;                                                              // return an error if we actually run for some reason
+}
diff --git a/src/boost/libs/date_time/test/posix_time/compile_fail/seconds_special_value.cpp b/src/boost/libs/date_time/test/posix_time/compile_fail/seconds_special_value.cpp
new file mode 100644
index 000000000..c3ccc7636
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/compile_fail/seconds_special_value.cpp
@@ -0,0 +1,19 @@
+//
+// Copyright (c) 2017 James E. King III
+// Use, modification and distribution is subject to the
+// Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+//
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/date_time/posix_time/posix_time_duration.hpp>
+#include <boost/date_time/special_defs.hpp>
+
+int main()
+{
+    using boost::date_time::pos_infin;
+    using boost::posix_time::seconds;
+    boost::ignore_unused(seconds(static_cast<boost::int64_t>(pos_infin))); // compiles: it's an integral
+    boost::ignore_unused(seconds(pos_infin));                              // won't compile: not an integral
+    return 1;                                                              // return an error if we actually run for some reason
+}
diff --git a/src/boost/libs/date_time/test/posix_time/testc_local_adjustor.cpp b/src/boost/libs/date_time/test/posix_time/testc_local_adjustor.cpp
new file mode 100644
index 000000000..d9947a6eb
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testc_local_adjustor.cpp
@@ -0,0 +1,131 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include <stdexcept>
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/date_time/c_local_time_adjustor.hpp"
+#include "../testfrmwk.hpp"
+
+int
+main() 
+{
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+
+  //These are a compile check / test.  They have to be hand inspected
+  //b/c they depend on the TZ settings of the machine and hence it is
+  //unclear what the results will be
+  typedef boost::date_time::c_local_adjustor<ptime> local_adj;
+  
+  bool btd1e = false;
+  bool btd2e = false;
+  bool btd3e = false;
+  time_duration td1;
+  time_duration td2;
+  time_duration td3;
+  
+  try
+      {
+      ptime t1(date(2002,Jan,1), hours(7)+millisec(5)); 
+      std::cout << "UTC <--> TZ Setting of Machine -- No DST" << std::endl;
+      ptime t2 = local_adj::utc_to_local(t1);
+      std::cout << t2 << " LOCAL is " 
+                << t1 << " UTC time "
+                << std::endl;
+      td1 = t2 - t1;
+      std::cout << "A difference of: " << td1
+                << std::endl;
+      }
+  catch (std::runtime_error & re)
+      {
+      btd1e = true;
+      check(re.what(), false);
+      }
+  
+  try
+      {
+      ptime t3(date(2002,May,1), hours(5)+millisec(5)); 
+      std::cout << "UTC <--> TZ Setting of Machine -- In DST" << std::endl;
+      ptime t4 = local_adj::utc_to_local(t3);
+      std::cout << t4 << " LOCAL is " 
+                << t3 << " UTC time "
+                << std::endl;
+      td2 = t4 - t3;
+      std::cout << "A difference of: " << td2
+                << std::endl;
+      }
+  catch (std::runtime_error & re)
+      {
+      btd2e = true;
+      check(re.what(), false);
+      }
+
+  try
+      {
+      ptime t5(date(2040,May,1), hours(5)+millisec(5));
+      std::cout << "UTC <--> TZ Setting of Machine -- In DST" << std::endl;
+      ptime t6 = local_adj::utc_to_local(t5);
+      std::cout << t6 << " LOCAL is " 
+                << t5 << " UTC time "
+                << std::endl;
+      td3 = t6 - t5;
+      std::cout << "a difference of: " << td3
+                << std::endl;
+      }
+  catch (std::runtime_error & re)
+      {
+      btd3e = true;
+      check(re.what(), false);
+      }
+  catch (std::bad_cast&)
+      {
+      btd3e = true;
+      check("32-bit time_t overflow detected", sizeof(std::time_t) < 8);
+      }
+
+  // The following tests are unaware of the local time zone, but they
+  // should help spot some errors. Manual inspection could still be
+  // required.
+
+  // Based on http://stackoverflow.com/questions/8131023
+  // All time zones are between -12 and +14
+  if (!btd1e)
+      {
+      check("td1 isn't too low", td1 >= hours(-12));
+      check("td1 isn't too high", td1 <= hours(14));
+      }
+  if (!btd2e)
+      {
+      check("td2 isn't too low", td2 >= hours(-12));
+      check("td2 isn't too high", td2 <= hours(14));
+      }
+  if (!btd3e)
+      {
+      check("td3 isn't too low", td3 >= hours(-12));
+      check("td3 isn't too high", td3 <= hours(14));
+      }
+
+  // Assuming that no one uses DST of more than an hour.
+  if (!btd1e && !btd2e)
+      {
+      check("td1 and td2 are close",
+              td1 - td2 <= hours(1) && td2 - td1 <= hours(1));
+      }
+  if (!btd2e && !btd3e)
+      {
+      check("td2 and td3 are close",
+              td2 - td3 <= hours(2) && td3 - td2 <= hours(2));
+      }
+  if (!btd1e && !btd3e)
+      {
+      check("td1 and td3 are close",
+              td1 - td3 <= hours(1) && td3 - td1 <= hours(1));
+      }
+
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testclock.cpp b/src/boost/libs/date_time/test/posix_time/testclock.cpp
new file mode 100644
index 000000000..6341cc81b
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testclock.cpp
@@ -0,0 +1,42 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include <boost/config.hpp>
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include <iostream>
+
+int
+main() 
+{
+
+  using namespace boost::posix_time;
+  ptime tl = second_clock::local_time();
+  std::cout << tl << std::endl;
+
+  ptime tu = second_clock::universal_time();
+  std::cout << tu << std::endl;
+
+#if !defined(BOOST_WINDOWS) && defined(_POSIX_TIMERS)
+  for (int i=0; i < 3; ++i) {
+    ptime t2 = second_clock::local_time();
+    std::cout << t2 << std::endl;
+    sleep(1);
+  }
+#endif
+
+#ifdef BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
+   for (int i=0; i < 10; ++i) {
+     //ptime t2 = high_precision_clock::local_time();
+     ptime t2 = microsec_clock::local_time();
+     std::cout << t2 << std::endl;
+   }
+#endif // BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
+
+  return 0;
+
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testdst_rules.cpp b/src/boost/libs/date_time/test/posix_time/testdst_rules.cpp
new file mode 100644
index 000000000..83fc1b523
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testdst_rules.cpp
@@ -0,0 +1,451 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/date_time/local_timezone_defs.hpp"
+#include "../testfrmwk.hpp"
+
+// Define dst rule for Paraguay which is transitions forward on Oct 1 and 
+// back Mar 1
+
+struct paraguay_dst_traits { 
+  typedef boost::gregorian::date           date_type;
+  typedef boost::gregorian::date::day_type day_type;
+  typedef boost::gregorian::date::month_type month_type;
+  typedef boost::gregorian::date::year_type year_type;
+  typedef boost::date_time::partial_date<boost::gregorian::date> start_rule_functor;
+  typedef boost::date_time::partial_date<boost::gregorian::date> end_rule_functor;
+  static day_type start_day(year_type) {return 1;}
+  static month_type start_month(year_type) {return boost::date_time::Oct;}
+  static day_type end_day(year_type) {return 1;}
+  static month_type end_month(year_type) {return boost::date_time::Mar;}
+  static int dst_start_offset_minutes() { return 120;}
+  static int dst_end_offset_minutes() { return 120; }
+  static int dst_shift_length_minutes() { return 60; }
+  static date_type local_dst_start_day(year_type year)
+  {
+    start_rule_functor start(start_day(year), 
+                             start_month(year));
+    return start.get_date(year);      
+  }
+  static date_type local_dst_end_day(year_type year)
+  {
+    end_rule_functor end(end_day(year), 
+                         end_month(year));
+    return end.get_date(year);      
+  }
+
+
+};
+
+
+// see http://www.timeanddate.com/time/aboutdst.html for some info
+// also 
+int
+main() 
+{
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+  date d(2002,Feb,1);
+  ptime t(d);
+
+  //The following defines the US dst boundaries, except that the
+  //start and end dates are hard coded.
+  typedef boost::date_time::us_dst_rules<date, time_duration, 120, 60> us_dst_local;
+  date dst_start(2002,Apr, 7);
+  date dst_end(2002,Oct, 27);
+
+  ptime t3a(dst_start, time_duration(2,0,0));   //invalid time label 
+  ptime t3b(dst_start, time_duration(2,59,59)); //invalid time label
+  ptime t4(dst_start, time_duration(1,59,59));   //not ds 
+  ptime t5(dst_start, time_duration(3,0,0));   //always dst
+  ptime t6(dst_end, time_duration(0,59,59)); //is dst
+  ptime t7(dst_end, time_duration(1,0,0));   //ambiguous
+  ptime t8(dst_end, time_duration(1,59,59));   //ambiguous 
+  ptime t9(dst_end, time_duration(2,0,0));   //always not dst
+
+  check("dst start", us_dst_local::local_dst_start_day(2002) == dst_start);
+  check("dst end",   us_dst_local::local_dst_end_day(2002) == dst_end);
+  check("dst boundary",   us_dst_local::is_dst_boundary_day(dst_start));
+  check("dst boundary",   us_dst_local::is_dst_boundary_day(dst_end));
+  check("check if time is dst -- not",   
+        us_dst_local::local_is_dst(t.date(), t.time_of_day())==boost::date_time::is_not_in_dst);
+  check("label on dst boundary invalid", 
+        us_dst_local::local_is_dst(t3a.date(),t3a.time_of_day())==boost::date_time::invalid_time_label);
+  check("label on dst boundary invalid",   
+        us_dst_local::local_is_dst(t3b.date(),t3b.time_of_day())==boost::date_time::invalid_time_label);
+   check("check if time is dst -- not",   
+         us_dst_local::local_is_dst(t4.date(),t4.time_of_day())==boost::date_time::is_not_in_dst);
+   check("check if time is dst -- yes",   
+         us_dst_local::local_is_dst(t5.date(),t5.time_of_day())==boost::date_time::is_in_dst);
+
+   check("check if time is dst -- not",   
+         us_dst_local::local_is_dst(t6.date(),t6.time_of_day())==boost::date_time::is_in_dst);
+   check("check if time is dst -- ambig", 
+         us_dst_local::local_is_dst(t7.date(),t7.time_of_day())==boost::date_time::ambiguous);
+   check("check if time is dst -- ambig", 
+         us_dst_local::local_is_dst(t8.date(),t8.time_of_day())==boost::date_time::ambiguous);
+   check("check if time is dst -- not",   
+         us_dst_local::local_is_dst(t9.date(),t9.time_of_day())==boost::date_time::is_not_in_dst);
+
+
+  //Now try a local without dst
+  typedef boost::date_time::null_dst_rules<date, time_duration> no_dst_adj;
+
+  check("check null dst rules",   
+        no_dst_adj::local_is_dst(t4.date(),t4.time_of_day())==boost::date_time::is_not_in_dst);
+  check("check null dst rules",   
+        no_dst_adj::local_is_dst(t5.date(),t5.time_of_day())==boost::date_time::is_not_in_dst);
+  check("check null dst rules",   
+        no_dst_adj::utc_is_dst(t4.date(),t4.time_of_day())==boost::date_time::is_not_in_dst);
+  check("check null dst rules",   
+        no_dst_adj::utc_is_dst(t5.date(),t5.time_of_day())==boost::date_time::is_not_in_dst);
+  
+
+  //Try a southern hemisphere adjustment calculation
+  //This is following the rules for South Australia as best I can
+  //decipher them.  Basically conversion to DST is last Sunday in
+  //October 02:00:00 and conversion off of dst is last sunday in
+  //March 02:00:00.  
+  //This stuff uses the dst calculator directly...
+  date dst_start2(2002,Oct,27); //last Sunday in Oct
+  date dst_end2(2002,Mar,31); //last Sunday in March
+
+  typedef boost::date_time::dst_calculator<date,time_duration> dstcalc;
+  //clearly not in dst
+  boost::date_time::time_is_dst_result a1 =
+    dstcalc::local_is_dst(date(2002,May,1),hours(3),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+
+  check("check southern not dst",  a1==boost::date_time::is_not_in_dst);
+
+  boost::date_time::time_is_dst_result a2 =
+    dstcalc::local_is_dst(date(2002,Jan,1),hours(3),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+
+  check("check southern is dst",  a2==boost::date_time::is_in_dst);
+
+  boost::date_time::time_is_dst_result a3 =
+    dstcalc::local_is_dst(date(2002,Oct,28),hours(3),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+
+  check("check southern is dst",  a3==boost::date_time::is_in_dst);
+  boost::date_time::time_is_dst_result a4 =
+    dstcalc::local_is_dst(date(2002,Oct,27),time_duration(1,59,59),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+  check("check southern boundary-not dst",  a4==boost::date_time::is_not_in_dst);
+  boost::date_time::time_is_dst_result a5 =
+    dstcalc::local_is_dst(date(2002,Oct,27),hours(3),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+  check("check southern boundary-is dst",  a5==boost::date_time::is_in_dst);
+  boost::date_time::time_is_dst_result a6 =
+    dstcalc::local_is_dst(date(2002,Oct,27),hours(2),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+  check("check southern boundary-invalid time",  a6==boost::date_time::invalid_time_label);
+  boost::date_time::time_is_dst_result a7 =
+    dstcalc::local_is_dst(date(2002,Mar,31),time_duration(1,59,59),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+  check("check southern boundary-is dst",  a7==boost::date_time::is_in_dst);
+  boost::date_time::time_is_dst_result a8 =
+    dstcalc::local_is_dst(date(2002,Mar,31),time_duration(2,0,0),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+  check("check southern boundary-ambiguous",  a8==boost::date_time::ambiguous);
+  boost::date_time::time_is_dst_result a9 =
+    dstcalc::local_is_dst(date(2002,Mar,31),time_duration(2,59,59),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+  check("check southern boundary-ambiguous",  a9==boost::date_time::ambiguous);
+  boost::date_time::time_is_dst_result a10 =
+    dstcalc::local_is_dst(date(2002,Mar,31),time_duration(3,0,0),
+                          dst_start2, 120,
+                          dst_end2, 180,
+                          60);
+  check("check southern boundary-not",  a10==boost::date_time::is_not_in_dst);
+
+  /******************** post release 1 -- new dst calc engine ********/
+  
+  typedef boost::date_time::us_dst_trait<date> us_dst_traits;
+  typedef boost::date_time::dst_calc_engine<date, time_duration, us_dst_traits>
+    us_dst_calc2;
+    
+  {
+    //  us_dst_calc2
+    check("dst start", us_dst_calc2::local_dst_start_day(2002) == dst_start);
+    check("dst end",   us_dst_calc2::local_dst_end_day(2002) == dst_end);
+    //  std::cout << us_dst_calc2::local_dst_end_day(2002) << std::endl;
+    check("dst boundary",   us_dst_calc2::is_dst_boundary_day(dst_start));
+    check("dst boundary",   us_dst_calc2::is_dst_boundary_day(dst_end));
+    
+    check("check if time is dst -- not",   
+          us_dst_calc2::local_is_dst(t.date(), t.time_of_day())==boost::date_time::is_not_in_dst);
+    check("label on dst boundary invalid", 
+          us_dst_calc2::local_is_dst(t3a.date(),t3a.time_of_day())==boost::date_time::invalid_time_label);
+    check("label on dst boundary invalid",   
+          us_dst_calc2::local_is_dst(t3b.date(),t3b.time_of_day())==boost::date_time::invalid_time_label);
+    check("check if time is dst -- not",   
+          us_dst_calc2::local_is_dst(t4.date(),t4.time_of_day())==boost::date_time::is_not_in_dst);
+    check("check if time is dst -- yes",   
+          us_dst_calc2::local_is_dst(t5.date(),t5.time_of_day())==boost::date_time::is_in_dst);
+
+    check("check if time is dst -- not",   
+          us_dst_calc2::local_is_dst(t6.date(),t6.time_of_day())==boost::date_time::is_in_dst);
+    check("check if time is dst -- ambig", 
+          us_dst_calc2::local_is_dst(t7.date(),t7.time_of_day())==boost::date_time::ambiguous);
+    check("check if time is dst -- ambig", 
+          us_dst_calc2::local_is_dst(t8.date(),t8.time_of_day())==boost::date_time::ambiguous);
+    check("check if time is dst -- not",   
+          us_dst_calc2::local_is_dst(t9.date(),t9.time_of_day())==boost::date_time::is_not_in_dst);
+  }
+  {
+    //some new checks for the new 2007 us dst rules
+    date dst_start07(2007,Mar, 11);
+    date dst_end07(2007,Nov, 4);
+
+    check("dst start07", us_dst_calc2::local_dst_start_day(2007) == dst_start07);
+    check("dst end07",   us_dst_calc2::local_dst_end_day(2007) == dst_end07);
+    check("dst boundary07",   us_dst_calc2::is_dst_boundary_day(dst_start07));
+    check("dst boundary07",   us_dst_calc2::is_dst_boundary_day(dst_end07));
+
+    date dst_start08(2008,Mar, 9);
+    date dst_end08(2008,Nov, 2);
+
+    check("dst start08", us_dst_calc2::local_dst_start_day(2008) == dst_start08);
+    check("dst end08",   us_dst_calc2::local_dst_end_day(2008) == dst_end08);
+    check("dst boundary08",   us_dst_calc2::is_dst_boundary_day(dst_start08));
+    check("dst boundary08",   us_dst_calc2::is_dst_boundary_day(dst_end08));
+
+    date dst_start09(2009,Mar, 8);
+    date dst_end09(2009,Nov, 1);
+
+    check("dst start09", us_dst_calc2::local_dst_start_day(2009) == dst_start09);
+    check("dst end09",   us_dst_calc2::local_dst_end_day(2009) == dst_end09);
+    check("dst boundary09",   us_dst_calc2::is_dst_boundary_day(dst_start09));
+    check("dst boundary09",   us_dst_calc2::is_dst_boundary_day(dst_end09));
+    
+  }
+
+
+
+  /******************** post release 1 -- new dst calc engine - eu dst ********/
+  
+
+   typedef boost::date_time::eu_dst_trait<date> eu_dst_traits;
+   typedef boost::date_time::dst_calc_engine<date, time_duration, eu_dst_traits>
+     eu_dst_calc;
+  date eu_dst_start(2002,Mar, 31);
+  date eu_dst_end(2002,Oct, 27);
+  ptime eu_invalid1(eu_dst_start, time_duration(2,0,0));   //invalid time label 
+  ptime eu_invalid2(eu_dst_start, time_duration(2,59,59)); //invalid time label
+  ptime eu_notdst1(eu_dst_start, time_duration(1,59,59));   //not ds 
+  ptime eu_isdst1(eu_dst_start, time_duration(3,0,0));   //always dst
+  ptime eu_isdst2(eu_dst_end, time_duration(1,59,59)); //is dst
+  ptime eu_amgbig1(eu_dst_end, time_duration(2,0,0));   //ambiguous
+  ptime eu_amgbig2(eu_dst_end, time_duration(2,59,59));   //ambiguous 
+  ptime eu_notdst2(eu_dst_end, time_duration(3,0,0));   //always not dst
+
+  check("eu dst start", eu_dst_calc::local_dst_start_day(2002) == eu_dst_start);
+  check("eu dst end",   eu_dst_calc::local_dst_end_day(2002) == eu_dst_end);
+  check("eu dst boundary",   eu_dst_calc::is_dst_boundary_day(eu_dst_start));
+  check("eu dst boundary",   eu_dst_calc::is_dst_boundary_day(eu_dst_end));
+  // on forward shift boundaries
+  check("eu label on dst boundary invalid", 
+        eu_dst_calc::local_is_dst(eu_invalid1.date(),eu_invalid1.time_of_day())==boost::date_time::invalid_time_label);
+  check("eu label on dst boundary invalid",   
+        eu_dst_calc::local_is_dst(eu_invalid2.date(),eu_invalid2.time_of_day())==boost::date_time::invalid_time_label);
+  check("eu check if time is dst -- not",   
+        eu_dst_calc::local_is_dst(eu_notdst1.date(),eu_notdst1.time_of_day())==boost::date_time::is_not_in_dst);
+  check("check if time is dst -- yes",   
+        eu_dst_calc::local_is_dst(eu_isdst1.date(),eu_isdst1.time_of_day())==boost::date_time::is_in_dst);
+  //backward shift boundary
+  check("eu check if time is dst -- yes",   
+        eu_dst_calc::local_is_dst(eu_isdst2.date(),eu_isdst2.time_of_day())==boost::date_time::is_in_dst);
+  check("eu check if time is dst -- ambig", 
+        eu_dst_calc::local_is_dst(eu_amgbig1.date(),eu_amgbig1.time_of_day())==boost::date_time::ambiguous);
+  check("eu check if time is dst -- ambig", 
+        eu_dst_calc::local_is_dst(eu_amgbig2.date(),eu_amgbig2.time_of_day())==boost::date_time::ambiguous);
+  check("eu check if time is dst -- not",   
+        eu_dst_calc::local_is_dst(eu_notdst2.date(),eu_notdst2.time_of_day())==boost::date_time::is_not_in_dst);
+  
+/******************** post release 1 -- new dst calc engine - gb dst ********/
+
+  
+  /* Several places in Great Britan use eu start and end rules for the 
+     day, but different local conversion times (eg: forward change at 1:00 
+     am local and  backward change at 2:00 am dst instead of 2:00am 
+     forward and 3:00am back for the EU).
+  */
+  
+  typedef boost::date_time::uk_dst_trait<date> uk_dst_traits;
+
+  typedef boost::date_time::dst_calc_engine<date, time_duration, uk_dst_traits>  uk_dst_calc;
+
+
+  date uk_dst_start(2002,Mar, 31);
+  date uk_dst_end(2002,Oct, 27);
+  ptime uk_invalid1(uk_dst_start, time_duration(1,0,0));   //invalid time label 
+  ptime uk_invalid2(uk_dst_start, time_duration(1,59,59)); //invalid time label
+  ptime uk_notdst1(uk_dst_start, time_duration(0,59,59));   //not ds 
+  ptime uk_isdst1(uk_dst_start, time_duration(2,0,0));   //always dst
+  ptime uk_isdst2(uk_dst_end, time_duration(0,59,59)); //is dst
+  ptime uk_amgbig1(uk_dst_end, time_duration(1,0,0));   //ambiguous
+  ptime uk_amgbig2(uk_dst_end, time_duration(1,59,59));   //ambiguous 
+  ptime uk_notdst2(uk_dst_end, time_duration(3,0,0));   //always not dst
+
+  check("uk dst start", uk_dst_calc::local_dst_start_day(2002) == uk_dst_start);
+  check("uk dst end",   uk_dst_calc::local_dst_end_day(2002) == uk_dst_end);
+  check("uk dst boundary",   uk_dst_calc::is_dst_boundary_day(uk_dst_start));
+  check("uk dst boundary",   uk_dst_calc::is_dst_boundary_day(uk_dst_end));
+  // on forward shift boundaries
+  check("uk label on dst boundary invalid", 
+        uk_dst_calc::local_is_dst(uk_invalid1.date(),uk_invalid1.time_of_day())==boost::date_time::invalid_time_label);
+  check("uk label on dst boundary invalid",   
+        uk_dst_calc::local_is_dst(uk_invalid2.date(),uk_invalid2.time_of_day())==boost::date_time::invalid_time_label);
+  check("uk check if time is dst -- not",   
+        uk_dst_calc::local_is_dst(uk_notdst1.date(),uk_notdst1.time_of_day())==boost::date_time::is_not_in_dst);
+  check("uk check if time is dst -- yes",   
+        uk_dst_calc::local_is_dst(uk_isdst1.date(),uk_isdst1.time_of_day())==boost::date_time::is_in_dst);
+  //backward shift boundary
+  check("uk check if time is dst -- yes",   
+        uk_dst_calc::local_is_dst(uk_isdst2.date(),uk_isdst2.time_of_day())==boost::date_time::is_in_dst);
+  check("uk check if time is dst -- ambig", 
+        uk_dst_calc::local_is_dst(uk_amgbig1.date(),uk_amgbig1.time_of_day())==boost::date_time::ambiguous);
+  check("uk check if time is dst -- ambig", 
+        uk_dst_calc::local_is_dst(uk_amgbig2.date(),uk_amgbig2.time_of_day())==boost::date_time::ambiguous);
+  check("uk check if time is dst -- not",   
+        uk_dst_calc::local_is_dst(uk_notdst2.date(),uk_notdst2.time_of_day())==boost::date_time::is_not_in_dst);
+
+
+//   /******************** post release 1 -- new dst calc engine ********/
+
+//   //Define dst rule for Paraguay which is transitions forward on Oct 1 and back Mar 1
+  
+  typedef boost::date_time::dst_calc_engine<date, time_duration, 
+                                            paraguay_dst_traits>  pg_dst_calc;
+
+  {
+
+    date pg_dst_start(2002,Oct, 1);
+    date pg_dst_end(2002,Mar, 1);
+    date pg_indst(2002,Dec, 1);
+    date pg_notdst(2002,Jul, 1);
+    ptime pg_invalid1(pg_dst_start, time_duration(2,0,0));   //invalid time label 
+    ptime pg_invalid2(pg_dst_start, time_duration(2,59,59)); //invalid time label
+    ptime pg_notdst1(pg_dst_start, time_duration(1,59,59));   //not ds 
+    ptime pg_isdst1(pg_dst_start, time_duration(3,0,0));   //always dst
+    ptime pg_isdst2(pg_dst_end, time_duration(0,59,59)); //is dst
+    ptime pg_amgbig1(pg_dst_end, time_duration(1,0,0));   //ambiguous
+    ptime pg_amgbig2(pg_dst_end, time_duration(1,59,59));   //ambiguous 
+    ptime pg_notdst2(pg_dst_end, time_duration(2,0,0));   //always not dst
+    
+    check("pg dst start", pg_dst_calc::local_dst_start_day(2002) == pg_dst_start);
+    check("pg dst end",   pg_dst_calc::local_dst_end_day(2002) == pg_dst_end);
+    check("pg dst boundary",   pg_dst_calc::is_dst_boundary_day(pg_dst_start));
+    check("pg dst boundary",   pg_dst_calc::is_dst_boundary_day(pg_dst_end));
+    // on forward shift boundaries
+    check("pg label on dst boundary invalid", 
+          pg_dst_calc::local_is_dst(pg_invalid1.date(),pg_invalid1.time_of_day())==boost::date_time::invalid_time_label);
+    check("pg label on dst boundary invalid",   
+          pg_dst_calc::local_is_dst(pg_invalid2.date(),pg_invalid2.time_of_day())==boost::date_time::invalid_time_label);
+    check("pg check if time is dst -- not",   
+          pg_dst_calc::local_is_dst(pg_notdst1.date(),pg_notdst1.time_of_day())==boost::date_time::is_not_in_dst);
+    check("check if time is dst -- yes",   
+          pg_dst_calc::local_is_dst(pg_isdst1.date(),pg_isdst1.time_of_day())==boost::date_time::is_in_dst);
+    //backward shift boundary
+    check("pg check if time is dst -- yes",   
+          pg_dst_calc::local_is_dst(pg_isdst2.date(),pg_isdst2.time_of_day())==boost::date_time::is_in_dst);
+    check("pg check if time is dst -- ambig", 
+          pg_dst_calc::local_is_dst(pg_amgbig1.date(),pg_amgbig1.time_of_day())==boost::date_time::ambiguous);
+    check("pg check if time is dst -- ambig", 
+          pg_dst_calc::local_is_dst(pg_amgbig2.date(),pg_amgbig2.time_of_day())==boost::date_time::ambiguous);
+    check("pg check if time is dst -- not",   
+          pg_dst_calc::local_is_dst(pg_notdst2.date(),pg_notdst2.time_of_day())==boost::date_time::is_not_in_dst);
+    // a couple not on the boudnary
+    check("pg check if time is dst -- yes",   
+          pg_dst_calc::local_is_dst(pg_indst,time_duration(0,0,0))==boost::date_time::is_in_dst);
+    check("pg check if time is dst -- not",   
+          pg_dst_calc::local_is_dst(pg_notdst,time_duration(0,0,0))==boost::date_time::is_not_in_dst);
+    
+  }
+
+//   /******************** post release 1 -- new dst calc engine ********/
+
+//   //Define dst rule for Adelaide australia
+  
+  typedef boost::date_time::acst_dst_trait<date> acst_dst_traits;
+  typedef boost::date_time::dst_calc_engine<date, time_duration, 
+                                            acst_dst_traits>  acst_dst_calc;
+
+  {
+
+    date acst_dst_start(2002,Oct, 27);
+    date acst_dst_end(2002,Mar, 31);
+    date acst_indst(2002,Dec, 1);
+    date acst_notdst(2002,Jul, 1);
+    ptime acst_invalid1(acst_dst_start, time_duration(2,0,0));   //invalid time label 
+    ptime acst_invalid2(acst_dst_start, time_duration(2,59,59)); //invalid time label
+    ptime acst_notdst1(acst_dst_start, time_duration(1,59,59));   //not ds 
+    ptime acst_isdst1(acst_dst_start, time_duration(3,0,0));   //always dst
+    ptime acst_isdst2(acst_dst_end, time_duration(1,59,59)); //is dst
+    ptime acst_amgbig1(acst_dst_end, time_duration(2,0,0));   //ambiguous
+    ptime acst_amgbig2(acst_dst_end, time_duration(2,59,59));   //ambiguous 
+    ptime acst_notdst2(acst_dst_end, time_duration(3,0,0));   //always not dst
+    
+//     std::cout << "acst dst_start: " << acst_dst_calc::local_dst_start_day(2002)
+//               << std::endl;
+    check("acst dst start", acst_dst_calc::local_dst_start_day(2002) == acst_dst_start);
+    check("acst dst end",   acst_dst_calc::local_dst_end_day(2002) == acst_dst_end);
+    check("acst dst boundary",   acst_dst_calc::is_dst_boundary_day(acst_dst_start));
+    check("acst dst boundary",   acst_dst_calc::is_dst_boundary_day(acst_dst_end));
+    // on forward shift boundaries
+    check("acst label on dst boundary invalid", 
+          acst_dst_calc::local_is_dst(acst_invalid1.date(),acst_invalid1.time_of_day())==boost::date_time::invalid_time_label);
+    check("acst label on dst boundary invalid",   
+          acst_dst_calc::local_is_dst(acst_invalid2.date(),acst_invalid2.time_of_day())==boost::date_time::invalid_time_label);
+    check("acst check if time is dst -- not",   
+          acst_dst_calc::local_is_dst(acst_notdst1.date(),acst_notdst1.time_of_day())==boost::date_time::is_not_in_dst);
+    check("check if time is dst -- yes",   
+          acst_dst_calc::local_is_dst(acst_isdst1.date(),acst_isdst1.time_of_day())==boost::date_time::is_in_dst);
+    //backward shift boundary
+    check("acst check if time is dst -- yes",   
+          acst_dst_calc::local_is_dst(acst_isdst2.date(),acst_isdst2.time_of_day())==boost::date_time::is_in_dst);
+    check("acst check if time is dst -- ambig", 
+          acst_dst_calc::local_is_dst(acst_amgbig1.date(),acst_amgbig1.time_of_day())==boost::date_time::ambiguous);
+    check("acst check if time is dst -- ambig", 
+          acst_dst_calc::local_is_dst(acst_amgbig2.date(),acst_amgbig2.time_of_day())==boost::date_time::ambiguous);
+    check("acst check if time is dst -- not",   
+          acst_dst_calc::local_is_dst(acst_notdst2.date(),acst_notdst2.time_of_day())==boost::date_time::is_not_in_dst);
+    // a couple not on the boudnary
+    check("acst check if time is dst -- yes",   
+          acst_dst_calc::local_is_dst(acst_indst,time_duration(0,0,0))==boost::date_time::is_in_dst);
+    check("acst check if time is dst -- not",   
+          acst_dst_calc::local_is_dst(acst_notdst,time_duration(0,0,0))==boost::date_time::is_not_in_dst);
+    //    ptime utc_t = ptime(acst_dst_start, hours(2)) - time_duration(16,30,0);
+    //    std::cout << "UTC date/time of Adelaide switch over: " << utc_t << std::endl;
+    
+  }
+
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testduration.cpp b/src/boost/libs/date_time/test/posix_time/testduration.cpp
new file mode 100644
index 000000000..061089290
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testduration.cpp
@@ -0,0 +1,282 @@
+/* Copyright (c) 2002-2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/posix_time/posix_time_duration.hpp"
+#include "boost/date_time/compiler_config.hpp"
+#if defined(BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS)
+#include "boost/date_time/posix_time/time_formatters_limited.hpp"
+#else
+#include "boost/date_time/posix_time/time_formatters.hpp"
+#endif
+#include "../testfrmwk.hpp"
+
+
+int
+main() 
+{
+  using namespace boost::posix_time;
+
+  
+//   std::cout << "Default limits: SECOND " << std::endl;
+  {
+    time_duration td;
+    check("default construction -- 0 ticks", td.ticks() == 0);
+//     check("default construction -- 0 secs", td.seconds() == 0);
+//     check("default construction -- 0 min", td.minutes() == 0); 
+  }
+  
+  // construct from components
+  time_duration td1(1,25,0);
+  time_duration td3(td1.hours(),td1.minutes(),td1.seconds());
+  check("total up elements", td1 == td3);
+  td1 = -td1; // td1 == "-1:25:00"
+  check("invert_sign",td3 == td1.invert_sign());
+  check("invert_sign",td1 == td3.invert_sign());
+  check("abs",td3 == td1.abs());
+  check("abs",td3 == td3.abs());
+  check("is_positive",td3.is_positive());
+  check("is_positive",!td1.is_positive());
+  check("is_negative",td1.is_negative());
+  check("is_negative",!td3.is_negative());
+  check("is_zero",!td1.is_zero());
+  check("is_zero",(td1 - td1).is_zero());
+  td3 = time_duration(td1.hours(),td1.minutes(),td1.seconds());
+  check("total up elements-inverted sign", td1 == td3);
+  
+  
+  time_duration t_1(0,1,40);
+  time_duration t_2(0,1,41);
+  check("less test", !(t_2 < t_2));
+  check("equal test", t_1 == t_1);
+  check("greater equal - equal", t_1 >= t_1);
+  check("greater equal - greater", t_2 >= t_1);
+  check("less equal - equal  ", t_2 <= t_2);
+  check("greater             ", t_2 > t_1);
+  check("greater - not       ", !(t_1 > t_2));
+  time_duration t_3(t_2);
+  check("copy constructor    ", t_2 == t_3);
+  time_duration t_4 = t_3;
+  check("assignment operator ", t_2 == t_4);
+
+  time_duration t_5(1,30,20,10); // 1hr, 30min, 20sec, 10 frac sec
+  t_5 /= 2;
+  check("divide equal",         (t_5.hours() == 0 &&
+                                 t_5.minutes() == 45 &&
+                                 t_5.seconds() == 10 &&
+                                 t_5.fractional_seconds() == 5));
+  t_5 = time_duration(3,15,8,0) / 2;
+  check("divide int", t_5 == time_duration(1,37,34,0));
+  {
+    time_duration td = hours(5);
+    td *= 5;
+    check("mult-equals int", time_duration(25,0,0,0) == td);
+  }
+ 
+  
+  t_5 = t_2 + t_1;
+  //VC6 goes ambiguous on the next line...
+#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+  //sorry ticks() doesn't work on VC6
+#else
+  std::cout << t_5.ticks() << std::endl;  
+#endif
+  check("add", t_5 == time_duration(0,3,21));
+  time_duration td_a(5,5,5,5);
+  time_duration td_b(4,4,4,4);
+  time_duration td_c(2,2,2,2);
+  td_a += td_b;
+  check("add equal", td_a == time_duration(9,9,9,9));
+  time_duration td_d = td_b - td_c; 
+  check("subtract", td_d == time_duration(2,2,2,2));
+  td_d -= td_b; 
+  check("subtract equal (neg result)", td_d == td_c - td_b);
+
+  time_duration utd(1,2,3,4);
+  time_duration utd2 = -utd;
+  //std::cout << td_d << '\n' << utd2 << std::endl;
+  check("unary-", ((utd2.hours() == -1) &&
+                   (utd2.minutes() == -2) &&
+                   (utd2.seconds() == -3) &&
+                   (utd2.fractional_seconds() == -4)) );
+  utd2 = -hours(5);
+  check("unary-", utd2.hours() == -5);
+  utd2 = -utd2;
+  check("unary-", utd2.hours() == 5);
+
+  time_duration t_6(5,4,3); //05:04:03
+  check("h-m-s 5-4-3 hours", t_6.hours() == 5);
+  check("h-m-s 5-4-3 minutes", t_6.minutes() == 4);
+  check("h-m-s 5-4-3 seconds", t_6.seconds() == 3);
+  std::cout << t_6.total_seconds() << std::endl;
+  check("h-m-s 5-4-3 total_seconds", t_6.total_seconds() == 18243);
+
+  hours tenhours(10);
+  minutes fivemin(5);
+  time_duration t7 = time_duration(1,2,3) + tenhours + fivemin;
+  check("short hand durations add", t7 == time_duration(11,7,3));
+  time_duration t8 = tenhours + time_duration(1,2,3) +  fivemin;
+  check("short hand durations add", t8 == time_duration(11,7,3));
+
+  if (time_duration::resolution() >= boost::date_time::micro) {
+    time_duration t_9(5,4,3,9876); //05:04:03.09876
+    check("h-m-s 5-4-3.21 hours",  t_9.hours() == 5);
+    check("h-m-s 5-4-3.21 min  ",  t_9.minutes() == 4);
+    check("h-m-s 5-4-3.21 sec  ",  t_9.seconds() == 3);
+    check("h-m-s 5-4-3.21 fs   ",  t_9.fractional_seconds() == 9876);
+    check("h-m-s 5-4-3.21 total_seconds", t_9.total_seconds() == 18243);
+    //  check("h-m-s 5-4-3.21 fs   ",  t_9.fs_as_double() == 0.9876);
+    //std::cout << t_9.fs_as_double() << std::endl;
+    std::cout << to_simple_string(t_9) << std::endl;
+  }
+
+  if (time_duration::resolution() >= boost::date_time::tenth) {
+    time_duration t_10(5,4,3,9); //05:04:03.00001
+    check("h-m-s 5-4-3.9 hours",  t_10.hours() == 5);
+    check("h-m-s 5-4-3.9 min  ",  t_10.minutes() == 4);
+    check("h-m-s 5-4-3.9 sec  ",  t_10.seconds() == 3);
+    check("h-m-s 5-4-3.9 fs   ",  t_10.fractional_seconds() == 9);
+    check("h-m-s 5-4-3.9 total_seconds", t_10.total_seconds() == 18243);
+    std::cout << to_simple_string(t_10) << std::endl;
+  }
+
+  if (time_duration::resolution() >= boost::date_time::milli) {
+    millisec ms(9);
+    //  time_duration t_10(0,0,0,); //00:00:00.009
+    std::cout << "time_resolution: " << time_duration::resolution() << std::endl;
+#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+  //sorry res_adjust() doesn't work on VC6
+#else
+    std::cout << "res_adjust " << time_res_traits::res_adjust() << std::endl;
+#endif
+    if (time_duration::resolution() == boost::date_time::nano) {
+      check("millisec",  ms.fractional_seconds() == 9000000);
+      check("total_seconds - nofrac", ms.total_seconds() == 0);
+      check("total_millisec", ms.total_milliseconds() == 9);
+      check("ticks per second", time_duration::ticks_per_second() == 1000000000);
+    }
+    else {
+      check("millisec 9000",  ms.fractional_seconds() == 9000);
+      check("total_seconds - nofrac", ms.total_seconds() == 0);
+      check("total_millisec", ms.total_milliseconds() == 9);
+    }
+  }
+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+  if (time_duration::resolution() >= boost::date_time::nano) {
+    nanosec ns(9);
+    //  time_duration t_10(0,0,0,); //00:00:00.00009
+    check("nanosec",  ns.fractional_seconds() == 9);
+    check("total nanosec",  ns.total_nanoseconds() == 9);
+    check("total microsec - truncated",  ns.total_microseconds() == 0);
+    std::cout << to_simple_string(ns) << std::endl;
+    time_duration ns18 = ns + ns;
+    check("nanosec",  ns18.fractional_seconds() == 18);
+    std::cout << to_simple_string(ns18) << std::endl;
+    nanosec ns2(1000000000); //one second
+    check("nano to second compare",  ns2 == seconds(1));
+    check("check total seconds",  ns2.total_seconds() == 1);
+    std::cout << to_simple_string(ns2) << std::endl;
+    check("division of nanoseconds", (nanosec(3)/2) == nanosec(1));
+    check("multiplication of nanosec", nanosec(3)*1000 == microsec(3));
+  }
+#endif  
+
+  // Test for overflows (ticket #3471)
+  {
+    ptime start(boost::gregorian::date(2000, 1, 1));
+    ptime end(boost::gregorian::date(2000, 5, 1));
+    time_duration td = end - start;
+    ptime end2 = start + microseconds(td.total_microseconds());
+    check("microseconds constructor overflow", end == end2);
+  }
+
+  time_duration t_11(3600,0,0);
+  check("3600 hours   ",  t_11.hours() == 3600);
+  check("total seconds 3600 hours",  t_11.total_seconds() == 12960000);
+
+  time_duration td_12(1,2,3,10); 
+  std::cout << td_12.total_seconds() << std::endl;
+  check("total seconds 3723 hours",  td_12.total_seconds() == 3723);
+
+  //  time_duration t_11a = t_11/time_duration(0,3,0);
+
+  check("division", (hours(2)/2) == hours(1));
+  check("division", (hours(3)/2) == time_duration(1,30,0));
+  check("division", (hours(3)/3) == hours(1));
+  check("multiplication", time_duration(3,0,0)*2 == hours(6));
+  check("multiplication", hours(360)*1000 == hours(360000));
+
+  // special_values operations
+  time_duration pi_dur(pos_infin), ni_dur(neg_infin), ndt_dur(not_a_date_time);
+  check("+infin + -infin", pi_dur + ni_dur == ndt_dur);
+  check("infin / int", pi_dur / 3 == pi_dur);
+  check("infin + duration", pi_dur + td_12 == pi_dur);
+  check("infin - duration", pi_dur - td_12 == pi_dur);
+  check("unary-", -pi_dur == ni_dur);
+  check("-infin less than +infin", ni_dur < pi_dur);
+  check("-infin less than duration", ni_dur < td_12);
+  check("+infin greater than duration", pi_dur > td_12);
+  std::string result(""), answer("+infinity");
+  result = to_simple_string(pi_dur);
+  check("to string +infin", result==answer);
+  result = to_simple_string(ni_dur);
+  answer = "-infinity";
+  check("to string +infin", result==answer);
+  result = to_simple_string(ndt_dur);
+  //answer = "not-a-number";
+  answer = "not-a-date-time";
+  check("to string +infin", result==answer);
+ 
+  using namespace boost::gregorian;
+  ptime t1(date(2001,7,14));
+  ptime t2(date(2002,7,14));
+  check("One year of hours: 365*24=8760",  365*24 == ((t2-t1).hours()));
+  check("Total seconds in a year",  365*24*3600 == ((t2-t1).total_seconds()));
+
+  std::cout << to_simple_string(time_duration(20000 * 24, 0, 0, 0)) << std::endl;
+  std::cout << to_simple_string(time_duration(24855 * 24, 0, 0, 0)) << std::endl;
+  std::cout << to_simple_string(time_duration(24856 * 24, 0, 0, 0)) << std::endl;
+  std::cout << to_simple_string(time_duration(25000 * 24, 0, 0, 0)) << std::endl;
+  time_duration tdl1(25000*24, 0, 0, 0);
+  check("600000 hours", tdl1.hours() == 600000);
+  time_duration tdl2(2000000, 0, 0, 0);
+  check("2000000 hours", tdl2.hours() == 2000000);
+
+  check("total milliseconds", seconds(1).total_milliseconds() == 1000);
+  check("total microseconds", seconds(1).total_microseconds() == 1000000);
+  check("total nanoseconds", seconds(1).total_nanoseconds() == 1000000000);
+  check("total milliseconds", hours(1).total_milliseconds() == 3600*1000);
+  boost::int64_t tms = static_cast<boost::int64_t>(3600)*1000000*1001; //ms per sec
+  check("total microseconds 1000 hours", hours(1001).total_microseconds() == tms);
+  tms = static_cast<boost::int64_t>(3600)*365*24*1000;
+  check("total milliseconds - one year", (t2-t1).total_milliseconds() == tms);
+  tms = 3600*365*24*static_cast<boost::int64_t>(1000000000);
+  check("total nanoseconds - one year", (t2-t1).total_nanoseconds() == tms);
+#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+#else
+  std::cout << "tms: " << (t2-t1).total_milliseconds() << std::endl;
+  std::cout << "nano per year: " << (t2-t1).total_nanoseconds() << std::endl;
+#endif
+  // make it into a double
+  double d1 = microseconds(25).ticks()/(double)time_duration::ticks_per_second();
+  std::cout << d1 << std::endl;
+  
+  //Following causes errors on several compilers about value to large for
+  //type.  So it is commented out for now.  Strangely works on gcc 3.3
+  //eg: integer constant out of range
+//   long sec_in_200k_hours(7200000000); 
+//   check("total sec in 2000000 hours", 
+//         tdl2.total_seconds() == sec_in_200k_hours);
+//   std::cout << to_simple_string(time_duration(2000000, 0, 0, 0)) << std::endl;
+
+  
+  return printTestStats();
+
+}
+
+
diff --git a/src/boost/libs/date_time/test/posix_time/testfiletime_functions.cpp b/src/boost/libs/date_time/test/posix_time/testfiletime_functions.cpp
new file mode 100644
index 000000000..d931dc1a5
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testfiletime_functions.cpp
@@ -0,0 +1,90 @@
+/* Copyright (c) 2002,2003, 2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "../testfrmwk.hpp"
+#include "boost/date_time/filetime_functions.hpp"
+#include <cmath>
+
+#if defined(BOOST_HAS_FTIME)
+#include <windows.h>
+#endif
+
+int main() 
+{
+#if defined(BOOST_HAS_FTIME) // skip tests if no FILETIME
+
+  using namespace boost::posix_time;
+
+  // adjustor is used to truncate ptime's fractional seconds for 
+  // comparison with SYSTEMTIME's milliseconds
+  const time_duration::tick_type adjustor = time_duration::ticks_per_second() / 1000;
+  
+  for(int i = 0; i < 5; ++i){
+
+    FILETIME ft;
+    SYSTEMTIME st;
+    GetSystemTime(&st);
+    SystemTimeToFileTime(&st,&ft); 
+
+    ptime pt = from_ftime<ptime>(ft);
+
+    check_equal("ptime year matches systemtime year", 
+        st.wYear, pt.date().year());
+    check_equal("ptime month matches systemtime month", 
+        st.wMonth, pt.date().month());
+    check_equal("ptime day matches systemtime day", 
+        st.wDay, pt.date().day());
+    check_equal("ptime hour matches systemtime hour", 
+        st.wHour, pt.time_of_day().hours());
+    check_equal("ptime minute matches systemtime minute", 
+        st.wMinute, pt.time_of_day().minutes());
+    check_equal("ptime second matches systemtime second", 
+        st.wSecond, pt.time_of_day().seconds());
+    check_equal("truncated ptime fractional second matches systemtime millisecond", 
+        st.wMilliseconds, (pt.time_of_day().fractional_seconds() / adjustor));
+
+    // burn up a little time
+    for (int j=0; j<100000; j++)
+    {
+      SYSTEMTIME tmp;
+      GetSystemTime(&tmp);
+    }
+
+  } // for loop
+
+  // check that time_from_ftime works for pre-1970-Jan-01 dates, too
+  // zero FILETIME should represent 1601-Jan-01 00:00:00.000
+  FILETIME big_bang_by_ms;
+  big_bang_by_ms.dwLowDateTime = big_bang_by_ms.dwHighDateTime = 0;
+  ptime pt = from_ftime<ptime>(big_bang_by_ms);
+
+  check_equal("big bang ptime year matches 1601", 
+      1601, pt.date().year());
+  check_equal("big bang ptime month matches Jan", 
+      1, pt.date().month());
+  check_equal("big bang ptime day matches 1", 
+      1, pt.date().day());
+  check_equal("big bang ptime hour matches 0", 
+      0, pt.time_of_day().hours());
+  check_equal("big bang ptime minute matches 0", 
+      0, pt.time_of_day().minutes());
+  check_equal("big bang ptime second matches 0", 
+      0, pt.time_of_day().seconds());
+  check_equal("big bang truncated ptime fractional second matches 0", 
+      0, (pt.time_of_day().fractional_seconds() / adjustor));
+
+
+#else // BOOST_HAS_FTIME
+  // we don't want a forced failure here, not a shortcoming
+  check("FILETIME not available for this compiler/platform", true);
+#endif // BOOST_HAS_FTIME
+  
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testformatters.cpp b/src/boost/libs/date_time/test/posix_time/testformatters.cpp
new file mode 100644
index 000000000..74dae8888
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testformatters.cpp
@@ -0,0 +1,18 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "../testfrmwk.hpp"
+
+int
+main() 
+{
+  //This has been deprecated for testtime_formatters.cpp
+  return 0;
+
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testgreg_duration_operators.cpp b/src/boost/libs/date_time/test/posix_time/testgreg_duration_operators.cpp
new file mode 100644
index 000000000..005a61711
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testgreg_duration_operators.cpp
@@ -0,0 +1,85 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "../testfrmwk.hpp"
+
+
+int main(){
+
+#if !defined(BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES)
+  // do not set this test to return fail - 
+  // this is not necessarily a compiler problem
+  check("Optional gregorian types not selected - no tests run", true);
+#else
+
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+      
+
+  /*** months ***/
+  {
+    ptime p(date(2001, Oct, 31), hours(5));
+    check("ptime + months", 
+        ptime(date(2002, Feb, 28), hours(5)) == p + months(4));
+    p += months(4);
+    check("ptime += months", 
+        ptime(date(2002, Feb, 28), hours(5)) == p);
+  }
+  {
+    ptime p(date(2001, Oct, 31), hours(5));
+    check("ptime - months", 
+        ptime(date(2001, Apr, 30), hours(5)) == p - months(6));
+    p -= months(6);
+    check("ptime -= months", 
+        ptime(date(2001, Apr, 30), hours(5)) == p);
+  }
+
+  /*** years ***/
+  {
+    ptime p(date(2001, Feb, 28), hours(5));
+    check("ptime + years", 
+        ptime(date(2004, Feb, 29), hours(5)) == p + years(3));
+    p += years(3);
+    check("ptime += years", 
+        ptime(date(2004, Feb, 29), hours(5)) == p);
+  }
+  {
+    ptime p(date(2000, Feb, 29), hours(5));
+    check("ptime - years", 
+        ptime(date(1998, Feb, 28), hours(5)) == p - years(2));
+    p -= years(2);
+    check("ptime -= years", 
+        ptime(date(1998, Feb, 28), hours(5)) == p);
+  }
+
+  
+  /*** weeks ***/
+  // shouldn't need many tests, it is nothing more than a date_duration
+  // so all date_duration tests should prove this class
+  {
+    ptime p(date(2001, Feb, 28), hours(5));
+    check("ptime + weeks", 
+        ptime(date(2001, Mar, 21), hours(5)) == p + weeks(3));
+    p += weeks(3);
+    check("ptime += weeks", 
+        ptime(date(2001, Mar, 21), hours(5)) == p);
+  }
+  {
+    ptime p(date(2001, Feb, 28), hours(5));
+    check("ptime - weeks", 
+        ptime(date(2001, Feb, 14), hours(5)) == p - weeks(2));
+    p -= weeks(2);
+    check("ptime -= weeks", 
+        ptime(date(2001, Feb, 14), hours(5)) == p);
+  }
+
+#endif // BOOST_DATE_TIME_OPTIONAL_GREGORIAN_TYPES
+
+  return printTestStats();
+}
diff --git a/src/boost/libs/date_time/test/posix_time/testiterator.cpp b/src/boost/libs/date_time/test/posix_time/testiterator.cpp
new file mode 100644
index 000000000..47ebb603c
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testiterator.cpp
@@ -0,0 +1,135 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include <iostream>
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "../testfrmwk.hpp"
+#if defined(BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS)
+#include "boost/date_time/gregorian/formatters_limited.hpp"
+#else
+#include "boost/date_time/gregorian/formatters.hpp"
+#endif
+
+void iterate_backward(const boost::posix_time::ptime *answers, int ary_len, 
+    const boost::posix_time::time_duration& td)
+{
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+  
+  int i = ary_len -1;
+  ptime end = answers[i];
+  time_iterator titr(end,td);
+  
+  std::cout << "counting down by previous duration..." << std::endl;
+  for (; titr >= answers[0]; --titr) {
+    std::cout << *titr << std::endl;
+    check("iterating backward", answers[i] == *titr);
+    --i;
+  }
+  check("iterating backward count", i == -1); // check the number of iterations
+  std::cout << std::endl;
+}
+
+int
+main() 
+{
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+
+  date d(2000,Jan,20);
+  ptime start(d);
+  const ptime answer1[] = {ptime(d), ptime(d,seconds(1)),
+                           ptime(d,seconds(2)), ptime(d,seconds(3))};
+  int i=0;
+  time_iterator titr(start,seconds(1)); 
+  for (; titr < ptime(d,seconds(4)); ++titr) {
+    std::cout << *titr << std::endl;
+    check("iterator -- 1 sec", answer1[i] == *titr);
+    i++;
+  }
+  check("iterator -- 1 sec", i == 4); // check the number of iterations
+
+  iterate_backward(answer1, 4, seconds(1));
+
+  //iterate by hours
+  const ptime answer2[] = {ptime(d), ptime(d,hours(1)),
+                           ptime(d,hours(2)), ptime(d,hours(3))};
+  i=0;
+  time_iterator titr2(start,hours(1)); 
+  for (; titr2 < ptime(d,hours(4)); ++titr2) {
+    std::cout << *titr2 << std::endl;
+    check("iterator -- 1 hour", answer2[i] == *titr2);
+    i++;
+  }
+  check("iterator -- 1 hour", i == 4); // check the number of iterations
+
+  iterate_backward(answer2, 4, hours(1));
+
+
+  //iterate by 15 mintues
+  const ptime answer3[] = {ptime(d), ptime(d,minutes(15)),
+                           ptime(d,minutes(30)), ptime(d,minutes(45)),
+                           ptime(d,minutes(60)), ptime(d,minutes(75))};
+  i=0;
+  time_iterator titr3(start,minutes(15)); 
+  for (; titr3 < ptime(d,time_duration(1,20,0)); ++titr3) {
+    std::cout << *titr3 << std::endl;
+    check("iterator -- 15 min", answer3[i] == *titr3);
+    i++;
+  }
+  check("iterator -- 15 min", i == 6); // check the number of iterations
+
+  iterate_backward(answer3, 6, minutes(15));
+
+  //iterate by .1 seconds
+  const ptime answer4[] = {ptime(d), ptime(d,time_duration(0,0,0,1000)),
+                           ptime(d,time_duration(0,0,0,2000)),
+                           ptime(d,time_duration(0,0,0,3000))};
+  i=0;
+  time_iterator titr4(start,time_duration(0,0,0,1000)); 
+  for (; titr4 < ptime(d,time_duration(0,0,0,4000)); ++titr4) {
+    std::cout << *titr4 << std::endl;
+    check("iterator -- tenth sec", answer4[i] == *titr4);
+    i++;
+  }
+  check("iterator -- tenth sec", i == 4); // check the number of iterations
+
+  iterate_backward(answer4, 4, time_duration(0,0,0,1000));
+
+  //iterate by crazy duration
+  time_duration crzyd = duration_from_string("2:18:32.423"); 
+  const ptime answer5[] = {ptime(d), ptime(d,crzyd),
+                           ptime(d, crzyd * 2),
+                           ptime(d, crzyd * 3)};
+  i=0;
+  time_iterator titr5(start,crzyd); 
+  for (; titr5 < ptime(d,crzyd * 4); ++titr5) {
+    std::cout << *titr5 << std::endl;
+    check("iterator -- crazy duration", answer5[i] == *titr5);
+    i++;
+  }
+  check("iterator -- crazy duration", i == 4); // check the number of iterations
+
+  iterate_backward(answer5, 4, crzyd);
+
+  //iterate up by neg_dur
+  time_duration pos_dur = minutes(3);
+  time_duration neg_dur = -pos_dur;
+  time_iterator up_itr(start, neg_dur), dn_itr(start, pos_dur);
+
+  for(i=0; i < 10; ++i)
+  {
+    check("up-by-neg == backward iterate", *up_itr == *dn_itr);
+    ++up_itr; // up by -3
+    --dn_itr; // down by 3
+  }
+  
+ 
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testlocal_adjustor.cpp b/src/boost/libs/date_time/test/posix_time/testlocal_adjustor.cpp
new file mode 100644
index 000000000..a9f434079
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testlocal_adjustor.cpp
@@ -0,0 +1,175 @@
+/* Copyright (c) 2002,2003, 2007 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/date_time/local_time_adjustor.hpp"
+#include "boost/date_time/local_timezone_defs.hpp"
+#include "../testfrmwk.hpp"
+
+int
+main() 
+{
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+
+  date dst_start(2002,Apr, 7);
+  date dst_end_day(2002,Oct, 27);  
+
+  typedef boost::date_time::utc_adjustment<time_duration,-5> us_eastern_offset_adj;
+  //Type that embeds rules for UTC-5 plus DST offset
+  typedef boost::date_time::static_local_time_adjustor<ptime, 
+                                                  us_dst, 
+                                                  us_eastern_offset_adj> us_eastern;
+  
+  //test some times clearly not in DST
+  date d3(2002,Feb,1);
+  ptime t10(d3, hours(4));
+  ptime t10_check(d3, hours(9)); //utc is 5 hours ahead
+  time_duration td = us_eastern::local_to_utc_offset(t10);//dst flag is defaulted
+  check("check local calculation",   td == hours(5));
+  ptime t10_local = t10 + td;
+  std::cout << t10_local << std::endl;
+  check("check local calculation",   t10_local == t10_check);
+  check("check utc is dst",          
+        us_eastern::utc_to_local_offset(t10) == hours(-5));
+  
+
+  //something clearly IN dst
+  date d4(2002,May,1);
+  ptime t11(d4, hours(3));
+  check("check local offset",us_eastern::local_to_utc_offset(t11) == hours(4));
+  std::cout << us_eastern::local_to_utc_offset(t11) << std::endl;
+  ptime t11_check(d4, hours(7));//now utc offset is only 4 hours
+  ptime t11_local = t11 + us_eastern::local_to_utc_offset(t11);
+  std::cout << t11_local << " " << t11_check << std::endl;
+  check("check local calculation", t11_local == t11_check);
+  //should get same offset with DST flag set
+  check("check local offset-dst flag on",   
+        us_eastern::local_to_utc_offset(t11, boost::date_time::is_dst) == hours(4));
+  check("check local offset-dst flag override",   
+        us_eastern::local_to_utc_offset(t11, boost::date_time::not_dst) == hours(5));
+ 
+
+  //Check the start of dst boundary
+  ptime l_not_dst(dst_start, time_duration(1,59,59)); //2002-Apr-07 01:59:59
+  check("check local dst start boundary case",   
+        us_eastern::local_to_utc_offset(l_not_dst) == hours(5));
+  ptime u_not_dst(dst_start, time_duration(6,59,59));
+  check("check utc dst start boundary case",   
+        us_eastern::utc_to_local_offset(u_not_dst) == hours(-5));
+  ptime l_in_dst(dst_start, hours(3)); //2002-Apr-07 03:00:00 1st sec of dst
+  check("check local dst start boundary case",   
+        us_eastern::local_to_utc_offset(l_in_dst, boost::date_time::is_dst) == hours(4));
+  ptime u_in_dst(dst_start, hours(7));
+  check("check utc dst start boundary case",   
+        us_eastern::utc_to_local_offset(u_in_dst) == hours(-4));
+
+
+  //Check the end of dst boundary
+  ptime dst_end(dst_end_day, time_duration(1,59,59)); //2002-Oct-27 01:00:00 DST
+  check("check local dst end boundary case - still dst",   
+        us_eastern::local_to_utc_offset(dst_end, boost::date_time::is_dst) == hours(4));
+  check("check local dst end boundary case - still dst",   
+        us_eastern::local_to_utc_offset(dst_end, boost::date_time::not_dst) == hours(5));
+  ptime u_dst_end1(dst_end_day, time_duration(5,59,59));
+  check("check utc dst end boundary case",   
+        us_eastern::utc_to_local_offset(u_dst_end1) == hours(-4));
+  ptime u_dst_end2(dst_end_day, time_duration(6,0,0));
+  check("check utc dst end boundary case",   
+        us_eastern::utc_to_local_offset(u_dst_end2) == hours(-5));
+  ptime u_dst_end3(dst_end_day, time_duration(6,59,59));
+  check("check utc dst end boundary case",   
+        us_eastern::utc_to_local_offset(u_dst_end3) == hours(-5));
+  ptime u_dst_end4(dst_end_day, time_duration(7,0,0));
+  check("check utc dst end boundary case",   
+        us_eastern::utc_to_local_offset(u_dst_end4) == hours(-5));
+  
+
+  //Now try a local adjustments without dst
+  typedef boost::date_time::utc_adjustment<time_duration,-7> us_az_offset_adj;
+  typedef boost::date_time::null_dst_rules<date, time_duration> us_az_dst_adj;
+  //Type that embeds rules for UTC-7 with no dst
+  typedef boost::date_time::static_local_time_adjustor<ptime, 
+                                                  us_az_dst_adj, 
+                                                  us_az_offset_adj> us_az;
+
+  check("check local offset - no dst",   
+        us_az::local_to_utc_offset(t10) == hours(7));
+  check("check local offset - no dst",   
+        us_az::local_to_utc_offset(t11) == hours(7));
+  check("check local offset - no dst",   
+        us_az::utc_to_local_offset(t10) == hours(-7));
+  check("check local offset - no dst",   
+        us_az::utc_to_local_offset(t11) == hours(-7));
+
+
+  //Arizona timezone is utc-7 with no dst
+  typedef boost::date_time::local_adjustor<ptime, -7, no_dst> us_arizona;
+
+  ptime t7(date(2002,May,31), hours(17)); 
+  ptime t8 = us_arizona::local_to_utc(t7);
+  ptime t9 = us_arizona::utc_to_local(t8);
+  //converted to local then back ot utc
+  check("check us_local_adjustor", t9 == t7);
+
+  typedef boost::date_time::local_adjustor<ptime, -5, us_dst> us_eastern2;
+
+  {
+    ptime t7a(date(2002,May,31), hours(17)); 
+    ptime t7b = us_eastern2::local_to_utc(t7a);
+    ptime t7c = us_eastern2::utc_to_local(t7b);
+    //converted to local then back ot utc
+    check("check us_local_adjustor", t7c == t7a);
+  }
+
+  typedef boost::date_time::us_dst_trait<date> us_dst_traits;
+  typedef boost::date_time::dst_calc_engine<date, time_duration, us_dst_traits>
+    us_dst_calc2;
+
+  typedef boost::date_time::local_adjustor<ptime, -5, us_dst_calc2> us_eastern3;
+  {
+    ptime t7a(date(2002,May,31), hours(17)); 
+    ptime t7b = us_eastern3::local_to_utc(t7a);
+    ptime t7c = us_eastern3::utc_to_local(t7b);
+    //converted to local then back ot utc
+    check("check us_local_adjustor3", t7c == t7a);
+  }
+
+  {
+    ptime t7a(date(2007,Mar,11), hours(4)); 
+    ptime t7b = us_eastern3::local_to_utc(t7a);
+    ptime t7c = us_eastern3::utc_to_local(t7b);
+    //converted to local then back ot utc
+    check("check us_local_adjustor3 2007", t7c == t7a);
+  }
+
+  {
+    ptime t7a(date(2007,Mar,11), hours(3)); 
+    ptime t7b = us_eastern3::local_to_utc(t7a);
+    ptime t7c = us_eastern3::utc_to_local(t7b);
+    //converted to local then back ot utc
+    check("check us_local_adjustor3 2007 a", t7c == t7a);
+  }
+
+  //still experimental
+  typedef boost::date_time::dynamic_local_time_adjustor<ptime, us_dst> lta;
+//  lta adjustor(hours(-7));
+  check("dst start", lta::local_dst_start_day(2002) == dst_start);
+  check("dst end",   lta::local_dst_end_day(2002) == dst_end_day);
+  check("dst boundary",   lta::is_dst_boundary_day(dst_start));
+  check("dst boundary",   lta::is_dst_boundary_day(dst_end_day));
+//   check("check non-dst offset",   adjustor.utc_offset(false)==hours(-7));
+//   check("check dst offset",   adjustor.utc_offset(true)==hours(-6));
+  
+
+  check("dst start", lta::local_dst_start_day(2007) == date(2007,Mar,11));
+  check("dst end",   lta::local_dst_end_day(2007) == date(2007,Nov,4));
+
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testmicrosec_time_clock.cpp b/src/boost/libs/date_time/test/posix_time/testmicrosec_time_clock.cpp
new file mode 100644
index 000000000..8f0553ab3
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testmicrosec_time_clock.cpp
@@ -0,0 +1,139 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+ */
+
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/date_time/microsec_time_clock.hpp"
+#include "../testfrmwk.hpp"
+#if defined(BOOST_HAS_FTIME)
+#include <windows.h>
+#endif
+
+void
+sync_to_next_second()
+{
+  using namespace boost::posix_time;
+
+  ptime t_prev;
+  ptime t_now = second_clock::local_time();
+
+  // Wait the next seconds
+  do
+  {
+    t_prev = t_now;
+    t_now = second_clock::local_time();
+  } while (t_now.time_of_day().seconds() == t_prev.time_of_day().seconds());
+
+  // Wait 300ms in order to avoid seconds of second_clock > microsec_clock.
+  t_now = microsec_clock::local_time();
+  t_prev = t_now;
+  do
+  {
+    t_now = microsec_clock::local_time();
+  } while (t_now - t_prev < milliseconds(300));
+
+}
+
+
+int
+main()
+{
+#ifdef BOOST_DATE_TIME_HAS_HIGH_PRECISION_CLOCK
+
+  using namespace boost::posix_time;
+
+  std::cout << "Check local time of microsec_clock against second_clock" << std::endl;
+
+  ptime last = microsec_clock::local_time();
+  int max = 30;
+  for (int i=0; i<max; i++)
+  {
+    // Some systems loop too fast so "last is less" tests fail due to
+    // 'last' & 't2' being equal. These calls slow it down enough to
+    // make 'last' & 't2' different. Moreover, we must wait the next
+    // second to avoid a change in hour, minute or second field
+    // between acquisition of t1 and t2.
+    sync_to_next_second();
+
+    ptime t1 = second_clock::local_time();
+    std::cout << t1 << std::endl;
+
+    ptime t2 = microsec_clock::local_time();
+    std::cout << t2 << std::endl;
+
+    check("check equality of hours "
+          "between second_clock and microsec_clock timestamps",
+          t1.time_of_day().hours() == t2.time_of_day().hours());
+
+    check("check equality of minutes "
+          "between second_clock and microsec_clock timestamps",
+          t1.time_of_day().minutes() == t2.time_of_day().minutes());
+
+    check("check equality of seconds "
+          "between second_clock and microsec_clock timestamps",
+          t1.time_of_day().seconds() == t2.time_of_day().seconds());
+
+    check("check equality of date"
+          "between second_clock and microsec_clock timestamps",
+          t1.date() == t2.date());
+
+    if( !check("check that previous microsec_clock timestamp "
+               "is less than the current", last < t2) ) {
+      std::cout << last << " < " << t2 << std::endl;
+    }
+
+    last = t2;
+  }
+
+
+  std::cout << "Check universal time of microsec_clock against second_clock" << std::endl;
+  max = 10;
+  last = microsec_clock::universal_time();
+  for (int i=0; i<max; i++)
+  {
+    // Some systems loop too fast so "last is less" tests fail due to
+    // 'last' & 't2' being equal. These calls slow it down enough to
+    // make 'last' & 't2' different. Moreover, we must wait the next
+    // second to avoid a change in hour, minute or second field
+    // between acquisition of t1 and t2.
+    sync_to_next_second();
+
+    ptime t1 = second_clock::universal_time();
+    std::cout << t1 << std::endl;
+
+    ptime t2 = microsec_clock::universal_time();
+    std::cout << t2 << std::endl;
+
+    check("check equality of hours "
+          "between second_clock and microsec_clock timestamps",
+          t1.time_of_day().hours() == t2.time_of_day().hours());
+
+    check("check equality of minutes "
+          "between second_clock and microsec_clock timestamps",
+          t1.time_of_day().minutes() == t2.time_of_day().minutes());
+
+    check("check equality of seconds "
+          "between second_clock and microsec_clock timestamps",
+          t1.time_of_day().seconds() == t2.time_of_day().seconds());
+
+    check("check equality of date"
+          "between second_clock and microsec_clock timestamps",
+          t1.date() == t2.date());
+
+    if( !check("check that previous microsec_clock timestamp "
+               "is less than the current", last < t2) ) {
+      std::cout << last << " < " << t2 << std::endl;
+    }
+
+    last = t2;
+  }
+
+#else
+  check("Get time of day micro second clock not supported due to inadequate compiler/platform", false);
+#endif
+  return printTestStats();
+
+}
diff --git a/src/boost/libs/date_time/test/posix_time/testparse_time.cpp b/src/boost/libs/date_time/test/posix_time/testparse_time.cpp
new file mode 100644
index 000000000..faa5a8640
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testparse_time.cpp
@@ -0,0 +1,280 @@
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "../testfrmwk.hpp"
+
+
+int 
+main()
+{
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+  {
+  std::string s1("12:11:10.123456789");
+  time_duration td1= duration_from_string(s1);
+  check("parse time duration: " + s1, 
+        td1 == time_duration(12,11,10,123456789));
+  std::string s2("12:11:10,123456789");
+  time_duration td2= boost::date_time::parse_delimited_time_duration<time_duration>(s2);
+  check("parse time duration: " + s2, 
+        td2 == time_duration(12,11,10,123456789));
+  std::string s3("12:11:10");
+  time_duration td3= boost::date_time::parse_delimited_time_duration<time_duration>(s3);
+  check("parse time duration: " + s3, 
+        td3 == time_duration(12,11,10,0));
+  std::string s4("23:59:59.000000001");
+  time_duration td4= boost::date_time::parse_delimited_time_duration<time_duration>(s4);
+  check("parse time duration: " + s4, 
+        td4 == time_duration(23,59,59)+nanosec(1));
+  std::string s5("23:59:59.999999999");
+  time_duration td5= boost::date_time::parse_delimited_time_duration<time_duration>(s5);
+  check("parse time duration: " + s5, 
+        td5 == time_duration(23,59,59)+nanosec(999999999));
+  std::string s5b("-23:59:59.999999999");
+  time_duration td5b= boost::date_time::parse_delimited_time_duration<time_duration>(s5b);
+  check("parse time duration: " + s5b, 
+        td5b == time_duration(-23,59,59)-nanosec(999999999));
+  
+  std::string s6b("1:00:00.1"); // we want 1/10th
+  time_duration td6b= boost::date_time::parse_delimited_time_duration<time_duration>(s6b);
+  check("parse time duration: " + s6b, 
+        td6b == time_duration(1,0,0)+nanosec(100000000)); // we want 1/10th
+  
+  std::string s7b("-1:00:00.0010"); // we want 1/1000th
+  time_duration td7b= boost::date_time::parse_delimited_time_duration<time_duration>(s7b);
+  check("parse time duration: " + s7b, 
+        td7b == time_duration(-1,0,0)-nanosec(1000000)); // we want 1/1000th
+  
+  std::string s8b("1:22:33.123456789321"); // too many digits
+  time_duration td8b= boost::date_time::parse_delimited_time_duration<time_duration>(s8b);
+  check("parse time duration: " + s8b, 
+        td8b == time_duration(1,22,33,123456789)); // excess digits should be dropped
+  }
+  {
+
+    std::string s3("12:11:10");
+    time_duration td3= boost::date_time::parse_delimited_time_duration<time_duration>(s3);
+    check("parse time duration: " + s3, 
+          td3 == time_duration(12,11,10,0));
+    std::string s4("23:59:59.000001");
+    time_duration td4= boost::date_time::parse_delimited_time_duration<time_duration>(s4);
+    check("parse time duration: " + s4, 
+          td4 == time_duration(23,59,59)+microsec(1));
+    std::string s5("23:59:59.999999");
+    time_duration td5= boost::date_time::parse_delimited_time_duration<time_duration>(s5);
+    check("parse time duration: " + s5, 
+          td5 == time_duration(23,59,59)+microsec(999999));
+    std::string s5b("-23:59:59.999999");
+    time_duration td5b= boost::date_time::parse_delimited_time_duration<time_duration>(s5b);
+    check("parse time duration: " + s5b, 
+          td5b == time_duration(-23,59,59)-microsec(999999));
+  
+    std::string s6b("1:00:00.1"); // we want 1/10th
+    time_duration td6b= boost::date_time::parse_delimited_time_duration<time_duration>(s6b);
+    check("parse time duration: " + s6b,
+          td6b == time_duration(1,0,0)+microsec(100000)); // we want 1/10th
+    
+    std::string s7b("-1:00:00.0010"); // we want 1/1000th
+    time_duration td7b= boost::date_time::parse_delimited_time_duration<time_duration>(s7b);
+    check("parse time duration: " + s7b, 
+          td7b == time_duration(-1,0,0)-microsec(1000)); // we want 1/1000th
+
+  }
+
+  {
+    std::string ts2("2002-12-31 00:00:00.999999999");
+    ptime t2 = time_from_string(ts2);
+    check("parse time: " + ts2, 
+          t2 == ptime(date(2002,12,31),time_duration(0,0,0)+nanosec(999999999)));
+  }
+  {
+    std::string ts2("2002-12-31 00:00:00.");
+    ptime t2 = time_from_string(ts2);
+    check("parse time (decimal but no digits): " + ts2, 
+          t2 == ptime(date(2002,12,31),time_duration(0,0,0)));
+  }
+#endif
+
+  if (time_duration::resolution() != boost::date_time::nano)
+  {
+
+    std::string s1("12:11:10.123456");
+    time_duration td1= duration_from_string(s1);
+    check("parse time duration: " + s1,
+          td1 == time_duration(12,11,10,123456));
+    std::cout << "td1: " << td1 << std::endl;
+
+    std::string s2("12:11:10,123456");
+    time_duration td2= boost::date_time::parse_delimited_time_duration<time_duration>(s2);
+    check("parse time duration: " + s2,
+          td2 == time_duration(12,11,10,123456));
+    std::cout << "td2: " << td2 << std::endl;
+
+    //truncate for non-nanosecond case
+    std::string s8b("1:22:33.123456321"); // too many digits
+    time_duration td8b= boost::date_time::parse_delimited_time_duration<time_duration>(s8b);
+    check("parse time duration: " + s8b,
+          td8b == time_duration(1,22,33,123456)); // excess digits should be dropped
+  }
+
+
+  std::string date_1, tod_1;
+  std::string ts1("2002-01-20 23:59:59.000");
+  boost::date_time::split(ts1, ' ', date_1, tod_1);
+  check("split function date part of " + ts1, 
+        date_1 == std::string("2002-01-20"));
+  check("time part of " + ts1, 
+        tod_1 == std::string("23:59:59.000"));
+//   std::cout << date_1 << "|" << std::endl;
+//   std::cout << tod_1  << "|" << std::endl;
+
+
+  {
+    ptime t1 = time_from_string(ts1);
+    check("parse time: " + ts1, 
+          t1 == ptime(date(2002,1,20),time_duration(23,59,59)));
+  }
+  {
+    std::string ts1x("2002-01-20 23:59:59.");
+    ptime t1 = time_from_string(ts1x);
+    check("parse time (decimal but no digits): " + ts1x, 
+          t1 == ptime(date(2002,1,20),time_duration(23,59,59)));
+  }
+
+  std::string s6("235859");
+  time_duration td6= boost::date_time::parse_undelimited_time_duration<time_duration>(s6);
+  check("parse time duration: " + s6, 
+        td6 == time_duration(23,58,59));
+
+  s6 = "-235859";
+  td6= boost::date_time::parse_undelimited_time_duration<time_duration>(s6);
+  check("parse negative time duration: " + s6, 
+        td6 == time_duration(-23,58,59));
+
+  {
+    std::string ts3("20020120T235859");
+    ptime t20 = from_iso_string(ts3);
+    check("parse iso time: " + ts3, 
+          t20 == ptime(date(2002,1,20),time_duration(23,58,59)));
+  }  
+
+  {
+    std::string ts4("19001231T000000");
+    ptime t21 = from_iso_string(ts4);
+    check("parse iso time: " + ts4, 
+          t21 == ptime(date(1900,12,31),time_duration(0,0,0)));
+  }
+
+  {
+    std::string ts5("19001231T23");
+    ptime t22 = from_iso_string(ts5);
+    check("parse iso time: " + ts5, 
+          t22 == ptime(date(1900,12,31),time_duration(23,0,0)));
+  }
+
+  {
+#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+    std::string ts3("20020120T235859.123456789");
+    ptime t20 = from_iso_string(ts3);
+    check("parse iso time w/ frac sec: " + ts3, 
+          t20 == ptime(date(2002,1,20),time_duration(23,58,59,123456789)));
+    
+    std::string ts4("19001231T000000.123");
+    ptime t21 = from_iso_string(ts4);
+    check("parse iso time w/ frac sec (too short): " + ts4, 
+          t21 == ptime(date(1900,12,31),time_duration(0,0,0,123000000)));
+
+    std::string ts5("19001231T230000.123456789876");
+    ptime t22 = from_iso_string(ts5);
+    check("parse iso time w/ frac sec (too long): " + ts5, 
+          t22 == ptime(date(1900,12,31),time_duration(23,0,0,123456789)));
+
+    std::string ts6("19001231T230000.");
+    ptime t23 = from_iso_string(ts6);
+    check("parse iso time w/ frac sec (dec only): " + ts6, 
+          t23 == ptime(date(1900,12,31),time_duration(23,0,0,0)));
+
+    std::string ts7("2002-01-20T23:58:59.123456789");
+    ptime t24 = from_iso_extended_string(ts7);
+    check("parse iso extended time w/ frac sec: " + ts7,
+          t24 == ptime(date(2002,1,20),time_duration(23,58,59,123456789)));
+
+    std::string ts8("1900-12-31T00:00:00.123");
+    ptime t25 = from_iso_extended_string(ts8);
+    check("parse iso extended time w/ frac sec (too short): " + ts8,
+          t25 == ptime(date(1900,12,31),time_duration(0,0,0,123000000)));
+
+    std::string ts9("1900-12-31T23:00:00.123456789876");
+    ptime t26 = from_iso_extended_string(ts9);
+    check("parse iso extended time w/ frac sec (too long): " + ts9,
+          t26 == ptime(date(1900,12,31),time_duration(23,0,0,123456789)));
+
+    std::string ts10("1900-12-31T23:00:00.");
+    ptime t27 = from_iso_extended_string(ts10);
+    check("parse iso extended time w/ frac sec (dec only): " + ts10,
+          t27 == ptime(date(1900,12,31),time_duration(23,0,0,0)));
+#else
+    std::string ts3("20020120T235859.123456");
+    ptime t20 = from_iso_string(ts3);
+    check("parse iso time w/ frac sec: " + ts3, 
+          t20 == ptime(date(2002,1,20),time_duration(23,58,59,123456)));
+    
+    std::string ts4("19001231T000000.123");
+    ptime t21 = from_iso_string(ts4);
+    check("parse iso time w/ frac sec (too short): " + ts4, 
+          t21 == ptime(date(1900,12,31),time_duration(0,0,0,123000)));
+
+    std::string ts5("19001231T230000.123456789876");
+    ptime t22 = from_iso_string(ts5);
+    check("parse iso time w/ frac sec (too long): " + ts5, 
+          t22 == ptime(date(1900,12,31),time_duration(23,0,0,123456)));
+
+    std::string ts6("19001231T230000.");
+    ptime t23 = from_iso_string(ts6);
+    check("parse iso time w/ frac sec (dec only): " + ts6, 
+          t23 == ptime(date(1900,12,31),time_duration(23,0,0,0)));
+
+    std::string ts7("2002-01-20T23:58:59.123456");
+    ptime t24 = from_iso_extended_string(ts7);
+    check("parse iso extended time w/ frac sec: " + ts7,
+          t24 == ptime(date(2002,1,20),time_duration(23,58,59,123456)));
+
+    std::string ts8("1900-12-31T00:00:00.123");
+    ptime t25 = from_iso_extended_string(ts8);
+    check("parse iso extended time w/ frac sec (too short): " + ts8,
+          t25 == ptime(date(1900,12,31),time_duration(0,0,0,123000)));
+
+    std::string ts9("1900-12-31T23:00:00.123456789876");
+    ptime t26 = from_iso_extended_string(ts9);
+    check("parse iso extended time w/ frac sec (too long): " + ts9,
+          t26 == ptime(date(1900,12,31),time_duration(23,0,0,123456)));
+
+    std::string ts10("1900-12-31T23:00:00.");
+    ptime t27 = from_iso_extended_string(ts10);
+    check("parse iso extended time w/ frac sec (dec only): " + ts10,
+          t27 == ptime(date(1900,12,31),time_duration(23,0,0,0)));
+#endif // BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+  }
+
+  std::string s7("-01:25:00"), s8("-00:40:00"), s9("0:45"), s10("0:-40");
+  time_duration tds1 = duration_from_string(s7);
+  time_duration tds2 = duration_from_string(s8);
+  time_duration tds3 = duration_from_string(s9);
+  time_duration tds4 = duration_from_string(s10);
+  check("from string construct", tds1 == time_duration(-1,25,0));
+  check("from string construct", tds2 == minutes(-40));
+  check("from string construct", tds3 == minutes(45));
+  // '-' in middle of string s10 should be ignored resulting in pos duration
+  check("from string construct", tds4 == minutes(40));
+
+  return printTestStats();
+ 
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testperiod.cpp b/src/boost/libs/date_time/test/posix_time/testperiod.cpp
new file mode 100644
index 000000000..211412e60
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testperiod.cpp
@@ -0,0 +1,22 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include <iostream>
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/date_time/posix_time/time_period.hpp"
+#include "../testfrmwk.hpp"
+
+int main() 
+{
+
+  //FILE OBSOLETE: replace by testtime_period.cpp
+  
+  return 1;
+  //  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/teststreams.cpp b/src/boost/libs/date_time/test/posix_time/teststreams.cpp
new file mode 100644
index 000000000..c772faebe
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/teststreams.cpp
@@ -0,0 +1,179 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "../testfrmwk.hpp"
+
+#ifndef BOOST_DATE_TIME_NO_LOCALE
+
+const char* const de_short_month_names[]={"Jan","Feb","Mar","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez", "NAM"};
+
+const char* const de_long_month_names[]={"Januar","Februar","Marz","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember","NichtDerMonat"};
+const char* const de_special_value_names[]={"NichtDatumzeit","-unbegrenztheit", "+unbegrenztheit"};
+
+const char* const de_short_weekday_names[]={"Son", "Mon", "Die","Mit", "Don", "Fre", "Sam"};
+
+const char* const de_long_weekday_names[]={"Sonntag", "Montag", "Dienstag","Mittwoch", "Donnerstag", "Freitag", "Samstag"};
+
+#endif
+
+int
+main() 
+{
+#ifndef BOOST_DATE_TIME_NO_LOCALE
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+  std::stringstream ss;
+  date d1(2002,May,1);
+  ptime t1(d1, hours(12)+minutes(10)+seconds(5));
+  time_duration td0(12,10,5,123);
+  ptime t0(d1, td0);
+  ss << t0;
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+  check("check time output: "+ss.str(), 
+        ss.str() == std::string("2002-May-01 12:10:05.000000123"));
+#else
+  check("check time output: "+ss.str(), 
+        ss.str() == std::string("2002-May-01 12:10:05.000123"));
+#endif // BOOST_DATE_TIME_HAS_NANOSECONDS
+  //  ss.imbue(global); 
+  time_period tp(t1, ptime(d1, hours(23)+time_duration::unit()));
+  ss.str("");
+  ss << tp;
+  check("check time period output: "+ ss.str(), 
+        ss.str() == std::string("[2002-May-01 12:10:05/2002-May-01 23:00:00]"));
+
+  //Send out the same time with german
+  typedef boost::date_time::all_date_names_put<greg_facet_config> date_facet;
+ 
+  ss.imbue(std::locale(std::locale::classic(),
+                       new date_facet(de_short_month_names, 
+                                      de_long_month_names,
+                                      de_special_value_names,
+                                      de_short_weekday_names,
+                                      de_long_weekday_names,
+                                      '.',
+                                      boost::date_time::ymd_order_dmy,
+                                      boost::date_time::month_as_short_string))); 
+  ss.str("");
+  ss << t1;
+  check("check time output: "+ ss.str(), 
+        ss.str() == std::string("01.Mai.2002 12:10:05"));
+
+
+  time_duration td(5,4,3);
+  time_duration td1(-1,25,0), td2(0,-40,0);
+  ss.str("");
+  ss << td;
+  check("check time period output: "+ ss.str(), 
+        ss.str() == std::string("05:04:03"));
+  ss.str("");
+  ss << td1;
+  check("check time period output: "+ ss.str(), 
+        ss.str() == std::string("-01:25:00"));
+  ss.str("");
+  ss << td2;
+  check("check time period output: "+ ss.str(), 
+        ss.str() == std::string("-00:40:00"));
+
+
+  ss.str("");
+  ss << tp;
+  check("check time period output - german: "+ ss.str(), 
+        ss.str() == std::string("[01.Mai.2002 12:10:05/01.Mai.2002 23:00:00]"));
+
+  /* Input streaming is only available for compilers that  
+   * do not have BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS defined */
+#ifndef BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS
+  
+  /****** test streaming in for time classes ******/
+  {
+    std::istringstream iss("01:02:03.000004 garbage");
+    iss >> td;
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+    check("Stream in time_duration", td == time_duration(1,2,3,4000));
+#else
+    check("Stream in time_duration", td == time_duration(1,2,3,4));
+#endif
+  }
+#if !defined(BOOST_NO_STD_ITERATOR_TRAITS) // vc6 & vc7
+  {
+    std::istringstream iss("2003-May-13 01:02:03");
+    iss >> t1;
+    check("Stream in ptime", t1 == ptime(date(2003,May,13), time_duration(1,2,3)));
+    std::istringstream iss2("2003-January-13 01:02:03");
+    iss2 >> t1;
+    check("Stream in ptime2", t1 == ptime(date(2003,Jan,13), time_duration(1,2,3)));
+    std::istringstream iss3("2003-feb-13 11:10:09");
+    iss3 >> t1;
+    check("Stream in ptime3", t1 == ptime(date(2003,Feb,13), time_duration(11,10,9)));
+
+    try {
+      std::istringstream iss4("2003-xxx-13 11:10:09");
+      iss3 >> t1;
+      check("Stream bad ptime", false); //never reach here, bad month exception
+    }
+    catch(std::exception& e) {
+      std::cout << "Got expected exception: " << e.what() << std::endl;
+      check("Stream bad ptime", true); 
+    }
+
+  }
+  {
+    date d1x(2001,Aug,1), d2x(2003,May,13);
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+    time_duration td1x(15,32,18,20304000), td2x(1,2,3);
+#else
+    time_duration td1x(15,32,18,20304), td2x(1,2,3);
+#endif
+
+    time_period result(ptime(d1x,td1x), ptime(d2x,td2x));
+    std::istringstream iss("[2001-Aug-01 15:32:18.020304/2003-May-13 01:02:03]");
+    iss >> tp;
+    check("Stream in time_period", tp == result);
+  }
+
+#if !defined(BOOST_NO_STD_WSTRING)
+  /*** wide streaming ***/
+  {
+    std::wistringstream wiss1(L"01:02:03");//.000004");
+    wiss1 >> td;
+    check("Wide stream in time_duration", td == time_duration(1,2,3));
+    
+    std::wistringstream wiss2(L"2003-May-23 03:20:10");
+    wiss2 >> t1;
+    check("Wide stream in ptime", t1 == ptime(date(2003,May,23), time_duration(3,20,10)));
+    
+    std::wistringstream wiss3(L"[2004-Jan-01 02:03:04/2004-May-13 01:00:00]");
+    wiss3 >> tp;
+    date d1x = date(2004,Jan,1);
+    date d2x = date(2004,May,13);
+    time_duration td1x = time_duration(2,3,4);
+    time_duration td2x = time_duration(1,0,0);
+    time_period result = time_period(ptime(d1x,td1x), ptime(d2x,td2x));
+    check("Wide stream in time_period", tp == result);
+  }
+#else
+  check("Wide streaming not available for this compiler", false);
+#endif // BOOST_NO_STD_WSTRING
+
+#else  // BOOST_NO_STD_ITERATOR_TRAITS
+  check("Streaming in of alphabetic dates (Ex: 2003-Aug-21) \
+      not supported by this compiler", false);
+#endif // BOOST_NO_STD_ITERATOR_TRAITS
+
+#else // BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS
+  check("Streaming in of time classes not supported by this compiler", false);
+#endif // BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS
+  
+#else  //BOOST_DATE_TIME_NO_LOCALE
+  check("No tests executed - Locales not supported by this compiler", false);
+#endif //BOOST_DATE_TIME_NO_LOCALE
+
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testtime.cpp b/src/boost/libs/date_time/test/posix_time/testtime.cpp
new file mode 100644
index 000000000..f66c8692c
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testtime.cpp
@@ -0,0 +1,336 @@
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include <iostream>
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "../testfrmwk.hpp"
+
+void special_values_tests()
+{
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+
+  time_duration td_pi(pos_infin), td_ni(neg_infin), td_ndt(not_a_date_time);
+  date_duration dd_pi(pos_infin), dd_ni(neg_infin), dd_ndt(not_a_date_time);
+  date d_pi(pos_infin), d_ni(neg_infin), d_ndt(not_a_date_time);
+  time_duration td(1,2,3,4);
+  date_duration dd(1234);
+  date d(2003,Oct,31);
+
+#if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
+  { // default constructor
+    ptime def;
+    check("Default constructor", def == ptime(not_a_date_time));
+  }
+#endif // DATE_TIME_NO_DEFAULT_CONSTRUCTOR
+
+  { // special values construction tests
+    ptime p_sv1(pos_infin);
+    std::string s("+infinity");
+    check("from special value +infinity", to_simple_string(p_sv1) == s);
+    ptime result = p_sv1 + dd;
+    check("Special value (pos infin) + date_duration = +infinity", to_iso_extended_string(result) == s);
+    check("is_special function - pos infin", result.is_special());
+    result = p_sv1 - dd;
+    check("Special value (pos infin) - date_duration = +infinity", to_iso_extended_string(result) == s);
+    result = p_sv1 - dd_ni;
+    check("Special value (pos infin) - date_duration (neg infin) = +infinity", to_iso_extended_string(result) == s);
+    ptime p_sv2(neg_infin);
+    s = "-infinity";
+    check("from special value -infinity", to_iso_string(p_sv2) == s);
+    result = p_sv2 - td_pi;
+    check("Special value (neg infin) - special time_duration (pos infin) = -infinity", to_iso_extended_string(result) == s);
+    ptime p_sv3(not_a_date_time);
+    check("is_special function - not_a_date_time", p_sv3.is_special());
+    s = "not-a-date-time";
+    check("from special value NADT", to_iso_extended_string(p_sv3) == s);
+    result = p_sv3 + td;
+    check("Special value (NADT) + time_duration = NADT", to_iso_extended_string(result) == s);
+    result = p_sv3 - td;
+    check("Special value (NADT) - time_duration = NADT", to_iso_extended_string(result) == s);
+    result = p_sv2 + td_pi;
+    check("Special value (neg infin) + special time_duration (pos infin) = NADT", to_iso_extended_string(result) == s);
+    result = p_sv1 + dd_ni;
+    check("Special value (pos infin) + date_duration (neg infin) = NADT", to_iso_extended_string(result) == s);
+    result = p_sv1 + dd_ndt;
+    check("Special value (pos infin) - date_duration (NADT) = NADT", to_iso_extended_string(result) == s);
+  }
+  { // special values construction tests
+    ptime p_sv1(d_pi, td);
+    std::string s("+infinity");
+    check("duration & special_date", to_simple_string(p_sv1) == s);
+    ptime p_sv2(d_ni, td);
+    s = "-infinity";
+    check("duration & special_date", to_iso_string(p_sv2) == s);
+    ptime p_sv3(d_ndt, td);
+    s = "not-a-date-time";
+    check("duration & special_date", to_iso_extended_string(p_sv3) == s);
+  }
+  { // special values construction tests
+    ptime p_sv1(d_ndt, td);
+    std::string s("not-a-date-time");
+    check("NADT & duration", to_simple_string(p_sv1) == s);
+    ptime p_sv2(d, td_ndt);
+    check("date & NADT", to_iso_string(p_sv2) == s);
+    ptime p_sv3(d_pi, td_ni);
+    check("+infinity_date & -infinity_duration", 
+    to_iso_extended_string(p_sv3) == s);
+
+  }
+  { // special values tests
+    ptime p_sv1(d, td_pi), pt(d,td);
+    std::string s("+infinity");
+    check("special_duration & date", to_simple_string(p_sv1) == s);
+    check("ptime::date() +infinity", to_simple_string(p_sv1.date()) == s);
+    ptime p_sv2(d, td_ni);
+    s = "-infinity";
+    check("special_duration & date", to_iso_string(p_sv2) == s);
+    check("ptime::time_of_day() -infinity", 
+    to_simple_string(p_sv2.time_of_day()) == s);
+    ptime p_sv3(d, td_ndt);
+    s = "not-a-date-time";
+    check("special_duration & date", to_iso_extended_string(p_sv3) == s);
+    check("ptime::date() - NADT", to_simple_string(p_sv3.date()) == s);
+    check("ptime::time_of_day() - NADT", 
+    to_simple_string(p_sv3.time_of_day()) == s);
+    check("-infinity less than ...", p_sv2 < p_sv1);
+    check("-infinity less than ...", p_sv2 < pt);
+    check("+infinity greater than ...", pt < p_sv1);
+    check("-infinity less than equal to ...", p_sv2 <= p_sv2);
+    check("-infinity less than equal to ...", p_sv2 <= pt);
+    check("+infinity greater than equal to ...", p_sv1 >= pt);
+    check("not equal", p_sv1 != p_sv2);
+    check("not equal", p_sv3 != p_sv2);
+    check("not equal", pt != p_sv1);
+
+    check("is_pos_infinity", p_sv1.is_infinity() && p_sv1.is_pos_infinity());
+    check("is_neg_infinity", p_sv2.is_infinity() && p_sv2.is_neg_infinity());
+    check("is_not_a_date_time", !p_sv3.is_infinity() && p_sv3.is_not_a_date_time());
+   
+    check("special_ptime + date_duration", p_sv1 + dd == p_sv1);
+    check("ptime - special_date_duration", pt - dd_pi == p_sv2);
+    check("ptime - special_date_duration", pt - dd_ndt == p_sv3);
+    
+    check("special_ptime + time_duration", p_sv2 + td == p_sv2);
+    check("special_ptime - time_duration", pt - td_ni == p_sv1);
+    check("ptime + special_time_duration", pt + td_ndt == p_sv3);
+    check("ptime - special_ptime", pt - p_sv1 == td_ni);
+    check("ptime - special_ptime", pt - p_sv2 == td_pi);
+    check("ptime - special_ptime", pt - p_sv3 == td_ndt);
+    check("special_ptime - special_ptime", p_sv2 - p_sv2 == td_ndt);
+  }
+}
+
+int
+main() 
+{
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+
+  date d(2001,Dec,1);
+  time_duration td(5,4,3);
+  ptime t1(d, td);     //2001-Dec-1 05:04:03
+  check("date part check", t1.date() == d);
+  check("time part check", t1.time_of_day() == td);
+  check("ptime with more than 24 hours", ptime(date(2005,10,30), hours(25)) == ptime(date(2005,10,31),hours(1)));
+  ptime t2(t1); //copy constructor
+  ptime t3 = t2; //assignment
+  check("date part check", t3.date() == d);
+  check("time part check", t3.time_of_day() == td);
+  check("equality", t1 == t3);
+  date d2(2001,Jan,1);
+  ptime t4(d2, td);  //2001-Jan-1 05:04:03
+  check("equality - not equal", !(t1 == t4));
+  time_duration td1(5,4,0);
+  ptime t5(d, td1); //2001-Dec-1 05:04:00
+  check("equality - not equal", !(t1 == t5));
+  check("not equal - not equal", t1 != t5);
+
+  check("less - not less",       !(t1 < t1));
+  check("less - less",           t4 < t1);
+  check("less - less",           t5 < t1);
+  check("less equal - equal",    t1 <= t1);
+  check("greater equal - equal", t1 >= t1);
+
+  date_duration twodays(2);
+  ptime t6 = t1 + twodays;
+  date d3(2001,Dec,3);
+  check("operator+(date_duration)", t6 == ptime(d3,td));
+  ptime t7 = t1 - twodays;
+  check("operator-(date_duration)", t7 == ptime(date(2001,Nov,29),td));
+  {
+    ptime t6b(date(2003,Oct,31),time_duration(10,0,0,0));
+    t6b += date_duration(55);
+    check("operator +=(date_duration)", t6b ==
+          ptime(date(2003,Dec,25), time_duration(10,0,0,0)));
+    t6b += hours(6);
+    check("operator +=(time_duration)", t6b ==
+          ptime(date(2003,Dec,25), time_duration(16,0,0,0)));
+    t6b -= date_duration(55);
+    check("operator -=(date_duration)", t6b ==
+          ptime(date(2003,Oct,31), time_duration(16,0,0,0)));
+    t6b -= hours(6);
+    check("operator -=(time_duration)", t6b ==
+          ptime(date(2003,Oct,31), time_duration(10,0,0,0)));
+    t6b += hours(25);
+    check("operator +=(time_duration, more than 24 hours)", t6b ==
+          ptime(date(2003,Nov,1), time_duration(11,0,0,0)));
+    t6b -= hours(49);
+    check("operator -=(time_duration, more than 48 hours)", t6b ==
+          ptime(date(2003,Oct,30), time_duration(10,0,0,0)));
+  }
+  time_duration td2(1,2,3); 
+  ptime t8(date(2001,Dec,1)); //midnight
+  ptime t9 = t8 + td2; //Dec 2 at 01:02:03
+  ptime t10(date(2001,Dec,1),time_duration(1,2,3));
+  std::cout << to_simple_string(t9) << std::endl;
+  std::cout << to_simple_string(t10) << std::endl;
+  std::cout << to_simple_string(td2) << std::endl;
+  check("add 2001-Dec-01 0:0:0 + 01:02:03", t9 == t10);
+  {
+    ptime t9x(date(2001,Dec,1), time_duration(12,0,0)); //Dec 1 at Noon
+    time_duration td3(-4,0,0);
+    check("add 2001-Dec-01 12:00:00 + (-04:00:00)", 
+    t9x+td3 == ptime(date(2001,Dec,1), time_duration(8,0,0)) );
+    std::cout << to_simple_string(t9x-td3) << std::endl;
+  }
+  time_duration td3(24,0,0); // a day
+  check("add 2001-Dec-01 0:0:0 + 24:00:00", t8+td3 == ptime(date(2001,Dec,2)));
+  time_duration td4(24,0,1); // a day, 1 second
+  check("add 2001-Dec-01 0:0:0 + 24:00:01", t8+td4
+        == ptime(date(2001,Dec,2), time_duration(0,0,1)));
+  //looks like this fails b/c limits are exceeded now that we have subseconds..
+  time_duration td5(168,0,1);  //one week 24X7
+  check("add 2001-Dec-01 0:0:0 + 168:00:01", t8+td5
+        == ptime(date(2001,Dec,8), time_duration(0,0,1)));
+  
+  //   ptime t10a = t8+td5;
+  //   std::cout << to_simple_string(t10a) << std::endl;
+
+  //Subtraction of time duration -- add more!!
+  ptime t11(date(2001,Dec,1), time_duration(12,0,0)); //noon
+  time_duration td6(12,0,1);
+  ptime t12 = t11-td6;
+  check("sub 2001-Dec-01 12:0:0 - 12:00:01", 
+        t12 == ptime(date(2001,Nov,30), time_duration(23,59,59)));
+  
+  check("sub 2001-Dec-01 12:0:0 - 13:00:00", 
+        (t11-time_duration(13,0,0))== ptime(date(2001,Nov,30), 
+                                            time_duration(23,0,0)));
+  check("sub 2001-Dec-01 12:0:0 - (-13:00:00)", 
+        (t11-time_duration(-13,0,0))== ptime(date(2001,Dec,2), 
+                                            time_duration(1,0,0)));
+  //  std::cout << to_simple_string(t12.date()) << std::endl;
+  
+  ptime t13(d, hours(3));
+  ptime t14(d, hours(4));
+  ptime t14a(d+date_duration(1), hours(4));
+  //Subtract 2 times
+  std::cout << to_simple_string(t14-t13) << std::endl;
+  //  time_duration td7 = 
+  check("time subtraction positive result", 
+        t14-t13 == hours(1));
+  std::cout << to_simple_string(t13-t14) << std::endl;
+  check("time subtraction negative result", 
+        t13-t14 == hours(-1));
+  check("time subtraction positive result", 
+        t14a-t14 == hours(24));
+  
+
+  ptime t15(d, time_duration(0,0,0,1));
+  ptime t16(d, time_duration(0,0,0,2));
+  check("time subsecond add test", 
+        t15 + time_duration::unit() == t16);
+  check("time subsecond sub test", 
+        t16 - time_duration::unit() == t15);
+  
+  ptime t17 = ptime(d) - time_duration::unit();
+  std::cout << to_simple_string(t17) << std::endl;
+  
+  ptime t18(d, hours(25));
+  std::cout << to_simple_string(t18) << std::endl;
+  
+  //time_t conversions:
+  t18 = from_time_t(0); //1970-1-1 0:0:0
+  check("time_t conversion of 0", t18 == ptime(date(1970,1,1)));
+  check("time_t conversion from 0", to_time_t(t18) == 0);
+  
+  std::time_t tt(500000000); 
+  t18 = from_time_t(tt); //1985-11-5 0:53:20
+  check("time_t conversion of 500000000", 
+        t18 == ptime(date(1985,11,5), time_duration(0,53,20)));
+  check("time_t conversion from 500000000", to_time_t(t18) == tt);
+  
+  std::time_t tt1(1060483634); 
+  t18 = from_time_t(tt1); //2003-08-10 2:47:14
+  check("time_t conversion of 1060483634", 
+        t18 == ptime(date(2003,8,10), time_duration(2,47,14)));
+  check("time_t conversion from 1060483634", to_time_t(t18) == tt1);
+  
+  std::time_t tt2(1760483634); 
+  t18 = from_time_t(tt2); //2025-10-14 23:13:54
+  check("time_t conversion of 1760483634", 
+        t18 == ptime(date(2025,10,14), time_duration(23,13,54)));
+  check("time_t conversion from 1760483634", to_time_t(t18) == tt2);
+  
+  std::time_t tt3(1960483634); 
+  t18 = from_time_t(tt3); //2032-2-15 18:47:14
+  check("time_t conversion of 1960483634", 
+        t18 == ptime(date(2032,2,15), time_duration(18,47,14)));
+  check("time_t conversion from 1960483634", to_time_t(t18) == tt3);
+
+  special_values_tests();
+
+  //min and max constructors
+  ptime min_ptime(min_date_time);
+  check("check min time constructor", min_ptime == ptime(date(1400,1,1), time_duration(0,0,0,0)));
+  //  std::cout << min_ptime << std::endl;
+  ptime max_ptime(max_date_time);
+  check("check max time constructor", max_ptime == ptime(date(9999,12,31), 
+                                                         hours(24)-time_duration::unit())); 
+  //  std::cout << max_ptime << std::endl;
+
+  //tm conversion checks
+  //converts to date and back -- should get same result -- note no fractional seconds in these times
+  check("tm conversion functions 2001-12-1 05:04:03", ptime_from_tm(to_tm(t1)) == t1);
+  check("tm conversion functions min date 1400-1-1 ", ptime_from_tm(to_tm(min_ptime)) == min_ptime);
+  //this conversion will drop fractional seconds
+  check("tm conversion functions max date 9999-12-31 23:59:59.9999 - truncated frac seconds", 
+        ptime_from_tm(to_tm(max_ptime)) == ptime(date(max_date_time), time_duration(23,59,59)));
+  
+  try{
+    ptime pt(pos_infin);
+    tm pt_tm = to_tm(pt);
+    check("Exception not thrown (special_value to_tm)", false);
+    //following code does nothing useful but stops compiler from complaining about unused pt_tm
+    std::cout << pt_tm.tm_sec << std::endl;
+  }catch(std::out_of_range&){
+    check("Caught expected exception (special_value to_tm)", true);
+  }catch(...){
+    check("Caught un-expected exception (special_value to_tm)", false);
+  }
+  try{
+    // exception is only thrown from gregorian::to_tm. Needed to
+    // be sure it always gets thrown.
+    ptime pt(date(2002,Oct,31), hours(1));
+    pt += time_duration(pos_infin);
+    tm pt_tm = to_tm(pt);
+    check("Exception not thrown (special_value to_tm)", false);
+    //following code does nothing useful but stops compiler from complaining about unused pt_tm
+    std::cout << pt_tm.tm_sec << std::endl;
+  }catch(std::out_of_range&){
+    check("Caught expected exception (special_value to_tm)", true);
+  }catch(...){
+    check("Caught un-expected exception (special_value to_tm)", false);
+  }
+
+  
+  return printTestStats();
+  
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testtime_facet.cpp b/src/boost/libs/date_time/test/posix_time/testtime_facet.cpp
new file mode 100644
index 000000000..f912f8d73
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testtime_facet.cpp
@@ -0,0 +1,458 @@
+
+/* Copyright (c) 2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "../testfrmwk.hpp"
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+template<class temporal_type, typename charT>
+inline
+void 
+teststreaming(std::string testname, 
+              temporal_type value,
+              std::basic_string<charT> expected_result,
+              const std::locale& locale = std::locale::classic())
+{
+  std::basic_stringstream<charT> ss;
+  ss.imbue(locale);
+  ss << value;
+  check_equal(testname, ss.str(), expected_result);
+}
+
+
+#if !defined(BOOST_NO_STD_WSTRING) 
+static const wchar_t* long_month_names[] =
+  {L"Januar",L"Februar",L"Marz",L"April",L"Mai",L"Juni",L"Juli",L"August",
+   L"September",L"Oktober",L"November",L"Dezember"};
+static const wchar_t* short_month_names[]=
+  {L"Jan",L"Feb",L"Mar",L"Apr",L"Mai",L"Jun",L"Jul",L"Aug",
+   L"Sep",L"Okt",L"Nov",L"Dez"};
+
+std::vector<std::basic_string<wchar_t> > de_short_month_names;
+std::vector<std::basic_string<wchar_t> > de_long_month_names;
+#endif // 
+
+int main() {
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+
+  try {
+    date d(2004,Oct,13);
+    date min_date(min_date_time);
+    date max_date(max_date_time);
+
+    date_period dp(d, d + date_duration(7));
+    ptime t(d, time_duration(18,01,56));
+    ptime tf = t + microseconds(3);
+    time_period tp(t, tf + days(7) + time_duration(1,1,1));
+    time_duration td = hours(3) + minutes(2) + seconds(1) + milliseconds(9);
+    time_duration longer_td = hours(10) + minutes(22) + seconds(15) + milliseconds(980); // two characters in hours
+    time_duration long_td = hours(300) + minutes(2) + seconds(1) + milliseconds(9); // more than two characters in hours
+    {
+      std::stringstream ss;
+      ss << t;
+      check("Stream and to_string formats match (ptime)", 
+          to_simple_string(t) == ss.str());
+      std::cout << t << ' ' << td << std::endl;
+      ss.str("");
+      ss << tf;
+      check("Stream and to_string formats match (ptime w/ fracsec)", 
+          to_simple_string(tf) == ss.str());
+      ss.str("");
+      ss << tp;
+      check("Stream and to_string formats match (time_period)", 
+          to_simple_string(tp) == ss.str());
+      ss.str("");
+      ss << td;
+      check("Stream and to_string formats match (time_duration)", 
+          to_simple_string(td) == ss.str());
+      std::cout << ss.str() << std::endl;
+
+      time_facet* f = new time_facet();
+      ss.imbue(std::locale(ss.getloc(), f));
+      ss.str("");
+
+      f->format("%Y-%b-%d %H:%M:%S %%d");
+      f->time_duration_format("%H:%M:%S %%S");
+      ss << t;
+      check("Literal '%' in format", ss.str() == std::string("2004-Oct-13 18:01:56 %d"));
+      ss.str("");
+      ss << td;
+      check("Literal '%' in time_duration format", ss.str() == std::string("03:02:01 %S"));
+      ss.str("");
+      f->format("%Y-%b-%d %H:%M:%S %%%d");
+      f->time_duration_format("%H:%M:%S %%%S");
+      ss << t;
+      check("Multiple literal '%'s in format", ss.str() == std::string("2004-Oct-13 18:01:56 %13"));
+      ss.str("");
+      ss << td;
+      check("Multiple literal '%'s in time_duration format", ss.str() == std::string("03:02:01 %01"));
+      ss.str("");
+
+      // Longer time durations
+      f->time_duration_format("%H:%M:%S");
+      ss << longer_td;
+      check("Longer time durations", ss.str() == std::string("10:22:15"));
+      ss.str("");
+
+      // Long time durations
+      f->time_duration_format("%O:%M:%S");
+      ss << long_td;
+      check("Long time durations", ss.str() == std::string("300:02:01"));
+      ss.str("");
+
+      // Short-hand format specifiers
+      f->format("%T");
+      f->time_duration_format("%T");
+      ss << t;
+      check("Short-hand '%T' in time format", ss.str() == std::string("18:01:56"));
+      ss.str("");
+      ss << td;
+      check("Short-hand '%T' in time_duration format", ss.str() == std::string("03:02:01"));
+      ss.str("");
+
+      f->format("%R");
+      f->time_duration_format("%R");
+      ss << t;
+      check("Short-hand '%R' in time format", ss.str() == std::string("18:01"));
+      ss.str("");
+      ss << td;
+      check("Short-hand '%R' in time_duration format", ss.str() == std::string("03:02"));
+      ss.str("");
+    }
+    { // negative time_duration tests
+      std::string result;
+      std::stringstream ss;
+      time_duration td1(2,0,0);
+      time_duration td2(1,0,0);
+      ss << td2 - td1;
+      result = "-01:00:00";
+      check("Negative time_duration", result == ss.str());
+      ss.str("");
+
+      time_duration td3(0,2,0);
+      time_duration td4(0,1,0);
+      ss << td4 - td3;
+      result = "-00:01:00";
+      check("Negative time_duration", result == ss.str());
+      ss.str("");
+
+      time_duration td5(0,0,2);
+      time_duration td6(0,0,1);
+      ss << td6 - td5;
+      result = "-00:00:01";
+      check("Negative time_duration", result == ss.str());
+      ss.str("");
+
+#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+      result = "-00:00:00.000000001";
+#else
+      result = "-00:00:00.000001";
+#endif
+      time_duration td7(0,0,0,123);
+      time_duration td8(0,0,0,122);
+      ss << td8 - td7;
+      check("Negative time_duration: " + ss.str(), result == ss.str());
+
+      //reset the sign to always print
+      time_facet* f = new time_facet();
+      ss.imbue(std::locale(ss.getloc(), f));
+      f->time_duration_format("%+%H:%M:%S""%F");
+
+      ss.str("");
+      ss << td4 - td3;
+      result = "-00:01:00";
+      check("Negative time_duration sign always: " + ss.str(), result == ss.str());
+
+      ss.str("");
+      ss << td3 - td4;
+      result = "+00:01:00";
+      check("time_duration sign always: " + ss.str(), result == ss.str());
+
+
+#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+      result = "-00:00:00.000000001";
+#else
+      result = "-00:00:00.000001";
+#endif
+      ss.str("");
+      ss << td8 - td7;
+      check("Negative time_duration: " + ss.str(), result == ss.str());
+
+#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+      result = "+00:00:00.000000001";
+#else
+      result = "+00:00:00.000001";
+#endif
+      ss.str("");
+      ss << td7 - td8;
+      check("time_duration sign bit always: " + ss.str(), result == ss.str());
+
+      f->time_duration_format("%-%H hours and %-%M minutes");
+      ss.str("");
+      ss << td4 - td3;
+      result = "-00 hours and -01 minutes";
+      check("Negative time_duration two sign flags" + ss.str(), result == ss.str());
+      ss.str("");
+
+      // Longer time durations
+      f->time_duration_format("%-%H:%M:%S");
+      ss << -longer_td;
+      check("Longer negative time durations", ss.str() == std::string("-10:22:15"));
+      ss.str("");
+
+      // Long time durations
+      f->time_duration_format("%-%O:%M:%S");
+      ss << -long_td;
+      check("Long negative time durations", ss.str() == std::string("-300:02:01"));
+      ss.str("");
+    }
+
+    // The test verifies that #2698 is fixed. That is, the time and date facet should
+    // not dereference end() iterator for the format string in do_put_tm.
+    {
+      boost::gregorian::date date(2009, 1, 1);
+      boost::posix_time::time_duration tdx(0, 0, 0, 0);
+      boost::posix_time::ptime boost_time(date, tdx);
+      std::stringstream sstr;
+    
+      boost::posix_time::time_facet* pFacet = new boost::posix_time::time_facet("");
+      sstr.imbue(std::locale(std::locale::classic(), pFacet));
+    
+      sstr << boost_time;
+    }
+
+#if !defined(BOOST_NO_STD_WSTRING) 
+    std::copy(&short_month_names[0], 
+              &short_month_names[12],
+              std::back_inserter(de_short_month_names));
+    
+    std::copy(&long_month_names[0], 
+              &long_month_names[12],
+              std::back_inserter(de_long_month_names));
+    
+
+    {
+      wtime_facet *timefacet = new wtime_facet(wtime_facet::standard_format);
+      teststreaming("widestream default classic time", t, 
+                    //std::wstring(L"Wed Oct 13 18:01:56 2004"),
+                    std::wstring(L"10/13/04 18:01:56"),
+                    std::locale(std::locale::classic(), timefacet));
+    }
+    {
+      wtime_facet *timefacet = new wtime_facet(wtime_facet::standard_format);
+      teststreaming("widestream default classic time with fractional seconds truncated", t, 
+                    //std::wstring(L"Wed Oct 13 18:01:56 2004"),
+                    std::wstring(L"10/13/04 18:01:56"),
+                    std::locale(std::locale::classic(), timefacet));
+    }
+    {
+      wtime_facet *timefacet = new wtime_facet(wtime_facet::standard_format);
+      teststreaming("widestream default time period with fractional seconds truncated", tp, 
+                    //std::wstring(L"[Wed Oct 13 18:01:56 2004/Wed Oct 20 19:02:57 2004]"),
+                    std::wstring(L"[10/13/04 18:01:56/10/20/04 19:02:57]"),
+                    std::locale(std::locale::classic(), timefacet));
+    }
+    {
+      wtime_facet *timefacet = new wtime_facet(L"%Y-%b-%d %I:%M:%S %p");
+      teststreaming("widestream time in 12 hours format w/ (AM/PM)", tp.begin(), 
+                    std::wstring(L"2004-Oct-13 06:01:56 PM"),
+                    std::locale(std::locale::classic(), timefacet));
+    }
+    {
+      wtime_facet *timefacet = new wtime_facet(wtime_facet::standard_format);
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+      teststreaming("widestream time duration", td, 
+                    std::wstring(L"03:02:01.009000000"),
+                    std::locale(std::locale::classic(), timefacet));
+#else
+      teststreaming("widestream time duration", td, 
+                    std::wstring(L"03:02:01.009000"),
+                    std::locale(std::locale::classic(), timefacet));
+#endif // BOOST_DATE_TIME_HAS_NANOSECONDS
+    }
+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+    teststreaming("widestream time duration", td, 
+                  std::wstring(L"03:02:01.009000000"));
+#else
+    teststreaming("widestream time duration", td, 
+                  std::wstring(L"03:02:01.009000"));
+#endif // BOOST_DATE_TIME_HAS_NANOSECONDS
+
+    //wtime_facet *timefacet = new wtime_facet();
+    //std::locale cloc = std::locale(std::locale::classic(), timefacet);
+    //ss.imbue(cloc);
+//     ss << L"classic date:               " << d << std::endl;
+//     ss << L"classic dateperiod:         " << dp << std::endl;
+    //ss << L"classic time:               " << t << std::endl;
+    //ss << L"classic timefrac:           " << tf << std::endl;
+    //ss << L"classic timeperiod:         " << tp << std::endl;
+
+    {
+      wtime_facet* wtimefacet = new wtime_facet(L"day: %j date: %Y-%b-%d weekday: %A time: %H:%M:%s");
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+      teststreaming("widestream custom time facet narly format", t, 
+                    std::wstring(L"day: 287 date: 2004-Oct-13 weekday: Wednesday time: 18:01:56.000000000"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#else
+      teststreaming("widestream custom time facet narly format", t, 
+                    std::wstring(L"day: 287 date: 2004-Oct-13 weekday: Wednesday time: 18:01:56.000000"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#endif
+    }
+    {
+      wtime_facet* wtimefacet = new wtime_facet(L"%Y-%b-%d %H:%M:%S,%f");
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+      teststreaming("widestream custom time fractional seconds: %Y-%b-%d %H:%M:%S,%f", t, 
+                    std::wstring(L"2004-Oct-13 18:01:56,000000000"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#else
+      teststreaming("widestream custom time fractional seconds: %Y-%b-%d %H:%M:%S,%f", t, 
+                    std::wstring(L"2004-Oct-13 18:01:56,000000"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#endif
+    }
+
+    {
+      wtime_facet* wtimefacet = new wtime_facet(L"%Y-%b-%d %H:%M:%S");
+      teststreaming("widestream custom time no frac seconds: %Y-%b-%d %H:%M:%S", t, 
+                    std::wstring(L"2004-Oct-13 18:01:56"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+    }
+
+    {
+      wtime_facet* wtimefacet = new wtime_facet(L"%Y-%b-%d %H:%M:%S");
+      wtimefacet->short_month_names(de_short_month_names);
+      teststreaming("widestream custom time no frac seconds, german months: %Y-%b-%d %H:%M:%S", t, 
+                    std::wstring(L"2004-Okt-13 18:01:56"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+    }
+
+    {
+      wtime_facet* wtimefacet = new wtime_facet();
+      wtimefacet->format(L"%B %b %Y");
+      wtimefacet->short_month_names(de_short_month_names);
+      wtimefacet->long_month_names(de_long_month_names);
+      teststreaming("widestream custom time no frac seconds, german months: %B %b %Y", t, 
+                    std::wstring(L"Oktober Okt 2004"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+    }
+
+    {
+      wtime_facet* wtimefacet = new wtime_facet(L"%Y-%b-%d %H:%M:%S" L"%F");
+      teststreaming("widestream custom time no frac seconds %F operator: %Y-%b-%d %H:%M:%S""%F", t, 
+                    std::wstring(L"2004-Oct-13 18:01:56"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+    }
+
+    {
+      wtime_facet* wtimefacet = new wtime_facet(L"%Y-%b-%d %H:%M:%S" L"%F");
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+      teststreaming("widestream custom time with frac seconds %F operator: %Y-%b-%d %H:%M:%S""%F", tf, 
+                    std::wstring(L"2004-Oct-13 18:01:56.000003000"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#else
+      teststreaming("widestream custom time with frac seconds %F operator: %Y-%b-%d %H:%M:%S""%F", tf, 
+                    std::wstring(L"2004-Oct-13 18:01:56.000003"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#endif // BOOST_DATE_TIME_HAS_NANOSECONDS
+    }
+    {
+      wtime_facet* wtimefacet = new wtime_facet();
+      wtimefacet->set_iso_format();
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+      teststreaming("widestream custom time iso format", tf, 
+                    std::wstring(L"20041013T180156.000003000"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#else
+      teststreaming("widestream custom time iso format", tf, 
+                    std::wstring(L"20041013T180156.000003"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#endif // BOOST_DATE_TIME_HAS_NANOSECONDS
+    }
+    {
+      wtime_facet* wtimefacet = new wtime_facet();
+      wtimefacet->set_iso_extended_format();
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+      teststreaming("widestream custom time iso extended format", tf, 
+                    std::wstring(L"2004-10-13 18:01:56.000003000"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#else
+      teststreaming("widestream custom time iso extended format", tf, 
+                    std::wstring(L"2004-10-13 18:01:56.000003"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#endif // BOOST_DATE_TIME_HAS_NANOSECONDS
+    }
+
+
+    {
+      wtime_facet* wtimefacet = new wtime_facet(L"%Y-%b-%d %H:%M:%S" L"%F");
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+      teststreaming("widestream time period frac seconds %F operator: %Y-%b-%d %H:%M:%S""%F", tp, 
+                    std::wstring(L"[2004-Oct-13 18:01:56/2004-Oct-20 19:02:57.000002999]"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#else
+      teststreaming("widestream time period frac seconds %F operator: %Y-%b-%d %H:%M:%S""%F", tp, 
+                    std::wstring(L"[2004-Oct-13 18:01:56/2004-Oct-20 19:02:57.000002]"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#endif // BOOST_DATE_TIME_HAS_NANOSECONDS
+    }
+
+    {
+      wtime_facet* wtimefacet = new wtime_facet(L"%Y-%b-%d %H:%M:%s");
+      wperiod_formatter pf(wperiod_formatter::AS_OPEN_RANGE, L" / ", L"[ ", L" )", L" ]");
+      wtimefacet->period_formatter(pf);
+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+      teststreaming("widestream custom time : %Y-%b-%d %H:%M:%s", tp, 
+                    std::wstring(L"[ 2004-Oct-13 18:01:56.000000000 / 2004-Oct-20 19:02:57.000003000 )"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#else
+      teststreaming("widestream custom time : %Y-%b-%d %H:%M:%s", tp, 
+                    std::wstring(L"[ 2004-Oct-13 18:01:56.000000 / 2004-Oct-20 19:02:57.000003 )"), 
+                    std::locale(std::locale::classic(), wtimefacet));
+#endif // BOOST_DATE_TIME_HAS_NANOSECONDS
+    }
+
+
+    {
+      ptime nt(not_a_date_time);
+      teststreaming("widestream custom time : not a datetime", nt,
+                    std::wstring(L"not-a-date-time"));
+    }
+
+
+
+
+//     //Denmark English has iso extended default format...
+//     std::locale gloc("en_DK"); 
+//     ss.imbue(gloc);
+//     ss << L"default english-denmark date:        " << d << std::endl;
+//     ss << L"default english-denmark dateperiod:  " << dp << std::endl;
+//     ss << L"default english-denmark time:        " << t << std::endl;
+//     ss << L"default english-denmark timefrac:    " << tf << std::endl;
+//     ss << L"default english-denmark timeperiod:  " << tp << std::endl;
+
+
+
+#endif 
+  }
+  catch(std::exception& e) {
+    std::cout << "Caught std::exception: " << e.what() << std::endl;
+  }
+  catch(...) {
+    std::cout << "bad exception" << std::endl;
+  }
+
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testtime_formatters.cpp b/src/boost/libs/date_time/test/posix_time/testtime_formatters.cpp
new file mode 100644
index 000000000..bf628d11b
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testtime_formatters.cpp
@@ -0,0 +1,116 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "../testfrmwk.hpp"
+
+#define CHECK_ROUNDTRIP(_PT) check_equal("from_iso_string(to_iso_string()) roundtrip of \"" + to_iso_string(_PT) + "\"", from_iso_string(to_iso_string(_PT)), _PT)
+
+int
+main() 
+{
+
+  using namespace boost::posix_time;
+  using namespace boost::gregorian;
+  date d1(2002,Jan,1);
+  std::string d1_string("2002-Jan-01");
+  std::string t1_string("01:02:03");
+  std::string t1_result = d1_string + " " + t1_string;
+  ptime t1(d1,time_duration(1,2,3)); //2002-Jan-1 01:02:03
+  std::cout << to_simple_string(t1) << std::endl;
+  check("simple:      " + t1_result, t1_result == to_simple_string(t1));
+  std::string iso_result = "20020101T010203";
+  check("iso:         " + iso_result, iso_result == to_iso_string(t1));
+  std::string iso_ext_result = "2002-01-01T01:02:03";
+  check("iso ext:     " + iso_ext_result, iso_ext_result == to_iso_extended_string(t1));
+
+  CHECK_ROUNDTRIP(t1);
+
+  if (time_duration::resolution() == boost::date_time::milli) {
+    ptime t4(d1,hours(1)+minutes(2)+seconds(3)+millisec(4));
+    std::string r3 = to_simple_string(t4);
+    check("simple subsecond: "+r3 , 
+          std::string("2002-Jan-01 01:02:03.004000") == r3);
+    CHECK_ROUNDTRIP(t4);
+  }
+
+
+  if (time_duration::resolution() == boost::date_time::micro) {
+    ptime t3(d1,hours(1)+minutes(2)+seconds(3)+microsec(4));
+    std::string result = to_simple_string(t3);
+    check("microsecond: "+result , 
+          std::string("2002-Jan-01 01:02:03.000004") == to_simple_string(t3));
+    
+    time_duration td2 =  hours(-12)+minutes(4)+seconds(2)+microsec(1);
+    //  time_duration td2 =  hours(-12)+minutes(4)+seconds(2)+millisec(1);
+    std::string r2 = to_simple_string(td2);
+    check("microseond neg subsecond duration: "+r2 , 
+          std::string("-11:55:57.999999") == r2);
+  
+    std::string s1("-01:25:00"), s2("-00:40:00"), is1("-012500"), is2("-004000");
+    time_duration td1(-1,25,0);
+    time_duration tds2(0,-40,0);
+    check("to string: " + to_simple_string(td1), to_simple_string(td1) == s1);
+    check("to string: " + to_simple_string(tds2), to_simple_string(tds2) == s2);
+    check("to string: " + to_iso_string(td1), to_iso_string(td1) == is1);
+    check("to string: " + to_iso_string(tds2), to_iso_string(tds2) == is2);
+
+    CHECK_ROUNDTRIP(t3);
+  }
+
+
+
+  if (time_duration::resolution() == boost::date_time::nano) {
+    ptime t2(d1,hours(12) + minutes(5) + seconds(1));
+    time_period p1(t1,t2); //last value in period is 12:05:00 1/10000 sec less than t2
+    std::string period_result("["+t1_result + "/" + d1_string + " " + "12:05:00.999999999]" );
+    check("simple:      " + period_result + "==" + to_simple_string(p1), period_result == to_simple_string(p1));
+    
+    ptime t3(d1,hours(1)+minutes(2)+seconds(3)+nanosec(4));
+    std::string result = to_simple_string(t3);
+    check("simple subsecond: "+result , 
+          std::string("2002-Jan-01 01:02:03.000000004") == to_simple_string(t3));
+    
+  
+    std::string s1("-01:25:00"), s2("-00:40:00"), is1("-012500"), is2("-004000");
+    time_duration td1(-1,25,0);
+    time_duration tds2(0,-40,0);
+    check("to string: " + to_simple_string(td1), to_simple_string(td1) == s1);
+    check("to string: " + to_simple_string(tds2), to_simple_string(tds2) == s2);
+    check("to string: " + to_iso_string(td1), to_iso_string(td1) == is1);
+    check("to string: " + to_iso_string(tds2), to_iso_string(tds2) == is2);
+    
+    time_duration td2 =  hours(-12)+minutes(4)+seconds(2)+nanosec(100);
+    std::string r2 = to_simple_string(td2);
+    check("neg subsecond duration: "+r2 , 
+          std::string("-11:55:57.999999900") == r2);
+    
+    ptime t4(d1,hours(1)+minutes(2)+seconds(3)+millisec(4));
+    std::string r3 = to_simple_string(t4);
+    check("simple subsecond: "+r3 , 
+          std::string("2002-Jan-01 01:02:03.004000000") == r3);
+
+    CHECK_ROUNDTRIP(t3);
+}
+
+
+  // Boost Trac 1078 (https://svn.boost.org/trac10/ticket/1078)
+  // from_iso_string should be able to parse output of to_iso_string
+  CHECK_ROUNDTRIP(ptime());
+  CHECK_ROUNDTRIP(ptime(not_a_date_time)); // should be same as previous
+  CHECK_ROUNDTRIP(ptime(pos_infin));
+  CHECK_ROUNDTRIP(ptime(neg_infin));
+  
+  // when min_date_time is formatted out, it is done so as an actual date/time
+  // i.e. it is not "special" in that sense
+  check_equal("from_iso_string(\"minimum-date-time\")", from_iso_string("minimum-date-time"), ptime(min_date_time));
+  check_equal("from_iso_string(\"maximum-date-time\")", from_iso_string("maximum-date-time"), ptime(max_date_time));
+
+  return printTestStats();
+}
+
+
diff --git a/src/boost/libs/date_time/test/posix_time/testtime_input_facet.cpp b/src/boost/libs/date_time/test/posix_time/testtime_input_facet.cpp
new file mode 100644
index 000000000..126810c62
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testtime_input_facet.cpp
@@ -0,0 +1,453 @@
+/* Copyright (c) 2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ * $Date$
+ */
+
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "../testfrmwk.hpp"
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+// for tests that are expected to fail and throw exceptions
+template<class temporal_type, class exception_type>
+bool failure_test(temporal_type component,
+                  const std::string& input,
+                  exception_type const& /*except*/,
+                  boost::posix_time::time_input_facet* facet)
+{
+  using namespace boost::posix_time;
+  bool result = false;
+  std::istringstream iss(input);
+  iss.exceptions(std::ios_base::failbit); // turn on exceptions
+  iss.imbue(std::locale(std::locale::classic(), facet));
+  try {
+    iss >> component;
+  }
+  catch(exception_type& e) {
+    std::cout << "Expected exception caught: \"" 
+              << e.what() << "\"" << std::endl;
+    result = iss.fail(); // failbit must be set to pass test
+  }
+  catch(...) {
+    result = false;
+  }
+
+  return result;
+}
+
+// for tests that are expected to fail quietly
+template<class temporal_type>
+bool failure_test(temporal_type& component,
+                  const std::string& input,
+                  boost::posix_time::time_input_facet* facet)
+{
+  using namespace boost::posix_time;
+  std::istringstream iss(input);
+  /* leave exceptions turned off
+   * iss.exceptions(std::ios_base::failbit); */
+  iss.imbue(std::locale(std::locale::classic(), facet));
+  try {
+    iss >> component;
+  }
+  catch(...) {
+    std::cout << "Caught unexpected exception" << std::endl;
+    return false;
+  }
+
+  return iss.fail(); // failbit must be set to pass test
+}
+
+using namespace boost::gregorian;
+using namespace boost::posix_time;
+ 
+
+void
+do_all_tests()
+{
+
+#if defined(USE_DATE_TIME_PRE_1_33_FACET_IO) // skip this file
+  check("No tests run for this compiler. Incompatible IO", true);
+#else
+
+  // set up initial objects
+  time_duration td = hours(0);
+  ptime pt(not_a_date_time);
+  time_period tp(pt, td);
+  // exceptions for failure_tests
+  std::ios_base::failure e_failure("default");
+
+  /* test ptime, time_duration, time_period.
+   * test all formats.
+   * test for bad input.
+   * test special values.
+   * do not test custom names (done in gregorian).
+   *
+   * format flags to test H,M,S,s,F,f,j
+   */
+
+  // default format tests: time_duration, ptime
+  std::istringstream iss("09:59:01.321987654321 2005-Jan-15 10:15:03.123456789123");
+  iss >> td;
+  iss >> pt;
+#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+  check_equal("Default format time_duration", td, time_duration(9,59,1,321987654));
+  check_equal("Default format ptime", pt, ptime(date(2005,01,15),time_duration(10,15,3,123456789)));
+#else
+  check_equal("Default format time_duration", td, time_duration(9,59,1,321987));
+  check_equal("Default format ptime", pt, ptime(date(2005,01,15),time_duration(10,15,3,123456)));
+#endif
+
+  // test all flags that appear in time_input_facet
+  iss.str("12:34:56 2005-Jan-15 12:34:56");
+  iss >> td;
+  iss >> pt;
+  check_equal("Default format time_duration no frac_sec", td, time_duration(12,34,56));
+  // the following test insures %F parsing stops at the appropriate point
+  check_equal("Default format ptime", pt, ptime(date(2005,01,15),time_duration(12,34,56)));
+
+  iss.str("14:13:12 extra stuff"); // using default %H:%M:%S%F format
+  iss >> td;
+  check_equal("Default frac_sec format time_duration", td, time_duration(14,13,12));
+
+  time_input_facet* facet = new time_input_facet();
+  std::locale loc(std::locale::classic(), facet);
+  facet->time_duration_format("%H:%M:%S""%f");
+  iss.imbue(loc);
+
+  iss.str("14:13:12.0 extra stuff");
+  iss >> td;
+  check_equal("Required-frac_sec format time_duration", td, time_duration(14,13,12));
+
+  iss.str("12");
+  facet->time_duration_format("%H");
+  iss >> td;
+  check_equal("Hours format", td, hours(12));
+
+  iss.str("05");
+  facet->time_duration_format("%M");
+  iss >> td;
+  check_equal("Minutes format", td, minutes(5));
+
+  iss.str("45");
+  facet->time_duration_format("%S");
+  iss >> td;
+  check_equal("Seconds w/o frac_sec format", td, seconds(45));
+
+  iss.str("10.01");
+  facet->time_duration_format("%s");
+  iss >> td;
+#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+  check_equal("Seconds w/ frac_sec format", td, time_duration(0,0,10,10000000));
+#else
+  check_equal("Seconds w/ frac_sec format", td, time_duration(0,0,10,10000));
+#endif
+
+  iss.str("2005-105T23:59");
+  facet->format("%Y-%jT%H:%M"); // extended ordinal format
+  iss >> pt;
+  check_equal("Extended Ordinal format", pt, ptime(date(2005,4,15),time_duration(23,59,0)));
+
+  /* this is not implemented yet. The flags: %I & %p are not parsed
+  iss.str("2005-Jun-14 03:15:00 PM");
+  facet->format("%Y-%b-%d %I:%M:%S %p");
+  iss >> pt;
+  check_equal("12 hour time format (AM/PM)", pt, ptime(date(2005,6,14),time_duration(15,15,0)));
+  */
+
+  iss.str("2005-Jun-14 15:15:00 %d");
+  facet->format("%Y-%b-%d %H:%M:%S %%d");
+  iss >> pt;
+  check_equal("Literal '%' in format", pt, ptime(date(2005,6,14),time_duration(15,15,0)));
+  iss.str("15:15:00 %d");
+  facet->time_duration_format("%H:%M:%S %%d");
+  iss >> td;
+  check_equal("Literal '%' in time_duration format", td, time_duration(15,15,0));
+  iss.str("2005-Jun-14 15:15:00 %14");
+  facet->format("%Y-%b-%d %H:%M:%S %%%d"); // %% => % & %d => day_of_month
+  iss >> pt;
+  check_equal("Multiple literal '%'s in format", pt, ptime(date(2005,6,14),time_duration(15,15,0)));
+  iss.str("15:15:00 %15");
+  facet->time_duration_format("%H:%M:%S %%%M");
+  iss >> td;
+  check_equal("Multiple literal '%'s in time_duration format", td, time_duration(15,15,0));
+
+  { /****** iso format tests (and custom 'scrunched-together formats) ******/
+    time_input_facet *facet2 = new time_input_facet();
+    facet2->set_iso_format();
+    facet2->time_duration_format("%H""%M""%S""%F"); // iso format
+    std::stringstream ss;
+    ss.imbue(std::locale(std::locale::classic(), facet2));
+    ptime pt2(not_a_date_time);
+    time_duration tdx(not_a_date_time);
+    date dx(2002,Oct,17);
+#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+    time_duration td2(23,12,17,123450000);
+#else
+    time_duration td2(23,12,17,123450);
+#endif
+    ptime result(dx, td2);
+
+    ss.str("20021017T231217.12345");
+    ss >> pt2;
+    check_equal("iso_format ptime", pt2, result);
+    ss.str("");
+    facet2->set_iso_extended_format();
+    ss.str("2002-10-17 23:12:17.12345");
+    ss >> pt2;
+    check_equal("iso_extended_format ptime", pt2, result);
+    ss.str("");
+    ss.str("231217.12345");
+    ss >> tdx;
+    check_equal("iso_format time_duration", tdx, td2);
+    ss.str("");
+    ss.str("-infinity");
+    ss >> tdx;
+    check_equal("iso_format time_duration (special_value)",
+        tdx, time_duration(neg_infin));
+    ss.str("");
+    // the above tests prove correct parsing of time values in these formats.
+    // these tests show they also handle special_values & exceptions properly
+    time_duration nadt(not_a_date_time);
+    ss.exceptions(std::ios_base::failbit); // we need exceptions turned on here
+    int count = 0;
+    try {
+      facet2->time_duration_format("%H""%M""%S""%F");
+      ss.str("not-a-date-time");
+      ++count;
+      ss >> tdx;
+      check_equal("special value w/ hours flag", tdx, nadt);
+      ss.str("");
+      facet2->time_duration_format("%M""%S""%F");
+      ss.str("not-a-date-time");
+      ++count;
+      ss >> tdx;
+      check_equal("special value w/ minutes flag", tdx, nadt);
+      ss.str("");
+      facet2->time_duration_format("%S""%F");
+      ss.str("not-a-date-time");
+      ++count;
+      ss >> tdx;
+      check_equal("special value w/ seconds flag", tdx, nadt);
+      ss.str("");
+      facet2->time_duration_format("%s");
+      ss.str("not-a-date-time");
+      ++count;
+      ss >> tdx;
+      check_equal("special value w/ sec w/frac_sec (always) flag", tdx, nadt);
+      ss.str("");
+      facet2->time_duration_format("%f");
+      ss.str("not-a-date-time");
+      ++count;
+      ss >> tdx;
+      check_equal("special value w/ frac_sec (always) flag", tdx, nadt);
+      ss.str("");
+    }
+    catch(...) {
+      // any exception is a failure
+      std::stringstream msg;
+      msg << "special_values with scrunched formats failed at test" << count;
+      check(msg.str(), false);
+    }
+    // exception tests
+    std::ios_base::failure exc("failure");
+    check("failure test w/ hours flag",
+        failure_test(td, "bad_input", exc, new time_input_facet("%H""%M""%S""%F")));
+    check("silent failure test w/ hours flag",
+        failure_test(td, "bad_input", new time_input_facet("%H""%M""%S""%F")));
+    check("failure test w/ minute flag",
+        failure_test(td, "bad_input", exc, new time_input_facet("%M""%S""%F")));
+    check("silent failure test w/ minute flag",
+        failure_test(td, "bad_input", new time_input_facet("%M""%S""%F")));
+    check("failure test w/ second flag",
+        failure_test(td, "bad_input", exc, new time_input_facet("%S""%F")));
+    check("silent failure test w/ second flag",
+        failure_test(td, "bad_input", new time_input_facet("%S""%F")));
+    check("failure test w/ sec w/frac (always) flag",
+        failure_test(td, "bad_input", exc, new time_input_facet("%s")));
+    check("silent failure test w/ sec w/frac (always) flag",
+        failure_test(td, "bad_input", new time_input_facet("%s")));
+    check("failure test w/ frac_sec flag",
+        failure_test(td, "bad_input", exc, new time_input_facet("%f")));
+    check("silent failure test w/ frac_sec flag",
+        failure_test(td, "bad_input", new time_input_facet("%f")));
+
+  }
+  // special_values tests. prove the individual flags catch special_values
+  // NOTE: these flags all by themselves will not parse a complete ptime,
+  // these are *specific* special_values tests
+  iss.str("+infinity -infinity");
+  facet->format("%H");
+  facet->time_duration_format("%H");
+  iss >> pt;
+  iss >> td;
+  check_equal("Special value: ptime %H flag", pt, ptime(pos_infin));
+  check_equal("Special value: time_duration %H flag", td, time_duration(neg_infin));
+
+  iss.str("not-a-date-time +infinity");
+  facet->format("%M");
+  facet->time_duration_format("%M");
+  iss >> pt;
+  iss >> td;
+  check_equal("Special value: ptime %M flag", pt, ptime(not_a_date_time));
+  check_equal("Special value: time_duration %M flag", td, time_duration(pos_infin));
+
+  iss.str("-infinity not-a-date-time ");
+  facet->format("%S");
+  facet->time_duration_format("%S");
+  iss >> pt;
+  iss >> td;
+  check_equal("Special value: ptime %S flag", pt, ptime(neg_infin));
+  check_equal("Special value: time_duration %S flag", td, time_duration(not_a_date_time));
+
+  iss.str("+infinity -infinity");
+  facet->format("%s");
+  facet->time_duration_format("%s");
+  iss >> pt;
+  iss >> td;
+  check_equal("Special value: ptime %s flag", pt, ptime(pos_infin));
+  check_equal("Special value: time_duration %s flag", td, time_duration(neg_infin));
+
+  iss.str("not-a-date-time +infinity");
+  facet->format("%j");
+  facet->time_duration_format("%f");
+  iss >> pt;
+  iss >> td;
+  check_equal("Special value: ptime %j flag", pt, ptime(not_a_date_time));
+  check_equal("Special value: time_duration %f flag", td, time_duration(pos_infin));
+
+  // time_period tests - the time_period_parser is thoroughly tested in gregorian tests
+  // default period format is closed range so last ptime is included in peiod
+  iss.str("[2005-Jan-01 00:00:00/2005-Dec-31 23:59:59]");
+  facet->format(time_input_facet::default_time_input_format); // reset format
+  iss >> tp;
+  check("Time period, default formats", 
+      (tp.begin() == ptime(date(2005,1,1),hours(0))) &&
+      (tp.last() == ptime(date(2005,12,31),time_duration(23,59,59))) &&
+      (tp.end() == ptime(date(2005,12,31),time_duration(23,59,59,1))) );
+  {
+    std::stringstream ss;
+    ptime ptx(not_a_date_time);
+    ptime pt2 = second_clock::local_time();
+    ptime pt3(neg_infin);
+    ptime pt4(pos_infin);
+    time_period tpx(pt2, ptx); // ptime/nadt
+    time_period tp2(ptx, ptx); // nadt/nadt
+    time_period tp3(pt3, pt4);
+    ss << tpx;
+    ss >> tp2;
+    check_equal("Special values period (reversibility test)", tpx, tp2);
+    ss.str("[-infinity/+infinity]");
+    ss >> tp2;
+    check_equal("Special values period (infinities)", tp3, tp2);
+  }
+
+  // Failure tests
+  // faliure tests for date elements tested in gregorian tests
+  time_input_facet* facet2 = new time_input_facet();
+  facet2->time_duration_format("%H:%M:%S""%f");
+  check("Failure test: Missing frac_sec with %f flag (w/exceptions)",
+        failure_test(td, "14:13:12 extra stuff", e_failure, facet2));
+  time_input_facet* facet3 = new time_input_facet();
+  facet3->time_duration_format("%H:%M:%S""%f");
+  check("Failure test: Missing frac_sec with %f flag (no exceptions)",
+        failure_test(td, "14:13:12 extra stuff", facet3));
+
+  // Reversable format tests
+  time_duration td_io(10,11,12,1234567);
+  ptime pt_io(date(2004,03,15), td_io);
+  time_facet* otp_facet = new time_facet();
+  time_input_facet* inp_facet = new time_input_facet();
+  std::stringstream ss;
+  std::locale loc2(std::locale::classic(), otp_facet);
+  ss.imbue(std::locale(loc2, inp_facet)); // imbue locale containing both facets
+
+  ss.str("");
+  ss << pt_io; // stream out pt_io
+  ss >> pt;
+  check_equal("Stream out one ptime then into another: default format", pt_io, pt);
+  ss.str("");
+  ss << td_io; // stream out td_io
+  ss >> td;
+  check_equal("Stream out one time_duration then into another: default format", td_io, td);
+
+  td_io = time_duration(1,29,59); // no frac_sec, default format has %F
+  pt_io = ptime(date(2004,2,29), td_io); // leap year
+  ss.str("");
+  ss << pt_io; // stream out pt_io
+  ss >> pt;
+  check_equal("Stream out one ptime then into another: default format", pt_io, pt);
+  ss.str("");
+  ss << td_io; // stream out td_io
+  ss >> td;
+  check_equal("Stream out one time_duration then into another: default format", td_io, td);
+
+  td_io = time_duration(13,05,0); // no seconds as the next formats won't use them
+  pt_io = ptime(date(2004,2,29), td_io); // leap year
+  otp_facet->format("%Y-%jT%H:%M"); // extended ordinal
+  inp_facet->format("%Y-%jT%H:%M");
+  ss.str("");
+  ss << pt_io; // stream out pt_io
+  ss >> pt;
+  check_equal("Stream out one ptime then into another: extended ordinal format", pt_io, pt);
+
+  otp_facet->format("Time: %H:%M, Date: %B %d, %Y"); // custom format with extra words
+  inp_facet->format("Time: %H:%M, Date: %B %d, %Y");
+  ss.str("");
+  ss << pt_io; // stream out pt_io
+  ss >> pt;
+  check_equal("Stream out one ptime then into another: custom format (" + ss.str() + ")", pt_io, pt);
+
+  {
+    // fully parameterized constructor - compile only test, all other features tested in gregorian
+    boost::date_time::format_date_parser<date, char> fdp("%Y-%b-%d", std::locale::classic());
+    special_values_parser svp; // default constructor
+    period_parser pp; // default constructor
+    boost::date_time::date_generator_parser<date, char> dgp; // default constructor
+    time_input_facet tif("%Y-%m-%d %H:%M:%s", fdp, svp, pp, dgp);
+  }
+
+  // trac 13194 (https://svn.boost.org/trac10/ticket/13194)
+  {
+      const std::string value = "December 07:27:10.435945 5 2017";
+      boost::posix_time::time_input_facet* facet4 = new boost::posix_time::time_input_facet("%B %H:%M:%s %e %Y");
+      boost::posix_time::ptime ptx;
+      check("trac 13194 %e on \"5\" failbit set", !failure_test(ptx, value, facet4)); // proves failbit was not set
+      check_equal("trac 13194 %e on \" 5\" valid value", "2017-12-05T07:27:10.435945000", to_iso_extended_string(ptx));
+  }
+
+  // trac 12910
+  {
+      const std::string value = "263-08:09:10";
+      boost::posix_time::time_input_facet* facet = new boost::posix_time::time_input_facet("%j-%H:%M:%S");
+      boost::posix_time::ptime pt;
+      check("trac 12910 %j without %Y no failbit", !failure_test(pt, value, facet)); // proves failbit was not set
+      check_equal("trac 12910 %j without %Y value", "1400-09-20T08:09:10", to_iso_extended_string(pt));
+  }
+
+#endif // USE_DATE_TIME_PRE_1_33_FACET_IO
+}
+
+
+
+int main(){
+
+  try {  //wrap all the tests -- we don't expect an exception
+    do_all_tests();
+  }
+  catch(std::exception& e) {
+    std::string failure("std::exception caught: ");
+    failure += e.what();
+    check(failure, false);
+  }
+  catch(...) {
+    check("Unknown exception caught -- failing", false);
+  }
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testtime_period.cpp b/src/boost/libs/date_time/test/posix_time/testtime_period.cpp
new file mode 100644
index 000000000..72b065277
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testtime_period.cpp
@@ -0,0 +1,77 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include <iostream>
+#include "boost/date_time/posix_time/posix_time.hpp"
+#include "boost/date_time/posix_time/time_period.hpp"
+#include "../testfrmwk.hpp"
+
+int main() 
+{
+  using namespace boost::gregorian;
+  using namespace boost::posix_time;
+  date d1(2001,Jan, 1);
+  ptime t1 (d1,hours(2));//2001-Jan-1 02:00:00
+  ptime t2 (d1,hours(3));//2001-Jan-1 03:00:00
+  time_period p1(t1,t2); //2001-Jan-1 02:59:59
+  time_period p2(p1);
+  check("copy construct & ==", p1 == p2);
+  time_period p3 = p2;
+  check("assignment", p3 == p2);
+  time_period p4(t1,hours(1));
+  check("length", p4.length() == hours(1));
+  std::cout << t1 << std::endl;
+  std::cout << p4 << std::endl;
+  std::cout << p1 << std::endl;
+  check("construction and ==", p1 == p4);
+  check("begin", p1.begin() == t1);
+  check("last",  p1.end()   == t2);
+  check("end",   p1.last()  == t2-time_duration::unit());
+  
+  std::cout << p1 << std::endl;
+  //  check("last",  p1.()  == t2);
+  check("contains begin", p1.contains(t1));
+  check("contains end-not", !p1.contains(t2));
+  check("contains last",  p1.contains(t2-seconds(1)));
+  ptime t3(date(2001,Jan,1),hours(4));
+  time_period p5(t2,t3);
+  check("check contains", !p1.contains(p5.begin()));
+  check("check contains", !p5.contains(p1.begin()));
+  check("operator== not equal case", !(p1 == p5));
+  check("less than order", p1 < p5);
+  check("greater than order", p5 > p1);
+  check("not equal", p5 != p1);
+  check("intersects with myself", p1.intersects(p1));
+  check("not intersects", !(p1.intersects(p5)));
+  check("not intersects", !(p5.intersects(p1)));
+
+  time_period p6(p5);
+  p6.shift(minutes(30));
+  std::cout << p5 << std::endl;
+  std::cout << p6 << std::endl;
+  check("shifted intersects",    p5.intersects(p6));
+  check("shifted intersects",    p6.intersects(p5));
+  check("contains begin",        p5.contains(p6.begin()));
+  p6.shift(minutes(30));
+  std::cout << p5 << std::endl;
+  std::cout << p6 << std::endl;
+  check("shifted !intersects",    !p5.intersects(p6));
+  check("shifted !intersects",    !p6.intersects(p5));
+  p6.shift(minutes(-30));
+  std::cout << p5 << std::endl;
+  std::cout << p6 << std::endl;
+  time_period p7 = p5.intersection(p6);
+  std::cout << p7 << std::endl;
+  check("shifted intersection",    
+        p7 == time_period(ptime(d1,time_duration(3,30,0)),
+                          ptime(d1,time_duration(4,0,0))));
+  
+  
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/posix_time/testtime_serialize.cpp b/src/boost/libs/date_time/test/posix_time/testtime_serialize.cpp
new file mode 100644
index 000000000..4d50534a0
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testtime_serialize.cpp
@@ -0,0 +1,125 @@
+/* Copyright (c) 2002-2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+ 
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/date_time/posix_time/time_serialize.hpp>
+#include "../testfrmwk.hpp"
+#include <sstream>
+
+using namespace boost;
+using namespace posix_time;
+using namespace gregorian;
+
+template<class archive_type, class temporal_type>
+void save_to(archive_type& ar, const temporal_type& tt)
+{
+  ar << tt;
+}
+
+int main(){
+  // originals
+  date d(2002, Feb, 14);
+#if defined(BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG)
+  time_duration td(12,13,52,123456789);
+#else
+  time_duration td(12,13,52,123456);
+#endif
+  ptime pt(d, td);
+  time_period tp(pt, ptime(date(2002, Oct, 31), hours(19)));
+  ptime sv_pt1(not_a_date_time);
+  ptime sv_pt2(pos_infin);
+  time_duration sv_td(neg_infin);
+
+  // for loading in from archive
+  date d2(not_a_date_time);
+  time_duration td2(1,0,0);
+  ptime pt2(d2, td2);
+  time_period tp2(pt2, hours(1));
+  ptime sv_pt3(min_date_time);
+  ptime sv_pt4(min_date_time);
+  time_duration sv_td2(0,0,0);
+  
+  std::ostringstream oss;
+
+  {
+  // NOTE: DATE_TIME_XML_SERIALIZE is only used in testing and is
+  // defined in the testing Jamfile
+#if defined(DATE_TIME_XML_SERIALIZE)
+  std::cout << "Running xml archive tests" << std::endl;
+  archive::xml_oarchive oa(oss);
+#else
+  std::cout << "Running text archive tests" << std::endl;
+  archive::text_oarchive oa(oss);
+#endif // DATE_TIME_XML_SERIALIZE
+
+  try{
+#if defined(DATE_TIME_XML_SERIALIZE)
+    save_to(oa, BOOST_SERIALIZATION_NVP(pt));
+    save_to(oa, BOOST_SERIALIZATION_NVP(sv_pt1));
+    save_to(oa, BOOST_SERIALIZATION_NVP(sv_pt2));
+    save_to(oa, BOOST_SERIALIZATION_NVP(tp));
+    save_to(oa, BOOST_SERIALIZATION_NVP(td));
+    save_to(oa, BOOST_SERIALIZATION_NVP(sv_td));
+#else
+    save_to(oa, pt);
+    save_to(oa, sv_pt1);
+    save_to(oa, sv_pt2);
+    save_to(oa, tp);
+    save_to(oa, td);
+    save_to(oa, sv_td);
+#endif // DATE_TIME_XML_SERIALIZE
+  }catch(archive::archive_exception& ae){
+    std::string s(ae.what());
+    check("Error writing to archive: " + s + "\nWritten data: \"" + oss.str() + "\"", false);
+    return printTestStats();
+  }
+  }
+
+  {
+  std::istringstream iss(oss.str());
+#if defined(DATE_TIME_XML_SERIALIZE)
+  archive::xml_iarchive ia(iss);
+#else
+  archive::text_iarchive ia(iss);
+#endif // DATE_TIME_XML_SERIALIZE
+
+  try{
+#if defined(DATE_TIME_XML_SERIALIZE)
+    ia >> BOOST_SERIALIZATION_NVP(pt2);
+    ia >> BOOST_SERIALIZATION_NVP(sv_pt3);
+    ia >> BOOST_SERIALIZATION_NVP(sv_pt4);
+    ia >> BOOST_SERIALIZATION_NVP(tp2);
+    ia >> BOOST_SERIALIZATION_NVP(td2);
+    ia >> BOOST_SERIALIZATION_NVP(sv_td2);
+#else
+    ia >> pt2;
+    ia >> sv_pt3;
+    ia >> sv_pt4;
+    ia >> tp2;
+    ia >> td2;
+    ia >> sv_td2;
+#endif // DATE_TIME_XML_SERIALIZE
+  }catch(archive::archive_exception& ae){
+    std::string s(ae.what());
+    check("Error readng from archive: " + s + "\nWritten data: \"" + oss.str() + "\"", false);
+    return printTestStats();
+  }
+  }
+
+  check("ptime", pt == pt2);
+  check("special_values ptime (nadt)", sv_pt1 == sv_pt3);
+  check("special_values ptime (pos_infin)", sv_pt2 == sv_pt4);
+  check("time_period", tp == tp2);
+  check("time_duration", td == td2);
+  check("special_values time_duration (neg_infin)", sv_td == sv_td2);
+
+  return printTestStats();
+}
diff --git a/src/boost/libs/date_time/test/posix_time/testtime_serialize_versioning.cpp b/src/boost/libs/date_time/test/posix_time/testtime_serialize_versioning.cpp
new file mode 100644
index 000000000..157627793
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testtime_serialize_versioning.cpp
@@ -0,0 +1,64 @@
+/* Copyright (c) 2017 James E. King III
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ */
+ 
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include <boost/date_time/posix_time/time_serialize.hpp>
+#include <boost/lexical_cast.hpp>
+#include "../testfrmwk.hpp"
+#include <fstream>
+
+using namespace boost;
+using namespace posix_time;
+
+void check_filesize(const std::string& filename, std::ifstream::pos_type expectedSize)
+{
+    std::ifstream in(filename.c_str(), std::ifstream::ate | std::ifstream::binary);
+    check_equal("check file size is " + boost::lexical_cast<std::string>(expectedSize), in.tellg(), expectedSize);
+}
+
+std::string get_fname(int version)
+{
+    return "time_duration_serialization." +
+        std::string((sizeof(size_t) == 4) ? "x32" : "x64") +
+        ".v" + boost::lexical_cast<std::string>(version);
+}
+
+int main() {
+    time_duration td(12, 13, 52, 123456);
+
+#if BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION == 0
+    std::ofstream ofs(get_fname(0).c_str(), std::ios_base::binary | std::ios_base::out | std::ios_base::trunc);
+    boost::archive::binary_oarchive oa(ofs);
+    oa << td;
+    ofs.close();
+
+#if defined(_MSC_VER)
+    check_filesize(get_fname(0), 58 + sizeof(size_t));
+#endif
+
+#else // BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION > 0
+    std::ifstream ifs(get_fname(0).c_str(), std::ios_base::binary | std::ios_base::in);
+    boost::archive::binary_iarchive ia(ifs);
+    time_duration tmp;
+    ia >> tmp;
+    ifs.close();
+    check_equal("read older version structure ok", td, tmp);
+
+    std::ofstream ofs(get_fname(1).c_str(), std::ios_base::binary | std::ios_base::out | std::ios_base::trunc);
+    boost::archive::binary_oarchive oa(ofs);
+    oa << td;
+    ofs.close();
+
+#if defined(_MSC_VER)
+    check_filesize(get_fname(1), 70 + sizeof(size_t));
+#endif
+
+#endif // BOOST_DATE_TIME_POSIX_TIME_DURATION_VERSION
+
+    return printTestStats();
+}
diff --git a/src/boost/libs/date_time/test/posix_time/testtime_wstream.cpp b/src/boost/libs/date_time/test/posix_time/testtime_wstream.cpp
new file mode 100644
index 000000000..f2b0c45c0
--- /dev/null
+++ b/src/boost/libs/date_time/test/posix_time/testtime_wstream.cpp
@@ -0,0 +1,89 @@
+/* Copyright (c) 2003-2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Bart Garst
+ * $Date$
+ */
+#include <iostream>
+#include <sstream>
+#include <boost/date_time/gregorian/gregorian.hpp>
+#include <boost/date_time/posix_time/posix_time.hpp>
+#include "../testfrmwk.hpp"
+#include <boost/lexical_cast.hpp>
+
+using namespace boost::gregorian;
+using namespace boost::posix_time;
+using boost::lexical_cast;
+
+int main(){
+#if defined(BOOST_NO_STD_WSTRING) || \
+    defined(BOOST_DATE_TIME_INCLUDE_LIMITED_HEADERS)
+  check("No wstring/wstream support for this compiler", false);
+#else
+  
+  std::wstring res, ws;
+  std::wstringstream wss;
+  /* time_period was used because all the time-type objects
+   * that have operator<< can be easily accessed from it.
+   * Tose are: ptime, time_duration, time_period */
+  date d1(2003,Jan,20), d2(2003,May,10);
+  time_period tp(ptime(d1,hours(1)), ptime(d2,hours(15)));
+
+  // ptime
+  wss << tp.begin(); 
+  res = L"2003-Jan-20 01:00:00";
+  check("ptime op<<", res == wss.str());
+  wss.str(L"");
+  ws = to_simple_wstring(tp.begin());
+  check("ptime to_simple_wstring", res == ws);
+  res = L"20030120T010000";
+  ws = to_iso_wstring(tp.begin());
+  check("ptime to_iso_wstring", res == ws);
+  res = L"2003-01-20T01:00:00";
+  ws = to_iso_extended_wstring(tp.begin());
+  check("ptime to_iso_extended_wstring", res == ws);
+  
+  // time_duration
+  wss << tp.length(); 
+  res = L"2654:00:00";
+  check("time_duration", res == wss.str());
+  wss.str(L"");
+  ws = to_simple_wstring(tp.length());
+  check("time_duration to_simple_wstring", res == ws);
+  res = L"26540000";
+  ws = to_iso_wstring(tp.length());
+  check("time_duration to_iso_wstring", res == ws);
+
+  // time_period
+  wss << tp;
+#ifdef BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+  res = L"[2003-Jan-20 01:00:00/2003-May-10 14:59:59.999999999]";
+#else
+  res = L"[2003-Jan-20 01:00:00/2003-May-10 14:59:59.999999]";
+#endif
+  check("time_period", res == wss.str());
+  wss.str(L"");
+  ws = to_simple_wstring(tp);
+  check("time_period to_simple_wstring", res == ws);
+
+  // special values
+  time_duration sv_td(neg_infin);
+  date sv_d(pos_infin);
+  ptime sv_tp(sv_d,hours(1));
+  res = L"+infinity";
+  wss << sv_tp;
+  check("ptime op<< special value", res == wss.str());
+  wss.str(L"");
+  ws = to_simple_wstring(sv_tp);
+  check("ptime to_simple_wstring special value", res == ws);
+  res = L"-infinity";
+  wss << sv_td;
+  check("time_duration op<< special value", res == wss.str());
+  wss.str(L"");
+  ws = to_simple_wstring(sv_td);
+  check("time_duration to_simple_wstring special value", res == ws);
+  
+#endif
+  return printTestStats();
+}
diff --git a/src/boost/libs/date_time/test/self_contained_header.cpp b/src/boost/libs/date_time/test/self_contained_header.cpp
new file mode 100644
index 000000000..3ff1abf4b
--- /dev/null
+++ b/src/boost/libs/date_time/test/self_contained_header.cpp
@@ -0,0 +1,22 @@
+/*
+ *             Copyright Andrey Semashev 2020.
+ * 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)
+ */
+/*!
+ * \file   self_contained_header.cpp
+ * \author Andrey Semashev
+ * \date   04.04.2020
+ *
+ * \brief  This file contains a test boilerplate for checking that every public header is self-contained and does not have any missing #includes.
+ */
+
+#define BOOST_DATE_TIME_TEST_INCLUDE_HEADER() <boost/BOOST_DATE_TIME_TEST_HEADER>
+
+#include BOOST_DATE_TIME_TEST_INCLUDE_HEADER()
+
+int main(int, char*[])
+{
+    return 0;
+}
diff --git a/src/boost/libs/date_time/test/testconstrained_value.cpp b/src/boost/libs/date_time/test/testconstrained_value.cpp
new file mode 100644
index 000000000..f8567f031
--- /dev/null
+++ b/src/boost/libs/date_time/test/testconstrained_value.cpp
@@ -0,0 +1,74 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/config.hpp"
+#include "boost/date_time/constrained_value.hpp"
+#include "testfrmwk.hpp"
+#include <iostream>
+
+class bad_day {}; //exception type
+
+
+class day_value_policies
+{
+public:
+  typedef unsigned int value_type;
+  static unsigned int min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; };
+  static unsigned int max BOOST_PREVENT_MACRO_SUBSTITUTION () { return 31;};
+  static void on_error(unsigned int&, unsigned int, boost::CV::violation_enum)
+  {
+    throw bad_day();
+  }
+};
+
+struct range_error {}; //exception type
+typedef boost::CV::simple_exception_policy<int,1,10,range_error> one_to_ten_range_policy;
+
+int main()
+{
+  using namespace boost::CV;
+  constrained_value<day_value_policies> cv1(0), cv2(31);
+  check("not equal", cv1 != cv2);
+  check("equal", cv1 == cv1);
+  check("greater", cv2 > cv1);
+  check("greater or equal ", cv2 >= cv1);
+  //various running of the conversion operator
+  std::cout << cv1 << std::endl;
+  unsigned int i = cv1; 
+  check("test conversion", i == cv1);
+
+
+  try {
+    constrained_value<one_to_ten_range_policy> cv3(11);
+    std::cout << "Not Reachable: " << cv3 << " ";
+    check("got range exception max", false);
+  }
+  catch(range_error&) {
+    check("got range exception max", true);
+  }
+
+  try {
+    constrained_value<one_to_ten_range_policy> cv3(0);
+    std::cout << "Not Reachable: " << cv3 << " ";
+    check("got range exception min", false);
+  }
+  catch(range_error&) {
+    check("got range exception min", true);
+  }
+
+  try {
+    constrained_value<one_to_ten_range_policy> cv4(1);
+    cv4 = 12;
+    check("range exception on assign", false);
+  }
+  catch(range_error&) {
+    check("range exception on assign", true);
+  }
+
+  return printTestStats();
+}
+
diff --git a/src/boost/libs/date_time/test/testfrmwk.hpp b/src/boost/libs/date_time/test/testfrmwk.hpp
new file mode 100644
index 000000000..fde39ab66
--- /dev/null
+++ b/src/boost/libs/date_time/test/testfrmwk.hpp
@@ -0,0 +1,113 @@
+
+#ifndef TEST_FRMWK_HPP___
+#define TEST_FRMWK_HPP___
+
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * $Date$
+ */
+
+
+#include <iostream>
+#include <string>
+#include <boost/config.hpp>
+
+//! Really simple test framework for counting and printing
+class TestStats
+{
+public:
+  static TestStats& instance() {static TestStats ts; return ts;}
+  void addPassingTest() {testcount_++; passcount_++;}
+  void addFailingTest() {testcount_++;}
+  unsigned int testcount() const {return testcount_;}
+  unsigned int passcount() const {return passcount_;}
+  void print(std::ostream& out = std::cout) const
+  {
+    out << testcount_ << " Tests Executed: " ;
+    if (passcount() != testcount()) {
+      out << (testcount() - passcount()) << " FAILURES";
+    }
+    else {
+      out << "All Succeeded" << std::endl;
+    }
+    out << std::endl;
+  }
+private:
+  TestStats() : testcount_(0), passcount_(0) {}
+  unsigned int testcount_;
+  unsigned int passcount_;
+};
+
+
+inline bool check(const std::string& testname, bool testcond) 
+{
+  TestStats& stat = TestStats::instance();
+  if (testcond) {
+    std::cout << "Pass :: " << testname << " " <<  std::endl;
+    stat.addPassingTest();
+    return true;
+  }
+  else {
+    stat.addFailingTest();
+    std::cout << "FAIL :: " << testname << " " <<  std::endl;
+    return false;
+  }
+}
+
+// In the comparisons below, it is possible that T and U are signed and unsigned integer types, which generates warnings in some compilers.
+#if defined(BOOST_MSVC)
+# pragma warning(push)
+# pragma warning(disable: 4389)
+#elif defined(BOOST_CLANG) && defined(__has_warning)
+# if __has_warning("-Wsign-compare")
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wsign-compare"
+# endif
+#elif defined(BOOST_GCC) && (BOOST_GCC+0) >= 40600
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+template< typename T, typename U >
+inline bool check_equal(const std::string& testname, T const& left, U const& right)
+{
+  bool res = check(testname, left == right);
+  if (!res)
+  {
+    std::cout << "        left = " << left << ", right = " << right << std::endl;
+  }
+  return res;
+}
+
+#if defined(BOOST_MSVC)
+# pragma warning(pop)
+#elif defined(BOOST_CLANG) && defined(__has_warning)
+# if __has_warning("-Wsign-compare")
+#  pragma clang diagnostic pop
+# endif
+#elif defined(BOOST_GCC) && (BOOST_GCC+0) >= 40600
+# pragma GCC diagnostic pop
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+inline bool check_equal(const std::string& testname, std::wstring const& left, std::wstring const& right)
+{
+  bool res = check(testname, left == right);
+  if (!res)
+  {
+    std::wcout << L"        left = " << left << L", right = " << right << std::endl;
+  }
+  return res;
+}
+#endif
+
+inline int printTestStats()
+{
+  TestStats& stat = TestStats::instance();
+  stat.print();
+  return stat.testcount() - stat.passcount();
+}
+
+#endif
diff --git a/src/boost/libs/date_time/test/testfrom_facet.cpp b/src/boost/libs/date_time/test/testfrom_facet.cpp
new file mode 100644
index 000000000..79faafe2e
--- /dev/null
+++ b/src/boost/libs/date_time/test/testfrom_facet.cpp
@@ -0,0 +1,50 @@
+/* Copyright (c) 2004 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland
+ * $Date$
+ *
+ * This file isn't part of the official regression test suite at
+ * the moment, but it is a basic test of the strings_from_facet.hpp
+ * infrastructure that can be compiled trivially.
+ */
+
+
+#include <string>
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include <fstream>
+
+#include "boost/date_time/strings_from_facet.hpp"
+#include "algorithm_ext/container_print.hpp"
+
+
+
+int
+main() 
+{
+  using boost::date_time::gather_month_strings;
+  using boost::date_time::gather_weekday_strings;
+
+  std::vector<std::string> data;
+  std::vector<std::wstring> wdata;
+
+  data = gather_month_strings<char>(std::locale::classic());
+  print(data, std::cout);
+  data = gather_month_strings<char>(std::locale::classic(), false);
+  print(data, std::cout);
+  data = gather_weekday_strings<char>(std::locale::classic());
+  print(data, std::cout);
+  data = gather_weekday_strings<char>(std::locale::classic(), false);
+  print(data, std::cout);
+
+  wdata = gather_month_strings<wchar_t>(std::locale::classic());
+  std::wofstream wof("from_facet_test.out");
+  int i=0;
+  while (i < wdata.size()) {
+    wof << wdata[i] << std::endl;
+    i++;
+  }
+}
diff --git a/src/boost/libs/date_time/test/testgeneric_period.cpp b/src/boost/libs/date_time/test/testgeneric_period.cpp
new file mode 100644
index 000000000..64c1ff56a
--- /dev/null
+++ b/src/boost/libs/date_time/test/testgeneric_period.cpp
@@ -0,0 +1,273 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Bart Garst
+ */
+
+#include <iostream>
+#include "boost/date_time/period.hpp"
+#include "testfrmwk.hpp"
+
+/*! duration_rep parameter for period requires a func unit() that
+ * returns the smallest unit of measure for this type. This minimal
+ * class fulfills that, and other, requirements */
+template<class int_type>
+class duration_type {
+  public:
+    duration_type(int_type a = 0) : _val(a) {}
+    static int_type unit() { return 1; }
+    int_type get_rep() { return _val; }
+    bool operator==(duration_type<int_type> rhs) { return _val == rhs._val; }
+    bool operator<(duration_type<int_type> rhs) { return _val < rhs._val; }
+    bool operator>(duration_type<int_type> rhs) { return _val > rhs._val; }
+  private:
+    int_type _val;
+};
+//! To enable things like "cout << period.length()"
+template<class int_type>
+inline
+std::ostream& operator<<(std::ostream& os, duration_type<int_type> dt){
+  os << dt.get_rep();
+  return os;
+}
+//! this operator is needed because period adds a duration_rep to a point_rep
+template<class int_type>
+inline
+int_type operator+(int i, duration_type<int_type> dt){
+  return i + dt.get_rep();
+}
+
+//! this operator is needed because period adds a duration_rep to a point_rep
+template<class int_type>
+inline
+int_type operator-(int i, duration_type<int_type> dt){
+  return i - dt.get_rep();
+}
+
+
+int main(){
+  using namespace boost::date_time;
+  typedef period<int, duration_type<int> > a_period;
+
+  /*** check all functions - normal periods ***/
+
+  a_period p1(1, duration_type<int>(9));
+  check("Different constructors", p1 == a_period(1, 10));
+  check("First", p1.begin() == 1); 
+  check("Last", p1.last() == 9);
+  check("End", p1.end() == 10);
+  check("Length", p1.length() == 9);
+  check("is_null (not)", !p1.is_null());
+
+  a_period p2(5, 30);
+  check("First", p2.begin() == 5); 
+  check("Last", p2.last() == 29);
+  check("End", p2.end() == 30);
+  check("Length", p2.length() == 25);
+  check("is_null (not)", !p2.is_null());
+
+  a_period p3(35, 81);
+  check("Operator ==", p1 == a_period(1,10));
+  check("Operator !=", p1 != p2);
+  check("Operator <", p1 < p3);
+  check("Operator >", p3 > p2);
+
+  {
+    a_period p(1,10);
+    p.shift(5);
+    check("Shift (right)", p == a_period(6,15));
+    p.shift(-15);
+    check("Shift (left)", p == a_period(-9,0));
+  }
+
+  check("Contains rep", p2.contains(20));
+  check("Contains rep (not)", !p2.contains(2));
+  check("Contains period", p1.contains(a_period(2,8)));
+  check("Contains period (not)", !p1.contains(p3));
+
+  check("Intersects", p1.intersects(p2));
+  check("Intersects", p2.intersects(p1));
+
+  check("Adjacent", p1.is_adjacent(a_period(-5,1)));
+  check("Adjacent", p1.is_adjacent(a_period(10,20)));
+  check("Adjacent (not)", !p1.is_adjacent(p3));
+
+  check("Is before", p1.is_before(15));
+  check("Is after", p3.is_after(15));
+
+  check("Intersection", (p1.intersection(p2) == a_period(5,10)));
+  check("Intersection", (p1.intersection(p3).is_null()));
+
+  check("Merge", p1.merge(p2) == a_period(1,30) );
+  check("Merge", p1.merge(p3).is_null());
+  
+  check("Span", p3.span(p1) == a_period(1, 81));
+
+  /*** zero length period ***/
+  
+  // treat a zero length period as a point
+  a_period zero_len(3,duration_type<int>(0));
+  check("Same beg & end == zero_length", 
+      a_period(1,1) == a_period(1, duration_type<int>(0)));
+  check("2 point (zero length) == 1 point zero duration",
+      a_period(3,3) == zero_len);
+ 
+  // zero_length period always returns false for is_before & is_after
+  check("Is Before zero period", !zero_len.is_before(5));
+  check("Is After zero period (not)", !zero_len.is_after(5));
+  check("Is Before zero period (not)", !zero_len.is_before(-5));
+  check("Is After zero period", !zero_len.is_after(-5));
+ 
+  check("is_null", zero_len.is_null());
+  check("Contains rep (not)", !zero_len.contains(20));
+  // a null_period cannot contain any points
+  check("Contains rep", !zero_len.contains(3));
+  check("Contains period (not)", !zero_len.contains(a_period(5,8)));
+  check("Contains period", p1.contains(zero_len));
+  check("Intersects", zero_len.intersects(p1));
+  check("Intersects", p1.intersects(zero_len));
+  check("Adjacent", zero_len.is_adjacent(a_period(-10,3)));
+  check("Adjacent", a_period(-10,3).is_adjacent(zero_len));
+  check("Intersection", (zero_len.intersection(p1) == zero_len));
+  check("Span", zero_len.span(p2) == a_period(3,30));
+
+  /*** invalid period ***/
+
+  a_period null_per(5,1);
+
+  check("Is Before invalid period (always false)", !null_per.is_before(7));
+  check("Is After invalid period (always false)", !null_per.is_after(7));
+  check("Is Before invalid period (always false)", !null_per.is_before(-5));
+  check("Is After invalid period (always false)", !null_per.is_after(-5));
+ 
+  check("is_null", null_per.is_null());
+  check("Contains rep larger (always false)", !null_per.contains(20));
+  check("Contains rep in-between (always false)", !null_per.contains(3));
+  check("Contains period (not)", !null_per.contains(a_period(7,9)));
+  check("Contains period", p1.contains(null_per));
+  check("Intersects", null_per.intersects(p1));
+  check("Intersects", p1.intersects(null_per));
+  check("Adjacent", null_per.is_adjacent(a_period(-10,5)));
+  check("Adjacent", null_per.is_adjacent(a_period(1,10)));
+
+  // what should this next one do?
+  //check("Intersection", (null_per.intersection(p1) == zero_len));
+  check("Span", null_per.span(p3) == a_period(5,81));
+
+  {
+    std::cout << std::endl;
+    a_period p1x(0, -2);
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == -3);
+    check("End", p1x.end() == -2);
+    check("Length", p1x.length() == -2);
+    check("is_null", p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(0, -1);
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == -2);
+    check("End", p1x.end() == -1);
+    check("Length", p1x.length() == -1);
+    check("is_null", p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(0, 0);
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == -1);
+    check("End", p1x.end() == 0);
+    check("Length", p1x.length() == 0);
+    check("is_null", p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(0, 1);
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == 0);
+    check("End", p1x.end() == 1);
+    check("Length", p1x.length() == 1);
+    check("is_null", !p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(0, 2);
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == 1);
+    check("End", p1x.end() == 2);
+    check("Length", p1x.length() == 2);
+    check("is_null", !p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(0, duration_type<int>(-1));
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == -2);
+    check("End", p1x.end() == -1);
+    check("Length", p1x.length() == -1);
+    check("is_null", p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(0, duration_type<int>(-2));
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == -3);
+    check("End", p1x.end() == -2);
+    check("Length", p1x.length() == -2);
+    check("is_null", p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(0, duration_type<int>(0));
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == -1);
+    check("End", p1x.end() == 0);
+    check("Length", p1x.length() == 0);
+    check("is_null", p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(0, duration_type<int>(1));
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == 0);
+    check("End", p1x.end() == 1);
+    check("Length", p1x.length() == 1);
+    check("is_null", !p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(0, duration_type<int>(2));
+    check("First", p1x.begin() == 0); 
+    check("Last", p1x.last() == 1);
+    check("End", p1x.end() == 2);
+    check("Length", p1x.length() == 2);
+    check("is_null", !p1x.is_null());
+  }
+  {
+    std::cout << std::endl;
+    a_period p1x(1,1); // length should be 0
+    a_period p2x(1,2); // length should be 1
+    a_period p3x(1,3); // length should be 2
+    check("Length p1", p1x.length() == 0);
+    check("Length p2", p2x.length() == 1);
+    check("Length p3", p3x.length() == 2);
+    check("is_null p1 (not)", p1x.is_null());
+    check("is_null p2 (not)", !p2x.is_null());
+  }
+
+  {
+    a_period p1x(1,2); // length should be 1
+    p1x.shift(duration_type<int>(1));
+    a_period p2x(2,3); // shifted result
+    check("shift", p1x == p2x);
+  }
+  {
+    a_period p1x(5,duration_type<int>(3)); 
+    a_period p2x(3,10); // expanded result
+    p1x.expand(duration_type<int>(2)); //from 2000-Jan-01--2000-Jan-04
+    check("expand", p1x == p2x);
+  } 
+  return printTestStats();
+}
diff --git a/src/boost/libs/date_time/test/testgregorian_calendar.cpp b/src/boost/libs/date_time/test/testgregorian_calendar.cpp
new file mode 100644
index 000000000..c0fedac09
--- /dev/null
+++ b/src/boost/libs/date_time/test/testgregorian_calendar.cpp
@@ -0,0 +1,253 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/gregorian_calendar.hpp"
+#include "boost/date_time/year_month_day.hpp"
+#include "testfrmwk.hpp"
+#include <iostream>
+
+int
+main() 
+{
+  typedef boost::date_time::year_month_day_base<unsigned long, 
+                                                unsigned short, 
+                                                unsigned short > simple_ymd_type;
+
+  typedef boost::date_time::gregorian_calendar_base<simple_ymd_type, unsigned long> 
+    gregorian_calendar;
+
+  //  using namespace boost::gregorian;
+  check("Day of week 2000-09-24 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,24))==0);
+  check("Day of week 2000-09-25 == 1 (Mon)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,25))==1);
+  check("Day of week 2000-09-26 == 2 (Tue)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,26))==2);
+  check("Day of week 2000-09-27 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,27))==3);
+  check("Day of week 2000-09-28 == 4 (Thu)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,28))==4);
+  check("Day of week 2000-09-29 == 5 (Fri)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,29))==5);
+  check("Day of week 2000-09-30 == 6 (Sat)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2000,9,30))==6);
+  //see calendar FAQ 2.2 for reference
+  check("Day of week 1953-08-02 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,2))==0);
+  check("Day of week 1953-08-03 == 1 (Mon)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,3))==1);
+  check("Day of week 1953-08-04 == 2 (Tue)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,4))==2);
+  check("Day of week 1953-08-05 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,5))==3);
+  check("Day of week 1953-08-06 == 4 (Thu)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,6))==4);
+  check("Day of week 1953-08-07 == 5 (Fri)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,7))==5);
+  check("Day of week 1953-08-08 == 6 (Sat)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1953,8,8))==6);
+  check("Day of week 2001-08-31 == 5 (Fri)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2001,8,31))==5);
+  
+  //Checked against Caledrical Calc M. Edition p 396 and www site
+  check("Day of week 1400-01-01 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1400,1,1))==3);
+  check("Day of week 1436-02-03 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1436,2,3))==3);
+  check("Day of week 1492-04-9 == 6 (Sat)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1492,4,9))==6);
+  check("Day of week 1560-03-5 == 6 (Sat)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1560,3,5))==6);
+  check("Day of week 1716-07-24 == 5 (Fri)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1716,7,24))==5);
+  check("Day of week 1768-06-19 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1768,6,19))==0);
+  check("Day of week 1839-03-27 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1839,3,27))==3);
+  check("Day of week 1819-08-02 == 1 (Mon)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1819,8,2))==1);
+  check("Day of week 1903-04-19 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1903,4,19))==0);
+  check("Day of week 1929-08-25 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(1929,8,25))==0);
+  check("Day of week 2038-11-10 == 3 (Wed)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2038,11,10))==3);
+  check("Day of week 2094-07-18 == 0 (Sun)", 
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(2094,7,18))==0);
+  //verified against website applet
+  check("Day of week 3002-07-10 == 6 (Sat)",
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(3002,7,10))==6);
+  //verified against website applet
+  check("Day of week 4002-07-10 == 3 (Wed)",
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(4002,7,10))==3);
+  //verified against website applet
+  check("Day of week 5002-07-10 == 6 (Sat)",
+        gregorian_calendar::day_of_week(gregorian_calendar::ymd_type(5002,7,10))==6);
+
+  check("1404 is a leap year", gregorian_calendar::is_leap_year(1404));
+  check("2000 is a leap year", gregorian_calendar::is_leap_year(2000));
+  check("2004 is a leap year", gregorian_calendar::is_leap_year(2004));
+  check("2400 is a leap year", gregorian_calendar::is_leap_year(2400));
+  check("4000 is a leap year", gregorian_calendar::is_leap_year(4000));
+  check("1400 is NOT a leap year", !gregorian_calendar::is_leap_year(1400));
+  check("1900 is NOT a leap year", !gregorian_calendar::is_leap_year(1900));
+  check("2100 is NOT a leap year", !gregorian_calendar::is_leap_year(2100));
+  check("1999 is NOT a leap year", !gregorian_calendar::is_leap_year(1999));
+  check("5000 is NOT a leap year", !gregorian_calendar::is_leap_year(5000));
+
+  int weeknum1 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(2004,10,18));
+  check("ToWeekNumber 2004-10-18 is week 43", weeknum1 == 43);
+  
+  int weeknum2 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(2002,1,1));
+  check("ToWeekNumber 2002-1-1 is week 1", weeknum2 == 1);
+  
+  int weeknum3 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(2000,12,31));
+  check("ToWeekNumber 2000-12-31 is week 52", weeknum3 == 52);
+
+  //check for week when week==0.
+  int weeknum4 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(2000,1,1));
+  check("ToWeekNumber 2000-1-1 is week 52", weeknum4 == 52);
+  
+  //check for week when week==53 and day==6.
+  int weeknum5 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(1998,12,31));
+  check("ToWeekNumber 1998-12-31 is week 53", weeknum5 == 53);
+  
+  //check for week when week==53 day==5 and the year is a leap year.
+  int weeknum6 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(1992,12,31));
+  check("ToWeekNumber 1992-12-31 is week 53", weeknum6 == 53);
+
+  //check for week when week==53 1993-Jan-1
+  int weeknum7 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(1993,1,1));
+  check("ToWeekNumber 1993-1-1 is week 53", weeknum7 == 53);
+
+  //check for week when week==53 1993-Jan-2
+  int weeknum8 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(1993,1,2));
+  check("ToWeekNumber 1993-Jan-2 is week 53", weeknum8 == 53);
+
+  //check for week when week==53 1993-Jan-3
+  int weeknum9 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(1993,1,3));
+  check("ToWeekNumber 1993-Jan-3 is week 53", weeknum9 == 53);
+
+  //check for week when week==1 1993-Jan-4
+  int weeknum10 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(1993,1,4));
+  check("ToWeekNumber 1993-Jan-4 is week 1", weeknum10 == 1);
+  
+  //check for week when week=53 and day != 6 and != 5.
+  int weeknum11 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(2001,12,31));
+  check("ToWeekNumber 2001-12-31 is week 1", weeknum11 == 1);
+
+  //test the boundaries of week_number
+  int weeknum12 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(1400,1,1));
+  check("ToWeekNumber 1400-1-1 is week 1", weeknum12 == 1);
+
+  int weeknum13 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(9999,12,31));
+  check("ToWeekNumber 9999-12-31 is week 52", weeknum13 == 52);
+
+  int weeknum14 = gregorian_calendar::week_number(gregorian_calendar::ymd_type(2003,12,29));
+  check("ToWeekNumber 2003-12-29 is week 1", weeknum14 == 1);
+
+
+  unsigned long jday1 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(2000,1,1));
+  unsigned long jday2 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(2001,1,1));
+//   unsigned short year, month, day;
+//   //2451545 is 2000-1-1
+  check("ToDayNumber 2000-1-1 is day 2451545", jday1 == 2451545);
+  check("ToDayNumber 2001-1-1 is day 2451911", jday2 == 2451911);
+  gregorian_calendar::ymd_type ymd = gregorian_calendar::from_day_number(jday1);
+  check("from_day_number test 2000-1-1",  (ymd.year==2000)&&
+                                          (ymd.month==1) &&
+                                          (ymd.day==1) );
+  
+  unsigned long julianday1 = gregorian_calendar::julian_day_number(gregorian_calendar::ymd_type(2000,12,31));
+  check("ToJulianDayNumber 2000-12-31 is day 2451910", julianday1 == 2451910);
+  gregorian_calendar::ymd_type ymd1 = gregorian_calendar::from_julian_day_number(julianday1);
+  std::cout << ymd1.year << "-" << ymd1.month << "-" << ymd1.day << std::endl;
+  check("from_julian_day_number test 2000-12-31", (ymd1.year==2000) &&
+                                                  (ymd1.month==12) &&
+                                                  (ymd1.day==31) );
+  unsigned long julianday2 = gregorian_calendar::modjulian_day_number(gregorian_calendar::ymd_type(2000,12,31));
+  std::cout << julianday2 << std::endl;
+  check("TomodJulianDayNumber 2000-12-31 is day 51909", julianday2 == 51909);
+  gregorian_calendar::ymd_type ymd2 = gregorian_calendar::from_modjulian_day_number(julianday2);
+  check("from_modjulian_day_number test 2000-12-31", (ymd2.year==2000) &&
+                                                     (ymd2.month==12) &&
+                                                     (ymd2.day==31) ); 
+  unsigned long julianday3 = gregorian_calendar::julian_day_number(gregorian_calendar::ymd_type(1400,1,1));
+  check("ToJulianDayNumber 1400-1-1 is day 2232400", julianday3 == 2232400);
+  gregorian_calendar::ymd_type ymd3 = gregorian_calendar::from_julian_day_number(julianday3);
+  check("from_julian_day_number test 1400-1-1",   (ymd3.year==1400) &&
+                                                  (ymd3.month==1) &&
+                                                  (ymd3.day==1) );
+  long mjd3 = gregorian_calendar::modjulian_day_number(gregorian_calendar::ymd_type(1400,1,1));
+  std::cout << "mjd3: " << mjd3 << std::endl;
+  check("mod julian day 1400-1-1 is day -167601", mjd3 == -167601);
+  gregorian_calendar::ymd_type mjd_ymd3 = gregorian_calendar::from_modjulian_day_number(mjd3);
+  check("from_julian_day_number test 1400-1-1",   (mjd_ymd3.year==1400) &&
+                                                  (mjd_ymd3.month==1) &&
+                                                  (mjd_ymd3.day==1) );
+
+
+  unsigned long julianday4 = gregorian_calendar::julian_day_number(gregorian_calendar::ymd_type(1900,2,28));
+  check("ToJulianDayNumber 1900-2-28 is day 2415079", julianday4 == 2415079);
+  gregorian_calendar::ymd_type ymd4 = gregorian_calendar::from_julian_day_number(julianday4);
+  check("from_julian_day_number test 1900-2-28",  (ymd4.year==1900) &&
+                                                  (ymd4.month==2) &&
+                                                  (ymd4.day==28) );
+
+  unsigned long julianday5 = gregorian_calendar::julian_day_number(gregorian_calendar::ymd_type(1436,2,3));
+  check("ToJulianDayNumber 1436-2-3 is day 2245581", julianday5 == 2245581);
+  gregorian_calendar::ymd_type ymd5 = gregorian_calendar::from_julian_day_number(julianday5);
+  check("from_julian_day_number test 1436-2-3",  (ymd5.year==1436) &&
+                                                 (ymd5.month==2) &&
+                                                 (ymd5.day==3) );
+
+  unsigned long julianday6 = gregorian_calendar::julian_day_number(gregorian_calendar::ymd_type(1996,2,25));
+  check("ToJulianDayNumber 1996-2-25 is day 2450139", julianday6 == 2450139);
+  gregorian_calendar::ymd_type ymd6 = gregorian_calendar::from_julian_day_number(julianday6);
+  check("from_julian_day_number test 1996-2-25",  (ymd6.year==1996) &&
+                                                  (ymd6.month==2) &&
+                                                  (ymd6.day==25) );
+  long mjd6 = gregorian_calendar::modjulian_day_number(gregorian_calendar::ymd_type(1996,2,25));
+  check("ToJulianDayNumber 1996-2-25 is day 50138", mjd6 == 50138);
+  gregorian_calendar::ymd_type mjd_ymd6 = gregorian_calendar::from_modjulian_day_number(mjd6);
+  check("from_julian_day_number test 1996-2-25",  (mjd_ymd6.year==1996) &&
+                                                  (mjd_ymd6.month==2) &&
+                                                  (mjd_ymd6.day==25) );
+
+
+  unsigned long jday3 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(1999,1,1));
+  check("366 days between 2000-1-1 and 2001-1-1", (jday2-jday1) == 366);
+  check("731 days between 1999-1-1 and 2001-1-1 ",(jday2-jday3) == 731);
+
+  unsigned long jday4 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(2000,2,28));
+  unsigned long jday5 = gregorian_calendar::day_number(gregorian_calendar::ymd_type(2000,3,1));
+  check("2 days between 2000-2-28 and 2000-3-1 ",(jday5-jday4) == 2);
+
+  check("31 days in month Jan 2000", gregorian_calendar::end_of_month_day(2000,1) == 31);
+  check("29 days in month Feb 2000", gregorian_calendar::end_of_month_day(2000,2) == 29);
+  check("28 days in month Feb 1999", gregorian_calendar::end_of_month_day(1999,2) == 28);
+  check("28 days in month Feb 2001", gregorian_calendar::end_of_month_day(2001,2) == 28);
+  check("31 days in month Mar 2000", gregorian_calendar::end_of_month_day(2000,3) == 31);
+  check("30 days in month Apr 2000", gregorian_calendar::end_of_month_day(2000,4) == 30);
+  check("31 days in month May 2000", gregorian_calendar::end_of_month_day(2000,5) == 31);
+  check("30 days in month Jun 2000", gregorian_calendar::end_of_month_day(2000,6) == 30);
+  check("31 days in month Jul 2000", gregorian_calendar::end_of_month_day(2000,7) == 31);
+  check("31 days in month Aug 2000", gregorian_calendar::end_of_month_day(2000,8) == 31);
+  check("30 days in month Sep 2000", gregorian_calendar::end_of_month_day(2000,9) == 30);
+  check("31 days in month Oct 2000", gregorian_calendar::end_of_month_day(2000,10) == 31);
+  check("30 days in month Nov 2000", gregorian_calendar::end_of_month_day(2000,11) == 30);
+  check("31 days in month Dec 2000", gregorian_calendar::end_of_month_day(2000,12) == 31);
+
+
+  std::cout << gregorian_calendar::epoch().year << std::endl;
+
+
+
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/testint64_range.cpp b/src/boost/libs/date_time/test/testint64_range.cpp
new file mode 100644
index 000000000..fe4266348
--- /dev/null
+++ b/src/boost/libs/date_time/test/testint64_range.cpp
@@ -0,0 +1,95 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+//#include "date_time/testfrmwk.hpp"
+#include <iostream>
+#include "boost/date_time/gregorian/gregorian.hpp"
+#include "boost/cstdint.hpp"
+
+int
+main()
+{
+#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+  //skipping tests here due to lack of operator<< support in msvc6
+  // TODO: this is a bit misleading: using STLport, this should work.
+  std::cout << "Skipping tests on MSVC6" << std::endl;
+
+#else
+
+  std::cout << "int64_t  max:  "
+            << (std::numeric_limits<boost::int64_t>::max)() 
+            << std::endl;
+  std::cout << "uint64_t max: "
+            << (std::numeric_limits<boost::uint64_t>::max)() 
+            << std::endl;
+
+
+  boost::int64_t seconds_per_day = 60*60*24;
+  boost::int64_t microsec_per_sec = 1000000;
+  boost::int64_t microsec_per_day = seconds_per_day*microsec_per_sec;
+  std::cout << "microsec per day: " 
+            << microsec_per_day
+            << std::endl;
+
+  boost::uint64_t total_days = (std::numeric_limits<boost::int64_t>::max)() / microsec_per_day;
+
+  std::cout << "Representable days: " 
+            << total_days
+            << std::endl;
+
+  boost::int64_t approx_years = total_days / 366;
+
+  std::cout << "Approximate years: " 
+            << approx_years
+            << std::endl;
+  
+  //getting day count
+ // usec_count / (seconds_per_day*usec_per_sec);
+  boost::int64_t day_count = 1000;
+  boost::int64_t usec_count1000 = day_count*microsec_per_day + 999999;
+  std::cout << "usec count at day 1000 + 999999: " 
+            << usec_count1000
+            << std::endl;
+  
+  boost::int64_t day_count_calc = usec_count1000 / microsec_per_day;
+  std::cout << "calc day count at day 1000: " 
+            << day_count_calc
+            << std::endl;
+
+  boost::int64_t remaining_usec_count = usec_count1000 % microsec_per_day;
+  std::cout << "remaining usec count: " 
+            << remaining_usec_count
+            << std::endl;
+  
+  boost::int32_t day_count3M = 3000000;
+  boost::int64_t usec_count3M = day_count3M*microsec_per_day + 999999;
+  std::cout << "usec count at day 3M + 999999: " 
+            << usec_count3M
+            << std::endl;
+
+  boost::int64_t day_count_calc3M = usec_count3M / microsec_per_day;
+  std::cout << "calc day count at day 3M: " 
+            << day_count_calc3M
+            << std::endl;
+
+  boost::int64_t remaining_usec_count3M = usec_count3M % microsec_per_day;
+  std::cout << "remaining usec count 3M: " 
+            << remaining_usec_count3M
+            << std::endl;
+
+#endif  
+
+//   std::cout << "Days from: "
+//          << to_simple_string(d1) << " to "
+//          << to_simple_string(d2) << " = "
+//          << day_count << std::endl; 
+
+
+  //  printTestStats();
+  return 0;
+};
+
diff --git a/src/boost/libs/date_time/test/testint_adapter.cpp b/src/boost/libs/date_time/test/testint_adapter.cpp
new file mode 100644
index 000000000..b5657f6a7
--- /dev/null
+++ b/src/boost/libs/date_time/test/testint_adapter.cpp
@@ -0,0 +1,158 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst
+ */
+
+#include "boost/date_time/int_adapter.hpp"
+#include "testfrmwk.hpp"
+#include "boost/cstdint.hpp"
+#include <iostream>
+#include <sstream>
+
+template<typename int_type> 
+void print()
+{
+  //MSVC 6 has problems with this, but it's not really important 
+  //so we will just skip them....
+#if (defined(BOOST_DATE_TIME_NO_LOCALE)) || (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+
+#else
+  std::cout << "min:       " << (int_type::min)().as_number() << std::endl;
+  std::cout << "max:       " << (int_type::max)().as_number() << std::endl;
+  std::cout << "neg_infin: " << 
+    int_type::neg_infinity().as_number() << std::endl;
+  std::cout << "pos_infin: " << 
+    int_type::pos_infinity().as_number() << std::endl;
+  std::cout << "not a number:  " << 
+    int_type::not_a_number().as_number() << std::endl;
+  std::stringstream ss("");
+  std::string s("");
+  int_type i = int_type::neg_infinity();
+  ss << i;
+  s = "-infinity";
+  check("streaming -infinity", ss.str() == s);
+  
+  i = int_type::pos_infinity();
+  ss.str("");
+  ss << i;
+  s = "+infinity";
+  check("streaming +infinity", ss.str() == s);
+  
+  i = int_type::not_a_number();
+  ss.str("");
+  ss << i;
+  s = "not-a-number";
+  check("streaming nan", ss.str() == s);
+
+  i = 12;
+  ss.str("");
+  ss << i;
+  s = "12";
+  check("streaming digits", ss.str() == s);
+#endif
+}
+
+
+template<typename int_type> 
+void test_int()
+{
+  int_type i = int_type::neg_infinity();
+
+  check("is infinity", i.is_infinity());
+  check("is special_value (neg_inf)", i.is_special());
+  check("as_special convert", boost::date_time::neg_infin == i.as_special() );
+  check("as_special convert", boost::date_time::neg_infin == int_type::to_special(i.as_number()) );
+  int_type h = int_type::neg_infinity();
+  i = int_type::pos_infinity();
+  check("is infinity", i.is_infinity());
+  check("as_special convert", boost::date_time::pos_infin == i.as_special() );
+  check("infinity less",     h < i);
+  check("infinity less",     h < 0);
+  check("infinity greater",  i > h);
+  check("infinity greater",  i > 0);
+  h = int_type::not_a_number();
+  check("nan less",  !(h < 0));
+  check("nan greater",  !(h > 0));
+  check("nan equal",  h == int_type::not_a_number());
+  i = 1;
+  check("is infinity", !i.is_infinity());
+  int_type j = int_type::neg_infinity();
+  check("infinity less",     j < i);
+  check("infinity less",     !(j < j));
+  check("infinity greater",  (i > j));
+  check("infinity equal",    !(j == i));
+  check("infinity equal",    j == j);
+  check("infinity equal",    !(j == 0));
+  check("infinity not equal",    j != 0);
+
+  int_type k = 1;
+  check("as_special convert", boost::date_time::not_special == k.as_special() );
+  check("equal",             i == k);
+  check("infinity not equal",    i != int_type::neg_infinity());
+  check("infinity not equal",    i != int_type::pos_infinity());
+  int_type l = i + int_type::pos_infinity();
+  check("is special_value (pos_inf)", l.is_special());
+  check("add infinity" ,         l == int_type::pos_infinity());
+  { // limiting the scope for these tests was easier than recalculating l
+    int_type m = i - int_type::pos_infinity();
+    check("value - +infinity",         m == int_type::neg_infinity());
+    m = i + int_type::neg_infinity();
+    check("value + -infinity",         m == int_type::neg_infinity());
+  }
+  check("inf - inf = nan",       (l - l) == int_type::not_a_number());
+  check("-inf + inf = nan",       (j + l) == int_type::not_a_number());
+  check("add 2",                 (i + 2) == 3);
+  i = int_type::not_a_number();
+  check("+inf * integer", (l * 2) == l);
+  check("+inf / integer", (l / 2) == l);
+  check("+inf % -integer", (l % -2) == j);
+  check("+inf % integer", (l % 2) == l);
+  check("+inf / -integer", (l / -2) == j);
+  check("+inf * -integer", (l * -2) == j);
+  check("+inf * -inf", (l * j) == j);
+  check("+inf / +inf", (l / l) == i);
+  check("+inf % +inf", (l % l) == i);
+  check("+inf * zero", (l * 0) == i);
+  check("is special_value (nan)", i.is_special());
+  check("as_special convert", boost::date_time::not_a_date_time == i.as_special() );
+  check("add not a number",      (i + 2) == int_type::not_a_number());
+  check("sub not a number",      (i - 2) == int_type::not_a_number());
+  check("sub from infin",        (l - 2) == int_type::pos_infinity());
+  i = 5;
+  h = 3;
+  check("add zero ",             (i + 0) == 5);
+  check("sub from 5-2 ",         (i - 2) == 3);
+  check("remainder from 5/2 ",   (i % 2) == 1);
+  check("remainder from 5/3 ",   (i % h) == 2);
+  //  std::cout << i.as_number() << std::endl;
+  check("from special ", 
+        int_type::from_special(boost::date_time::pos_infin) == int_type::pos_infinity());
+  check("from special ", 
+        int_type::from_special(boost::date_time::neg_infin) == int_type::neg_infinity());
+  check("from special ", 
+        int_type::from_special(boost::date_time::not_a_date_time) == int_type::not_a_number());
+  check("from special ", 
+        int_type::from_special(boost::date_time::min_date_time) == (int_type::min)());
+  check("from special ", 
+        int_type::from_special(boost::date_time::max_date_time) == (int_type::max)());
+}
+
+int
+main() 
+{
+  using namespace boost::date_time;
+
+  print< int_adapter<unsigned long> >();
+  test_int< int_adapter<unsigned long> >();
+  print< int_adapter<long> >();
+  test_int< int_adapter<long> >();
+  print< int_adapter<boost::int64_t> >();
+  test_int< int_adapter<boost::int64_t> >();
+
+
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/testmisc.cpp b/src/boost/libs/date_time/test/testmisc.cpp
new file mode 100644
index 000000000..e648ea8ec
--- /dev/null
+++ b/src/boost/libs/date_time/test/testmisc.cpp
@@ -0,0 +1,59 @@
+/* Copyright (c) 2020 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland
+ */
+
+#include "boost/date_time/wrapping_int.hpp"
+
+//#include <boost/date_time.hpp>
+#include "boost/date_time/posix_time/posix_time_duration.hpp"
+
+#include "testfrmwk.hpp"
+#include <iostream>
+
+using std::cout;
+using std::endl;
+
+int
+main() 
+{
+  using namespace boost::date_time;
+  using namespace boost::posix_time;
+
+#ifdef BOOST_NO_CXX14_CONSTEXPR
+  check("constexpr not configured", true);
+#else
+  constexpr wrapping_int<int, 3600> wi(3599);
+  static_assert(wi == 3599, "constexpr construction/conversion");
+  check("constexpr wrapping construct and equal", true);
+
+  constexpr microseconds ms(1000);
+  static_assert(ms.is_special()  == false, "constexpr duration is_special");
+  static_assert(ms.is_positive() == true,  "constexpr duration is_positive");
+  static_assert(ms.is_negative() == false, "constexpr duration is_negative");
+  static_assert(ms.total_microseconds() == 1000, "constexpr total_microseconds");
+  check("constexpr microseconds - total_microseconds", true);
+  
+#endif 
+  
+#ifdef BOOST_DATE_TIME_POSIX_TIME_STD_CONFIG
+  cout << "Standard Config" << endl;
+#else 
+  cout << "NOT Standard Config" << endl;
+#endif
+
+#ifdef BOOST_DATE_TIME_HAS_NANOSECONDS
+  cout << "Has NANO: " << endl;
+#else
+  cout << "NO NANO: " << endl;
+#endif
+  
+  check("success", true);
+
+  return printTestStats();
+
+}
+
+
diff --git a/src/boost/libs/date_time/test/testtime_resolution_traits.cpp b/src/boost/libs/date_time/test/testtime_resolution_traits.cpp
new file mode 100644
index 000000000..20d0ae3e7
--- /dev/null
+++ b/src/boost/libs/date_time/test/testtime_resolution_traits.cpp
@@ -0,0 +1,72 @@
+/* Copyright (c) 2002,2003 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland 
+ */
+
+#include "boost/date_time/time_resolution_traits.hpp"
+#include "testfrmwk.hpp"
+
+
+int
+main() 
+{
+  using namespace boost::date_time;
+  check("milli traits num digits",  milli_res::num_fractional_digits() == 3);
+  check("milli traits resolution adjust",  
+        milli_res::res_adjust() == 1000);
+  check("milli tick calculations",  
+        milli_res::to_tick_count(0,0,0,1) == 1);
+  check("milli tick calculations",  
+        milli_res::to_tick_count(0,0,1,1) == 1001);
+  check("milli tick calculations",  
+        milli_res::to_tick_count(0,1,0,0) == 60000);
+  boost::int64_t one_hour_milli = 3600*1000;
+  check("milli tick calculations",  
+        milli_res::to_tick_count(1,0,0,0) == one_hour_milli);
+  
+  check("micro traits num digits",  micro_res::num_fractional_digits() == 6);
+  check("micro traits resolution adjust",  
+        micro_res::res_adjust() == 1000000);
+  check("micro tick calculations",  
+        micro_res::to_tick_count(0,0,0,1) == 1);
+  check("micro tick calculations",  
+        micro_res::to_tick_count(0,0,1,1) == 1000001);
+  check("micro tick calculations",  
+        micro_res::to_tick_count(0,1,0,0) == 60000000);
+  boost::int64_t one_hour_micro = 3600*1000;
+  one_hour_micro = one_hour_micro*1000; //avoid compiler overflow!
+  check("micro tick calculations",  
+        micro_res::to_tick_count(1,0,0,0) == one_hour_micro);
+
+  check("nano traits num digits",  nano_res::num_fractional_digits() == 9);
+  check("nano traits resolution adjust",  
+        nano_res::res_adjust() == 1000000000);
+  check("nano tick calculations",  
+        nano_res::to_tick_count(0,0,0,1) == 1);
+  check("nano tick calculations",  
+        nano_res::to_tick_count(0,0,1,1) == 1000000001);
+  boost::int64_t one_minute_nano = 60*1000*1000;
+  one_minute_nano = one_minute_nano*1000;
+  check("nano tick calculations",  
+        nano_res::to_tick_count(0,1,0,0) == one_minute_nano);
+
+  //skip io on VC6 b/c of lack of operator<< for int64
+#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+#else
+  std::cout << one_hour_micro << std::endl;
+#endif
+  boost::int64_t one_hour_nano = one_hour_micro*1000;
+#if (defined(BOOST_MSVC) && (_MSC_VER < 1300))
+#else
+  std::cout << one_hour_nano << std::endl;
+#endif
+  check("nano tick calculations",  
+        nano_res::to_tick_count(1,0,0,0) == one_hour_nano);
+
+
+  return printTestStats();
+
+}
+
diff --git a/src/boost/libs/date_time/test/testwrapping_int.cpp b/src/boost/libs/date_time/test/testwrapping_int.cpp
new file mode 100644
index 000000000..b33a9d256
--- /dev/null
+++ b/src/boost/libs/date_time/test/testwrapping_int.cpp
@@ -0,0 +1,138 @@
+/* Copyright (c) 2002,2003,2005 CrystalClear Software, Inc.
+ * Use, modification and distribution is subject to the 
+ * Boost Software License, Version 1.0. (See accompanying
+ * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ * Author: Jeff Garland, Bart Garst 
+ */
+
+#include "boost/date_time/wrapping_int.hpp"
+//#define BOOST_INCLUDE_MAIN
+//#include <boost/test/test_tools.hpp>
+#include "testfrmwk.hpp"
+#include "boost/cstdint.hpp"
+#include <iostream>
+
+
+int
+main() 
+// int 
+// test_main(int, char*[])
+{
+  using namespace boost::date_time;
+  
+  wrapping_int<int, 3600> wi(3599);
+  check("construction/conversion", wi == 3599);
+  check("add with wrap",    wi.add(1) == 1);
+  check("added value ok",   wi == 0);
+  check("add with 2 wraps", wi.add(7201) == 2);
+  check("added value ok",   wi == 1);
+  check("add with 3 wraps", wi.add(10800) == 3);
+  check("added value ok",   wi == 1);
+  check("subtract no wrap", wi.subtract(1) == 0);
+  check("subtract val ok",  wi == 0);
+  check("subtract no wrap", wi.subtract(3601) == 2);
+  check("subtract val ok",  wi == 3599);
+  check("add again",        (wi.add(2) == 1) && (wi == 1));
+  check("subtract again",   (wi.subtract(2) == 1) && (wi == 3599));
+  check("add again",        (wi.add(2) == 1) && (wi == 1));
+  check("subtract again",   (wi.subtract(3600) == 1) && (wi == 1));
+  check("subtract again",   (wi.subtract(3599) == 1) && (wi == 2));
+  check("subtract again",   (wi.subtract(1) == 0) && (wi == 1));
+  std::cout << wi << std::endl;
+
+  wrapping_int<short, 60> wi2(0);
+  check("add with wrap - return",  wi2.add(121) == 2);
+  check("add with wrap - value",   wi2 == 1);
+
+  wrapping_int<short, 60> wi3(-5);
+  check("signed int - add return",  wi3.add(5) == 0);
+  check("signed int - value",   wi3 == 0);
+
+  { // subtracting negative values
+    wrapping_int<short, 10> wi4(5);
+    check("subtract negative value to cause wrap",
+          (wi4.subtract(-8) == -1 && wi4 == 3));
+    check("reset", wi4.add(2) == 0 && wi4 ==5);
+    check("add negative value to cause wrap",
+          (wi4.add(-8) == -1 && wi4 == 7));
+  }
+
+  wrapping_int2<short, 1, 5> wi4(1);
+  check("construct",  wi4 == 1);
+  check("add up to wrap value",   (wi4.add(4) == 0 && wi4 == 5));
+  check("add over the wrap value", (wi4.add(1) == 1 && wi4 == 1));
+  check("add over the wrap value X 2", (wi4.add(10) == 2 && wi4 == 1));
+  check("add over the wrap value X 3", (wi4.add(15) == 3 && wi4 == 1));
+
+  wrapping_int2<short, 1, 12> wi5(12);
+  check("construct",  wi5 == 12);
+  check("add over the wrap value", (wi5.add(1) == 1 && wi5 == 1));
+  
+  check("subtract of the wrap value", (wi5.subtract(1) == -1 && wi5 == 12));
+  check("subtract of the wrap value", (wi5.subtract(13) == -1 && wi5 == 11));
+
+  // min_values other than 1
+  wrapping_int2<short, 2, 6> wi6(2);
+  check("construct",  wi6 == 2);
+  check("add up to wrap value",   (wi6.add(4) == 0 && wi6 == 6));
+  check("add over the wrap value", (wi6.add(1) == 1 && wi6 == 2));
+  check("add over the wrap value X 2", wi6.add(11) == 2);
+  check("add over the wrap value X 2", wi6 == 3);
+  check("sub down to wrap value", wi6.subtract(1) == 0 && wi6 == 2);
+  check("sub under the wrap value", wi6.subtract(1) == -1 && wi6 == 6);
+  check("sub under the wrap value X 2", wi6.subtract(11) == -2 && wi6 == 5);
+  //std::cout << wi6 << std::endl;
+
+  // adding & subtracting negative values
+  wrapping_int2<short, 1, 12> wi7(6);
+  wrapping_int2<short, -5, 5> wi8(0);
+  check("add negative value", (wi7.add(-2) == 0 && wi7 == 4));
+  check("add negative value", (wi8.add(-2) == 0 && wi8 == -2));
+  check("add negative value to cause single wrap", 
+        (wi7.add(-6) == -1 && wi7 == 10));
+  check("add negative value to cause single wrap", 
+        (wi8.add(-5) == -1 && wi8 == 4));
+  check("add negative value to cause multiple wrap", 
+        (wi7.add(-22) == -2 && wi7 == 12));
+  check("add negative value to cause multiple wrap", 
+        (wi8.add(-22) == -2 && wi8 == 4));
+  // reset values to mid range
+  wi7.subtract(6);
+  check("reset", wi7 == 6);
+  wi8.subtract(4);
+  check("reset", wi8 == 0);
+  check("subtract negative value", (wi7.subtract(-2) == 0 && wi7 == 8));
+  check("subtract negative value", (wi8.subtract(-2) == 0 && wi8 == 2));
+  check("subtract negative value to cause single wrap", 
+        (wi7.subtract(-6) == 1 && wi7 == 2));
+  check("subtract negative value to cause single wrap", 
+        (wi8.subtract(-5) == 1 && wi8 == -4));
+  check("subtract negative value to cause multiple wrap", 
+        (wi7.subtract(-23) == 2 && wi7 == 1));
+  check("subtract negative value to cause multiple wrap", 
+        (wi8.subtract(-22) == 2 && wi8 == -4));
+
+// #ifdef BOOST_HAS_LONG_LONG
+//   wrapping_int<boost::int64_t, 86400*100000LL> wi4(0);
+//   check("construction/conversion", wi4 == 0);
+//   boost::int64_t off2 = 372300000;
+//   boost::int64_t wrap = 86400LL*100000LL;
+//   boost::int64_t wrap2 = 86400000000;
+//   wrapping_int<boost::int64_t,86400000000LL> wi5((3600*1 + 60*2 + 3)*100000);
+//   std::cout << wi5 << std::endl;
+//   boost::int64_t over = wi4.add(off2);
+//   std::cout << over << std::endl;
+//   std::cout << wrap << std::endl;
+//   std::cout << wrap2 << std::endl;
+//   //  check("construction/conversion", wi4 == 0);
+// #endif
+
+//   wrapping_int<int, 60> wi(121);
+//   check("construction/conversion", wi == 121);
+//   check("add with wrap",    wi.add(1) == 1);
+
+  return printTestStats();
+
+}
+
+