C++23 enable in CMakeLists.txt

Add linux build support

.gitignore

@@ -0,0 +1,194 @@
+#ignore thumbnails created by windows
+Thumbs.db
+#Ignore files build by Visual Studio
+*.obj
+*.exe
+*.pdb
+*.user
+*.aps
+*.pch
+*.vspscc
+*_i.c
+*_p.c
+*.ncb
+*.suo
+*.tlb
+*.tlh
+*.bak
+*.cache
+*.ilk
+*.log
+[Bb]in
+[Dd]ebug*/
+*.lib
+*.sbr
+obj/
+[Rr]elease*/
+_ReSharper*/
+[Tt]est[Rr]esult*
+.idea/
+*.opensdf
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+# User-specific folders
+*.sln.ide/
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+x64/
+x86/
+build/
+bld/
+[Bb]in/
+[Oo]bj/
+# Roslyn cache directories
+*.ide/
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+#NUNIT
+*.VisualState.xml
+TestResult.xml
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+# Chutzpah Test files
+_Chutzpah*
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opensdf
+*.sdf
+*.cachefile
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+# TFS 2012 Local Workspace
+$tf/
+# Guidance Automation Toolkit
+*.gpState
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+# JustCode is a .NET coding addin-in
+.JustCode
+# TeamCity is a build add-in
+_TeamCity*
+# DotCover is a Code Coverage Tool
+*.dotCover
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+# Web workbench (sass)
+.sass-cache/
+# Installshield output folder
+[Ee]xpress/
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+# Click-Once directory
+publish/
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings 
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# If using the old MSBuild-Integrated Package Restore, uncomment this:
+#!**/packages/repositories.config
+# Windows Azure Build Output
+csx/
+*.build.csdef
+# Windows Store app package directory
+AppPackages/
+# Others
+sql/
+*.Cache
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+bower_components/
+# RIA/Silverlight projects
+Generated_Code/
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+# SQL Server files
+*.mdf
+*.ldf
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+# Microsoft Fakes
+FakesAssemblies/
+*.suo
+*.vcxproj.filters
+*.npp
+CMakeFiles/*
+nbproject/*
+*.cd
+*.cd
+a.out
+cmake-build-debug/*

.travis.yml

@@ -0,0 +1,147 @@
+language: cpp
+
+env:
+  global:
+    - CMAKE_EXTRA_CONF="-DCOMPILE_WITH_C_LOCALE=ON"
+    - CTEST_OUTPUT_ON_FAILURE=1
+
+matrix:
+  include:
+
+    - name: "Ubuntu 16.04 LTS (Xenial Xerus) GCC 7"
+      os: linux
+      dist: xenial
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-7
+      env:
+        - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
+
+    - name: "Ubuntu 16.04 LTS (Xenial Xerus) GCC 8"
+      os: linux
+      dist: xenial
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-8
+      env:
+        - MATRIX_EVAL="CC=gcc-8 && CXX=g++-8"
+
+    - name: "Ubuntu 16.04 LTS (Xenial Xerus) GCC 9"
+      os: linux
+      dist: xenial
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-9
+      env:
+        - MATRIX_EVAL="CC=gcc-9 && CXX=g++-9"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) GCC 7"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-7
+      env:
+        - MATRIX_EVAL="CC=gcc-7 && CXX=g++-7"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) GCC 8"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+          packages:
+            - g++-8
+      env:
+        - MATRIX_EVAL="CC=gcc-8 && CXX=g++-8"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) Clang 6"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-6.0
+          packages:
+            - clang-6.0
+      env:
+        - MATRIX_EVAL="CC=clang-6.0 && CXX=clang++-6.0"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) Clang 7"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-7
+          packages:
+            - clang-7
+      env:
+        - MATRIX_EVAL="CC=clang-7 && CXX=clang++-7"
+
+    - name: "Ubuntu 18.04 LTS (Bionic Beaver) Clang 8"
+      os: linux
+      dist: bionic
+      addons:
+        apt:
+          sources:
+            - llvm-toolchain-bionic-8
+          packages:
+            - clang-8
+      env:
+        - MATRIX_EVAL="CC=clang-8 && CXX=clang++-8"
+
+    - &macos
+      name: xcode10
+      os: osx
+      osx_image: xcode10.2
+      env:
+        - CMAKE_EXTRA_CONF=""
+      addons:
+        homebrew:
+          packages:
+            - bash
+            - ninja
+
+    - <<: *macos
+      name: xcode9
+      # xcode 9 only works if we tell it to use c++14 explicitly
+      env:
+        - CMAKE_EXTRA_CONF="-DCMAKE_CXX_STANDARD=14"
+      osx_image: xcode9.4
+
+    - <<: *macos
+      osx_image: xcode11
+      name: xcode11
+
+before_install:
+  - eval "${MATRIX_EVAL}"
+  - ci/install_cmake.sh 3.15.2
+  - export OPENSSL_ROOT=$(brew --prefix openssl@1.1)
+  - if [ "$(uname)" = "Darwin" ] ; then export PATH="$HOME/cmake/CMake.app/Contents/bin:${PATH}"; fi
+  - if [ "$(uname)" = "Linux" ] ; then export PATH="$HOME/cmake/bin:${PATH}"; fi
+
+cache:
+  directories:
+    - $HOME/cmake
+
+script:
+  - mkdir -p build
+  - cd build
+  - eval cmake -DENABLE_DATE_TESTING=ON -DBUILD_SHARED_LIBS=ON ${CMAKE_EXTRA_CONF} ..
+  - cmake --build . --parallel
+  - cmake --build . --parallel --target testit
+

CMakeLists.txt

@@ -0,0 +1,23 @@
+if(DEFINED IDF_TARGET)
+  idf_component_register(INCLUDE_DIRS include)
+  set_property(TARGET ${COMPONENT_LIB} PROPERTY CXX_STANDARD 23)
+  target_compile_definitions(${COMPONENT_TARGET} INTERFACE HAS_UNCAUGHT_EXCEPTIONS=1)
+else()
+  add_library(date
+      include/date/chrono_io.h
+      include/date/date.h
+      include/date/ios.h
+      include/date/islamic.h
+      include/date/iso_week.h
+      include/date/julian.h
+      include/date/ptz.h
+      include/date/solar_hijri.h
+      include/date/tz.h
+      include/date/tz_private.h
+      src/tz.cpp
+  )
+
+  target_include_directories(date PUBLIC
+      include/
+  )
+endif()

LICENSE.txt

@@ -0,0 +1,31 @@
+The source code in this project is released using the MIT License. There is no
+global license for the project because each file is licensed individually with
+different author names and/or dates.
+
+If you contribute to this project, please add your name to the license of each
+file you modify.  If you have already contributed to this project and forgot to
+add your name to the license, please feel free to submit a new P/R to add your
+name to the license in each file you modified.
+
+For convenience, here is a copy of the MIT license found in each file except
+without author names or dates:
+
+The MIT License (MIT)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,23 +1,84 @@
+# Date
+
+[![Build Status](https://travis-ci.org/HowardHinnant/date.svg?branch=master)](https://travis-ci.org/HowardHinnant/date)
 [![Join the chat at https://gitter.im/HowardHinnant/date](https://badges.gitter.im/HowardHinnant/date.svg)](https://gitter.im/HowardHinnant/date?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-This is actually several separate C++11/C++14 libraries:
+---
 
-1.  `"date.h"` is a header-only library which builds upon `<chrono>`.  It adds some new `duration` types, and new `time_point` types.  It also adds "field" types such as `year_month_day` which is a struct `{year, month, day}`.  And it provides convenient means to convert between the "field" types and the `time_point` types.  See http://howardhinnant.github.io/date/date.html for more details.
+**[Try it out on wandbox!](https://wandbox.org/permlink/oyXjibyF680HHoyS)**
 
-    Here is the Cppcon 2015 presentation on date.h: https://www.youtube.com/watch?v=tzyGjOm8AKo
+## Summary
 
-    Here are the Cppcon 2015 slides on date.h: http://schd.ws/hosted_files/cppcon2015/43/hinnant_dates.pdf
+This is actually several separate C++11/C++14/C++17 libraries:
 
-2. `"tz.h"` / `"tz.cpp"`  are a timezone library built on top of the `"date.h"` library.  This timezone library is a complete parser of the IANA timezone database.  It provides for an easy way to access all of the data in this database, using the types from `"date.h"` and `<chrono>`.  The IANA database also includes data on leap seconds, and this library provides utilities to compute with that information as well.  See http://howardhinnant.github.io/date/tz.html for more details.
+1. `"date.h"` is a header-only library which builds upon `<chrono>`.  It adds some new `duration` types, and new `time_point` types.  It also adds "field" types such as `year_month_day` which is a struct `{year, month, day}`.  And it provides convenient means to convert between the "field" types and the `time_point` types.
 
-3.  `"chrono_io.h"` is a header-only library for streaming out chrono durations.  See http://howardhinnant.github.io/date/chrono_io.html for more details.
+    * Documentation: http://howardhinnant.github.io/date/date.html
+    * Video: https://www.youtube.com/watch?v=tzyGjOm8AKo
+    * Slides: http://schd.ws/hosted_files/cppcon2015/43/hinnant_dates.pdf
 
-4. `"iso_week.h"` is a header-only library built on top of the `"date.h"` library which implements the ISO week date calendar.  See http://howardhinnant.github.io/date/iso_week.html for more details.
+1. `"tz.h"` / `"tz.cpp"`  are a timezone library built on top of the `"date.h"` library.  This timezone library is a complete parser of the IANA timezone database.  It provides for an easy way to access all of the data in this database, using the types from `"date.h"` and `<chrono>`.  The IANA database also includes data on leap seconds, and this library provides utilities to compute with that information as well.
 
-5. `"julian.h"` is a header-only library built on top of the `"date.h"` library which implements a proleptic Julian calendar which is fully interoperable with everything above.  See http://howardhinnant.github.io/date/julian.html for more details.
+    * Documentation: http://howardhinnant.github.io/date/tz.html
+    * Video: https://www.youtube.com/watch?v=Vwd3pduVGKY
+    * Slides: http://schd.ws/hosted_files/cppcon2016/0f/Welcome%20To%20The%20Time%20Zone%20-%20Howard%20Hinnant%20-%20CppCon%202016.pdf
 
-6. `"islamic.h"` is a header-only library built on top of the `"date.h"` library which implements a proleptic Islamic calendar which is fully interoperable with everything above.  See http://howardhinnant.github.io/date/islamic.html for more details.
+1. `"iso_week.h"` is a header-only library built on top of the `"date.h"` library which implements the ISO week date calendar.
 
-There has been a recent change in the library design.  If you are trying to migrate from the previous design, rename `day_point` to `sys_days` everywhere, and that ought to bring the number of errors down to a small roar.
+    * Documentation: http://howardhinnant.github.io/date/iso_week.html
 
-`"date.h"` and `"tz.h"` are now proposed for standardization here:  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0355r0.html
+1. `"julian.h"` is a header-only library built on top of the `"date.h"` library which implements a proleptic Julian calendar which is fully interoperable with everything above.
+
+    * Documentation: http://howardhinnant.github.io/date/julian.html
+
+1. `"islamic.h"` is a header-only library built on top of the `"date.h"` library which implements a proleptic Islamic calendar which is fully interoperable with everything above.
+
+    * Documentation: http://howardhinnant.github.io/date/islamic.html
+
+## Standardization
+
+Slightly modified versions of `"date.h"` and `"tz.h"` were voted into the C++20 working draft at the Jacksonville FL meeting on 2018-03-17:
+
+* http://howardhinnant.github.io/date/d0355r7.html
+
+## Build & Test
+
+The recommended way to use any of these libraries besides `"tz.h"` is to just include it.  These are header-only libraries (except `"tz.h"`).
+
+To use `"tz.h"`, there is a single source file (`src/tz.cpp`) that needs to be compiled. Here are the recommended directions:  https://howardhinnant.github.io/date/tz.html#Installation.
+
+One can run tests by cd'ing into the `test` subdirectory and running `testit`.  There are known failures on all platforms except for macOS.  And even on macOS if C++11 is used.  If any of these failures present problems for you, there exist workarounds.
+
+Additionally there is unsupported support for [vcpkg](https://github.com/Microsoft/vcpkg) and [CMake](https://cmake.org/).  I don't personally use or maintain these systems as for me they cause more problems than they solve (for this small project).  If you would like to contribute to these build systems please feel free to file a PR.
+
+You can download and install Date using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    vcpkg install date
+
+The Date port in vcpkg is updated by Microsoft team members and community contributors. If the version falls behind, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository.
+
+You can optionally build using [CMake](https://cmake.org/). Here is a guide of how to build and test using the CMake Makefile generator.
+
+```bash
+mkdir build
+cd build
+cmake ../
+cmake --build . --target testit # Consider '-- -j4' for multithreading
+```
+## Projects using this library
+
+* www.safe.com
+* www.webtoolkit.eu/wt
+* https://github.com/ViewTouch/viewtouch
+* https://routinghub.com
+* https://github.com/valhalla
+* https://github.com/siodb/siodb
+* https://github.com/KomodoPlatform/atomicDEX-Pro
+* https://github.com/Kotlin/kotlinx-datetime
+* https://github.com/royalbee/jewish_date
+
+If you would like your project (or product) on this list, just let me know.

chrono_io.h

@@ -1,668 +0,0 @@
-#ifndef CHRONO_IO_H
-#define CHRONO_IO_H
-
-// The MIT License (MIT)
-//
-// Copyright (c) 2016 Howard Hinnant
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-//
-// Our apologies.  When the previous paragraph was written, lowercase had not yet
-// been invented (that woud involve another several millennia of evolution).
-// We did not mean to shout.
-
-#include <chrono>
-#include <cstddef>
-#include <cstdint>
-#include <iosfwd>
-#include <ratio>
-#include <string>
-#include <type_traits>
-
-namespace date
-{
-
-namespace detail
-{
-
-#if __cplusplus >= 201402
-
-template <class CharT, std::size_t N>
-class string_literal
-{
-    CharT p_[N];
-
-public:
-    using const_iterator = const CharT*;
-
-    string_literal(string_literal const&) = default;
-    string_literal& operator=(string_literal const&) = delete;
-
-    template <std::size_t N1 = 2,
-              class = std::enable_if_t<N1 == N>>
-    constexpr string_literal(CharT c) noexcept
-        : p_{c}
-    {
-    }
-
-    constexpr string_literal(const CharT(&a)[N]) noexcept
-        : p_{}
-    {
-        for (std::size_t i = 0; i < N; ++i)
-            p_[i] = a[i];
-    }
-
-    template <class U = CharT, class = std::enable_if_t<1 < sizeof(U)>>
-    constexpr string_literal(const char(&a)[N]) noexcept
-        : p_{}
-    {
-        for (std::size_t i = 0; i < N; ++i)
-            p_[i] = a[i];
-    }
-
-    template <class CharT2, class = std::enable_if_t<!std::is_same<CharT2, CharT>{}>>
-    constexpr string_literal(string_literal<CharT2, N> const& a) noexcept
-        : p_{}
-    {
-        for (std::size_t i = 0; i < N; ++i)
-            p_[i] = a[i];
-    }
-
-    template <std::size_t N1, std::size_t N2,
-              class = std::enable_if_t<N1 + N2 - 1 == N>>
-    constexpr string_literal(const string_literal<CharT, N1>& x,
-                             const string_literal<CharT, N2>& y) noexcept
-        : p_{}
-    {
-        std::size_t i = 0;
-        for (; i < N1-1; ++i)
-            p_[i] = x[i];
-        for (std::size_t j = 0; j < N2; ++j, ++i)
-            p_[i] = y[j];
-    }
-
-    constexpr const CharT* data() const noexcept {return p_;}
-    constexpr std::size_t size() const noexcept {return N-1;}
-
-    constexpr const_iterator begin() const noexcept {return p_;}
-    constexpr const_iterator end()   const noexcept {return p_ + N-1;}
-
-    constexpr CharT const& operator[](std::size_t n) const noexcept
-    {
-        return p_[n];
-    }
-
-    template <class Traits>
-    friend
-    std::basic_ostream<CharT, Traits>&
-    operator<<(std::basic_ostream<CharT, Traits>& os, const string_literal& s)
-    {
-        return os << s.p_;
-    }
-};
-
-template <class CharT1, class CharT2, std::size_t N1, std::size_t N2>
-constexpr
-inline
-string_literal<std::conditional_t<sizeof(CharT2) <= sizeof(CharT1), CharT1, CharT2>,
-               N1 + N2 - 1>
-operator+(const string_literal<CharT1, N1>& x, const string_literal<CharT2, N2>& y) noexcept
-{
-    using CharT = std::conditional_t<sizeof(CharT2) <= sizeof(CharT1), CharT1, CharT2>;
-    return string_literal<CharT, N1 + N2 - 1>{string_literal<CharT, N1>{x},
-                                              string_literal<CharT, N2>{y}};
-}
-
-template <class CharT, std::size_t N>
-constexpr
-inline
-string_literal<CharT, N>
-msl(const CharT(&a)[N]) noexcept
-{
-    return string_literal<CharT, N>{a};
-}
-
-template <class CharT,
-          class = std::enable_if_t<std::is_same<CharT, char>{} ||
-                                   std::is_same<CharT, wchar_t>{} ||
-                                   std::is_same<CharT, char16_t>{} ||
-                                   std::is_same<CharT, char32_t>{}>>
-constexpr
-inline
-string_literal<CharT, 2>
-msl(CharT c) noexcept
-{
-    return string_literal<CharT, 2>{c};
-}
-
-constexpr
-std::size_t
-to_string_len(std::intmax_t i)
-{
-    std::size_t r = 0;
-    do
-    {
-        i /= 10;
-        ++r;
-    } while (i > 0);
-    return r;
-}
-
-template <std::intmax_t N>
-constexpr
-inline
-std::enable_if_t
-<
-    N < 10,
-    string_literal<char, to_string_len(N)+1>
->
-msl() noexcept
-{
-    return msl(char(N % 10 + '0'));
-}
-
-template <std::intmax_t N>
-constexpr
-inline
-std::enable_if_t
-<
-    10 <= N,
-    string_literal<char, to_string_len(N)+1>
->
-msl() noexcept
-{
-    return msl<N/10>() + msl(char(N % 10 + '0'));
-}
-
-template <class CharT, std::intmax_t N, std::intmax_t D>
-constexpr
-inline
-std::enable_if_t
-<
-    std::ratio<N, D>::type::den != 1,
-    string_literal<CharT, to_string_len(std::ratio<N, D>::type::num) +
-                          to_string_len(std::ratio<N, D>::type::den) + 4>
->
-msl(std::ratio<N, D>) noexcept
-{
-    using R = typename std::ratio<N, D>::type;
-    return msl(CharT{'['}) + msl<R::num>() + msl(CharT{'/'}) +
-                             msl<R::den>() + msl(CharT{']'});
-}
-
-template <class CharT, std::intmax_t N, std::intmax_t D>
-constexpr
-inline
-std::enable_if_t
-<
-    std::ratio<N, D>::type::den == 1,
-    string_literal<CharT, to_string_len(std::ratio<N, D>::type::num) + 3>
->
-msl(std::ratio<N, D>) noexcept
-{
-    using R = typename std::ratio<N, D>::type;
-    return msl(CharT{'['}) + msl<R::num>() + msl(CharT{']'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::atto) noexcept
-{
-    return msl(CharT{'a'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::femto) noexcept
-{
-    return msl(CharT{'f'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::pico) noexcept
-{
-    return msl(CharT{'p'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::nano) noexcept
-{
-    return msl(CharT{'n'});
-}
-
-template <class CharT>
-constexpr
-inline
-std::enable_if_t
-<
-    std::is_same<CharT, char>{},
-    string_literal<char, 3>
->
-msl(std::micro) noexcept
-{
-    return string_literal<char, 3>{"\xC2\xB5"};
-}
-
-template <class CharT>
-constexpr
-inline
-std::enable_if_t
-<
-    !std::is_same<CharT, char>{},
-    string_literal<CharT, 2>
->
-msl(std::micro) noexcept
-{
-    return string_literal<CharT, 2>{CharT{static_cast<unsigned char>('\xB5')}};
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::milli) noexcept
-{
-    return msl(CharT{'m'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::centi) noexcept
-{
-    return msl(CharT{'c'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::deci) noexcept
-{
-    return msl(CharT{'d'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::deca) noexcept
-{
-    return string_literal<CharT, 3>{"da"};
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::hecto) noexcept
-{
-    return msl(CharT{'h'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::kilo) noexcept
-{
-    return msl(CharT{'k'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::mega) noexcept
-{
-    return msl(CharT{'M'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::giga) noexcept
-{
-    return msl(CharT{'G'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::tera) noexcept
-{
-    return msl(CharT{'T'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::peta) noexcept
-{
-    return msl(CharT{'P'});
-}
-
-template <class CharT>
-constexpr
-inline
-auto
-msl(std::exa) noexcept
-{
-    return msl(CharT{'E'});
-}
-
-template <class CharT, class Rep, class Period>
-constexpr
-auto
-get_units(const std::chrono::duration<Rep, Period>&)
-{
-    return msl<CharT>(Period{}) + string_literal<CharT, 2>{"s"};
-}
-
-template <class CharT, class Rep>
-constexpr
-auto
-get_units(const std::chrono::duration<Rep, std::ratio<1>>&)
-{
-    return string_literal<CharT, 2>{"s"};
-}
-
-template <class CharT, class Rep>
-constexpr
-auto
-get_units(const std::chrono::duration<Rep, std::ratio<60>>&)
-{
-    return string_literal<CharT, 4>{"min"};
-}
-
-template <class CharT, class Rep>
-constexpr
-auto
-get_units(const std::chrono::duration<Rep, std::ratio<3600>>&)
-{
-    return string_literal<CharT, 2>{"h"};
-}
-
-#else  //  __cplusplus < 201402
-
-inline
-std::string
-to_string(std::uint64_t x)
-{
-    return std::to_string(x);
-}
-
-template <class CharT>
-std::basic_string<CharT>
-to_string(std::uint64_t x)
-{
-    auto y = std::to_string(x);
-    return std::basic_string<CharT>(y.begin(), y.end());
-}
-
-template <class CharT, std::intmax_t N, std::intmax_t D>
-constexpr
-inline
-typename std::enable_if
-<
-    std::ratio<N, D>::type::den != 1,
-    std::basic_string<CharT>
->::type
-msl(std::ratio<N, D>) noexcept
-{
-    using R = typename std::ratio<N, D>::type;
-    return std::basic_string<CharT>(1, '[') + to_string<CharT>(R::num) + CharT{'/'} +
-                                              to_string<CharT>(R::den) + CharT{']'};
-}
-
-template <class CharT, std::intmax_t N, std::intmax_t D>
-constexpr
-inline
-typename std::enable_if
-<
-    std::ratio<N, D>::type::den == 1,
-    std::basic_string<CharT>
->::type
-msl(std::ratio<N, D>) noexcept
-{
-    using R = typename std::ratio<N, D>::type;
-    return std::basic_string<CharT>(1, '[') + to_string<CharT>(R::num) + CharT{']'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::atto) noexcept
-{
-    return {1, 'a'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::femto) noexcept
-{
-    return {1, 'f'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::pico) noexcept
-{
-    return {1, 'p'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::nano) noexcept
-{
-    return {1, 'n'};
-}
-
-template <class CharT>
-constexpr
-inline
-typename std::enable_if
-<
-    std::is_same<CharT, char>::value,
-    std::string
->::type
-msl(std::micro) noexcept
-{
-    return "\xC2\xB5";
-}
-
-template <class CharT>
-constexpr
-inline
-typename std::enable_if
-<
-    !std::is_same<CharT, char>::value,
-    std::basic_string<CharT>
->::type
-msl(std::micro) noexcept
-{
-    return {1, CharT(static_cast<unsigned char>('\xB5'))};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::milli) noexcept
-{
-    return {1, 'm'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::centi) noexcept
-{
-    return {1, 'c'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::deci) noexcept
-{
-    return {1, 'd'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::deca) noexcept
-{
-    return {'d', 'a'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::hecto) noexcept
-{
-    return {1, 'h'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::kilo) noexcept
-{
-    return {1, 'k'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::mega) noexcept
-{
-    return {1, 'M'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::giga) noexcept
-{
-    return {1, 'G'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::tera) noexcept
-{
-    return {1, 'T'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::peta) noexcept
-{
-    return {1, 'P'};
-}
-
-template <class CharT>
-constexpr
-inline
-std::basic_string<CharT>
-msl(std::exa) noexcept
-{
-    return {1, 'E'};
-}
-
-template <class CharT, class Rep, class Period>
-std::basic_string<CharT>
-get_units(const std::chrono::duration<Rep, Period>&)
-{
-    return msl<CharT>(Period{}) + CharT{'s'};
-}
-
-template <class CharT, class Rep>
-std::basic_string<CharT>
-get_units(const std::chrono::duration<Rep, std::ratio<1>>&)
-{
-    return {1, 's'};
-}
-
-template <class CharT, class Rep>
-std::basic_string<CharT>
-get_units(const std::chrono::duration<Rep, std::ratio<60>>&)
-{
-    return {'m', 'i', 'n'};
-}
-
-template <class CharT, class Rep>
-std::basic_string<CharT>
-get_units(const std::chrono::duration<Rep, std::ratio<3600>>&)
-{
-    return {1, 'h'};
-}
-
-#endif  //  __cplusplus >= 201402
-
-}  // namespace detail
-
-template <class CharT, class Traits, class Rep, class Period>
-inline
-std::basic_ostream<CharT, Traits>&
-operator<<(std::basic_ostream<CharT, Traits>& os,
-           const std::chrono::duration<Rep, Period>& d)
-{
-    using namespace std::chrono;
-    return os << d.count()
-              << detail::get_units<CharT>(duration<Rep, typename Period::type>{});
-}
-
-}  // namespace date
-
-#endif  // CHRONO_IO_H

ci/install_cmake.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -e
+
+IFS=. read cm_maj cm_min cm_rel <<<"$1"
+: ${cm_rel:-0}
+CMAKE_ROOT=${2:-"${HOME}/cmake"}
+
+function cmake_version ()
+{
+    if [[ -d ${CMAKE_ROOT} ]] ; then
+        local perms=$(test $(uname) = "Linux" && echo "/111" || echo "+111")
+        local installed=$(find ${CMAKE_ROOT} -perm ${perms} -type f -name cmake)
+        if [[ "${installed}" != "" ]] ; then
+            echo "$(${installed} --version | head -1)"
+        fi
+    fi
+}
+
+installed=$(cmake_version)
+if [[ "${installed}" != "" && ${installed} =~ ${cm_maj}.${cm_min}.${cm_rel} ]] ; then
+    echo "cmake already installed: ${installed}"
+    exit
+fi
+
+pkgname="cmake-${cm_maj}.${cm_min}.${cm_rel}-$(uname)-x86_64.tar.gz"
+tmppkg="/tmp/cmake.tar.gz"
+wget --quiet https://cmake.org/files/v${cm_maj}.${cm_min}/${pkgname} -O ${tmppkg}
+mkdir -p ${CMAKE_ROOT}
+cd ${CMAKE_ROOT}
+tar --strip-components 1 -xf ${tmppkg}
+rm -f ${tmppkg}
+echo "installed: $(cmake_version)"
+
+

cmake/dateConfig.cmake

@@ -0,0 +1,11 @@
+include( CMakeFindDependencyMacro )
+include( "${CMAKE_CURRENT_LIST_DIR}/dateTargets.cmake" )
+if( NOT MSVC AND TARGET date::date-tz )
+    find_dependency( Threads REQUIRED)
+    get_target_property( _tzill date::date-tz  INTERFACE_LINK_LIBRARIES )
+    if( _tzill AND "${_tzill}" MATCHES "libcurl" )
+        find_dependency( CURL )
+    endif( )
+endif( )
+
+

compile_fail.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+export TEST_BIN_NAME=$1
+#echo "Building ${TEST_BIN_NAME}"
+shift 1
+export BUILD_COMMAND=$@
+#echo "Build command: ${BUILD_COMMAND}"
+eval ${BUILD_COMMAND} >/dev/null 2>/dev/null
+
+if [ $? -eq 0 ]; then
+	echo -ne "#!/bin/bash\nexit 1;" > ${TEST_BIN_NAME}
+else
+	echo -ne "#!/bin/bash\nexit 0;" > ${TEST_BIN_NAME}
+fi
+chmod u+x ${TEST_BIN_NAME}
+exit 0;
+

date.pri

@@ -0,0 +1 @@
+QMAKE_CXXFLAGS += -isystem $$PWD/include

include/date/chrono_io.h

@@ -0,0 +1,34 @@
+#ifndef CHRONO_IO_H
+#define CHRONO_IO_H
+
+// The MIT License (MIT)
+//
+// Copyright (c) 2016, 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// Our apologies.  When the previous paragraph was written, lowercase had not yet
+// been invented (that would involve another several millennia of evolution).
+// We did not mean to shout.
+
+// This functionality has moved to "date.h"
+
+#include "date.h"
+
+#endif  // CHRONO_IO_H

include/date/ios.h

@@ -0,0 +1,50 @@
+//
+//  ios.h
+//  DateTimeLib
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Alexander Kormanovsky
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef ios_hpp
+#define ios_hpp
+
+#if __APPLE__
+# include <TargetConditionals.h>
+# if TARGET_OS_IPHONE
+#   include <string>
+
+    namespace date
+    {
+    namespace iOSUtils
+    {
+    
+    std::string get_tzdata_path();
+    std::string get_current_timezone();
+    
+    }  // namespace iOSUtils
+    }  // namespace date
+
+# endif  // TARGET_OS_IPHONE
+#else   // !__APPLE__
+# define TARGET_OS_IPHONE 0
+#endif  // !__APPLE__
+#endif // ios_hpp

include/date/islamic.h

@@ -24,7 +24,7 @@
 // SOFTWARE.
 //
 // Our apologies.  When the previous paragraph was written, lowercase had not yet
-// been invented (that woud involve another several millennia of evolution).
+// been invented (that would involve another several millennia of evolution).
 // We did not mean to shout.
 
 #include "date.h"
@@ -39,10 +39,10 @@ using days = date::days;
 using weeks = date::weeks;
 
 using years = std::chrono::duration
-    <int, std::ratio_multiply<std::ratio<10631, 30>, days::period>>;
+    <int, date::detail::ratio_multiply<std::ratio<10631, 30>, days::period>>;
 
 using months = std::chrono::duration
-    <int, std::ratio_divide<years::period, std::ratio<12>>>;
+    <int, date::detail::ratio_divide<years::period, std::ratio<12>>>;
 
 // time_point
 
@@ -253,7 +253,7 @@ public:
     CONSTCD14 year& operator+=(const years& y) NOEXCEPT;
     CONSTCD14 year& operator-=(const years& y) NOEXCEPT;
 
-    CONSTCD11 bool is_leap() const NOEXCEPT;
+    CONSTCD14 bool is_leap() const NOEXCEPT;
 
     CONSTCD11 explicit operator int() const NOEXCEPT;
     CONSTCD11 bool ok() const NOEXCEPT;
@@ -866,7 +866,7 @@ inline
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const day& d)
 {
-    date::detail::save_stream<CharT, Traits> _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os.fill('0');
     os.flags(std::ios::dec | std::ios::right);
     os.width(2);
@@ -1046,7 +1046,7 @@ CONSTCD14 inline year year::operator--(int) NOEXCEPT {auto tmp(*this); --(*this)
 CONSTCD14 inline year& year::operator+=(const years& y) NOEXCEPT {*this = *this + y; return *this;}
 CONSTCD14 inline year& year::operator-=(const years& y) NOEXCEPT {*this = *this - y; return *this;}
 
-CONSTCD11
+CONSTCD14
 inline
 bool
 year::is_leap() const NOEXCEPT
@@ -1177,7 +1177,7 @@ inline
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const year& y)
 {
-    date::detail::save_stream<CharT, Traits> _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os.fill('0');
     os.flags(std::ios::dec | std::ios::internal);
     os.width(4 + (y < year{0}));
@@ -2236,7 +2236,7 @@ inline
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day& ymd)
 {
-    date::detail::save_stream<CharT, Traits> _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os.fill('0');
     os.flags(std::ios::dec | std::ios::right);
     os << ymd.year() << '-';

include/date/iso_week.h

@@ -3,7 +3,7 @@
 
 // The MIT License (MIT)
 //
-// Copyright (c) 2015, 2016 Howard Hinnant
+// Copyright (c) 2015, 2016, 2017 Howard Hinnant
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -25,6 +25,8 @@
 
 #include "date.h"
 
+#include <climits>
+
 namespace iso_week
 {
 
@@ -341,7 +343,7 @@ public:
     year_lastweek_weekday& operator-=(const years& y) NOEXCEPT;
 
     CONSTCD11 iso_week::year    year()    const NOEXCEPT;
-    CONSTCD11 iso_week::weeknum weeknum() const NOEXCEPT;
+    CONSTCD14 iso_week::weeknum weeknum() const NOEXCEPT;
     CONSTCD11 iso_week::weekday weekday() const NOEXCEPT;
 
     CONSTCD14 operator sys_days() const NOEXCEPT;
@@ -449,7 +451,7 @@ weekday::weekday(unsigned wd) NOEXCEPT
 CONSTCD11
 inline
 weekday::weekday(date::weekday wd) NOEXCEPT
-    : wd_(to_iso_encoding(static_cast<unsigned>(wd)))
+    : wd_(wd.iso_encoding())
     {}
 
 CONSTCD11
@@ -605,7 +607,10 @@ inline
 year
 year::min() NOEXCEPT
 {
-    using namespace std::chrono;
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    using std::chrono::hours;
+    using std::chrono::duration_cast;
     static_assert(sizeof(seconds)*CHAR_BIT >= 41, "seconds may overflow");
     static_assert(sizeof(hours)*CHAR_BIT >= 30, "hours may overflow");
     return sizeof(minutes)*CHAR_BIT < 34 ?
@@ -618,7 +623,10 @@ inline
 year
 year::max() NOEXCEPT
 {
-    using namespace std::chrono;
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    using std::chrono::hours;
+    using std::chrono::duration_cast;
     static_assert(sizeof(seconds)*CHAR_BIT >= 41, "seconds may overflow");
     static_assert(sizeof(hours)*CHAR_BIT >= 30, "hours may overflow");
     return sizeof(minutes)*CHAR_BIT < 34 ?
@@ -711,7 +719,7 @@ inline
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const year& y)
 {
-    date::detail::save_stream<CharT, Traits> _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os.fill('0');
     os.flags(std::ios::dec | std::ios::internal);
     os.width(4 + (y < year{0}));
@@ -873,7 +881,7 @@ inline
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const weeknum& wn)
 {
-    date::detail::save_stream<CharT, Traits> _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os << 'W';
     os.fill('0');
     os.flags(std::ios::dec | std::ios::right);
@@ -1013,9 +1021,9 @@ weeknum
 year_lastweek::weeknum() const NOEXCEPT
 {
     const auto y = date::year{static_cast<int>(y_)};
-    const auto s0 = sys_days{(y-years{1})/12/date::thu[date::last]};
-    const auto s1 = sys_days{y/12/date::thu[date::last]};
-    return iso_week::weeknum(date::trunc<weeks>(s1-s0).count());
+    const auto s0 = sys_days((y-years{1})/12/date::thu[date::last]);
+    const auto s1 = sys_days(y/12/date::thu[date::last]);
+    return iso_week::weeknum(static_cast<unsigned>(date::trunc<weeks>(s1-s0).count()));
 }
 
 CONSTCD11 inline bool year_lastweek::ok() const NOEXCEPT {return y_.ok();}
@@ -1297,7 +1305,7 @@ year_lastweek_weekday::operator-=(const years& y) NOEXCEPT
 
 CONSTCD11 inline year year_lastweek_weekday::year() const NOEXCEPT {return y_;}
 
-CONSTCD11
+CONSTCD14
 inline
 weeknum
 year_lastweek_weekday::weeknum() const NOEXCEPT
@@ -1311,16 +1319,16 @@ CONSTCD14
 inline
 year_lastweek_weekday::operator sys_days() const NOEXCEPT
 {
-    return sys_days{date::year{static_cast<int>(y_)}/date::dec/date::thu[date::last]}
-         + (mon - thu) - (mon - wd_);
+    return sys_days(date::year{static_cast<int>(y_)}/date::dec/date::thu[date::last])
+         + (sun - thu) - (sun - wd_);
 }
 
 CONSTCD14
 inline
 year_lastweek_weekday::operator local_days() const NOEXCEPT
 {
-    return local_days{date::year{static_cast<int>(y_)}/date::dec/date::thu[date::last]}
-         + (mon - thu) - (mon - wd_);
+    return local_days(date::year{static_cast<int>(y_)}/date::dec/date::thu[date::last])
+         + (sun - thu) - (sun - wd_);
 }
 
 CONSTCD11
@@ -1469,7 +1477,7 @@ CONSTCD14
 inline
 year_weeknum_weekday::operator sys_days() const NOEXCEPT
 {
-    return sys_days{date::year{static_cast<int>(y_)-1}/date::dec/date::thu[date::last]}
+    return sys_days(date::year{static_cast<int>(y_)-1}/date::dec/date::thu[date::last])
          + (date::mon - date::thu) + weeks{static_cast<unsigned>(wn_)-1} + (wd_ - mon);
 }
 
@@ -1477,7 +1485,7 @@ CONSTCD14
 inline
 year_weeknum_weekday::operator local_days() const NOEXCEPT
 {
-    return local_days{date::year{static_cast<int>(y_)-1}/date::dec/date::thu[date::last]}
+    return local_days(date::year{static_cast<int>(y_)-1}/date::dec/date::thu[date::last])
          + (date::mon - date::thu) + weeks{static_cast<unsigned>(wn_)-1} + (wd_ - mon);
 }
 
@@ -1497,13 +1505,14 @@ year_weeknum_weekday::from_days(days d) NOEXCEPT
     const auto dp = sys_days{d};
     const auto wd = iso_week::weekday{dp};
     auto y = date::year_month_day{dp + days{3}}.year();
-    auto start = sys_days{(y - date::years{1})/date::dec/date::thu[date::last]} + (mon-thu);
+    auto start = sys_days((y - date::years{1})/date::dec/date::thu[date::last]) + (mon-thu);
     if (dp < start)
     {
         --y;
-        start = sys_days{(y - date::years{1})/date::dec/date::thu[date::last]} + (mon-thu);
+        start = sys_days((y - date::years{1})/date::dec/date::thu[date::last]) + (mon-thu);
     }
-    const auto wn = iso_week::weeknum(date::trunc<weeks>(dp - start).count() + 1);
+    const auto wn = iso_week::weeknum(
+                       static_cast<unsigned>(date::trunc<weeks>(dp - start).count() + 1));
     return {iso_week::year(static_cast<int>(y)), wn, wd};
 }
 
@@ -1606,7 +1615,7 @@ inline
 year_weeknum
 operator/(const year& y, int wn) NOEXCEPT
 {
-    return y/weeknum(wn);
+    return y/weeknum(static_cast<unsigned>(wn));
 }
 
 CONSTCD11

include/date/julian.h

@@ -24,7 +24,7 @@
 // SOFTWARE.
 //
 // Our apologies.  When the previous paragraph was written, lowercase had not yet
-// been invented (that woud involve another several millennia of evolution).
+// been invented (that would involve another several millennia of evolution).
 // We did not mean to shout.
 
 #include "date.h"
@@ -39,10 +39,10 @@ using days = date::days;
 using weeks = date::weeks;
 
 using years = std::chrono::duration
-    <int, std::ratio_multiply<std::ratio<1461, 4>, days::period>>;
+    <int, date::detail::ratio_multiply<std::ratio<1461, 4>, days::period>>;
 
 using months = std::chrono::duration
-    <int, std::ratio_divide<years::period, std::ratio<12>>>;
+    <int, date::detail::ratio_divide<years::period, std::ratio<12>>>;
 
 // time_point
 
@@ -879,7 +879,7 @@ inline
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const day& d)
 {
-    date::detail::save_stream<CharT, Traits> _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os.fill('0');
     os.flags(std::ios::dec | std::ios::right);
     os.width(2);
@@ -1171,7 +1171,7 @@ inline
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const year& y)
 {
-    date::detail::save_stream<CharT, Traits> _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os.fill('0');
     os.flags(std::ios::dec | std::ios::internal);
     os.width(4 + (y < year{0}));
@@ -1655,9 +1655,12 @@ inline
 bool
 month_day::ok() const NOEXCEPT
 {
-    CONSTDATA julian::day d[] =
-        {31_d, 29_d, 31_d, 30_d, 31_d, 30_d, 31_d, 31_d, 30_d, 31_d, 30_d, 31_d};
-    return m_.ok() && 1_d <= d_ && d_ <= d[static_cast<unsigned>(m_)-1];
+    CONSTDATA julian::day d[] = { 
+        julian::day(31), julian::day(29), julian::day(31), julian::day(30), 
+        julian::day(31), julian::day(30), julian::day(31), julian::day(31), 
+        julian::day(30), julian::day(31), julian::day(30), julian::day(31) 
+    };
+    return m_.ok() && julian::day(1) <= d_ && d_ <= d[static_cast<unsigned>(m_)-1];
 }
 
 CONSTCD11
@@ -1946,9 +1949,12 @@ inline
 day
 year_month_day_last::day() const NOEXCEPT
 {
-    CONSTDATA julian::day d[] =
-        {31_d, 28_d, 31_d, 30_d, 31_d, 30_d, 31_d, 31_d, 30_d, 31_d, 30_d, 31_d};
-    return month() != feb || !y_.is_leap() ? d[static_cast<unsigned>(month())-1] : 29_d;
+    CONSTDATA julian::day d[] = { 
+        julian::day(31), julian::day(28), julian::day(31), julian::day(30), 
+        julian::day(31), julian::day(30), julian::day(31), julian::day(31), 
+        julian::day(30), julian::day(31), julian::day(30), julian::day(31) 
+    };
+    return month() != feb || !y_.is_leap() ? d[static_cast<unsigned>(month())-1] : julian::day(29);
 }
 
 CONSTCD14
@@ -2190,7 +2196,7 @@ year_month_day::ok() const NOEXCEPT
 {
     if (!(y_.ok() && m_.ok()))
         return false;
-    return 1_d <= d_ && d_ <= (y_/m_/last).day();
+    return julian::day(1) <= d_ && d_ <= (y_/m_/last).day();
 }
 
 CONSTCD11
@@ -2250,7 +2256,7 @@ inline
 std::basic_ostream<CharT, Traits>&
 operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day& ymd)
 {
-    date::detail::save_stream<CharT, Traits> _(os);
+    date::detail::save_ostream<CharT, Traits> _(os);
     os.fill('0');
     os.flags(std::ios::dec | std::ios::right);
     os << ymd.year() << '-';

include/date/ptz.h

@@ -0,0 +1,788 @@
+#ifndef PTZ_H
+#define PTZ_H
+
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// This header allows Posix-style time zones as specified for TZ here:
+// http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap08.html#tag_08_03
+//
+// Posix::time_zone can be constructed with a posix-style string and then used in
+// a zoned_time like so:
+//
+// zoned_time<system_clock::duration, Posix::time_zone> zt{"EST5EDT,M3.2.0,M11.1.0",
+//                                                         system_clock::now()};
+// or:
+//
+// Posix::time_zone tz{"EST5EDT,M3.2.0,M11.1.0"};
+// zoned_time<system_clock::duration, Posix::time_zone> zt{tz, system_clock::now()};
+//
+// If the rule set is missing (everything starting with ','), then the rule is that the
+// alternate offset is never enabled.
+//
+// Note, Posix-style time zones are not recommended for all of the reasons described here:
+// https://stackoverflow.com/tags/timezone/info
+//
+// They are provided here as a non-trivial custom time zone example, and if you really
+// have to have Posix time zones, you're welcome to use this one.
+
+#include "date/tz.h"
+#include <cctype>
+#include <ostream>
+#include <string>
+
+namespace Posix
+{
+
+namespace detail
+{
+
+#if HAS_STRING_VIEW
+
+using string_t = std::string_view;
+
+#else  // !HAS_STRING_VIEW
+
+using string_t = std::string;
+
+#endif  // !HAS_STRING_VIEW
+
+class rule;
+
+void throw_invalid(const string_t& s, unsigned i, const string_t& message);
+unsigned read_date(const string_t& s, unsigned i, rule& r);
+unsigned read_name(const string_t& s, unsigned i, std::string& name);
+unsigned read_signed_time(const string_t& s, unsigned i, std::chrono::seconds& t);
+unsigned read_unsigned_time(const string_t& s, unsigned i, std::chrono::seconds& t);
+unsigned read_unsigned(const string_t& s, unsigned i,  unsigned limit, unsigned& u,
+                       const string_t& message = string_t{});
+
+class rule
+{
+    enum {off, J, M, N};
+
+    date::month m_;
+    date::weekday wd_;
+    unsigned short n_    : 14;
+    unsigned short mode_ : 2;
+    std::chrono::duration<std::int32_t> time_ = std::chrono::hours{2};
+
+public:
+    rule() : mode_(off) {}
+
+    bool ok() const {return mode_ != off;}
+    date::local_seconds operator()(date::year y) const;
+    std::string to_string() const;
+
+    friend std::ostream& operator<<(std::ostream& os, const rule& r);
+    friend unsigned read_date(const string_t& s, unsigned i, rule& r);
+    friend bool operator==(const rule& x, const rule& y);
+};
+
+inline
+bool
+operator==(const rule& x, const rule& y)
+{
+    if (x.mode_ != y.mode_)
+        return false;
+    switch (x.mode_)
+    {
+    case rule::J:
+    case rule::N:
+        return x.n_ == y.n_;
+    case rule::M:
+        return x.m_ == y.m_ && x.n_ == y.n_ && x.wd_ == y.wd_;
+    default:
+        return true;
+    }
+}
+
+inline
+bool
+operator!=(const rule& x, const rule& y)
+{
+    return !(x == y);
+}
+
+inline
+date::local_seconds
+rule::operator()(date::year y) const
+{
+    using date::local_days;
+    using date::January;
+    using date::days;
+    using date::last;
+    using sec = std::chrono::seconds;
+    date::local_seconds t;
+    switch (mode_)
+    {
+    case J:
+        t = local_days{y/January/0} + days{n_ + (y.is_leap() && n_ > 59)} + sec{time_};
+        break;
+    case M:
+        t = (n_ == 5 ? local_days{y/m_/wd_[last]} : local_days{y/m_/wd_[n_]}) + sec{time_};
+        break;
+    case N:
+        t = local_days{y/January/1} + days{n_} + sec{time_};
+        break;
+    default:
+        assert(!"rule called with bad mode");
+    }
+    return t;
+}
+
+inline
+std::string
+rule::to_string() const
+{
+    using namespace std::chrono;
+    auto print_offset = [](seconds off)
+        {
+            std::string nm;
+            if (off != hours{2})
+            {
+                date::hh_mm_ss<seconds> offset{off};
+                nm = '/';
+                nm += std::to_string(offset.hours().count());
+                if (offset.minutes() != minutes{0} || offset.seconds() != seconds{0})
+                {
+                    nm += ':';
+                    if (offset.minutes() < minutes{10})
+                        nm += '0';
+                    nm += std::to_string(offset.minutes().count());
+                    if (offset.seconds() != seconds{0})
+                    {
+                        nm += ':';
+                        if (offset.seconds() < seconds{10})
+                            nm += '0';
+                        nm += std::to_string(offset.seconds().count());
+                    }
+                }
+            }
+            return nm;
+        };
+
+    std::string nm;
+    switch (mode_)
+    {
+    case rule::J:
+        nm = 'J';
+        nm += std::to_string(n_);
+        break;
+    case rule::M:
+        nm = 'M';
+        nm += std::to_string(static_cast<unsigned>(m_));
+        nm += '.';
+        nm += std::to_string(n_);
+        nm += '.';
+        nm += std::to_string(wd_.c_encoding());
+        break;
+    case rule::N:
+        nm = std::to_string(n_);
+        break;
+    default:
+        break;
+    }
+    nm += print_offset(time_);
+    return nm;
+}
+
+inline
+std::ostream&
+operator<<(std::ostream& os, const rule& r)
+{
+    switch (r.mode_)
+    {
+    case rule::J:
+        os << 'J' << r.n_ << date::format(" %T", r.time_);
+        break;
+    case rule::M:
+        if (r.n_ == 5)
+            os << r.m_/r.wd_[date::last];
+        else
+            os << r.m_/r.wd_[r.n_];
+        os <<  date::format(" %T", r.time_);
+        break;
+    case rule::N:
+        os << r.n_ << date::format(" %T", r.time_);
+        break;
+    default:
+        break;
+    }
+    return os;
+}
+
+}  // namespace detail
+
+class time_zone
+{
+    std::string          std_abbrev_;
+    std::string          dst_abbrev_ = {};
+    std::chrono::seconds offset_;
+    std::chrono::seconds save_ = std::chrono::hours{1};
+    detail::rule         start_rule_;
+    detail::rule         end_rule_;
+
+public:
+    explicit time_zone(const detail::string_t& name);
+
+    template <class Duration>
+        date::sys_info   get_info(date::sys_time<Duration> st) const;
+    template <class Duration>
+        date::local_info get_info(date::local_time<Duration> tp) const;
+
+    template <class Duration>
+        date::sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+        to_sys(date::local_time<Duration> tp) const;
+
+    template <class Duration>
+        date::sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+        to_sys(date::local_time<Duration> tp, date::choose z) const;
+
+    template <class Duration>
+        date::local_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+        to_local(date::sys_time<Duration> tp) const;
+
+    friend std::ostream& operator<<(std::ostream& os, const time_zone& z);
+
+    const time_zone* operator->() const {return this;}
+
+    std::string name() const;
+
+    friend bool operator==(const time_zone& x, const time_zone& y);
+};
+
+inline
+time_zone::time_zone(const detail::string_t& s)
+{
+    using detail::read_name;
+    using detail::read_signed_time;
+    using detail::throw_invalid;
+    auto i = read_name(s, 0, std_abbrev_);
+    i = read_signed_time(s, i, offset_);
+    offset_ = -offset_;
+    if (i != s.size())
+    {
+        i = read_name(s, i, dst_abbrev_);
+        if (i != s.size())
+        {
+            if (s[i] != ',')
+            {
+                i = read_signed_time(s, i, save_);
+                save_ = -save_ - offset_;
+            }
+            if (i != s.size())
+            {
+                if (s[i] != ',')
+                    throw_invalid(s, i, "Expecting end of string or ',' to start rule");
+                ++i;
+                i = read_date(s, i, start_rule_);
+                if (i == s.size() || s[i] != ',')
+                    throw_invalid(s, i, "Expecting ',' and then the ending rule");
+                ++i;
+                i = read_date(s, i, end_rule_);
+                if (i != s.size())
+                    throw_invalid(s, i, "Found unexpected trailing characters");
+            }
+        }
+    }
+}
+
+template <class Duration>
+date::sys_info
+time_zone::get_info(date::sys_time<Duration> st) const
+{
+    using date::sys_info;
+    using date::year_month_day;
+    using date::sys_seconds;
+    using date::sys_days;
+    using date::floor;
+    using date::ceil;
+    using date::days;
+    using date::years;
+    using date::year;
+    using date::January;
+    using date::December;
+    using date::last;
+    using std::chrono::minutes;
+    sys_info r{};
+    r.offset = offset_;
+    if (start_rule_.ok())
+    {
+        auto y = year_month_day{floor<days>(st)}.year();
+        auto start = sys_seconds{(start_rule_(y) - offset_).time_since_epoch()};
+        auto end   = sys_seconds{(end_rule_(y) - (offset_ + save_)).time_since_epoch()};
+        if (start <= st && st < end)
+        {
+            r.begin = start;
+            r.end = end;
+            r.offset += save_;
+            r.save = ceil<minutes>(save_);
+            r.abbrev = dst_abbrev_;
+        }
+        else if (st < start)
+        {
+            r.begin = sys_seconds{(end_rule_(y-years{1}) -
+                                   (offset_ + save_)).time_since_epoch()};
+            r.end = start;
+            r.abbrev = std_abbrev_;
+        }
+        else  // st >= end
+        {
+            r.begin = end;
+            r.end = sys_seconds{(start_rule_(y+years{1}) - offset_).time_since_epoch()};
+            r.abbrev = std_abbrev_;
+        }
+    }
+    else  //  constant offset
+    {
+        r.begin = sys_days{year::min()/January/1};
+        r.end   = sys_days{year::max()/December/last};
+        r.abbrev = std_abbrev_;
+    }
+    return r;
+}
+
+template <class Duration>
+date::local_info
+time_zone::get_info(date::local_time<Duration> tp) const
+{
+    using date::local_info;
+    using date::year_month_day;
+    using date::days;
+    using date::sys_days;
+    using date::sys_seconds;
+    using date::years;
+    using date::year;
+    using date::ceil;
+    using date::January;
+    using date::December;
+    using date::last;
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    local_info r{};
+    using date::floor;
+    if (start_rule_.ok())
+    {
+        auto y = year_month_day{floor<days>(tp)}.year();
+        auto start = sys_seconds{(start_rule_(y) - offset_).time_since_epoch()};
+        auto end   = sys_seconds{(end_rule_(y) - (offset_ + save_)).time_since_epoch()};
+        auto utcs = sys_seconds{floor<seconds>(tp - offset_).time_since_epoch()};
+        auto utcd = sys_seconds{floor<seconds>(tp - (offset_ + save_)).time_since_epoch()};
+        if ((utcs < start) != (utcd < start))
+        {
+            r.first.begin = sys_seconds{(end_rule_(y-years{1}) -
+                                         (offset_ + save_)).time_since_epoch()};
+            r.first.end = start;
+            r.first.offset = offset_;
+            r.first.abbrev = std_abbrev_;
+            r.second.begin = start;
+            r.second.end = end;
+            r.second.abbrev = dst_abbrev_;
+            r.second.offset = offset_ + save_;
+            r.second.save = ceil<minutes>(save_);
+            r.result = save_ > seconds{0} ? local_info::nonexistent
+                                          : local_info::ambiguous;
+        }
+        else if ((utcs < end) != (utcd < end))
+        {
+            r.first.begin = start;
+            r.first.end = end;
+            r.first.offset = offset_ + save_;
+            r.first.save = ceil<minutes>(save_);
+            r.first.abbrev = dst_abbrev_;
+            r.second.begin = end;
+            r.second.end = sys_seconds{(start_rule_(y+years{1}) -
+                                        offset_).time_since_epoch()};
+            r.second.abbrev = std_abbrev_;
+            r.second.offset = offset_;
+            r.result = save_ > seconds{0} ? local_info::ambiguous
+                                          : local_info::nonexistent;
+        }
+        else if (utcs < start)
+        {
+            r.first.begin = sys_seconds{(end_rule_(y-years{1}) -
+                                   (offset_ + save_)).time_since_epoch()};
+            r.first.end = start;
+            r.first.offset = offset_;
+            r.first.abbrev = std_abbrev_;
+        }
+        else if (utcs < end)
+        {
+            r.first.begin = start;
+            r.first.end = end;
+            r.first.offset = offset_ + save_;
+            r.first.save = ceil<minutes>(save_);
+            r.first.abbrev = dst_abbrev_;
+        }
+        else
+        {
+            r.first.begin = end;
+            r.first.end = sys_seconds{(start_rule_(y+years{1}) -
+                                       offset_).time_since_epoch()};
+            r.first.abbrev = std_abbrev_;
+            r.first.offset = offset_;
+        }
+    }
+    else  //  constant offset
+    {
+        r.first.begin = sys_days{year::min()/January/1};
+        r.first.end   = sys_days{year::max()/December/last};
+        r.first.abbrev = std_abbrev_;
+        r.first.offset = offset_;
+    }
+    return r;
+}
+
+template <class Duration>
+date::sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+time_zone::to_sys(date::local_time<Duration> tp) const
+{
+    using date::local_info;
+    using date::sys_time;
+    using date::ambiguous_local_time;
+    auto i = get_info(tp);
+    if (i.result == local_info::nonexistent)
+        throw nonexistent_local_time(tp, i);
+    else if (i.result == local_info::ambiguous)
+        throw ambiguous_local_time(tp, i);
+    return sys_time<Duration>{tp.time_since_epoch()} - i.first.offset;
+}
+
+template <class Duration>
+date::sys_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+time_zone::to_sys(date::local_time<Duration> tp, date::choose z) const
+{
+    using date::local_info;
+    using date::sys_time;
+    using date::choose;
+    auto i = get_info(tp);
+    if (i.result == local_info::nonexistent)
+    {
+        return i.first.end;
+    }
+    else if (i.result == local_info::ambiguous)
+    {
+        if (z == choose::latest)
+            return sys_time<Duration>{tp.time_since_epoch()} - i.second.offset;
+    }
+    return sys_time<Duration>{tp.time_since_epoch()} - i.first.offset;
+}
+
+template <class Duration>
+date::local_time<typename std::common_type<Duration, std::chrono::seconds>::type>
+time_zone::to_local(date::sys_time<Duration> tp) const
+{
+    using date::local_time;
+    using std::chrono::seconds;
+    using LT = local_time<typename std::common_type<Duration, seconds>::type>;
+    auto i = get_info(tp);
+    return LT{(tp + i.offset).time_since_epoch()};
+}
+
+inline
+std::ostream&
+operator<<(std::ostream& os, const time_zone& z)
+{
+    using date::operator<<;
+    os << '{';
+    os << z.std_abbrev_ << ", " << z.dst_abbrev_ << date::format(", %T, ", z.offset_)
+       << date::format("%T, [", z.save_) << z.start_rule_ << ", " << z.end_rule_ << ")}";
+    return os;
+}
+
+inline
+std::string
+time_zone::name() const
+{
+    using namespace date;
+    using namespace std::chrono;
+    auto nm = std_abbrev_;
+    auto print_offset = [](seconds off)
+        {
+            std::string nm;
+            hh_mm_ss<seconds> offset{-off};
+            if (offset.is_negative())
+                nm += '-';
+            nm += std::to_string(offset.hours().count());
+            if (offset.minutes() != minutes{0} || offset.seconds() != seconds{0})
+            {
+                nm += ':';
+                if (offset.minutes() < minutes{10})
+                    nm += '0';
+                nm += std::to_string(offset.minutes().count());
+                if (offset.seconds() != seconds{0})
+                {
+                    nm += ':';
+                    if (offset.seconds() < seconds{10})
+                        nm += '0';
+                    nm += std::to_string(offset.seconds().count());
+                }
+            }
+            return nm;
+        };
+    nm += print_offset(offset_);
+    if (!dst_abbrev_.empty())
+    {
+        nm += dst_abbrev_;
+        if (save_ != hours{1})
+            nm += print_offset(offset_+save_);
+        if (start_rule_.ok())
+        {
+            nm += ',';
+            nm += start_rule_.to_string();
+            nm += ',';
+            nm += end_rule_.to_string();
+        }
+    }
+    return nm;
+}
+
+inline
+bool
+operator==(const time_zone& x, const time_zone& y)
+{
+    return x.std_abbrev_ == y.std_abbrev_ &&
+           x.dst_abbrev_ == y. dst_abbrev_ &&
+           x.offset_ == y.offset_ &&
+           x.save_ == y.save_ &&
+           x.start_rule_ == y.start_rule_ &&
+           x.end_rule_ == y.end_rule_;
+}
+
+inline
+bool
+operator!=(const time_zone& x, const time_zone& y)
+{
+    return !(x == y);
+}
+
+namespace detail
+{
+
+inline
+void
+throw_invalid(const string_t& s, unsigned i, const string_t& message)
+{
+    throw std::runtime_error(std::string("Invalid time_zone initializer.\n") +
+                             std::string(message) + ":\n" +
+                             std::string(s) + '\n' +
+                             "\x1b[1;32m" +
+                             std::string(i, '~') + '^' +
+                             std::string(i < s.size() ? s.size()-i-1 : 0, '~') +
+                             "\x1b[0m");
+}
+
+inline
+unsigned
+read_date(const string_t& s, unsigned i, rule& r)
+{
+    using date::month;
+    using date::weekday;
+    if (i == s.size())
+        throw_invalid(s, i, "Expected rule but found end of string");
+    if (s[i] == 'J')
+    {
+        ++i;
+        unsigned n;
+        i = read_unsigned(s, i, 3, n, "Expected to find the Julian day [1, 365]");
+        r.mode_ = rule::J;
+        r.n_ = n;
+    }
+    else if (s[i] == 'M')
+    {
+        ++i;
+        unsigned m;
+        i = read_unsigned(s, i, 2, m, "Expected to find month [1, 12]");
+        if (i == s.size() || s[i] != '.')
+            throw_invalid(s, i, "Expected '.' after month");
+        ++i;
+        unsigned n;
+        i = read_unsigned(s, i, 1, n, "Expected to find week number [1, 5]");
+        if (i == s.size() || s[i] != '.')
+            throw_invalid(s, i, "Expected '.' after weekday index");
+        ++i;
+        unsigned wd;
+        i = read_unsigned(s, i, 1, wd, "Expected to find day of week [0, 6]");
+        r.mode_ = rule::M;
+        r.m_ = month{m};
+        r.wd_ = weekday{wd};
+        r.n_ = n;
+    }
+    else if (std::isdigit(s[i]))
+    {
+        unsigned n;
+        i = read_unsigned(s, i, 3, n);
+        r.mode_ = rule::N;
+        r.n_ = n;
+    }
+    else
+        throw_invalid(s, i, "Expected 'J', 'M', or a digit to start rule");
+    if (i != s.size() && s[i] == '/')
+    {
+        ++i;
+        std::chrono::seconds t;
+        i = read_unsigned_time(s, i, t);
+        r.time_ = t;
+    }
+    return i;
+}
+
+inline
+unsigned
+read_name(const string_t& s, unsigned i, std::string& name)
+{
+    if (i == s.size())
+        throw_invalid(s, i, "Expected a name but found end of string");
+    if (s[i] == '<')
+    {
+        ++i;
+        while (true)
+        {
+            if (i == s.size())
+                throw_invalid(s, i,
+                              "Expected to find closing '>', but found end of string");
+            if (s[i] == '>')
+                break;
+            name.push_back(s[i]);
+            ++i;
+        }
+        ++i;
+    }
+    else
+    {
+        while (i != s.size() && std::isalpha(s[i]))
+        {
+            name.push_back(s[i]);
+            ++i;
+        }
+    }
+    if (name.size() < 3)
+        throw_invalid(s, i, "Found name to be shorter than 3 characters");
+    return i;
+}
+
+inline
+unsigned
+read_signed_time(const string_t& s, unsigned i,
+                                  std::chrono::seconds& t)
+{
+    if (i == s.size())
+        throw_invalid(s, i, "Expected to read signed time, but found end of string");
+    bool negative = false;
+    if (s[i] == '-')
+    {
+        negative = true;
+        ++i;
+    }
+    else if (s[i] == '+')
+        ++i;
+    i = read_unsigned_time(s, i, t);
+    if (negative)
+        t = -t;
+    return i;
+}
+
+inline
+unsigned
+read_unsigned_time(const string_t& s, unsigned i, std::chrono::seconds& t)
+{
+    using std::chrono::seconds;
+    using std::chrono::minutes;
+    using std::chrono::hours;
+    if (i == s.size())
+        throw_invalid(s, i, "Expected to read unsigned time, but found end of string");
+    unsigned x;
+    i = read_unsigned(s, i, 2, x, "Expected to find hours [0, 24]");
+    t = hours{x};
+    if (i != s.size() && s[i] == ':')
+    {
+        ++i;
+        i = read_unsigned(s, i, 2, x, "Expected to find minutes [0, 59]");
+        t += minutes{x};
+        if (i != s.size() && s[i] == ':')
+        {
+            ++i;
+            i = read_unsigned(s, i, 2, x, "Expected to find seconds [0, 59]");
+            t += seconds{x};
+        }
+    }
+    return i;
+}
+
+inline
+unsigned
+read_unsigned(const string_t& s, unsigned i, unsigned limit, unsigned& u,
+              const string_t& message)
+{
+    if (i == s.size() || !std::isdigit(s[i]))
+        throw_invalid(s, i, message);
+    u = static_cast<unsigned>(s[i] - '0');
+    unsigned count = 1;
+    for (++i; count < limit && i != s.size() && std::isdigit(s[i]); ++i, ++count)
+        u = u * 10 + static_cast<unsigned>(s[i] - '0');
+    return i;
+}
+
+}  // namespace detail
+
+}  // namespace Posix
+
+namespace date
+{
+
+template <>
+struct zoned_traits<Posix::time_zone>
+{
+
+#if HAS_STRING_VIEW
+
+    static
+    Posix::time_zone
+    locate_zone(std::string_view name)
+    {
+        return Posix::time_zone{name};
+    }
+
+#else  // !HAS_STRING_VIEW
+
+    static
+    Posix::time_zone
+    locate_zone(const std::string& name)
+    {
+        return Posix::time_zone{name};
+    }
+
+    static
+    Posix::time_zone
+    locate_zone(const char* name)
+    {
+        return Posix::time_zone{name};
+    }
+
+#endif  // !HAS_STRING_VIEW
+
+};
+
+}  // namespace date
+
+#endif  // PTZ_H

include/date/tz_private.h

@@ -24,16 +24,32 @@
 // SOFTWARE.
 //
 // Our apologies.  When the previous paragraph was written, lowercase had not yet
-// been invented (that woud involve another several millennia of evolution).
+// been invented (that would involve another several millennia of evolution).
 // We did not mean to shout.
 
+#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
 #include "tz.h"
+#else
+#include "date.h"
+#include <vector>
+#endif
 
 namespace date
 {
 
+namespace detail
+{
+
+#if !USE_OS_TZDB
+
 enum class tz {utc, local, standard};
 
+//forward declare to avoid warnings in gcc 6.2
+class MonthDayTime;
+std::istream& operator>>(std::istream& is, MonthDayTime& x);
+std::ostream& operator<<(std::ostream& os, const MonthDayTime& x);
+
+
 class MonthDayTime
 {
 private:
@@ -110,11 +126,25 @@ public:
 // A Rule specifies one or more set of datetimes without using an offset.
 // Multiple dates are specified with multiple years.  The years in effect
 // go from starting_year_ to ending_year_, inclusive.  starting_year_ <=
-// ending_year_. save_ is ineffect for times from the specified time
+// ending_year_. save_ is in effect for times from the specified time
 // onward, including the specified time. When the specified time is
 // local, it uses the save_ from the chronologically previous Rule, or if
 // there is none, 0.
 
+//forward declare to avoid warnings in gcc 6.2
+class Rule;
+bool operator==(const Rule& x, const Rule& y);
+bool operator<(const Rule& x, const Rule& y);
+bool operator==(const Rule& x, const date::year& y);
+bool operator<(const Rule& x, const date::year& y);
+bool operator==(const date::year& x, const Rule& y);
+bool operator<(const date::year& x, const Rule& y);
+bool operator==(const Rule& x, const std::string& y);
+bool operator<(const Rule& x, const std::string& y);
+bool operator==(const std::string& x, const Rule& y);
+bool operator<(const std::string& x, const Rule& y);
+std::ostream& operator<<(std::ostream& os, const Rule& r);
+
 class Rule
 {
 private:
@@ -187,7 +217,7 @@ inline bool operator> (const std::string& x, const Rule& y) {return   y < x;}
 inline bool operator<=(const std::string& x, const Rule& y) {return !(y < x);}
 inline bool operator>=(const std::string& x, const Rule& y) {return !(x < y);}
 
-struct time_zone::zonelet
+struct zonelet
 {
     enum tag {has_rule, has_save, is_empty};
 
@@ -215,7 +245,7 @@ struct time_zone::zonelet
     sys_seconds                        until_utc_;
     local_seconds                      until_std_;
     local_seconds                      until_loc_;
-    std::chrono::minutes               initial_save_{};
+    std::chrono::minutes               initial_save_{0};
     std::string                        initial_abbrev_;
     std::pair<const Rule*, date::year> first_rule_{nullptr, date::year::min()};
     std::pair<const Rule*, date::year> last_rule_{nullptr, date::year::max()};
@@ -226,6 +256,61 @@ struct time_zone::zonelet
     zonelet& operator=(const zonelet&) = delete;
 };
 
+#else  // USE_OS_TZDB
+
+struct ttinfo
+{
+    std::int32_t  tt_gmtoff;
+    unsigned char tt_isdst;
+    unsigned char tt_abbrind;
+    unsigned char pad[2];
+};
+
+static_assert(sizeof(ttinfo) == 8, "");
+
+struct expanded_ttinfo
+{
+    std::chrono::seconds offset;
+    std::string          abbrev;
+    bool                 is_dst;
+};
+
+struct transition
+{
+    sys_seconds            timepoint;
+    const expanded_ttinfo* info;
+
+    transition(sys_seconds tp, const expanded_ttinfo* i = nullptr)
+        : timepoint(tp)
+        , info(i)
+        {}
+
+    friend
+    std::ostream&
+    operator<<(std::ostream& os, const transition& t)
+    {
+        using date::operator<<;
+        os << t.timepoint << "Z ";
+        if (t.info->offset >= std::chrono::seconds{0})
+            os << '+';
+        os << make_time(t.info->offset);
+        if (t.info->is_dst > 0)
+            os << " daylight ";
+        else
+            os << " standard ";
+        os << t.info->abbrev;
+        return os;
+    }
+};
+
+#endif  // USE_OS_TZDB
+
+}  // namespace detail
+
 }  // namespace date
 
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+#include "tz.h"
+#endif
+
 #endif  // TZ_PRIVATE_H

library.json

@@ -0,0 +1,11 @@
+{
+    "name": "date",
+    "version": "1.0.0",
+    "build": {
+        "includeDir": "include",
+        "srcFilter":
+        [
+            "+<->"
+        ]
+    }
+}

src/ios.mm

@@ -0,0 +1,337 @@
+//
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Alexander Kormanovsky
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+#include "date/ios.h"
+
+#if TARGET_OS_IPHONE
+
+#include <Foundation/Foundation.h>
+
+#include <fstream>
+#include <zlib.h>
+#include <sys/stat.h>
+
+#ifndef TAR_DEBUG
+#  define TAR_DEBUG 0
+#endif
+
+#define INTERNAL_DIR        "Library"
+#define TZDATA_DIR          "tzdata"
+#define TARGZ_EXTENSION     "tar.gz"
+
+#define TAR_BLOCK_SIZE                  512
+#define TAR_TYPE_POSITION               156
+#define TAR_NAME_POSITION               0
+#define TAR_NAME_SIZE                   100
+#define TAR_SIZE_POSITION               124
+#define TAR_SIZE_SIZE                   12
+
+namespace date
+{
+    namespace iOSUtils
+    {
+        
+        struct TarInfo
+        {
+            char objType;
+            std::string objName;
+            size_t realContentSize; // writable size without padding zeroes
+            size_t blocksContentSize; // adjusted size to 512 bytes blocks
+            bool success;
+        };
+        
+        std::string convertCFStringRefPathToCStringPath(CFStringRef ref);
+        bool extractTzdata(CFURLRef homeUrl, CFURLRef archiveUrl, std::string destPath);
+        TarInfo getTarObjectInfo(std::ifstream &readStream);
+        std::string getTarObject(std::ifstream &readStream, int64_t size);
+        bool writeFile(const std::string &tzdataPath, const std::string &fileName,
+                       const std::string &data, size_t realContentSize);
+        
+        std::string
+        get_current_timezone()
+        {
+            CFTimeZoneRef tzRef = CFTimeZoneCopySystem();
+            CFStringRef tzNameRef = CFTimeZoneGetName(tzRef);
+            CFIndex bufferSize = CFStringGetLength(tzNameRef) + 1;
+            char buffer[bufferSize];
+            
+            if (CFStringGetCString(tzNameRef, buffer, bufferSize, kCFStringEncodingUTF8))
+            {
+                CFRelease(tzRef);
+                return std::string(buffer);
+            }
+            
+            CFRelease(tzRef);
+            
+            return "";
+        }
+        
+        std::string
+        get_tzdata_path()
+        {
+            CFURLRef homeUrlRef = CFCopyHomeDirectoryURL();
+            CFStringRef homePath = CFURLCopyPath(homeUrlRef);
+            std::string path(std::string(convertCFStringRefPathToCStringPath(homePath)) +
+                             INTERNAL_DIR + "/" + TZDATA_DIR);
+            std::string result_path(std::string(convertCFStringRefPathToCStringPath(homePath)) +
+                                    INTERNAL_DIR);
+            
+            if (access(path.c_str(), F_OK) == 0)
+            {
+#if TAR_DEBUG
+                printf("tzdata dir exists\n");
+#endif
+                CFRelease(homeUrlRef);
+                CFRelease(homePath);
+                
+                return result_path;
+            }
+            
+            CFBundleRef mainBundle = CFBundleGetMainBundle();
+            CFArrayRef paths = CFBundleCopyResourceURLsOfType(mainBundle, CFSTR(TARGZ_EXTENSION),
+                                                              NULL);
+            
+            if (CFArrayGetCount(paths) != 0)
+            {
+                // get archive path, assume there is no other tar.gz in bundle
+                CFURLRef archiveUrl = static_cast<CFURLRef>(CFArrayGetValueAtIndex(paths, 0));
+                CFStringRef archiveName = CFURLCopyPath(archiveUrl);
+                archiveUrl = CFBundleCopyResourceURL(mainBundle, archiveName, NULL, NULL);
+                
+                extractTzdata(homeUrlRef, archiveUrl, path);
+                
+                CFRelease(archiveUrl);
+                CFRelease(archiveName);
+            }
+            
+            CFRelease(homeUrlRef);
+            CFRelease(homePath);
+            CFRelease(paths);
+            
+            return result_path;
+        }
+        
+        std::string
+        convertCFStringRefPathToCStringPath(CFStringRef ref)
+        {
+            CFIndex bufferSize = CFStringGetMaximumSizeOfFileSystemRepresentation(ref);
+            char *buffer = new char[bufferSize];
+            CFStringGetFileSystemRepresentation(ref, buffer, bufferSize);
+            auto result = std::string(buffer);
+            delete[] buffer;
+            return result;
+        }
+        
+        bool
+        extractTzdata(CFURLRef homeUrl, CFURLRef archiveUrl, std::string destPath)
+        {
+            std::string TAR_TMP_PATH = "/tmp.tar";
+            
+            CFStringRef homeStringRef = CFURLCopyPath(homeUrl);
+            auto homePath = convertCFStringRefPathToCStringPath(homeStringRef);
+            CFRelease(homeStringRef);
+            
+            CFStringRef archiveStringRef = CFURLCopyPath(archiveUrl);
+            auto archivePath = convertCFStringRefPathToCStringPath(archiveStringRef);
+            CFRelease(archiveStringRef);
+            
+            // create Library path
+            auto libraryPath = homePath + INTERNAL_DIR;
+            
+            // create tzdata path
+            auto tzdataPath = libraryPath + "/" + TZDATA_DIR;
+            
+            // -- replace %20 with " "
+            const std::string search = "%20";
+            const std::string replacement = " ";
+            size_t pos = 0;
+            
+            while ((pos = archivePath.find(search, pos)) != std::string::npos) {
+                archivePath.replace(pos, search.length(), replacement);
+                pos += replacement.length();
+            }
+            
+            gzFile tarFile = gzopen(archivePath.c_str(), "rb");
+            
+            // create tar unpacking path
+            auto tarPath = libraryPath + TAR_TMP_PATH;
+            
+            // create tzdata directory
+            mkdir(destPath.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+            
+            // ======= extract tar ========
+            
+            std::ofstream os(tarPath.c_str(), std::ofstream::out | std::ofstream::app);
+            unsigned int bufferLength = 1024 * 256;  // 256Kb
+            unsigned char *buffer = (unsigned char *)malloc(bufferLength);
+            bool success = true;
+            
+            while (true)
+            {
+                int readBytes = gzread(tarFile, buffer, bufferLength);
+                
+                if (readBytes > 0)
+                {
+                    os.write((char *) &buffer[0], readBytes);
+                }
+                else
+                    if (readBytes == 0)
+                    {
+                        break;
+                    }
+                    else
+                        if (readBytes == -1)
+                        {
+                            printf("decompression failed\n");
+                            success = false;
+                            break;
+                        }
+                        else
+                        {
+                            printf("unexpected zlib state\n");
+                            success = false;
+                            break;
+                        }
+            }
+            
+            os.close();
+            free(buffer);
+            gzclose(tarFile);
+            
+            if (!success)
+            {
+                remove(tarPath.c_str());
+                return false;
+            }
+            
+            // ======== extract files =========
+            
+            uint64_t location = 0; // Position in the file
+            
+            // get file size
+            struct stat stat_buf;
+            int res = stat(tarPath.c_str(), &stat_buf);
+            if (res != 0)
+            {
+                printf("error file size\n");
+                remove(tarPath.c_str());
+                return false;
+            }
+            int64_t tarSize = stat_buf.st_size;
+            
+            // create read stream
+            std::ifstream is(tarPath.c_str(), std::ifstream::in | std::ifstream::binary);
+            
+            // process files
+            while (location < tarSize)
+            {
+                TarInfo info = getTarObjectInfo(is);
+                
+                if (!info.success || info.realContentSize == 0)
+                {
+                    break; // something wrong or all files are read
+                }
+                
+                switch (info.objType)
+                {
+                    case '0':   // file
+                    case '\0':  //
+                    {
+                        std::string obj = getTarObject(is, info.blocksContentSize);
+#if TAR_DEBUG
+                        size += info.realContentSize;
+                        printf("#%i %s file size %lld written total %ld from %lld\n", ++count,
+                               info.objName.c_str(), info.realContentSize, size, tarSize);
+#endif
+                        writeFile(tzdataPath, info.objName, obj, info.realContentSize);
+                        location += info.blocksContentSize;
+                        
+                        break;
+                    }
+                }
+            }
+            
+            remove(tarPath.c_str());
+            
+            return true;
+        }
+        
+        TarInfo
+        getTarObjectInfo(std::ifstream &readStream)
+        {
+            int64_t length = TAR_BLOCK_SIZE;
+            char buffer[length];
+            char type;
+            char name[TAR_NAME_SIZE + 1];
+            char sizeBuf[TAR_SIZE_SIZE + 1];
+            
+            readStream.read(buffer, length);
+            
+            memcpy(&type, &buffer[TAR_TYPE_POSITION], 1);
+            
+            memset(&name, '\0', TAR_NAME_SIZE + 1);
+            memcpy(&name, &buffer[TAR_NAME_POSITION], TAR_NAME_SIZE);
+            
+            memset(&sizeBuf, '\0', TAR_SIZE_SIZE + 1);
+            memcpy(&sizeBuf, &buffer[TAR_SIZE_POSITION], TAR_SIZE_SIZE);
+            size_t realSize = strtol(sizeBuf, NULL, 8);
+            size_t blocksSize = realSize + (TAR_BLOCK_SIZE - (realSize % TAR_BLOCK_SIZE));
+            
+            return {type, std::string(name), realSize, blocksSize, true};
+        }
+        
+        std::string
+        getTarObject(std::ifstream &readStream, int64_t size)
+        {
+            char buffer[size];
+            readStream.read(buffer, size);
+            return std::string(buffer);
+        }
+        
+        bool
+        writeFile(const std::string &tzdataPath, const std::string &fileName, const std::string &data,
+                  size_t realContentSize)
+        {
+            std::ofstream os(tzdataPath + "/" + fileName, std::ofstream::out | std::ofstream::binary);
+            
+            if (!os) {
+                return false;
+            }
+            
+            // trim empty space
+            char trimmedData[realContentSize + 1];
+            memset(&trimmedData, '\0', realContentSize);
+            memcpy(&trimmedData, data.c_str(), realContentSize);
+            
+            // write
+            os.write(trimmedData, realContentSize);
+            os.close();
+            
+            return true;
+        }
+        
+    }  // namespace iOSUtils
+}  // namespace date
+
+#endif  // TARGET_OS_IPHONE

test/clock_cast_test/constexpr.pass.cpp

@@ -0,0 +1,75 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 nanoric
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+#include <cassert>
+#include <type_traits>
+
+struct const_clock {
+  using duration =
+      typename std::common_type<std::chrono::system_clock::duration,
+          date::days>::type;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<const_clock, duration>;
+
+  static constexpr date::sys_days epoch { date::days { 1000 } };
+
+  template <typename Duration>
+  static std::chrono::time_point<std::chrono::system_clock,
+      typename std::common_type<Duration, date::days>::type>
+      CONSTCD11 to_sys(std::chrono::time_point<const_clock, Duration> const& tp)
+  {
+    return epoch + tp.time_since_epoch();
+  }
+
+  template <typename Duration>
+  static std::chrono::time_point<const_clock,
+      typename std::common_type<Duration, date::days>::type>
+      CONSTCD11 from_sys(
+          std::chrono::time_point<std::chrono::system_clock, Duration> const&
+              tp)
+  {
+    using res = std::chrono::time_point<const_clock,
+        typename std::common_type<Duration, date::days>::type>;
+    return res(tp - epoch);
+  }
+};
+
+int main()
+{
+  using namespace date;
+  using namespace std::chrono;
+  using const_days = time_point<const_clock, days>;
+
+  CONSTCD14 sys_days sys { days { 1024 } };
+  static_assert(sys.time_since_epoch().count() == 1024, "");
+
+  CONSTCD14 const_days c {clock_cast<const_clock>(sys)};
+  CONSTCD14 sys_days sys2 {clock_cast<system_clock>(c)};
+  CONSTCD14 sys_days sys3 { clock_cast<system_clock>(const_days(days(48))) };
+#if __cplusplus >= 201402L
+  static_assert(c.time_since_epoch().count() == 24, "");
+  static_assert(sys2.time_since_epoch().count() == 1024, "");
+  static_assert(sys3.time_since_epoch().count() == 1048, "");
+#endif
+}

test/clock_cast_test/custom_clock.pass.cpp

@@ -0,0 +1,213 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017, 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+#include <cassert>
+#include <type_traits>
+
+//used to count number of conversion
+int conversions = 0;
+
+//to/from impl
+struct mil_clock
+{
+  using duration = typename std::common_type<std::chrono::system_clock::duration, date::days>::type;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<mil_clock, duration>;
+
+  static constexpr date::sys_days epoch{date::days{1000}};
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<std::chrono::system_clock, typename std::common_type<Duration, date::days>::type>
+  to_sys(std::chrono::time_point<mil_clock, Duration> const& tp)
+  {
+    ++conversions;
+    return epoch + tp.time_since_epoch();
+  }
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>
+  from_sys(std::chrono::time_point<std::chrono::system_clock, Duration> const& tp)
+  {
+    ++conversions;
+    using res = std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>;
+    return res(tp - epoch);
+  }
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<date::local_t, typename std::common_type<Duration, date::days>::type>
+  to_local(std::chrono::time_point<mil_clock, Duration> const& tp)
+  {
+     return date::clock_cast<date::local_t>(to_sys(tp));
+  }
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>
+  from_local(std::chrono::time_point<date::local_t, Duration> const& tp)
+  {
+    return from_sys(date::clock_cast<std::chrono::system_clock>(tp));
+  }
+
+
+  static time_point now()
+  {
+    return from_sys(std::chrono::system_clock::now());
+  }
+};
+
+
+date::sys_days const mil_clock::epoch;
+
+// traits example
+struct s2s_clock
+{
+  using duration = std::chrono::system_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<s2s_clock, duration>;
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<std::chrono::system_clock, Duration>
+  to_sys(std::chrono::time_point<s2s_clock, Duration> const& tp)
+  {
+    ++conversions;
+    return std::chrono::time_point<std::chrono::system_clock, Duration>(tp.time_since_epoch());
+  }
+
+  template<typename Duration>
+  static
+  std::chrono::time_point<s2s_clock, Duration>
+  from_sys(std::chrono::time_point<std::chrono::system_clock, Duration> const& tp)
+  {
+    ++conversions;
+    return std::chrono::time_point<s2s_clock, Duration>(tp.time_since_epoch());
+  }
+
+  static time_point now()
+  {
+    return from_sys(std::chrono::system_clock::now());
+  }
+};
+
+namespace date
+{
+   template<>
+   struct clock_time_conversion<mil_clock, s2s_clock>
+   {
+     template<typename Duration>
+     std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>
+     operator()(std::chrono::time_point<s2s_clock, Duration> const& tp)
+     {
+       ++conversions;
+       using res = std::chrono::time_point<mil_clock, typename std::common_type<Duration, date::days>::type>;
+       return res(tp.time_since_epoch() - mil_clock::epoch.time_since_epoch());
+     }
+   };
+}
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    // self
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+
+       assert(clock_cast<mil_clock>(mt) == mt);
+    }
+
+    // mil <-> local
+    {
+       local_days lt(1997_y/dec/12);
+       auto mt = mil_clock::from_local(lt);
+
+       assert(clock_cast<mil_clock>(lt) == mt);
+       assert(clock_cast<local_t>(mt) == lt);
+    }
+
+    // mil <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+
+       assert(clock_cast<mil_clock>(st) == mt);
+       assert(clock_cast<sys_clock>(mt) == st);
+    }
+
+    // mil <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+       auto ut = utc_clock::from_sys(st);
+
+       assert(clock_cast<mil_clock>(ut) == mt);
+       assert(clock_cast<utc_clock>(mt) == ut);
+    }
+
+    // mil <-> tai
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(clock_cast<tai_clock>(mt) == tt);
+       assert(clock_cast<mil_clock>(tt) == mt);
+    }
+
+    // mil <-> gps
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(clock_cast<gps_clock>(mt) == gt);
+       assert(clock_cast<mil_clock>(gt) == mt);
+    }
+
+    // s2s -> mil
+    {
+       sys_days st(1997_y/dec/12);
+       auto mt = mil_clock::from_sys(st);
+       auto s2t = s2s_clock::from_sys(st);
+
+       //direct trait conversion
+       conversions = 0;
+       assert(clock_cast<mil_clock>(s2t) == mt);
+       assert(conversions == 1);
+
+       //uses sys_clock
+       conversions = 0;
+       assert(clock_cast<s2s_clock>(mt) == s2t);
+       assert(conversions == 2);
+    }
+}

test/clock_cast_test/deprecated.pass.cpp

@@ -0,0 +1,90 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+#include <cassert>
+
+int
+main()
+{
+    using namespace date;
+
+    // sys <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+
+       assert(to_utc_time(st) == ut);
+       assert(to_sys_time(ut) == st);
+    }
+
+    // tai <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(to_tai_time(ut) == tt);
+       assert(to_utc_time(tt) == ut);
+    }
+
+    // tai <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(to_tai_time(st) == tt);
+       assert(to_sys_time(tt) == st);
+    }
+
+    // gps <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(to_gps_time(ut) == gt);
+       assert(to_utc_time(gt) == ut);
+    }
+
+    // gps <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(to_gps_time(st) == gt);
+       assert(to_sys_time(gt) == st);
+    }
+
+    // tai <-> gps
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(to_gps_time(tt) == gt);
+       assert(to_tai_time(gt) == tt);
+    }
+}

test/clock_cast_test/local_t.pass.cpp

@@ -0,0 +1,132 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include <chrono>
+#include "date/tz.h"
+
+int
+main()
+{
+   using namespace date;
+   using namespace std::chrono;
+
+   // self
+   {
+     auto ls = local_days{1970_y/January/1_d};
+     assert(clock_cast<local_t>(ls) == ls);
+   }
+
+   /// sys epoch
+   {
+     auto ls = local_days{1970_y/January/1_d};
+     auto st = clock_cast<system_clock>(ls);
+     assert(clock_cast<local_t>(st) == ls);
+     assert(st.time_since_epoch() == seconds(0));
+   }
+
+   /// sys 2000 case
+   {
+     auto ls = local_days{2000_y/January/1_d};
+     auto st = clock_cast<system_clock>(ls);
+     assert(clock_cast<local_t>(st) == ls);
+     assert(st.time_since_epoch() == seconds(946684800));
+   }
+
+   /// utc epoch
+   {
+     auto lu = local_days{1970_y/January/1_d};
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<local_t>(ut) == lu);
+     assert(ut.time_since_epoch() == seconds(0));
+   }
+
+   // utc leap second
+   {
+     auto lu = local_days{2015_y/July/1_d} - milliseconds(1);
+     auto ut = clock_cast<utc_clock>(lu) + milliseconds(50); //into leap second
+
+     assert(clock_cast<local_t>(ut) == lu);
+   }
+
+   /// utc paper example
+   {
+     auto lu = local_days{2000_y/January/1_d};
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<local_t>(ut) == lu);
+     assert(ut.time_since_epoch() == seconds(946684822));
+   }
+
+   /// tai epoch
+   {
+     auto lt = local_days{1958_y/January/1_d};
+     auto tt = clock_cast<tai_clock>(lt);
+     assert(clock_cast<local_t>(tt) == lt);
+     assert(tt.time_since_epoch() == seconds(0));
+
+     auto lu = local_days{1958_y/January/1_d} - seconds(10);
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<tai_clock>(ut) == tt);
+   }
+
+   // tai paper example
+   {
+      auto lt = local_days{2000_y/January/1_d} + seconds(32);
+      auto tt = clock_cast<tai_clock>(lt);
+      assert(clock_cast<local_t>(tt) == lt);
+
+      auto lu = local_days{2000_y/January/1_d};
+      auto ut = clock_cast<utc_clock>(lu);
+      assert(clock_cast<tai_clock>(ut) == tt);
+   }
+
+   /// gps epoch
+   {
+     auto lg = local_days{1980_y/January/Sunday[1]};
+     auto gt = clock_cast<gps_clock>(lg);
+     assert(clock_cast<local_t>(gt) == lg);
+     assert(gt.time_since_epoch() == seconds(0));
+
+     auto lu = local_days{1980_y/January/Sunday[1]};
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<gps_clock>(ut) == gt);
+
+     auto lt = local_days{1980_y/January/Sunday[1]} + seconds(19);
+     auto tt = clock_cast<tai_clock>(lt);
+     assert(clock_cast<gps_clock>(tt) == gt);
+   }
+
+   // gps 2000 example
+   {
+     auto lg = local_days{2000_y/January/1_d};
+     auto gt = clock_cast<gps_clock>(lg);
+     assert(clock_cast<local_t>(gt) == lg);
+
+     auto lu = local_days{2000_y/January/1_d} - seconds(13);
+     auto ut = clock_cast<utc_clock>(lu);
+     assert(clock_cast<gps_clock>(ut) == gt);
+
+     auto lt = local_days{2000_y/January/1_d} + seconds(19);
+     auto tt = clock_cast<tai_clock>(lt);
+     assert(clock_cast<gps_clock>(tt) == gt);
+   }
+
+}

test/clock_cast_test/noncastable.pass.cpp

@@ -0,0 +1,251 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017, 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+#include <type_traits>
+#include <cassert>
+
+template<typename SourceClock, typename DestClock, typename = void>
+struct is_clock_castable
+  : std::false_type
+{};
+
+template<typename SourceClock, typename DestClock>
+struct is_clock_castable<SourceClock, DestClock, decltype(date::clock_cast<DestClock>(typename SourceClock::time_point()), void())>
+  : std::true_type
+{};
+
+
+//Clock based on steady clock, not related to wall time (sys_clock/utc_clock)
+struct steady_based_clock
+{
+  using duration = std::chrono::steady_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<steady_based_clock, duration>;
+
+  static time_point now()
+  {
+    return time_point(std::chrono::steady_clock::now().time_since_epoch());
+  }
+};
+
+//Traits that allow conversion between steady_clock and steady_based clock
+//Does not use wall-time clocks as rally (sys/utc)
+namespace date
+{
+   template<>
+   struct clock_time_conversion<std::chrono::steady_clock, steady_based_clock>
+   {
+     template<typename Duration>
+     std::chrono::time_point<std::chrono::steady_clock, Duration>
+     operator()(std::chrono::time_point<steady_based_clock, Duration> const& tp) const
+     {
+       using res = std::chrono::time_point<std::chrono::steady_clock, Duration>;
+       return res(tp.time_since_epoch());
+     }
+   };
+
+   template<>
+   struct clock_time_conversion<steady_based_clock, std::chrono::steady_clock>
+   {
+     template<typename Duration>
+     std::chrono::time_point<steady_based_clock, Duration>
+     operator()(std::chrono::time_point<std::chrono::steady_clock, Duration> const& tp) const
+     {
+       using res = std::chrono::time_point<steady_based_clock, Duration>;
+       return res(tp.time_since_epoch());
+     }
+   };
+}
+
+//Ambigous clocks both providing to/from_sys and to/from_utc
+//They are mock_ups just returning zero time_point
+struct amb1_clock
+{
+   using duration = std::chrono::seconds;
+   using rep = duration::rep;
+   using period = duration::period;
+   using time_point = std::chrono::time_point<amb1_clock>;
+
+   static time_point now()
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<std::chrono::system_clock, Duration>
+   to_sys(std::chrono::time_point<amb1_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<amb1_clock, Duration>
+   from_sys(std::chrono::time_point<std::chrono::system_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<date::utc_clock, Duration>
+   to_utc(std::chrono::time_point<amb1_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<amb1_clock, Duration>
+   from_utc(std::chrono::time_point<date::utc_clock, Duration> const&)
+   {
+     return {};
+   }
+};
+
+struct amb2_clock
+{
+   using duration = std::chrono::seconds;
+   using rep = duration::rep;
+   using period = duration::period;
+   using time_point = std::chrono::time_point<amb2_clock>;
+
+   static time_point now()
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<std::chrono::system_clock, Duration>
+   to_sys(std::chrono::time_point<amb2_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<amb2_clock, Duration>
+   from_sys(std::chrono::time_point<std::chrono::system_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<date::utc_clock, Duration>
+   to_utc(std::chrono::time_point<amb2_clock, Duration> const&)
+   {
+     return {};
+   }
+
+   template<typename Duration>
+   static
+   std::chrono::time_point<amb2_clock, Duration>
+   from_utc(std::chrono::time_point<date::utc_clock, Duration> const&)
+   {
+     return {};
+   }
+};
+
+namespace date
+{
+   //Disambiguates that sys_clock is preffered
+   template<>
+   struct clock_time_conversion<amb1_clock, amb2_clock>
+   {
+     template<typename Duration>
+     std::chrono::time_point<amb1_clock, Duration>
+     operator()(std::chrono::time_point<amb2_clock, Duration> const& tp) const
+     {
+       return amb1_clock::from_sys(amb2_clock::to_sys(tp));
+     }
+   };
+}
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+    using sys_clock = std::chrono::system_clock;
+
+    //steady_clock (must be different that sys_clock)
+    static_assert(is_clock_castable<steady_clock, steady_clock>::value, "steady_clock -> steady_clock");
+    static_assert(!is_clock_castable<steady_clock, local_t>::value, "steady_clock -> local_t");
+    static_assert(!is_clock_castable<local_t, steady_clock>::value, "local_t -> steady_clock");
+    static_assert(!is_clock_castable<steady_clock, sys_clock>::value, "steady_clock -> sys_clock");
+    static_assert(!is_clock_castable<sys_clock, steady_clock>::value, "sys_clock -> steady_clock");
+    static_assert(!is_clock_castable<steady_clock, utc_clock>::value, "steady_clock -> utc_clock");
+    static_assert(!is_clock_castable<utc_clock, steady_clock>::value, "utc_clock -> steady_clock");
+    static_assert(!is_clock_castable<steady_clock, tai_clock>::value, "steady_clock -> tai_clock");
+    static_assert(!is_clock_castable<tai_clock, steady_clock>::value, "tai_clock -> steady_clock");
+
+    //steady_based_clock (unrelated to sys_clock and utc_clocks)
+    static_assert(is_clock_castable<steady_based_clock, steady_based_clock>::value, "steady_based_clock -> steady_based_clock");
+    static_assert(!is_clock_castable<steady_based_clock, local_t>::value, "steady_based_clock -> local_t");
+    static_assert(!is_clock_castable<local_t, steady_based_clock>::value, "local_t -> steady_based_clock");
+    static_assert(!is_clock_castable<steady_based_clock, sys_clock>::value, "steady_based_clock -> sys_clock");
+    static_assert(!is_clock_castable<sys_clock, steady_based_clock>::value, "sys_clock -> steady_based_clock");
+    static_assert(!is_clock_castable<steady_based_clock, utc_clock>::value, "steady_based_clock -> utc_clock");
+    static_assert(!is_clock_castable<utc_clock, steady_based_clock>::value, "utc_clock -> steady_based_clock");
+    static_assert(!is_clock_castable<steady_based_clock, tai_clock>::value, "steady_based_clock -> tai_clock");
+    static_assert(!is_clock_castable<tai_clock, steady_based_clock>::value, "tai_clock -> steady_based_clock");
+
+    //steady_based <-> steady_clock
+    {
+      auto s1 = steady_clock::time_point(steady_clock::duration(200));
+      auto s2 = steady_based_clock::time_point(steady_based_clock::duration(200));
+
+      assert(clock_cast<steady_based_clock>(s1) == s2);
+      assert(clock_cast<steady_clock>(s2) == s1);
+    }
+
+    //ambX <-> sys/utc works as one rally can be used in each case, or one lead to quicker conversione
+    static_assert(is_clock_castable<amb1_clock, amb1_clock>::value, "amb1_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb1_clock, sys_clock>::value, "amb1_clock -> sys_clock");
+    static_assert(is_clock_castable<sys_clock, amb1_clock>::value, "sys_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb1_clock, utc_clock>::value, "amb1_clock -> utc_clock");
+    static_assert(is_clock_castable<utc_clock, amb1_clock>::value, "utc_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb1_clock, tai_clock>::value, "amb1_clock -> tai_clock");
+    static_assert(is_clock_castable<tai_clock, amb1_clock>::value, "tai_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb1_clock, tai_clock>::value, "amb1_clock -> tai_clock");
+    static_assert(is_clock_castable<gps_clock, amb1_clock>::value, "gps_clock -> amb1_clock");
+    static_assert(is_clock_castable<amb2_clock, amb2_clock>::value, "amb2_clock -> amb2_clock");
+    static_assert(is_clock_castable<amb2_clock, sys_clock>::value, "amb2_clock -> sys_clock");
+    static_assert(is_clock_castable<sys_clock, amb2_clock>::value, "sys_clock -> amb2_clock");
+    static_assert(is_clock_castable<amb2_clock, utc_clock>::value, "amb2_clock -> utc_clock");
+    static_assert(is_clock_castable<utc_clock, amb2_clock>::value, "utc_clock -> amb2_clock");
+    static_assert(is_clock_castable<amb2_clock, tai_clock>::value, "amb2_clock -> tai_clock");
+    static_assert(is_clock_castable<tai_clock, amb2_clock>::value, "tai_clock -> amb2_clock");
+    static_assert(is_clock_castable<amb2_clock, tai_clock>::value, "amb2_clock -> tai_clock");
+    static_assert(is_clock_castable<gps_clock, amb2_clock>::value, "gps_clock -> amb2_clock");
+
+    //amb1 -> amb2: ambigous because can either go trough sys_clock or utc_clock
+    static_assert(!is_clock_castable<amb1_clock, amb2_clock>::value, "amb1_clock -> amb2_clock");
+
+    //amb2 -> amb1: disambiguated via trait specialization
+    static_assert(is_clock_castable<amb2_clock, amb1_clock>::value, "amb2_clock -> amb1_clock");
+}

test/clock_cast_test/normal_clocks.pass.cpp

@@ -0,0 +1,102 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+#include <cassert>
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    // self
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(clock_cast<sys_clock>(st) == st);
+       assert(clock_cast<utc_clock>(ut) == ut);
+       assert(clock_cast<tai_clock>(tt) == tt);
+    }
+
+    // sys <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+
+       assert(clock_cast<utc_clock>(st) == ut);
+       assert(clock_cast<sys_clock>(ut) == st);
+    }
+
+    // tai <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(clock_cast<tai_clock>(ut) == tt);
+       assert(clock_cast<utc_clock>(tt) == ut);
+    }
+
+    // tai <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+
+       assert(clock_cast<tai_clock>(st) == tt);
+       assert(clock_cast<sys_clock>(tt) == st);
+    }
+
+    // gps <-> utc
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(clock_cast<gps_clock>(ut) == gt);
+       assert(clock_cast<utc_clock>(gt) == ut);
+    }
+
+    // gps <-> sys
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(clock_cast<gps_clock>(st) == gt);
+       assert(clock_cast<sys_clock>(gt) == st);
+    }
+
+    // tai <-> gps
+    {
+       sys_days st(1997_y/dec/12);
+       auto ut = utc_clock::from_sys(st);
+       auto tt = tai_clock::from_utc(ut);
+       auto gt = gps_clock::from_utc(ut);
+
+       assert(clock_cast<gps_clock>(tt) == gt);
+       assert(clock_cast<tai_clock>(gt) == tt);
+    }
+}

test/clock_cast_test/to_sys_return_int.fail.cpp

@@ -0,0 +1,49 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+
+struct bad_clock
+{
+  using duration = std::chrono::system_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<bad_clock, duration>;
+
+  template<typename Duration>
+  static
+  int
+  to_sys(std::chrono::time_point<bad_clock, Duration> const& tp)
+  {
+    return tp.time_since_epoch().count();
+  }
+};
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    auto bt = bad_clock::time_point();
+    clock_cast<sys_clock>(bt);
+}

test/clock_cast_test/to_sys_return_reference.fail.cpp

@@ -0,0 +1,51 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+
+struct bad_clock
+{
+  using duration = std::chrono::system_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<bad_clock, duration>;
+
+  template<typename Duration>
+  static
+  date::sys_time<Duration> const&
+  to_sys(std::chrono::time_point<bad_clock, Duration> const& tp)
+  {
+    static date::sys_time<Duration> val;
+    val = date::sys_time<Duration>(tp.time_since_epoch());
+    return val;
+  }
+};
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    auto bt = bad_clock::time_point();
+    clock_cast<sys_clock>(bt);
+}

test/clock_cast_test/to_sys_return_utc_time.fail.cpp

@@ -0,0 +1,49 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017, 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+
+struct bad_clock
+{
+  using duration = std::chrono::system_clock::duration;
+  using rep = duration::rep;
+  using period = duration::period;
+  using time_point = std::chrono::time_point<bad_clock, duration>;
+
+  template<typename Duration>
+  static
+  date::utc_time<Duration>
+  to_sys(std::chrono::time_point<bad_clock, Duration> const& tp)
+  {
+    return date::utc_time<Duration>(tp.time_since_epoch());
+  }
+};
+
+int
+main()
+{
+    using namespace date;
+    using sys_clock = std::chrono::system_clock;
+
+    auto bt = bad_clock::time_point();
+    clock_cast<sys_clock>(bt);
+}

test/date_test/day.pass.cpp

@@ -60,7 +60,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::day>{}, "");
-static_assert(!std::is_default_constructible<date::day>{}, "");
+static_assert( std::is_default_constructible<date::day>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::day>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::day>{}, "");
 static_assert( std::is_trivially_move_constructible<date::day>{}, "");

test/date_test/detail/decimal_format_seconds.pass.cpp

@@ -0,0 +1,141 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// template <class Duration>
+// class decimal_format_seconds
+// {
+//     using CT = typename std::common_type<Duration, std::chrono::seconds>::type;
+//     using rep = typename CT::rep;
+// public:
+//     static unsigned constexpr width = detail::width<CT::period::den>::value < 19 ?
+//                                       detail::width<CT::period::den>::value : 6u;
+//     using precision = std::chrono::duration<rep,
+//                                             std::ratio<1, static_pow10<width>::value>>;
+// private:
+//     std::chrono::seconds s_;
+//     precision            sub_s_;
+// 
+// public:
+//     constexpr explicit decimal_format_seconds(const Duration& d) noexcept;
+// 
+//     constexpr std::chrono::seconds& seconds() noexcept;
+//     constexpr std::chrono::seconds seconds() const noexcept;
+//     constexpr precision subseconds() const noexcept;
+//     constexpr precision to_duration() const noexcept;
+// 
+//     template <class CharT, class Traits>
+//     friend
+//     std::basic_ostream<CharT, Traits>&
+//     operator<<(std::basic_ostream<CharT, Traits>& os, const decimal_format_seconds& x);
+// };
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+using fortnights = std::chrono::duration<date::weeks::rep,
+                                         date::detail::ratio_multiply<std::ratio<2>,
+                                                                      date::weeks::period>>;
+
+using microfortnights = std::chrono::duration<std::int64_t,
+                                              date::detail::ratio_multiply<fortnights::period,
+                                                                           std::micro>>;
+
+int
+main()
+{
+    using namespace date::detail;
+    using namespace std;
+    using namespace std::chrono;
+
+    {
+        using D = decimal_format_seconds<minutes>;
+        static_assert(is_same<D::precision, seconds>{}, "");
+        static_assert(D::width == 0, "");
+        D dfs{minutes{3}};
+        assert(dfs.seconds() == seconds{180});
+        assert(dfs.to_duration() == seconds{180});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "180");
+    }
+    {
+        using D = decimal_format_seconds<seconds>;
+        static_assert(is_same<D::precision, seconds>{}, "");
+        static_assert(D::width == 0, "");
+        D dfs{seconds{3}};
+        assert(dfs.seconds() == seconds{3});
+        assert(dfs.to_duration() == seconds{3});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "03");
+    }
+    {
+        using D = decimal_format_seconds<milliseconds>;
+        static_assert(D::width == 3, "");
+        D dfs{seconds{3}};
+        assert(dfs.seconds() == seconds{3});
+        assert(dfs.to_duration() == seconds{3});
+        assert(dfs.subseconds() == milliseconds{0});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "03.000");
+    }
+    {
+        using D = decimal_format_seconds<milliseconds>;
+        static_assert(D::width == 3, "");
+        D dfs{milliseconds{3}};
+        assert(dfs.seconds() == seconds{0});
+        assert(dfs.to_duration() == milliseconds{3});
+        assert(dfs.subseconds() == milliseconds{3});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "00.003");
+    }
+    {
+        using D = decimal_format_seconds<microfortnights>;
+        static_assert(D::width == 4, "");
+        D dfs{microfortnights{3}};
+        using S = D::precision;
+        assert(dfs.seconds() == seconds{3});
+        assert(dfs.to_duration() == S{36288});
+        assert(dfs.subseconds() == S{6288});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "03.6288");
+    }
+    {
+        using CT = common_type<seconds, microfortnights>::type;
+        using D = decimal_format_seconds<CT>;
+        static_assert(D::width == 4, "");
+        D dfs{microfortnights{3}};
+        using S = D::precision;
+        assert(dfs.seconds() == seconds{3});
+        assert(dfs.to_duration() == S{36288});
+        assert(dfs.subseconds() == S{6288});
+        ostringstream out;
+        out << dfs;
+        assert(out.str() == "03.6288");
+    }
+}

test/date_test/detail/static_pow10.pass.cpp

@@ -0,0 +1,50 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// template <unsigned exp>
+// struct static_pow10
+// {
+//     static constepxr std::uint64_t value = ...;
+// };
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+int
+main()
+{
+    using namespace date::detail;
+    static_assert(static_pow10<0>::value ==  1, "");
+    static_assert(static_pow10<1>::value ==  10, "");
+    static_assert(static_pow10<2>::value ==  100, "");
+    static_assert(static_pow10<3>::value ==  1000, "");
+    static_assert(static_pow10<4>::value ==  10000, "");
+    static_assert(static_pow10<5>::value ==  100000, "");
+    static_assert(static_pow10<6>::value ==  1000000, "");
+    static_assert(static_pow10<7>::value ==  10000000, "");
+    static_assert(static_pow10<8>::value ==  100000000, "");
+    static_assert(static_pow10<9>::value ==  1000000000, "");
+    static_assert(static_pow10<10>::value == 10000000000, "");
+}

test/date_test/detail/width.pass.cpp

@@ -0,0 +1,64 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// width<n>::value is the number of fractional decimal digits in 1/n
+// width<0>::value and width<1>::value are defined to be 0
+// If 1/n takes more than 18 fractional decimal digits,
+//   the result is truncated to 19.
+// Example:  width<2>::value    ==  1
+// Example:  width<3>::value    == 19
+// Example:  width<4>::value    ==  2
+// Example:  width<10>::value   ==  1
+// Example:  width<1000>::value ==  3
+// template <std::uint64_t n>
+//
+// struct width
+// {
+//     static constexpr unsigned value = ...;
+// };
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+int
+main()
+{
+    using namespace date::detail;
+    static_assert(width<0, 1>::value == 0, "");
+    static_assert(width<1, 1>::value == 0, "");
+    static_assert(width<1, 2>::value == 1, "");
+    static_assert(width<1, 3>::value == 19, "");
+    static_assert(width<1, 4>::value == 2, "");
+    static_assert(width<1, 5>::value == 1, "");
+    static_assert(width<1, 6>::value == 19, "");
+    static_assert(width<1, 7>::value == 19, "");
+    static_assert(width<1, 8>::value == 3, "");
+    static_assert(width<1, 9>::value == 19, "");
+    static_assert(width<1, 10>::value == 1, "");
+    static_assert(width<1, 100>::value == 2, "");
+    static_assert(width<1, 1000>::value == 3, "");
+    static_assert(width<1, 10000>::value == 4, "");
+    static_assert(width<756, 625>::value == 4, "");
+}

test/date_test/durations_output.pass.cpp

@@ -0,0 +1,328 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+
+void test_SI()
+{
+   using namespace std::chrono;
+   using namespace date;
+
+   std::ostringstream os;
+
+   // atto
+   {
+     duration<int, std::atto> d(13);
+     os << d;
+     assert(os.str() == "13as");
+     os.str("");
+   }
+
+   // femto
+   {
+     duration<int, std::femto> d(13);
+     os << d;
+     assert(os.str() == "13fs");
+     os.str("");
+   }
+
+   // pico
+   {
+     duration<int, std::pico> d(13);
+     os << d;
+     assert(os.str() == "13ps");
+     os.str("");
+   }
+
+   // nano
+   {
+     duration<int, std::nano> d(13);
+     os << d;
+     assert(os.str() == "13ns");
+     os.str("");
+   }
+
+   // mikro
+   {
+     duration<int, std::micro> d(13);
+     os << d;
+     assert(os.str() == "13\xC2\xB5s");
+     os.str("");
+   }
+
+   // milli
+   {
+     duration<int, std::milli> d(13);
+     os << d;
+     assert(os.str() == "13ms");
+     os.str("");
+   }
+
+   // centi
+   {
+     duration<int, std::centi> d(13);
+     os << d;
+     assert(os.str() == "13cs");
+     os.str("");
+   }
+
+   // deci
+   {
+     duration<int, std::deci> d(13);
+     os << d;
+     assert(os.str() == "13ds");
+     os.str("");
+   }
+
+   // seconds
+   {
+     duration<int> d(13);
+     os << d;
+     assert(os.str() == "13s");
+     os.str("");
+   }
+
+   // deca
+   {
+     duration<int, std::deca> d(13);
+     os << d;
+     assert(os.str() == "13das");
+     os.str("");
+   }
+
+   // hecto
+   {
+     duration<int, std::hecto> d(13);
+     os << d;
+     assert(os.str() == "13hs");
+     os.str("");
+   }
+
+   // kilo
+   {
+     duration<int, std::kilo> d(13);
+     os << d;
+     assert(os.str() == "13ks");
+     os.str("");
+   }
+
+   // mega
+   {
+     duration<int, std::mega> d(13);
+     os << d;
+     assert(os.str() == "13Ms");
+     os.str("");
+   }
+
+   // giga
+   {
+     duration<int, std::giga> d(13);
+     os << d;
+     assert(os.str() == "13Gs");
+     os.str("");
+   }
+
+   // tera
+   {
+     duration<int, std::tera> d(13);
+     os << d;
+     assert(os.str() == "13Ts");
+     os.str("");
+   }
+
+   // peta
+   {
+     duration<int, std::peta> d(13);
+     os << d;
+     assert(os.str() == "13Ps");
+     os.str("");
+   }
+
+   // femto
+   {
+     duration<int, std::exa> d(13);
+     os << d;
+     assert(os.str() == "13Es");
+     os.str("");
+   }
+}
+
+void test_calendar()
+{
+   using namespace std::chrono;
+   using namespace date;
+
+   std::ostringstream os;
+
+   // minutes
+   {
+      minutes d(13);
+      os << d;
+      assert(os.str() == "13min");
+      os.str("");
+   }
+
+   // hours
+   {
+      hours d(13);
+      os << d;
+      assert(os.str() == "13h");
+      os.str("");
+   }
+
+   // days
+   {
+      days d(13);
+      os << d;
+      assert(os.str() == "13d");
+      os.str("");
+   }
+}
+
+void test_integral_scale()
+{
+   using namespace std::chrono;
+   using namespace date;
+
+   std::ostringstream os;
+
+   // ratio 123 / 1
+   {
+      duration<int, std::ratio<123, 1>> d(13);
+      os << d;
+      assert(os.str() == "13[123]s");
+      os.str("");
+   }
+
+   // ratio 100 / 4 = ratio 25 / 1
+   {
+      duration<int, std::ratio<25, 1>> d(13);
+      os << d;
+      assert(os.str() == "13[25]s");
+      os.str("");
+   }
+
+   // weeks = ratio 7 * 24 * 60 * 60 / 1 = ratio 604800 / 1
+   {
+      weeks d(13);
+      os << d;
+      assert(os.str() == "13[604800]s");
+      os.str("");
+   }
+
+   // years = 146097/400 days = ratio 146097/400 * 24 * 60 * 60 = ratio 31556952 / 1
+   {
+      years d(13);
+      os << d;
+      assert(os.str() == "13[31556952]s");
+      os.str("");
+   }
+
+   // months = 1/12 years = ratio 1/12 * 31556952  = ratio 2629746 / 1
+   {
+      months d(13);
+      os << d;
+      assert(os.str() == "13[2629746]s");
+      os.str("");
+   }
+}
+
+void test_ratio_scale()
+{
+   using namespace std::chrono;
+   using namespace date;
+
+   std::ostringstream os;
+
+   // ratio 1 / 2
+   {
+      duration<int, std::ratio<1, 2>> d(13);
+      os << d;
+      assert(os.str() == "13[1/2]s");
+      os.str("");
+   }
+
+   // ratio 100 / 3
+   {
+      duration<int, std::ratio<100, 3>> d(13);
+      os << d;
+      assert(os.str() == "13[100/3]s");
+      os.str("");
+   }
+
+   // ratio 100 / 6 = ratio 50 / 3
+   {
+      duration<int, std::ratio<100, 6>> d(13);
+      os << d;
+      assert(os.str() == "13[50/3]s");
+      os.str("");
+   }
+}
+
+void test_constexpr()
+{
+  using date::detail::get_units;
+
+  CONSTCD11 auto as = get_units<char>(std::atto{});
+  CONSTCD11 auto fs = get_units<char>(std::femto{});
+  CONSTCD11 auto ps = get_units<char>(std::pico{});
+  CONSTCD11 auto ns = get_units<char>(std::nano{});
+  CONSTCD11 auto us = get_units<char>(std::micro{});
+  CONSTCD11 auto usw = get_units<wchar_t>(std::micro{});
+  CONSTCD11 auto ms = get_units<char>(std::milli{});
+  CONSTCD11 auto cs = get_units<char>(std::centi{});
+  CONSTCD11 auto ds = get_units<char>(std::deci{});
+  CONSTCD11 auto s = get_units<char>(std::ratio<1>{});
+  CONSTCD11 auto das = get_units<char>(std::deca{});
+  CONSTCD11 auto hs = get_units<char>(std::hecto{});
+  CONSTCD11 auto ks = get_units<char>(std::kilo{});
+  CONSTCD11 auto Ms = get_units<char>(std::mega{});
+  CONSTCD11 auto Gs = get_units<char>(std::giga{});
+  CONSTCD11 auto Ts = get_units<char>(std::tera{});
+  CONSTCD11 auto Ps = get_units<char>(std::peta{});
+  CONSTCD11 auto Es = get_units<char>(std::exa{});
+  (void)as, (void)fs, (void)ps, (void)ns, (void)usw, (void)us,
+  (void)ms, (void)cs, (void)ds, (void)s,  (void)das, (void)hs,
+  (void)ks, (void)Ms, (void)Gs, (void)Ts, (void)Ps,  (void)Es;
+
+  CONSTCD11 auto min = get_units<char>(std::ratio<60>{});
+  CONSTCD11 auto h = get_units<char>(std::ratio<3600>{});
+  CONSTCD11 auto d = get_units<char>(std::ratio<86400>{});
+  (void)min, (void)h, (void)d;
+
+  CONSTCD14 auto integer = get_units<char>(std::ratio<123>{});
+  CONSTCD14 auto ratio = get_units<char>(std::ratio<123, 3>{});
+  (void)integer, (void)ratio;
+}
+
+int
+main()
+{
+  test_SI();
+  test_calendar();
+  test_integral_scale();
+  test_ratio_scale();
+}

test/date_test/format/century.pass.cpp

@@ -0,0 +1,117 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+    std::ostringstream os;
+    os << format("%C", sys_days{jun/1/20001});
+    assert(os.str() == "200");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/20000});
+    assert(os.str() == "200");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/19999});
+    assert(os.str() == "199");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/2001});
+    assert(os.str() == "20");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/2000});
+    assert(os.str() == "20");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/1999});
+    assert(os.str() == "19");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/101});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/100});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/99});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/1});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/0});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-1});
+    assert(os.str() == "-01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-99});
+    assert(os.str() == "-01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-100});
+    assert(os.str() == "-01");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-101});
+    assert(os.str() == "-02");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-1999});
+    assert(os.str() == "-20");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-2000});
+    assert(os.str() == "-20");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-2001});
+    assert(os.str() == "-21");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-19999});
+    assert(os.str() == "-200");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-20000});
+    assert(os.str() == "-200");
+
+    os.str("");
+    os << format("%C", sys_days{jun/1/-20001});
+    assert(os.str() == "-201");
+}

test/date_test/format/misc.pass.cpp

@@ -0,0 +1,52 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "date.h"
+#include <cassert>
+#include <sstream>
+
+template <class T>
+void
+test(const std::string& in_fmt, const std::string& input,
+     const std::string& out_fmt, const std::string& output)
+{
+    using namespace date;
+    std::istringstream in{input};
+    T t;
+    in >> parse(in_fmt, t);
+    assert(!in.fail());
+    auto s = format(out_fmt, t);
+    assert(s == output);
+}
+
+int
+main()
+{
+    using namespace date;
+    test<year>("%Y", "2017", "%Y", "2017");
+    test<month>("%m", "3", "%m", "03");
+    test<day>("%d", "25", "%d", "25");
+    test<year_month>("%Y-%m", "2017-03", "%Y-%m", "2017-03");
+    test<year_month>("%y%m", "1703", "%Y-%m", "2017-03");
+    test<month_day>("%m/%d", "3/25", "%m/%d", "03/25");
+    test<weekday>("%w", "3", "%w", "3");
+}

test/date_test/format/range.pass.cpp

@@ -0,0 +1,78 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+using fortnights = std::chrono::duration<date::weeks::rep,
+                                         date::detail::ratio_multiply<std::ratio<2>,
+                                                                      date::weeks::period>>;
+
+using microfortnights = std::chrono::duration<std::int64_t,
+                                              date::detail::ratio_multiply<fortnights::period,
+                                                                           std::micro>>;
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+    std::ostringstream os;
+    os << format("%F %T", sys_days{jan/1/year::min()});
+    assert(os.str() == "-32767-01-01 00:00:00");
+    os.str("");
+    os << format("%F %T", sys_days{dec/last/year::max()});
+    assert(os.str() == "32767-12-31 00:00:00");
+    os.str("");
+    os << format("%F %T", sys_days{dec/last/year::max()} + hours{23} + minutes{59} +
+                                                  seconds{59} + microseconds{999999});
+    assert(os.str() == "32767-12-31 23:59:59.999999");
+    os.str("");
+
+    os << format("%Y-%m-%d %H:%M:%S", sys_days{jan/1/year::min()});
+    assert(os.str() == "-32767-01-01 00:00:00");
+    os.str("");
+    os << format("%Y-%m-%d %H:%M:%S", sys_days{dec/last/year::max()});
+    assert(os.str() == "32767-12-31 00:00:00");
+    os.str("");
+    os << format("%Y-%m-%d %H:%M:%S", sys_days{dec/last/year::max()} + hours{23} +
+                                        minutes{59} + seconds{59} + microseconds{999999});
+    assert(os.str() == "32767-12-31 23:59:59.999999");
+    os.str("");
+
+    os << format("%F %T", sys_days{jan/1/year::min()} + microfortnights{1});
+    assert(os.str() == "-32767-01-01 00:00:01.2096");
+    os.str("");
+    os << format("%F %T", sys_days{dec/last/year::max()} + microfortnights{1});
+    assert(os.str() == "32767-12-31 00:00:01.2096");
+    os.str("");
+
+    os << format("%F", jan/1/year::min());
+    assert(os.str() == "-32767-01-01");
+    os.str("");
+    os << format("%F", dec/last/year::max());
+    assert(os.str() == "32767-12-31");
+    os.str("");
+}

test/date_test/format/two_dight_year.pass.cpp

@@ -0,0 +1,121 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+    std::ostringstream os;
+    os << format("%y", sys_days{jun/1/20001});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/20000});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/19999});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/2001});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/2000});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/1999});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/101});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/100});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/99});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/1});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/0});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-1});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-99});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-100});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-101});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-1999});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-2000});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-2001});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-19999});
+    assert(os.str() == "99");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-20000});
+    assert(os.str() == "00");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/-20001});
+    assert(os.str() == "01");
+
+    os.str("");
+    os << format("%y", sys_days{jun/1/year::min()});
+    assert(os.str() == "67");
+}

test/date_test/make_time.pass.cpp

@@ -27,27 +27,6 @@
 // time_of_day<std::chrono::duration<Rep, Period>>
 // make_time(std::chrono::duration<Rep, Period> d) noexcept;
 
-// constexpr
-// time_of_day<std::chrono::hours>
-// make_time(std::chrono::hours h, unsigned md) noexcept;
-
-// constexpr
-// time_of_day<std::chrono::minutes>
-// make_time(std::chrono::hours h, std::chrono::minutes m, unsigned md) noexcept;
-
-// constexpr
-// time_of_day<std::chrono::seconds>
-// make_time(std::chrono::hours h, std::chrono::minutes m, std::chrono::seconds s,
-//           unsigned md) noexcept;
-
-// template <class Rep, class Period,
-//           class = typename std::enable_if<std::ratio_less<Period,
-//                                                           std::ratio<1>>::value>::type>
-// constexpr
-// time_of_day<std::chrono::duration<Rep, Period>>
-// make_time(std::chrono::hours h, std::chrono::minutes m, std::chrono::seconds s,
-//           std::chrono::duration<Rep, Period> sub_s, unsigned md) noexcept;
-
 #include "date.h"
 
 #include <cassert>
@@ -68,7 +47,6 @@ main()
         assert(tod.minutes() == minutes{7});
         assert(tod.seconds() == seconds{9});
         assert(tod.subseconds() == nanoseconds{22});
-        assert(tod.mode() == 0);
     }
     {
         static_assert(is_same<decltype(make_time(microseconds{18429000022})),
@@ -78,7 +56,6 @@ main()
         assert(tod.minutes() == minutes{7});
         assert(tod.seconds() == seconds{9});
         assert(tod.subseconds() == microseconds{22});
-        assert(tod.mode() == 0);
     }
     {
         static_assert(is_same<decltype(make_time(seconds{18429})),
@@ -87,7 +64,6 @@ main()
         assert(tod.hours() == hours{5});
         assert(tod.minutes() == minutes{7});
         assert(tod.seconds() == seconds{9});
-        assert(tod.mode() == 0);
     }
     {
         static_assert(is_same<decltype(make_time(minutes{307})),
@@ -95,70 +71,11 @@ main()
         auto tod = make_time(minutes{307});
         assert(tod.hours() == hours{5});
         assert(tod.minutes() == minutes{7});
-        assert(tod.mode() == 0);
     }
     {
         static_assert(is_same<decltype(make_time(hours{5})),
                               time_of_day<hours>>{}, "");
         auto tod = make_time(hours{5});
         assert(tod.hours() == hours{5});
-        assert(tod.mode() == 0);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, seconds{9},
-                                                 nanoseconds{22}, pm)),
-                              time_of_day<nanoseconds>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, seconds{9}, nanoseconds{22}, pm);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.seconds() == seconds{9});
-        assert(tod.subseconds() == nanoseconds{22});
-        assert(tod.mode() == pm);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, seconds{9},
-                                                 microseconds{22}, 0)),
-                              time_of_day<microseconds>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, seconds{9}, microseconds{22}, 0);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.seconds() == seconds{9});
-        assert(tod.subseconds() == microseconds{22});
-        assert(tod.mode() == 0);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, seconds{9},
-                                                 milliseconds{22}, am)),
-                              time_of_day<milliseconds>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, seconds{9}, milliseconds{22}, am);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.seconds() == seconds{9});
-        assert(tod.subseconds() == milliseconds{22});
-        assert(tod.mode() == am);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, seconds{9}, am)),
-                              time_of_day<seconds>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, seconds{9}, am);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.seconds() == seconds{9});
-        assert(tod.mode() == am);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, minutes{7}, pm)),
-                              time_of_day<minutes>>{}, "");
-        auto tod = make_time(hours{5}, minutes{7}, pm);
-        assert(tod.hours() == hours{5});
-        assert(tod.minutes() == minutes{7});
-        assert(tod.mode() == pm);
-    }
-    {
-        static_assert(is_same<decltype(make_time(hours{5}, 0)),
-                              time_of_day<hours>>{}, "");
-        auto tod = make_time(hours{5}, 0);
-        assert(tod.hours() == hours{5});
-        assert(tod.mode() == 0);
     }
 }

test/date_test/month.pass.cpp

@@ -72,7 +72,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::month>{}, "");
-static_assert(!std::is_default_constructible<date::month>{}, "");
+static_assert( std::is_default_constructible<date::month>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::month>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::month>{}, "");
 static_assert( std::is_trivially_move_constructible<date::month>{}, "");

test/date_test/month_day.pass.cpp

@@ -47,7 +47,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::month_day>{}, "");
-static_assert(!std::is_default_constructible<date::month_day>{}, "");
+static_assert( std::is_default_constructible<date::month_day>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::month_day>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::month_day>{}, "");
 static_assert( std::is_trivially_move_constructible<date::month_day>{}, "");

test/date_test/multi_year_duration_addition.pass.cpp

@@ -0,0 +1,487 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2018 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "date.h"
+#include <chrono>
+#include <cassert>
+#include <type_traits>
+
+#define CPP11_ASSERT(...) static_assert(__VA_ARGS__, "")
+
+#if __cplusplus >= 201402
+// C++14
+#  define CPP14_ASSERT(...) static_assert(__VA_ARGS__, "")
+#else
+// C++11
+#  define CPP14_ASSERT(...) assert(__VA_ARGS__)
+#endif
+
+#define NOEXCEPT_ASSERT(...) static_assert(noexcept(__VA_ARGS__), "")
+
+//Invocation involves a conversion between duration that is currently
+//not marked as noexcept.
+#define NOEXCEPT_CONVERSION(...)
+
+template<typename T>
+constexpr T copy(T const& t) noexcept { return t; }
+
+struct ConvertibleToYears
+{
+   CONSTCD11 operator date::years() const NOEXCEPT
+   { return date::years{1}; };
+};
+
+struct ConvertibleToMonths
+{
+   CONSTCD11 operator date::months() const NOEXCEPT
+   { return date::months{1}; };
+};
+
+struct ConvertibleToYearsAndMonths
+{
+   CONSTCD11 operator date::years() const NOEXCEPT
+   { return date::years{1}; };
+
+   CONSTCD11 operator date::months() const NOEXCEPT
+   { return date::months{1}; };
+
+};
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+
+    using decades = duration<int, date::detail::ratio_multiply<std::ratio<10>, years::period>>;
+    using decamonths = duration<int, date::detail::ratio_multiply<std::ratio<10>, months::period>>;
+
+    constexpr months one_month{1};
+    constexpr years one_year{1};
+    constexpr decades one_decade{1};
+    constexpr decamonths one_decamonth{1};
+
+    constexpr ConvertibleToMonths custom_month;
+    constexpr ConvertibleToYears custom_year;
+    constexpr ConvertibleToYearsAndMonths prefer_year;
+    
+
+    {
+       constexpr year_month ym = 2001_y/feb;
+       CPP14_ASSERT(ym + one_month == 2001_y/mar);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+
+    {
+       constexpr year_month_day ym = 2001_y/feb/10;
+       CPP14_ASSERT(ym + one_month == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan/10);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan/10);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb/10);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb/10);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb/10);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb/10);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb/10);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec/10);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec/10);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr/10);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec/10);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr/10);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan/10);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar/10);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan/10);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb/10);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+
+    {
+       constexpr year_month_day_last ym = 2001_y/feb/last;
+       CPP14_ASSERT(ym + one_month == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan/last);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan/last);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb/last);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb/last);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb/last);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb/last);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb/last);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec/last);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec/last);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr/last);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec/last);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr/last);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan/last);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar/last);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan/last);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb/last);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+
+    {
+       constexpr year_month_weekday ym = 2001_y/feb/fri[4];
+       CPP14_ASSERT(ym + one_month == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan/fri[4]);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb/fri[4]);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec/fri[4]);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec/fri[4]);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr/fri[4]);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec/fri[4]);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr/fri[4]);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan/fri[4]);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb/fri[4]);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+
+    {
+       constexpr year_month_weekday_last ym = 2001_y/feb/fri[last];
+       CPP14_ASSERT(ym + one_month == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(ym + one_month);
+       CPP14_ASSERT(one_month + ym == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(one_month + ym);
+       CPP14_ASSERT(ym - one_month == 2001_y/jan/fri[last]);
+       NOEXCEPT_ASSERT(ym - one_month);
+       CPP14_ASSERT((copy(ym) += one_month) == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += one_month);
+       CPP14_ASSERT((copy(ym) -= one_month) == 2001_y/jan/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= one_month);
+      
+       CPP11_ASSERT(ym + one_year == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym + one_year);
+       CPP11_ASSERT(one_year + ym == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(one_year + ym);
+       CPP11_ASSERT(ym - one_year == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym - one_year);
+       CPP14_ASSERT((copy(ym) += one_year) == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += one_year);
+       CPP14_ASSERT((copy(ym) -= one_year) == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= one_year);
+
+       CPP11_ASSERT(ym + one_decade == 2011_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(ym + one_decade);
+       CPP11_ASSERT(one_decade + ym == 2011_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(one_decade + ym);
+       CPP11_ASSERT(ym - one_decade == 1991_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(ym - one_decade);
+       CPP14_ASSERT((copy(ym) += one_decade) == 2011_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decade);
+       CPP14_ASSERT((copy(ym) -= one_decade) == 1991_y/feb/fri[last]);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decade);
+
+       CPP14_ASSERT(ym + one_decamonth == 2001_y/dec/fri[last]);
+       NOEXCEPT_CONVERSION(ym + one_decamonth);
+       CPP14_ASSERT(one_decamonth + ym  == 2001_y/dec/fri[last]);
+       NOEXCEPT_CONVERSION(one_decamonth + ym);
+       CPP14_ASSERT(ym - one_decamonth == 2000_y/apr/fri[last]);
+       NOEXCEPT_CONVERSION(ym - one_decamonth);
+       CPP14_ASSERT((copy(ym) += one_decamonth) == 2001_y/dec/fri[last]);
+       NOEXCEPT_CONVERSION(copy(ym) += one_decamonth);
+       CPP14_ASSERT((copy(ym) -= one_decamonth) == 2000_y/apr/fri[last]);
+       NOEXCEPT_CONVERSION(copy(ym) -= one_decamonth);
+
+       CPP14_ASSERT(ym + custom_month == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(ym + custom_month);
+       CPP14_ASSERT(custom_month + ym == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(custom_month + ym);
+       CPP14_ASSERT(ym - custom_month == 2001_y/jan/fri[last]);
+       NOEXCEPT_ASSERT(ym - custom_month);
+       CPP14_ASSERT((copy(ym) += custom_month) == 2001_y/mar/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += custom_month);
+       CPP14_ASSERT((copy(ym) -= custom_month) == 2001_y/jan/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_month);
+      
+       CPP11_ASSERT(ym + custom_year == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym + custom_year);
+       CPP11_ASSERT(custom_year + ym == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(custom_year + ym);
+       CPP11_ASSERT(ym - custom_year == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym - custom_year);
+       CPP14_ASSERT((copy(ym) += custom_year) == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += custom_year);
+       CPP14_ASSERT((copy(ym) -= custom_year) == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= custom_year);
+
+       CPP11_ASSERT(ym + prefer_year == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym + prefer_year);
+       CPP11_ASSERT(prefer_year + ym == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(prefer_year + ym);
+       CPP11_ASSERT(ym - prefer_year == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(ym - prefer_year);
+       CPP14_ASSERT((copy(ym) += prefer_year) == 2002_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) += prefer_year);
+       CPP14_ASSERT((copy(ym) -= prefer_year) == 2000_y/feb/fri[last]);
+       NOEXCEPT_ASSERT(copy(ym) -= prefer_year);
+    }
+}

test/date_test/parse.pass.cpp

@@ -0,0 +1,906 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// This test is meant to maintain a record of the sizeof each type.
+
+#include "date.h"
+#include <cassert>
+#include <sstream>
+
+void
+test_a()
+{
+    using namespace date;
+    {
+        // correct abbreviation
+        std::istringstream in{"Sun 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct abbreviation
+        std::istringstream in{"Sun 2016-12-11"};
+        sys_days tp;
+        in >> parse("%A %F", tp);
+        // this may fail with libstdc++, see https://github.com/HowardHinnant/date/issues/388
+        // possible workaround: compile date.h with -DONLY_C_LOCALE=1
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"Sunday 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"Sunday 2016-12-11"};
+        sys_days tp;
+        in >> parse("%A %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // not a valid name
+        std::istringstream in{"Dec 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert( in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 1970_y/1/1);
+    }
+    {
+        // wrong name
+        std::istringstream in{"Sat 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert( in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 1970_y/1/1);
+    }
+    {
+        // extra ws in input
+        std::istringstream in{"Sun  2016-12-11"};
+        sys_days tp;
+        in >> parse("%a %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // extra ws in format
+        std::istringstream in{"Sun 2016-12-11"};
+        sys_days tp;
+        in >> parse("%a  %F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+}
+
+void
+test_b()
+{
+    using namespace date;
+    {
+        // correct abbreviation
+        std::istringstream in{"Dec 11 2016"};
+        sys_days tp;
+        in >> parse("%b %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct abbreviation
+        std::istringstream in{"Dec 11 2016"};
+        sys_days tp;
+        in >> parse("%B %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct abbreviation
+        std::istringstream in{"Dec 11 2016"};
+        sys_days tp;
+        in >> parse("%h %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"December 11 2016"};
+        sys_days tp;
+        in >> parse("%b %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"December 11 2016"};
+        sys_days tp;
+        in >> parse("%B %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // correct full name
+        std::istringstream in{"December 11 2016"};
+        sys_days tp;
+        in >> parse("%h %d %Y", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        // incorrect abbreviation
+        std::istringstream in{"Dece 11 2016"};
+        sys_days tp;
+        in >> parse("%b %d %Y", tp);
+        assert( in.fail());
+        assert(!in.bad());
+        assert(!in.eof());
+        assert(tp == 1970_y/1/1);
+    }
+}
+
+void
+test_c()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        // correct abbreviation
+        std::istringstream in{"Sun Dec 11 14:02:43 2016"};
+        sys_seconds tp;
+        in >> parse("%c", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{14} + minutes{2} + seconds{43});
+    }
+}
+
+void
+test_x()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        // correct abbreviation
+        std::istringstream in{"12/11/16"};
+        sys_seconds tp;
+        in >> parse("%x", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11});
+    }
+}
+
+void
+test_X()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        // correct abbreviation
+        std::istringstream in{"2016-12-11 14:02:43"};
+        sys_seconds tp;
+        in >> parse("%F %X", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{14} + minutes{2} + seconds{43});
+    }
+}
+
+void
+test_C()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"20 16 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/11);
+    }
+    {
+        std::istringstream in{"-2 1 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == -101_y/12/11);
+    }
+    {
+        std::istringstream in{"-1 0 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == -100_y/12/11);
+    }
+    {
+        std::istringstream in{"-1 99 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == -99_y/12/11);
+    }
+    {
+        std::istringstream in{"-1 1 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == -1_y/12/11);
+    }
+    {
+        std::istringstream in{"0 0 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 0_y/12/11);
+    }
+    {
+        std::istringstream in{"0 1 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 1_y/12/11);
+    }
+    {
+        std::istringstream in{"0 99 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 99_y/12/11);
+    }
+    {
+        std::istringstream in{"1 0 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 100_y/12/11);
+    }
+    {
+        std::istringstream in{"1 1 12 11"};
+        sys_days tp;
+        in >> parse("%C %y %m %d", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 101_y/12/11);
+    }
+}
+
+void
+test_d()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016 09 12"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/9);
+    }
+    {
+        std::istringstream in{"2016 09 12"};
+        sys_days tp;
+        in >> parse("%Y %e %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/9);
+    }
+    {
+        std::istringstream in{"2016 9 12"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/9);
+    }
+    {
+        std::istringstream in{"2016 9 12"};
+        sys_days tp;
+        in >> parse("%Y %e %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/9);
+    }
+    {
+        std::istringstream in{"2016 31 11"};
+        sys_days tp;
+        in >> parse("%Y %e %m", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_D()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"12/11/16"};
+        sys_days tp;
+        in >> parse("%D", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/11);
+    }
+}
+
+void
+test_F()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-13"};
+        sys_days tp;
+        in >> parse("%F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/13);
+    }
+    {
+        std::istringstream in{"2016-12-13"};
+        year_month_day tp;
+        in >> parse("%F", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/12/13);
+    }
+}
+
+void
+test_H()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 15"};
+        sys_time<hours> tp;
+        in >> parse("%F %H", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{15});
+    }
+    {
+        std::istringstream in{"2016-12-11 24"};
+        sys_time<hours> tp;
+        in >> parse("%F %H", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_Ip()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 1 pm"};
+        sys_time<hours> tp;
+        in >> parse("%F %I %p", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{13});
+    }
+    {
+        std::istringstream in{"2016-12-11 1 am"};
+        sys_time<hours> tp;
+        in >> parse("%F %I %p", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{1});
+    }
+    {
+        std::istringstream in{"2016-12-11 13 am"};
+        sys_time<hours> tp;
+        in >> parse("%F %I %p", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_j()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016 361"};
+        sys_days tp;
+        in >> parse("%Y %j", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+}
+
+void
+test_m()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016 12 09"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/9/12);
+    }
+    {
+        std::istringstream in{"2016 12 9"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == 2016_y/9/12);
+    }
+    {
+        std::istringstream in{"2016 12 13"};
+        sys_days tp;
+        in >> parse("%Y %d %m", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_M()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 15"};
+        sys_time<minutes> tp;
+        in >> parse("%F %M", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + minutes{15});
+    }
+    {
+        std::istringstream in{"2016-12-11 65"};
+        sys_time<minutes> tp;
+        in >> parse("%F %M", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_S()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 15"};
+        sys_seconds tp;
+        in >> parse("%F %S", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + seconds{15});
+    }
+    {
+        std::istringstream in{"2016-12-11 15.001"};
+        sys_time<milliseconds> tp;
+        in >> parse("%F %S", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + seconds{15} + milliseconds{1});
+    }
+    {
+        std::istringstream in{"2016-12-11 60"};
+        sys_seconds tp;
+        in >> parse("%F %S", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_T()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 15:43:22"};
+        sys_seconds tp;
+        in >> parse("%F %T", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{15} + minutes{43} + seconds{22});
+    }
+    {
+        std::istringstream in{"2016-12-11 15:43:22.001"};
+        sys_time<milliseconds> tp;
+        in >> parse("%F %T", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{15} + minutes{43} + seconds{22} +
+                                              milliseconds{1});
+    }
+    {
+        std::istringstream in{"2016-12-11 15:43:22"};
+        sys_time<milliseconds> tp;
+        in >> parse("%F %T", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{15} + minutes{43} + seconds{22});
+    }
+    {
+        std::istringstream in{"15:43:22.001"};
+        milliseconds d;
+        in >> parse("%T", d);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(d == hours{15} + minutes{43} + seconds{22} + milliseconds{1});
+    }
+    {
+        std::istringstream in{"2016-12-11 24:43:22"};
+        sys_seconds tp;
+        in >> parse("%F %T", tp);
+        assert(in.fail());
+    }
+    {
+        std::istringstream in{"2016-12-11 15:60:22"};
+        sys_seconds tp;
+        in >> parse("%F %T", tp);
+        assert(in.fail());
+    }
+    {
+        std::istringstream in{"2016-12-11 15:43:60"};
+        sys_seconds tp;
+        in >> parse("%F %T", tp);
+        assert(in.fail());
+    }
+}
+
+void
+test_p()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-11 11pm"};
+        sys_time<hours> tp;
+        in >> parse("%F %I%p", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/11} + hours{23});
+    }
+}
+
+void
+test_r()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-26 1:36:57 pm"};
+        sys_seconds tp;
+        in >> parse("%F %r", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26} + hours{13} + minutes{36} + seconds{57});
+    }
+}
+
+void
+test_R()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-26 13:36"};
+        sys_seconds tp;
+        in >> parse("%F %R", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26} + hours{13} + minutes{36});
+    }
+}
+
+void
+test_U()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-52-1"};
+        sys_days tp;
+        in >> parse("%Y-%U-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+}
+
+void
+test_W()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-52-1"};
+        sys_days tp;
+        in >> parse("%Y-%W-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+}
+
+void
+test_GV()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-52-1"};
+        sys_days tp;
+        in >> parse("%G-%V-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+    {
+        std::istringstream in{"2016-52-1"};
+        sys_days tp;
+        in >> parse("%G-%V-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+    {
+        std::istringstream in{"20 16-52-1"};
+        sys_days tp;
+        in >> parse("%C %g-%V-%w", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+    {
+        std::istringstream in{"20 16-52-1"};
+        sys_days tp;
+        in >> parse("%C %g-%V-%u", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26});
+    }
+}
+
+void
+test_z()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::istringstream in{"2016-12-26 15:53:22 -0500"};
+        sys_seconds tp;
+        in >> parse("%F %T %z", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26} + hours{20} + minutes{53} + seconds{22});
+    }
+    {
+        std::istringstream in{"2016-12-26 15:53:22 -0500"};
+        local_seconds tp;
+        in >> parse("%F %T %z", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == local_days{2016_y/12/26} + hours{15} + minutes{53} + seconds{22});
+    }
+    {
+        std::istringstream in{"2016-12-26 15:53:22 -05:00"};
+        sys_seconds tp;
+        in >> parse("%F %T %Ez", tp);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == sys_days{2016_y/12/26} + hours{20} + minutes{53} + seconds{22});
+    }
+}
+
+void
+test_Z()
+{
+    using namespace date;
+    using namespace std::chrono;
+    {
+        std::string a;
+        std::istringstream in{"2016-12-26 15:53:22 word"};
+        local_seconds tp;
+        in >> parse("%F %T %Z", tp, a);
+        assert(!in.fail());
+        assert(!in.bad());
+        assert(tp == local_days{2016_y/12/26} + hours{15} + minutes{53} + seconds{22});
+        assert(a == "word");
+    }
+}
+
+void
+test_trailing_Z()
+{
+    std::string format = "%FT%TZ";
+    std::string datetime = "2017-2-15T13:13:13";
+    std::istringstream input(datetime);
+    date::sys_seconds tp;
+    input >> date::parse(format, tp);
+    assert(input.fail());
+    assert(input.eof());
+}
+
+void
+test_leading_ws()
+{
+    using namespace std;
+    using namespace date;
+    istringstream in{"05/04/17 5/4/17"};
+    year_month_day d1, d2;
+    in >> parse("%D", d1) >> parse("%n%D", d2);
+    assert(d1 == may/4/2017);
+    assert(d2 == may/4/2017);
+}
+
+void
+test_space()
+{
+    using namespace std;
+    using namespace date;
+    {
+        istringstream in{"05/04/17"};
+        year_month_day d1;
+        in >> parse(" %D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{" 05/04/17"};
+        year_month_day d1;
+        in >> parse(" %D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{"  05/04/17"};
+        year_month_day d1;
+        in >> parse(" %D", d1);
+        assert(d1 == may/4/2017);
+    }
+}
+
+void
+test_n()
+{
+    using namespace std;
+    using namespace date;
+    {
+        istringstream in{"05/04/17"};
+        year_month_day d1;
+        in >> parse("%n%D", d1);
+        assert(in.fail());
+    }
+    {
+        istringstream in{" 05/04/17"};
+        year_month_day d1;
+        in >> parse("%n%D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{"  05/04/17"};
+        year_month_day d1;
+        in >> parse("%n%D", d1);
+        assert(in.fail());
+    }
+}
+
+void
+test_t()
+{
+    using namespace std;
+    using namespace date;
+    {
+        istringstream in{"05/04/17"};
+        year_month_day d1;
+        in >> parse("%t%D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{" 05/04/17"};
+        year_month_day d1;
+        in >> parse("%t%D", d1);
+        assert(d1 == may/4/2017);
+    }
+    {
+        istringstream in{"  05/04/17"};
+        year_month_day d1;
+        in >> parse("%t%D", d1);
+        assert(in.fail());
+    }
+}
+
+int
+main()
+{
+    test_a();
+    test_b();
+    test_c();
+    test_C();
+    test_d();
+    test_D();
+    test_F();
+    test_H();
+    test_Ip();
+    test_j();
+    test_m();
+    test_M();
+    test_p();
+    test_r();
+    test_R();
+    test_S();
+    test_T();
+    test_U();
+    test_W();
+    test_GV();
+    test_x();
+    test_X();
+    test_z();
+    test_Z();
+    test_trailing_Z();
+    test_leading_ws();
+    test_space();
+    test_n();
+    test_t();
+}

test/date_test/time_of_day_hours.pass.cpp

@@ -57,10 +57,10 @@ main()
 
     using tod = time_of_day<hours>;
 
-    static_assert(is_same<tod::precision, hours>{}, "");
+    static_assert(is_same<tod::precision::period, seconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -68,14 +68,12 @@ main()
 
     static_assert(is_nothrow_constructible<tod, hours>{}, "");
     static_assert(!is_convertible<hours, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
 
     constexpr tod t1 = tod{hours{13}};
     static_assert(t1.hours() == hours{13}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13}, "");
     static_assert(t1.to_duration() == hours{13}, "");
@@ -83,23 +81,14 @@ main()
 
     auto t2 = t1;
     assert(t2.hours() == t1.hours());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
-    assert(os.str() == "1300");
-    t2.make12();
+    assert(os.str() == "13:00:00");
+    auto h = make12(t2.hours());
     os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.mode() == pm);
+    assert(h == hours{1});
     assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1300");
+    assert(!is_am(t2.hours()));
+    assert(is_pm(t2.hours()));
 }

test/date_test/time_of_day_microfortnights.pass.cpp

@@ -0,0 +1,111 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// enum {am = 1, pm};
+
+// template <class Rep, class Period>
+// class time_of_day<std::chrono::duration<Rep, Period>>
+// {
+// public:
+//     using precision = std::chrono::std::chrono::duration<Rep, Period>;
+//
+//     constexpr explicit time_of_day(precision since_midnight) noexcept;
+//     constexpr time_of_day(std::chrono::hours h, std::chrono::minutes m,
+//                           std::chrono::seconds s, precision sub_s,
+//                           unsigned md) noexcept;
+//
+//     constexpr std::chrono::hours hours() const noexcept;
+//     constexpr std::chrono::minutes minutes() const noexcept;
+//     constexpr std::chrono::seconds seconds() const noexcept;
+//     constexpr precision subseconds() const noexcept;
+//     constexpr unsigned mode() const noexcept;
+//
+//     constexpr explicit operator precision() const noexcept;
+//     constexpr precision to_duration() const noexcept;
+//
+//     void make24() noexcept;
+//     void make12() noexcept;
+// };
+
+// template <class Rep, class Period>
+// std::ostream&
+// operator<<(std::ostream& os, const time_of_day<std::chrono::duration<Rep, Period>>& t);
+
+#include "date.h"
+
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+using fortnights = std::chrono::duration<date::weeks::rep,
+                                         date::detail::ratio_multiply<std::ratio<2>,
+                                                                      date::weeks::period>>;
+
+using microfortnights = std::chrono::duration<std::int64_t,
+                                              date::detail::ratio_multiply<fortnights::period,
+                                                                           std::micro>>;
+
+int
+main()
+{
+    using namespace date;
+    using namespace std;
+    using namespace std::chrono;
+
+    using tod = time_of_day<typename common_type<hours, minutes, microfortnights>::type>;
+
+    static_assert(is_same<tod::precision::period, ratio<1, 10000>>{}, "");
+
+    static_assert( is_trivially_destructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
+    static_assert( is_trivially_copy_constructible<tod>{}, "");
+    static_assert( is_trivially_copy_assignable<tod>{}, "");
+    static_assert( is_trivially_move_constructible<tod>{}, "");
+    static_assert( is_trivially_move_assignable<tod>{}, "");
+
+    static_assert(is_constructible<tod, microfortnights>{}, "");
+    static_assert(!is_convertible<microfortnights, tod>{}, "");
+
+    static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
+    static_assert(!is_convertible<tod, tod::precision>{}, "");
+
+    constexpr tod t1 = tod{hours{13} + minutes{7} + microfortnights{5}};
+    static_assert(t1.hours() == hours{13}, "");
+    static_assert(t1.minutes() == minutes{7}, "");
+    static_assert(t1.seconds() == seconds{6}, "");
+    static_assert(t1.subseconds() == tod::precision{480}, "");
+#if __cplusplus >= 201402
+    static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}
+                                                     + microfortnights{5}, "");
+    static_assert(t1.to_duration() == hours{13} + minutes{7} + microfortnights{5}, "");
+#endif
+
+    auto t2 = t1;
+    assert(t2.hours() == t1.hours());
+    assert(t2.minutes() == t1.minutes());
+    assert(t2.seconds() == t1.seconds());
+    assert(t2.subseconds() == t1.subseconds());
+    assert(t2.to_duration() == t1.to_duration());
+    ostringstream os;
+    os << t2;
+    assert(os.str() == "13:07:06.0480");
+}

test/date_test/time_of_day_milliseconds.pass.cpp

@@ -65,10 +65,10 @@ main()
 
     using tod = time_of_day<milliseconds>;
 
-    static_assert(is_same<tod::precision, milliseconds>{}, "");
+    static_assert(is_same<tod::precision::period, milliseconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -76,8 +76,6 @@ main()
 
     static_assert(is_nothrow_constructible<tod, milliseconds>{}, "");
     static_assert(!is_convertible<milliseconds, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, minutes, seconds, milliseconds,
-                                                unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
@@ -87,7 +85,6 @@ main()
     static_assert(t1.minutes() == minutes{7}, "");
     static_assert(t1.seconds() == seconds{5}, "");
     static_assert(t1.subseconds() == milliseconds{22}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}
                                                      + seconds{5} + milliseconds{22}, "");
@@ -100,29 +97,8 @@ main()
     assert(t2.minutes() == t1.minutes());
     assert(t2.seconds() == t1.seconds());
     assert(t2.subseconds() == t1.subseconds());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
     assert(os.str() == "13:07:05.022");
-    t2.make12();
-    os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.subseconds() == milliseconds{22});
-    assert(t2.mode() == pm);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1:07:05.022pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.subseconds() == milliseconds{22});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "13:07:05.022");
 }

test/date_test/time_of_day_minutes.pass.cpp

@@ -59,10 +59,10 @@ main()
 
     using tod = time_of_day<minutes>;
 
-    static_assert(is_same<tod::precision, minutes>{}, "");
+    static_assert(is_same<tod::precision::period, seconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -70,7 +70,6 @@ main()
 
     static_assert(is_nothrow_constructible<tod, minutes>{}, "");
     static_assert(!is_convertible<minutes, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, minutes, unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
@@ -78,7 +77,6 @@ main()
     constexpr tod t1 = tod{hours{13} + minutes{7}};
     static_assert(t1.hours() == hours{13}, "");
     static_assert(t1.minutes() == minutes{7}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}, "");
     static_assert(t1.to_duration() == hours{13} + minutes{7}, "");
@@ -87,25 +85,8 @@ main()
     auto t2 = t1;
     assert(t2.hours() == t1.hours());
     assert(t2.minutes() == t1.minutes());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
-    assert(os.str() == "13:07");
-    t2.make12();
-    os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.mode() == pm);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1:07pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "13:07");
+    assert(os.str() == "13:07:00");
 }

test/date_test/time_of_day_nanoseconds.pass.cpp

@@ -65,10 +65,10 @@ main()
 
     using tod = time_of_day<nanoseconds>;
 
-    static_assert(is_same<tod::precision, nanoseconds>{}, "");
+    static_assert(is_same<tod::precision::period, nanoseconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -76,8 +76,6 @@ main()
 
     static_assert(is_nothrow_constructible<tod, nanoseconds>{}, "");
     static_assert(!is_convertible<nanoseconds, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, minutes, seconds, nanoseconds,
-                                                unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
@@ -87,7 +85,6 @@ main()
     static_assert(t1.minutes() == minutes{7}, "");
     static_assert(t1.seconds() == seconds{5}, "");
     static_assert(t1.subseconds() == nanoseconds{22}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}
                                                      + seconds{5} + nanoseconds{22}, "");
@@ -100,29 +97,8 @@ main()
     assert(t2.minutes() == t1.minutes());
     assert(t2.seconds() == t1.seconds());
     assert(t2.subseconds() == t1.subseconds());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
     assert(os.str() == "13:07:05.000000022");
-    t2.make12();
-    os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.subseconds() == nanoseconds{22});
-    assert(t2.mode() == pm);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1:07:05.000000022pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.subseconds() == nanoseconds{22});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "13:07:05.000000022");
 }

test/date_test/time_of_day_seconds.pass.cpp

@@ -60,10 +60,10 @@ main()
 
     using tod = time_of_day<seconds>;
 
-    static_assert(is_same<tod::precision, seconds>{}, "");
+    static_assert(is_same<tod::precision::period, seconds::period>{}, "");
 
     static_assert( is_trivially_destructible<tod>{}, "");
-    static_assert(!is_default_constructible<tod>{}, "");
+    static_assert( is_default_constructible<tod>{}, "");
     static_assert( is_trivially_copy_constructible<tod>{}, "");
     static_assert( is_trivially_copy_assignable<tod>{}, "");
     static_assert( is_trivially_move_constructible<tod>{}, "");
@@ -71,7 +71,6 @@ main()
 
     static_assert(is_nothrow_constructible<tod, seconds>{}, "");
     static_assert(!is_convertible<seconds, tod>{}, "");
-    static_assert(is_nothrow_constructible<tod, hours, minutes, seconds, unsigned>{}, "");
 
     static_assert(is_nothrow_constructible<tod::precision, tod>{}, "");
     static_assert(!is_convertible<tod, tod::precision>{}, "");
@@ -80,7 +79,6 @@ main()
     static_assert(t1.hours() == hours{13}, "");
     static_assert(t1.minutes() == minutes{7}, "");
     static_assert(t1.seconds() == seconds{5}, "");
-    static_assert(t1.mode() == 0, "");
 #if __cplusplus >= 201402
     static_assert(static_cast<tod::precision>(t1) == hours{13} + minutes{7}
                                                      + seconds{5}, "");
@@ -91,27 +89,8 @@ main()
     assert(t2.hours() == t1.hours());
     assert(t2.minutes() == t1.minutes());
     assert(t2.seconds() == t1.seconds());
-    assert(t2.mode() == t1.mode());
     assert(t2.to_duration() == t1.to_duration());
     ostringstream os;
     os << t2;
     assert(os.str() == "13:07:05");
-    t2.make12();
-    os.str("");
-    assert(t2.hours() == hours{1});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.mode() == pm);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "1:07:05pm");
-    t2.make24();
-    os.str("");
-    assert(t2.hours() == hours{13});
-    assert(t2.minutes() == minutes{7});
-    assert(t2.seconds() == seconds{5});
-    assert(t2.mode() == 0);
-    assert(t2.to_duration() == t1.to_duration());
-    os << t2;
-    assert(os.str() == "13:07:05");
 }

test/date_test/weekday.pass.cpp

@@ -69,7 +69,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::weekday>{}, "");
-static_assert(!std::is_default_constructible<date::weekday>{}, "");
+static_assert( std::is_default_constructible<date::weekday>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::weekday>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::weekday>{}, "");
 static_assert( std::is_trivially_move_constructible<date::weekday>{}, "");
@@ -77,11 +77,9 @@ static_assert( std::is_trivially_move_assignable<date::weekday>{}, "");
 
 static_assert( std::is_nothrow_constructible<date::weekday, unsigned>{}, "");
 static_assert( std::is_nothrow_constructible<date::weekday, date::sys_days>{}, "");
-static_assert( std::is_nothrow_constructible<unsigned, date::weekday>{}, "");
 static_assert(!std::is_convertible<unsigned, date::weekday>{}, "");
 static_assert( std::is_convertible<date::sys_days, date::weekday>{}, "");
 static_assert(!std::is_convertible<date::weekday, unsigned>{}, "");
-static_assert(static_cast<unsigned>(date::weekday{1u}) == 1, "");
 
 static_assert( date::weekday{0u}.ok(), "");
 static_assert( date::weekday{1u}.ok(), "");
@@ -90,7 +88,8 @@ static_assert( date::weekday{3u}.ok(), "");
 static_assert( date::weekday{4u}.ok(), "");
 static_assert( date::weekday{5u}.ok(), "");
 static_assert( date::weekday{6u}.ok(), "");
-static_assert(!date::weekday{7u}.ok(), "");
+static_assert( date::weekday{7u}.ok(), "");
+static_assert(!date::weekday{8u}.ok(), "");
 
 void
 test_weekday_arithmetic()

test/date_test/weekday_indexed.pass.cpp

@@ -23,6 +23,7 @@
 // class weekday_indexed
 // {
 // public:
+//     weekday_indexed() = default;
 //     constexpr weekday_indexed(const date::weekday& wd, unsigned index) noexcept;
 //
 //     constexpr date::weekday weekday() const noexcept;
@@ -42,7 +43,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::weekday_indexed>{}, "");
-static_assert(!std::is_default_constructible<date::weekday_indexed>{}, "");
+static_assert( std::is_default_constructible<date::weekday_indexed>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::weekday_indexed>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::weekday_indexed>{}, "");
 static_assert( std::is_trivially_move_constructible<date::weekday_indexed>{}, "");

test/date_test/year.pass.cpp

@@ -64,7 +64,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::year>{}, "");
-static_assert(!std::is_default_constructible<date::year>{}, "");
+static_assert( std::is_default_constructible<date::year>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::year>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::year>{}, "");
 static_assert( std::is_trivially_move_constructible<date::year>{}, "");
@@ -107,7 +107,7 @@ main()
     static_assert(year::max().ok(), "");
 
 #if __cplusplus >= 201402
-    using int64_t = std::int64_t;
+    using std::int64_t;
     static_assert(sys_days(year::min()/jan/1)  - sys_days(1970_y/jan/1)
         >= as<int64_t>(days::min()), "");
     static_assert(sys_days(year::min()/jan/1)  - sys_days(1970_y/jan/1)

test/date_test/year_month.pass.cpp

@@ -61,7 +61,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::year_month>{}, "");
-static_assert(!std::is_default_constructible<date::year_month>{}, "");
+static_assert( std::is_default_constructible<date::year_month>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::year_month>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::year_month>{}, "");
 static_assert( std::is_trivially_move_constructible<date::year_month>{}, "");
@@ -109,6 +109,90 @@ test_arithmetic()
     }
 }
 
+
+void test_arithemtic_not_ok()
+{
+  using namespace date;
+  using namespace std::chrono;
+
+  year_month ym{2018_y, month{14}};
+
+  {
+    year_month ym2{2019_y, month{2}};
+    assert(ym + months{0} == ym2);
+    assert(ym - months{0} == ym2);
+    assert(ym - ym2 == months{0});
+    assert(ym2 - ym == months{0});
+   
+    auto ymc = ym;
+    ymc += months{0};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+  {
+    year_month ym2{2019_y, month{6}};
+    assert(ym + months{4} == ym2);
+    assert(ym2 - ym == months{4});
+    assert(ym - ym2 == -months{4});
+
+    auto ymc = ym;
+    ymc += months{4};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+  {
+    year_month ym2{2018_y, month{10}};
+    assert(ym - months{4} == ym2);
+    assert(ym2 - ym == -months{4});
+    assert(ym - ym2 == months{4});
+
+    auto ymc = ym;
+    ymc -= months{4};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+
+  {
+    year_month ym2{2020_y, month{6}};
+    assert(ym + months{16} == ym2);
+    assert(ym2 - ym == months{16});
+    assert(ym - ym2 == -months{16});
+
+    auto ymc = ym;
+    ymc += months{16};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+  {
+    year_month ym2{2017_y, month{10}};
+    assert(ym - months{16} == ym2);
+    assert(ym2 - ym == -months{16});
+    assert(ym - ym2 == months(16));
+
+    auto ymc = ym;
+    ymc -= months{16};
+    assert(ymc.ok());
+    assert(ymc == ym2);
+  }
+
+  {
+    year_month ym2{2018_y, month{25}};
+    assert(ym2 - ym == months{11});
+    assert(ym - ym2 == -months{11});
+  }
+
+  {
+    year_month ym2{2019_y, month{25}};
+    assert(ym2 - ym == months{23});
+    assert(ym - ym2 == -months{23});
+  }
+
+}
+
 int
 main()
 {
@@ -135,6 +219,7 @@ main()
     static_assert(ym1 - ym2 == -months{11}, "");
 
     test_arithmetic();
+    test_arithemtic_not_ok();
 
     std::ostringstream os;
     os << ym1;

test/date_test/year_month_day.pass.cpp

@@ -64,7 +64,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::year_month_day>{}, "");
-static_assert(!std::is_default_constructible<date::year_month_day>{}, "");
+static_assert( std::is_default_constructible<date::year_month_day>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::year_month_day>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::year_month_day>{}, "");
 static_assert( std::is_trivially_move_constructible<date::year_month_day>{}, "");

test/date_test/year_month_day_last.pass.cpp

@@ -105,7 +105,7 @@ test_arithmetic()
 
     for (int y1 = 2010; y1 <= 2015; ++y1)
     {
-        for (unsigned m1 = 1; m1 <= 12; ++m1)
+        for (int m1 = 1; m1 <= 12; ++m1)
         {
             auto ymd1 = last/m1/y1;;
             auto ymd2 = ymd1 + months(24);

test/date_test/year_month_weekday.pass.cpp

@@ -23,6 +23,7 @@
 // class year_month_weekday
 // {
 // public:
+//     year_month_weekday() = default;
 //     constexpr year_month_weekday(const date::year& y, const date::month& m,
 //                                    const date::weekday_indexed& wdi) noexcept;
 //     constexpr year_month_weekday(const sys_days& dp) noexcept;
@@ -83,7 +84,7 @@
 #include <type_traits>
 
 static_assert( std::is_trivially_destructible<date::year_month_weekday>{}, "");
-static_assert(!std::is_default_constructible<date::year_month_weekday>{}, "");
+static_assert( std::is_default_constructible<date::year_month_weekday>{}, "");
 static_assert( std::is_trivially_copy_constructible<date::year_month_weekday>{}, "");
 static_assert( std::is_trivially_copy_assignable<date::year_month_weekday>{}, "");
 static_assert( std::is_trivially_move_constructible<date::year_month_weekday>{}, "");
@@ -106,7 +107,7 @@ test_arithmetic()
 
     for (int y1 = 2010; y1 <= 2015; ++y1)
     {
-        for (unsigned m1 = 1; m1 <= 12; ++m1)
+        for (int m1 = 1; m1 <= 12; ++m1)
         {
             auto ymd1 = mon[2]/m1/y1;;
             auto ymd2 = ymd1 + months(24);

test/date_test/year_month_weekday_last.pass.cpp

@@ -101,7 +101,7 @@ test_arithmetic()
 
     for (int y1 = 2010; y1 <= 2015; ++y1)
     {
-        for (unsigned m1 = 1; m1 <= 12; ++m1)
+        for (int m1 = 1; m1 <= 12; ++m1)
         {
             auto ymd1 = mon[last]/m1/y1;;
             auto ymd2 = ymd1 + months(24);

test/iso_week/weekday.pass.cpp

@@ -171,7 +171,7 @@ test_with_date_weekday()
     auto constexpr d1 = iso_week::sun;
     static_assert(unsigned{d1} == 7, "");
     auto constexpr d2 = date::weekday{d1};
-    static_assert(unsigned{d2} == 0, "");
+    static_assert(d2 == date::Sunday, "");
     auto constexpr d3 = iso_week::weekday{d2};
     static_assert(unsigned{d3} == 7, "");
 }

test/iso_week/year_lastweek_weekday.pass.cpp

@@ -115,4 +115,15 @@ main()
     std::ostringstream os;
     os << x0;
     assert(os.str() == "2015-W last-Tue");
+
+    for (auto y = 1950_y; y <= 2050_y; ++y)
+    {
+        auto wd = mon;
+        do
+        {
+            auto x = y/last/wd;
+            assert(date::year_month_day{x} == date::year_month_day{year_weeknum_weekday{x}});
+            ++wd;
+        } while (wd != mon);
+    }
 }

test/solar_hijri_test/parse.pass.cpp

@@ -0,0 +1,237 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Asad. Gharighi
+// Copyright (c) 2020 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "date.h"
+#include "solar_hijri.h"
+#include "islamic.h"
+#include "tz.h"
+#include <cassert>
+#include <iostream>
+#include <chrono>
+#include <math.h>
+
+void
+test_a() {
+  constexpr auto civil = date::year{2020}/date::January/27;
+  using namespace solar_hijri;
+  static_assert(year_month_day{civil} == 1398_y/11/07, "");
+}
+
+void
+test_b() {
+  using namespace solar_hijri::literals;
+  static_assert(date::year_month_day{475_y/far/1} == date::year{1096}/03/21, "");
+  static_assert(date::year_month_weekday{475_y/far/1} ==
+                date::year{1096}/03/date::Saturday[3], "");
+}
+
+void
+test_c() {
+  using namespace solar_hijri;
+  auto date = solar_hijri::year_month_day{1398_y/bah/6};
+  for (auto i = 0; i < 24; i++) {
+    auto weekday = solar_hijri::weekday{date};
+    assert(date == 1398_y/11/06 + months{i});
+    assert(date.month() == month{(i+10u)%12 + 1});
+    assert(weekday == (weekday[1]/date.month()/date.year()).weekday());
+    auto k = weekday;
+    for (auto j = 0; j < 14; j++, k++) {
+      assert(weekday + days{j} == k);
+    }
+    date+=solar_hijri::months(1);
+  }
+}
+
+void
+test_d() {
+  auto zt = date::make_zoned(date::current_zone(), std::chrono::system_clock::now());
+  auto ld = date::floor<date::days>(zt.get_local_time());
+  solar_hijri::year_month_day ymd{ld};
+  auto time = date::make_time(zt.get_local_time() - ld);
+  (void)time;
+}
+
+void
+test_e() {
+  auto sd = date::floor<solar_hijri::days>(std::chrono::system_clock::now());
+  auto today = solar_hijri::year_month_day{sd};
+  assert(solar_hijri::year_month_weekday{today}.weekday() == solar_hijri::weekday{sd});
+}
+
+void
+test_f() {
+  constexpr auto isl = islamic::year{1441}/6/1;
+  using namespace solar_hijri;
+  static_assert(year_month_day{isl} == 1398_y/11/07, "");
+}
+
+void
+test_g() {
+  date::year_month_day ymdd[] = {
+    date::year{1583}/date::November/21,
+    date::year{1583}/date::November/22,
+    date::year{1583}/date::December/6,
+    date::year{1591}/date::December/26,
+    date::year{1616}/date::October/20,
+    date::year{1619}/date::October/13,
+    date::year{1627}/date::August/9,
+    date::year{1649}/date::October/15,
+    date::year{1657}/date::August/9,
+    date::year{1682}/date::June/23,
+    date::year{1691}/date::October/12,
+    date::year{1712}/date::September/13,
+    date::year{1718}/date::July/17,
+    date::year{1747}/date::January/4,
+    date::year{1756}/date::January/1,
+    date::year{1770}/date::January/15,
+    date::year{1798}/date::October/24,
+    date::year{1809}/date::July/11,
+    date::year{1834}/date::July/17,
+    date::year{1850}/date::September/9,
+    date::year{1865}/date::November/4,
+    date::year{1902}/date::December/21,
+    date::year{1926}/date::March/21,
+    date::year{1926}/date::March/22,
+    date::year{1957}/date::June/1,
+    date::year{1977}/date::March/7,
+    date::year{1982}/date::May/30,
+    date::year{1992}/date::December/8
+  };
+
+  solar_hijri::year_month_day ymdh[] = {
+    solar_hijri::year{962}/solar_hijri::Aban/30,
+    solar_hijri::year{962}/solar_hijri::Azar/1,
+    solar_hijri::year{962}/solar_hijri::Azar/15,
+    solar_hijri::year{970}/solar_hijri::Dey/5,
+    solar_hijri::year{995}/solar_hijri::Mehr/29,
+    solar_hijri::year{998}/solar_hijri::Mehr/21,
+    solar_hijri::year{1006}/solar_hijri::Mordad/18,
+    solar_hijri::year{1028}/solar_hijri::Mehr/24,
+    solar_hijri::year{1036}/solar_hijri::Mordad/19,
+    solar_hijri::year{1061}/solar_hijri::Tir/3,
+    solar_hijri::year{1070}/solar_hijri::Mehr/20,
+    solar_hijri::year{1091}/solar_hijri::Shahrivar/22,
+    solar_hijri::year{1097}/solar_hijri::Tir/26,
+    solar_hijri::year{1125}/solar_hijri::Dey/14,
+    solar_hijri::year{1134}/solar_hijri::Dey/11,
+    solar_hijri::year{1148}/solar_hijri::Dey/26,
+    solar_hijri::year{1177}/solar_hijri::Aban/2,
+    solar_hijri::year{1188}/solar_hijri::Tir/20,
+    solar_hijri::year{1213}/solar_hijri::Tir/26,
+    solar_hijri::year{1229}/solar_hijri::Shahrivar/18,
+    solar_hijri::year{1244}/solar_hijri::Aban/13,
+    solar_hijri::year{1281}/solar_hijri::Azar/29,
+    solar_hijri::year{1304}/solar_hijri::Esfand/30,
+    solar_hijri::year{1305}/solar_hijri::Farvardin/1,
+    solar_hijri::year{1336}/solar_hijri::Khordad/11,
+    solar_hijri::year{1355}/solar_hijri::Esfand/16,
+    solar_hijri::year{1361}/solar_hijri::Khordad/9,
+    solar_hijri::year{1371}/solar_hijri::Azar/17
+  };
+
+  solar_hijri::year_month_weekday ymdwd[] = {
+    solar_hijri::year{962}/solar_hijri::Aban/solar_hijri::Doshanbe[5],
+    solar_hijri::year{962}/solar_hijri::Azar/solar_hijri::Seshanbe[1],
+    solar_hijri::year{962}/solar_hijri::Azar/solar_hijri::Seshanbe[3],
+    solar_hijri::year{970}/solar_hijri::Dey/solar_hijri::Panjshanbe[1],
+    solar_hijri::year{995}/solar_hijri::Mehr/solar_hijri::Panjshanbe[5],
+    solar_hijri::year{998}/solar_hijri::Mehr/solar_hijri::Yekshanbe[3],
+    solar_hijri::year{1006}/solar_hijri::Mordad/solar_hijri::Doshanbe[3],
+    solar_hijri::year{1028}/solar_hijri::Mehr/solar_hijri::Adine[4],
+    solar_hijri::year{1036}/solar_hijri::Mordad/solar_hijri::Panjshanbe[3],
+    solar_hijri::year{1061}/solar_hijri::Tir/solar_hijri::Seshanbe[1],
+    solar_hijri::year{1070}/solar_hijri::Mehr/solar_hijri::Adine[3],
+    solar_hijri::year{1091}/solar_hijri::Shahrivar/solar_hijri::Seshanbe[4],
+    solar_hijri::year{1097}/solar_hijri::Tir/solar_hijri::Yekshanbe[4],
+    solar_hijri::year{1125}/solar_hijri::Dey/solar_hijri::Chaharshanbe[2],
+    solar_hijri::year{1134}/solar_hijri::Dey/solar_hijri::Panjshanbe[2],
+    solar_hijri::year{1148}/solar_hijri::Dey/solar_hijri::Doshanbe[4],
+    solar_hijri::year{1177}/solar_hijri::Aban/solar_hijri::Chaharshanbe[1],
+    solar_hijri::year{1188}/solar_hijri::Tir/solar_hijri::Seshanbe[3],
+    solar_hijri::year{1213}/solar_hijri::Tir/solar_hijri::Panjshanbe[4],
+    solar_hijri::year{1229}/solar_hijri::Shahrivar/solar_hijri::Doshanbe[3],
+    solar_hijri::year{1244}/solar_hijri::Aban/solar_hijri::Shanbe[2],
+    solar_hijri::year{1281}/solar_hijri::Azar/solar_hijri::Yekshanbe[5],
+    solar_hijri::year{1304}/solar_hijri::Esfand/solar_hijri::Yekshanbe[5],
+    solar_hijri::year{1305}/solar_hijri::Farvardin/solar_hijri::Doshanbe[1],
+    solar_hijri::year{1336}/solar_hijri::Khordad/solar_hijri::Shanbe[2],
+    solar_hijri::year{1355}/solar_hijri::Esfand/solar_hijri::Doshanbe[3],
+    solar_hijri::year{1361}/solar_hijri::Khordad/solar_hijri::Yekshanbe[2],
+    solar_hijri::year{1371}/solar_hijri::Azar/solar_hijri::Seshanbe[3]
+  };
+
+  bool leaps[] = {
+    true,
+    true,
+    true,
+    true,
+    true,
+    false,
+    false,
+    true,
+    true,
+    true,
+    false,
+    false,
+    false,
+    false,
+    false,
+    true,
+    false,
+    false,
+    false,
+    false,
+    false,
+    false,
+    true,
+    false,
+    false,
+    false,
+    false,
+    false
+  };
+
+  static_assert(sizeof(ymdd)/sizeof(ymdd[0]) == sizeof(ymdwd)/sizeof(ymdwd[0]), "");
+  static_assert(sizeof(ymdd)/sizeof(ymdd[0]) == sizeof(ymdh)/sizeof(ymdh[0]), "");
+  static_assert(sizeof(ymdd)/sizeof(ymdd[0]) == sizeof(leaps)/sizeof(leaps[0]), "");
+
+  for (auto i = 0; i < sizeof(ymdd)/sizeof(ymdd[0]); ++i)
+  {
+    assert(solar_hijri::year_month_day{ymdd[i]} == ymdh[i]);
+    assert(ymdd[i] == date::year_month_day{ymdh[i]});
+    assert(ymdh[i].year().is_leap() == leaps[i]);
+    assert(solar_hijri::year_month_weekday{ymdd[i]} == ymdwd[i]);
+  }
+}
+
+int
+main()
+{
+  test_a();
+  test_b();
+  test_c();
+  test_d();
+  test_e();
+  test_f();
+  test_g();
+}

test/solar_hijri_test/year_month_day.pass.cpp

@@ -0,0 +1,168 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Asad. Gharighi
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// class year_month_day
+// {
+// public:
+//     constexpr year_month_day(const date::year& y, const date::month& m,
+//                                const date::day& d) noexcept;
+//     constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
+//     constexpr year_month_day(const sys_days& dp) noexcept;
+//
+//     year_month_day& operator+=(const months& m) noexcept;
+//     year_month_day& operator-=(const months& m) noexcept;
+//     year_month_day& operator+=(const years& y)  noexcept;
+//     year_month_day& operator-=(const years& y)  noexcept;
+//
+//     constexpr date::year  year()  const noexcept;
+//     constexpr date::month month() const noexcept;
+//     constexpr date::day   day()   const noexcept;
+//
+//     constexpr operator sys_days() const noexcept;
+//     constexpr bool ok() const noexcept;
+// };
+
+// constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
+// constexpr bool operator!=(const year_month_day& x, const year_month_day& y) noexcept;
+// constexpr bool operator< (const year_month_day& x, const year_month_day& y) noexcept;
+// constexpr bool operator> (const year_month_day& x, const year_month_day& y) noexcept;
+// constexpr bool operator<=(const year_month_day& x, const year_month_day& y) noexcept;
+// constexpr bool operator>=(const year_month_day& x, const year_month_day& y) noexcept;
+
+// constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
+// constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
+// constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
+// constexpr year_month_day operator+(const year_month_day& ymd, const years& dy)  noexcept;
+// constexpr year_month_day operator+(const years& dy, const year_month_day& ymd)  noexcept;
+// constexpr year_month_day operator-(const year_month_day& ymd, const years& dy)  noexcept;
+
+// std::ostream& operator<<(std::ostream& os, const year_month_day& ymd);
+
+#include "date.h"
+#include "solar_hijri.h"
+
+#include <iostream>
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+static_assert( std::is_trivially_destructible<solar_hijri::year_month_day>{}, "");
+static_assert( std::is_default_constructible<solar_hijri::year_month_day>{}, "");
+static_assert( std::is_trivially_copy_constructible<solar_hijri::year_month_day>{}, "");
+static_assert( std::is_trivially_copy_assignable<solar_hijri::year_month_day>{}, "");
+static_assert( std::is_trivially_move_constructible<solar_hijri::year_month_day>{}, "");
+static_assert( std::is_trivially_move_assignable<solar_hijri::year_month_day>{}, "");
+
+static_assert(std::is_nothrow_constructible<solar_hijri::year_month_day, solar_hijri::year,
+                                                                  solar_hijri::month,
+                                                                  solar_hijri::day>{}, "");
+static_assert(std::is_nothrow_constructible<solar_hijri::year_month_day,
+                                            solar_hijri::year_month_day_last>{}, "");
+static_assert(std::is_convertible<solar_hijri::year_month_day_last, solar_hijri::year_month_day>{}, "");
+static_assert(std::is_nothrow_constructible<solar_hijri::year_month_day, solar_hijri::sys_days>{}, "");
+static_assert(std::is_convertible<solar_hijri::sys_days, solar_hijri::year_month_day>{}, "");
+static_assert(std::is_nothrow_constructible<solar_hijri::sys_days, solar_hijri::year_month_day>{}, "");
+static_assert(std::is_convertible<solar_hijri::year_month_day, solar_hijri::sys_days>{}, "");
+
+void
+test_arithmetic()
+{
+    using namespace solar_hijri;
+
+    for (int y1 = 1380; y1 <= 1400; ++y1)
+    {
+        for (unsigned m1 = 1; m1 <= 12; ++m1)
+        {
+            year_month_day ymd1{year{y1}, month{m1}, 9_d};
+            year_month_day ymd2 = ymd1 + months(24);
+            assert((ymd2 == year_month_day{year{y1+2}, ymd1.month(), ymd1.day()}));
+            ymd2 = ymd1 - months(24);
+            assert((ymd2 == year_month_day{year{y1-2}, ymd1.month(), ymd1.day()}));
+            for (int m2 = -24; m2 <= 24; ++m2)
+            {
+                months m{m2};
+                year_month_day ymd3 = ymd1 + m;
+                months dm = year_month{ymd3.year(), ymd3.month()} -
+                            year_month{ymd2.year(), ymd2.month()};
+                assert(dm == m + years{2});
+                assert(ymd3 - m == ymd1);
+                assert(ymd3 + -m == ymd1);
+                assert(-m + ymd3 == ymd1);
+                assert((year_month_day{ymd1} += m) == ymd3);
+                assert((year_month_day{ymd3} -= m) == ymd1);
+            }
+            for (int y2 = -2; y2 <= 5; ++y2)
+            {
+                years y{y2};
+                year_month_day ymd3 = ymd1 + y;
+                years dy = date::floor<years>(year_month{ymd3.year(), ymd3.month()} -
+                                        year_month{ymd2.year(), ymd2.month()});
+                assert(dy == y + years{2});
+                assert(ymd3 - y == ymd1);
+                assert(ymd3 + -y == ymd1);
+                assert(-y + ymd3 == ymd1);
+                assert((year_month_day{ymd1} += y) == ymd3);
+                assert((year_month_day{ymd3} -= y) == ymd1);
+            }
+        }
+    }
+}
+
+void
+test_day_point_conversion()
+{
+    using namespace solar_hijri;
+    year y   = year{-30000};
+    year end =       30000_y;
+    sys_days prev_dp = sys_days(year_month_day{y, far, 1_d}) - days{1};
+    weekday  prev_wd = weekday{prev_dp};
+    for (; y <= end; ++y)
+    {
+        month m = far;
+        do
+        {
+            day last_day = year_month_day_last{y, month_day_last{m}}.day();
+            for (day d = 1_d; d <= last_day; ++d)
+            {
+                year_month_day ymd = {y, m, d};
+                assert(ymd.ok());
+                sys_days dp = sys_days(ymd);
+                assert(dp == prev_dp + days{1});
+                year_month_day ymd2 = dp;
+                assert(ymd2 == ymd);
+                weekday wd = dp;
+                assert(wd.ok());
+                assert(wd == prev_wd + days{1});
+                prev_wd = wd;
+                prev_dp = dp;
+            }
+        } while (++m != far);
+    }
+}
+
+int
+main()
+{
+  test_arithmetic();
+  test_day_point_conversion();
+}

test/testit

@@ -48,7 +48,10 @@ if [ -z "$CXX_LANG" ]
 then
     CXX_LANG=c++14
 fi
-OPTIONS="-std=${CXX_LANG} $OPTIONS -I$ROOT -Wall"
+OPTIONS="-std=${CXX_LANG} $OPTIONS -I$ROOT -Wall $ROOT/src/tz.cpp -lcurl"
+
+echo $ROOT
+HEADER_INCLUDE="-I$ROOT/include -I$ROOT/include/date"
 
 case $TRIPLE in
   *-*-mingw* | *-*-cygwin* | *-*-win*)

test/tz_test/OffsetZone.h

@@ -0,0 +1,73 @@
+#ifndef OFFSET_ZONE_H
+#define OFFSET_ZONE_H
+
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// Test custom time zone support
+
+#include "tz.h"
+
+class OffsetZone
+{
+    std::chrono::minutes offset_;
+
+public:
+    explicit OffsetZone(std::chrono::minutes offset)
+        : offset_{offset}
+        {}
+
+    template <class Duration>
+        auto
+        to_local(date::sys_time<Duration> tp) const
+        {
+            using namespace date;
+            using namespace std::chrono;
+            using LT = local_time<std::common_type_t<Duration, minutes>>;
+            return LT{(tp + offset_).time_since_epoch()};
+        }
+
+    template <class Duration>
+        auto
+        to_sys(date::local_time<Duration> tp, date::choose = date::choose::earliest) const
+        {
+            using namespace date;
+            using namespace std::chrono;
+            using ST = sys_time<std::common_type_t<Duration, minutes>>;
+            return ST{(tp - offset_).time_since_epoch()};
+        }
+
+    template <class Duration>
+        date::sys_info
+        get_info(date::sys_time<Duration> st) const
+        {
+            using namespace date;
+            using namespace std::chrono;
+            return {sys_seconds::min(), sys_seconds::max(), offset_,
+                    minutes{0}, offset_ >= minutes{0} ? "+" + date::format("%H%M", offset_)
+                                          : "-" + date::format("%H%M", -offset_)};
+        }
+
+    const OffsetZone* operator->() const {return this;}
+};
+
+#endif // OFFSET_ZONE_H

test/tz_test/OffsetZone.pass.cpp

@@ -0,0 +1,38 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// Test custom time zone support
+
+#include "tz.h"
+#include "OffsetZone.h"
+#include <cassert>
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+    auto now = system_clock::now();
+    auto offset = hours{-4};
+    zoned_time<system_clock::duration, OffsetZone> zt{OffsetZone{offset}, now};
+    assert(zt.get_local_time().time_since_epoch() == now.time_since_epoch() + offset);
+}

test/tz_test/README.md

@@ -1,21 +1,15 @@
-To test: * Install tz.cpp by downloading the IANA timezone database
-at: http://www.iana.org/time-zones You only need the data, not the
-code.
+# TZ Test
 
-* Change the string `install` in tz.cpp to point to your downloaded
-IANA database.
+## How to Test
 
+* Install tz.cpp by downloading the IANA timezone database at: http://www.iana.org/time-zones You only need the data, not the code.
+* Change the string `install` in tz.cpp to point to your downloaded IANA database.
 * Compile validate.cpp along with tz.cpp.
-
 * Run the binary and direct the terminal output to a temporary file.
+* Unzip the tzdata file that has the version corresponding to the IANA database you downloaded (e.g. tzdata2015f.txt.zip).
+* Compare the unzipped txt file with the output of your validate test program. If they are identical, the test passes, else it fails.
 
-* Unzip the tzdata file that has the version corresponding to the IANA
-database you downloaded (e.g. tzdata2015f.txt.zip).
-
-* Compare the unzipped txt file with the output of your validate test
-program. If they are identical, the test passes, else it fails.
-
-Miscellaneous:
+## Miscellaneous
 
 You can also compare one version of the tzdatabase with another using
 these uncompressed text files.  The text files contain for each
@@ -25,4 +19,4 @@ versions change, minor updates to the set of these transitions are
 typically made, typically due to changes in government policies.
 
 The tests in this section will run much faster with optimizations
-cranked up.
+cranked up.

test/tz_test/tzdb_list.pass.cpp

@@ -0,0 +1,36 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2020 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+#include <type_traits>
+
+int
+main()
+{
+    using namespace date;
+    static_assert( std::is_nothrow_destructible<tzdb_list>{}, "");
+    static_assert( std::is_nothrow_default_constructible<tzdb_list>{}, "");
+    static_assert(!std::is_copy_constructible<tzdb_list>{}, "");
+    static_assert(!std::is_copy_assignable<tzdb_list>{}, "");
+    static_assert( std::is_nothrow_move_constructible<tzdb_list>{}, "");
+    static_assert(!std::is_move_assignable<tzdb_list>{}, "");
+}

test/tz_test/validate.cpp

@@ -1,4 +1,4 @@
-#include "tz.h"
+#include "date/tz.h"
 #include <iostream>
 
 void
@@ -89,12 +89,18 @@ tzmain()
     using namespace std::chrono;
     auto& db = get_tzdb();
     std::vector<std::string> names;
-    names.reserve(db.zones.size() + db.links.size());
-    for (const auto& zone : db.zones)
+#if USE_OS_TZDB
+    names.reserve(db.zones.size());
+    for (auto& zone : db.zones)
         names.push_back(zone.name());
-    for (const auto& link : db.links)
+#else  // !USE_OS_TZDB
+    names.reserve(db.zones.size() + db.links.size());
+    for (auto& zone : db.zones)
+        names.push_back(zone.name());
+    for (auto& link : db.links)
         names.push_back(link.name());
     std::sort(names.begin(), names.end());
+#endif  // !USE_OS_TZDB
     std::cout << db.version << "\n\n";
     for (auto const& name : names)
     {

test/tz_test/zone.pass.cpp

@@ -1,3 +1,25 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2015, 2016 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
 #include "tz.h"
 #include <type_traits>
 

test/tz_test/zoned_time.pass.cpp

@@ -0,0 +1,464 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Howard Hinnant
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// template <class Duration>
+// class zoned_time
+// {
+// public:
+//     using duration = typename std::common_type<Duration, std::chrono::seconds>::type;
+// 
+//              zoned_time();
+//              zoned_time(const sys_time<Duration>& st);
+//     explicit zoned_time(const time_zone* z);
+//     explicit zoned_time(std::string_view name);
+// 
+//     template <class Duration2,
+//               class = typename std::enable_if
+//                       <
+//                           std::is_convertible<sys_time<Duration2>,
+//                                               sys_time<Duration>>::value
+//                       >::type>
+//         zoned_time(const zoned_time<Duration2>& zt) NOEXCEPT;
+// 
+//     zoned_time(const time_zone* z,    const local_time<Duration>& tp);
+//     zoned_time(std::string_view name, const local_time<Duration>& tp);
+//     zoned_time(const time_zone* z,    const local_time<Duration>& tp, choose c);
+//     zoned_time(std::string_view name, const local_time<Duration>& tp, choose c);
+// 
+//     zoned_time(const time_zone* z,    const zoned_time<Duration>& zt);
+//     zoned_time(std::string_view name, const zoned_time<Duration>& zt);
+//     zoned_time(const time_zone* z,    const zoned_time<Duration>& zt, choose);
+//     zoned_time(std::string_view name, const zoned_time<Duration>& zt, choose);
+// 
+//     zoned_time(const time_zone* z,    const sys_time<Duration>& st);
+//     zoned_time(std::string_view name, const sys_time<Duration>& st);
+// 
+//     zoned_time& operator=(const sys_time<Duration>& st);
+//     zoned_time& operator=(const local_time<Duration>& ut);
+// 
+//     explicit operator sys_time<duration>() const;
+//     explicit operator local_time<duration>() const;
+// 
+//     const time_zone*     get_time_zone() const;
+//     local_time<duration> get_local_time() const;
+//     sys_time<duration>   get_sys_time() const;
+//     sys_info             get_info() const;
+// 
+//     template <class Duration1, class Duration2>
+//     friend
+//     bool
+//     operator==(const zoned_time<Duration1>& x, const zoned_time<Duration2>& y);
+// 
+//     template <class CharT, class Traits, class Duration1>
+//     friend
+//     std::basic_ostream<CharT, Traits>&
+//     operator<<(std::basic_ostream<CharT, Traits>& os, const zoned_time<Duration1>& t);
+// };
+//
+// using zoned_seconds = zoned_time<std::chrono::seconds>;
+//
+// template <class Duration1, class Duration2>
+// inline
+// bool
+// operator!=(const zoned_time<Duration1>& x, const zoned_time<Duration2>& y);
+//
+// template <class Duration>
+// zoned_time(sys_time<Duration>)
+//     -> zoned_time<std::common_type_t<Duration, std::chrono::seconds>>;
+//
+// template <class Zone, class Duration>
+// zoned_time(Zone, sys_time<Duration>)
+//     -> zoned_time<std::common_type_t<Duration, std::chrono::seconds>>;
+//
+// template <class Zone, class Duration>
+// zoned_time(Zone, local_time<Duration>, choose = choose::earliest)
+//     -> zoned_time<std::common_type_t<Duration, std::chrono::seconds>>;
+//
+// template <class Zone, class Duration>
+// zoned_time(Zone, zoned_time<Duration>, choose = choose::earliest)
+//     -> zoned_time<std::common_type_t<Duration, std::chrono::seconds>>;
+
+#include "tz.h"
+#include <cassert>
+#include <sstream>
+#include <type_traits>
+
+int
+main()
+{
+    using namespace std;
+    using namespace std::chrono;
+    using namespace date;
+    static_assert( is_nothrow_destructible<zoned_seconds>{}, "");
+    static_assert( is_default_constructible<zoned_seconds>{}, "");
+    static_assert( is_nothrow_copy_constructible<zoned_seconds>{}, "");
+    static_assert( is_nothrow_copy_assignable<zoned_seconds>{}, "");
+    static_assert( is_nothrow_move_constructible<zoned_seconds>{}, "");
+    static_assert( is_nothrow_move_assignable<zoned_seconds>{}, "");
+
+    static_assert(is_same<zoned_time<minutes>::duration, seconds>{}, "");
+    static_assert(is_same<zoned_seconds::duration, seconds>{}, "");
+    static_assert(is_same<zoned_time<milliseconds>::duration, milliseconds>{}, "");
+
+    // zoned_time();
+    {
+        zoned_seconds zt;
+        assert(zt.get_sys_time() == sys_seconds{});
+        assert(zt.get_time_zone()->name() == "Etc/UTC");
+    }
+
+    // zoned_time(const sys_time<Duration>& st);
+    {
+        static_assert(!is_convertible<sys_days, zoned_seconds>{}, "");
+        static_assert( is_constructible<zoned_seconds, sys_days>{}, "");
+        static_assert( is_convertible<sys_seconds, zoned_seconds>{}, "");
+        static_assert(!is_convertible<sys_time<milliseconds>, zoned_seconds>{}, "");
+        static_assert(!is_constructible<zoned_seconds, sys_time<milliseconds>>{}, "");
+
+        auto now = floor<seconds>(system_clock::now());
+        zoned_seconds zt = now;
+        assert(zt.get_sys_time() == now);
+        assert(zt.get_time_zone()->name() == "Etc/UTC");
+    }
+
+    // explicit zoned_time(const time_zone* z);
+    {
+        static_assert(!is_convertible<const time_zone*, zoned_seconds>{}, "");
+        static_assert( is_constructible<zoned_seconds, const time_zone*>{}, "");
+        zoned_seconds zt{locate_zone("America/New_York")};
+        assert(zt.get_sys_time() == sys_seconds{});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+    }
+
+    // explicit zoned_time(std::string_view name);
+    {
+        static_assert(!is_convertible<std::string, zoned_seconds>{}, "");
+        static_assert( is_constructible<zoned_seconds, std::string>{}, "");
+        static_assert( is_constructible<zoned_seconds, const char*>{}, "");
+        static_assert( is_constructible<zoned_seconds, const char[3]>{}, "");
+        zoned_seconds zt{"America/New_York"};
+        assert(zt.get_sys_time() == sys_seconds{});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+    }
+
+    // template <class Duration2,
+    //           class = typename std::enable_if
+    //                   <
+    //                       std::is_convertible<sys_time<Duration2>,
+    //                                           sys_time<Duration>>::value
+    //                   >::type>
+    //     zoned_time(const zoned_time<Duration2>& zt) NOEXCEPT;
+    {
+        static_assert( is_convertible<zoned_time<days>, zoned_seconds>{}, "");
+        static_assert(!is_constructible<zoned_time<days>, zoned_seconds>{}, "");
+        zoned_time<days> zt1{"America/New_York", sys_days{2017_y/jul/5}};
+        zoned_seconds zt2 = zt1;
+        assert(zt2.get_sys_time() == sys_days{2017_y/jul/5});
+        assert(zt2.get_time_zone()->name() == "America/New_York");
+    }
+
+    // zoned_time(const time_zone* z, const local_time<Duration>& tp);
+    {
+        static_assert( is_constructible<zoned_seconds, const time_zone*, local_days>{}, "");
+        zoned_seconds zt = {locate_zone("America/New_York"), local_days{2017_y/jul/5}};
+        assert(zt.get_local_time() == local_days{2017_y/jul/5});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+        try
+        {
+            zoned_seconds zt1 = {locate_zone("America/New_York"),
+                                 local_days{2017_y/mar/sun[2]} + hours{2} + minutes{15}};
+            assert(false);
+        }
+        catch(const nonexistent_local_time&)
+        {
+        }
+        try
+        {
+            zoned_seconds zt1 = {locate_zone("America/New_York"),
+                                 local_days{2017_y/nov/sun[1]} + hours{1} + minutes{15}};
+            assert(false);
+        }
+        catch(const ambiguous_local_time&)
+        {
+        }
+    }
+
+    // zoned_time(std::string_view name, const local_time<Duration>& tp);
+    {
+        static_assert( is_constructible<zoned_seconds, std::string, local_days>{}, "");
+        static_assert( is_constructible<zoned_seconds, const char*, local_days>{}, "");
+        zoned_seconds zt = {"America/New_York", local_days{2017_y/jul/5}};
+        assert(zt.get_local_time() == local_days{2017_y/jul/5});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+        try
+        {
+            zoned_seconds zt1 = {"America/New_York",
+                                 local_days{2017_y/mar/sun[2]} + hours{2} + minutes{15}};
+            assert(false);
+        }
+        catch(const nonexistent_local_time&)
+        {
+        }
+        try
+        {
+            zoned_seconds zt1 = {"America/New_York",
+                                 local_days{2017_y/nov/sun[1]} + hours{1} + minutes{15}};
+            assert(false);
+        }
+        catch(const ambiguous_local_time&)
+        {
+        }
+    }
+
+    // zoned_time(const time_zone* z, const local_time<Duration>& tp, choose c);
+    {
+        static_assert( is_constructible<zoned_seconds, const time_zone*, local_days, choose>{}, "");
+        zoned_seconds zt = {locate_zone("America/New_York"),
+                            local_days{2017_y/jul/5} + hours{2} + minutes{15},
+                            choose::earliest};
+        assert(zt.get_sys_time() == sys_days{2017_y/jul/5} + hours{6} + minutes{15});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+
+        zt = {locate_zone("America/New_York"),
+                            local_days{2017_y/jul/5} + hours{2} + minutes{15},
+                            choose::latest};
+        assert(zt.get_sys_time() == sys_days{2017_y/jul/5} + hours{6} + minutes{15});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+
+        static_assert( is_constructible<zoned_seconds, const time_zone*, local_days, choose>{}, "");
+        zoned_seconds zt1 = {locate_zone("America/New_York"),
+                             local_days{2017_y/mar/sun[2]} + hours{2} + minutes{15},
+                             choose::earliest};
+        assert(zt1.get_sys_time() == sys_days{2017_y/mar/12} + hours{7});
+        assert(zt1.get_time_zone()->name() == "America/New_York");
+
+        zoned_seconds zt2 = {locate_zone("America/New_York"),
+                             local_days{2017_y/mar/sun[2]} + hours{2} + minutes{15},
+                             choose::latest};
+        assert(zt2.get_sys_time() == sys_days{2017_y/mar/12} + hours{7});
+        assert(zt2.get_time_zone()->name() == "America/New_York");
+
+        zoned_seconds zt3 = {locate_zone("America/New_York"),
+                             local_days{2017_y/nov/sun[1]} + hours{1} + minutes{15},
+                             choose::earliest};
+        assert(zt3.get_sys_time() == sys_days{2017_y/nov/5} + hours{5} + minutes{15});
+        assert(zt3.get_time_zone()->name() == "America/New_York");
+
+        zoned_seconds zt4 = {locate_zone("America/New_York"),
+                             local_days{2017_y/nov/sun[1]} + hours{1} + minutes{15},
+                             choose::latest};
+        assert(zt4.get_sys_time() == sys_days{2017_y/nov/5} + hours{6} + minutes{15});
+        assert(zt4.get_time_zone()->name() == "America/New_York");
+    }
+
+    // zoned_time(std::string_view name, const local_time<Duration>& tp, choose c);
+    {
+        static_assert( is_constructible<zoned_seconds, std::string, local_days, choose>{}, "");
+        static_assert( is_constructible<zoned_seconds, const char*, local_days, choose>{}, "");
+        zoned_seconds zt = {"America/New_York",
+                            local_days{2017_y/jul/5} + hours{2} + minutes{15},
+                            choose::earliest};
+        assert(zt.get_sys_time() == sys_days{2017_y/jul/5} + hours{6} + minutes{15});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+
+        zt = {"America/New_York",
+                            local_days{2017_y/jul/5} + hours{2} + minutes{15},
+                            choose::latest};
+        assert(zt.get_sys_time() == sys_days{2017_y/jul/5} + hours{6} + minutes{15});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+
+        static_assert( is_constructible<zoned_seconds, const time_zone*, local_days, choose>{}, "");
+        zoned_seconds zt1 = {"America/New_York",
+                             local_days{2017_y/mar/sun[2]} + hours{2} + minutes{15},
+                             choose::earliest};
+        assert(zt1.get_sys_time() == sys_days{2017_y/mar/12} + hours{7});
+        assert(zt1.get_time_zone()->name() == "America/New_York");
+
+        zoned_seconds zt2 = {"America/New_York",
+                             local_days{2017_y/mar/sun[2]} + hours{2} + minutes{15},
+                             choose::latest};
+        assert(zt2.get_sys_time() == sys_days{2017_y/mar/12} + hours{7});
+        assert(zt2.get_time_zone()->name() == "America/New_York");
+
+        zoned_seconds zt3 = {"America/New_York",
+                             local_days{2017_y/nov/sun[1]} + hours{1} + minutes{15},
+                             choose::earliest};
+        assert(zt3.get_sys_time() == sys_days{2017_y/nov/5} + hours{5} + minutes{15});
+        assert(zt3.get_time_zone()->name() == "America/New_York");
+
+        zoned_seconds zt4 = {"America/New_York",
+                             local_days{2017_y/nov/sun[1]} + hours{1} + minutes{15},
+                             choose::latest};
+        assert(zt4.get_sys_time() == sys_days{2017_y/nov/5} + hours{6} + minutes{15});
+        assert(zt4.get_time_zone()->name() == "America/New_York");
+    }
+
+    // zoned_time(const time_zone* z, const sys_time<Duration>& st);
+    {
+        static_assert( is_constructible<zoned_seconds, const time_zone*, sys_days>{}, "");
+
+        zoned_seconds zt = {locate_zone("America/New_York"),
+                            sys_days{2017_y/jul/5} + hours{2} + minutes{15}};
+        assert(zt.get_sys_time() == sys_days{2017_y/jul/5} + hours{2} + minutes{15});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+    }
+
+    // zoned_time(std::string_view name, const sys_time<Duration>& st);
+    {
+        static_assert( is_constructible<zoned_seconds, std::string, sys_days>{}, "");
+        static_assert( is_constructible<zoned_seconds, const char*, sys_days>{}, "");
+
+        zoned_seconds zt = {"America/New_York",
+                            sys_days{2017_y/jul/5} + hours{2} + minutes{15}};
+        assert(zt.get_sys_time() == sys_days{2017_y/jul/5} + hours{2} + minutes{15});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+    }
+
+    // zoned_time& operator=(const sys_time<Duration>& st);
+    {
+        static_assert( is_assignable<zoned_seconds, const sys_days&>{}, "");
+
+        zoned_seconds zt{"America/New_York"};
+        zt = sys_days{2017_y/jul/5};
+        assert(zt.get_sys_time() == sys_days{2017_y/jul/5});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+    }
+
+    // zoned_time& operator=(const local_time<Duration>& st);
+    {
+        static_assert( is_assignable<zoned_seconds, const local_days&>{}, "");
+
+        zoned_seconds zt{"America/New_York"};
+        zt = local_days{2017_y/jul/5};
+        assert(zt.get_local_time() == local_days{2017_y/jul/5});
+        assert(zt.get_time_zone()->name() == "America/New_York");
+        try
+        {
+            zt = {"America/New_York",
+                                 local_days{2017_y/mar/sun[2]} + hours{2} + minutes{15}};
+            assert(false);
+        }
+        catch(const nonexistent_local_time&)
+        {
+            assert(zt.get_local_time() == local_days{2017_y/jul/5});
+            assert(zt.get_time_zone()->name() == "America/New_York");
+        }
+        try
+        {
+            zt = {"America/New_York",
+                                 local_days{2017_y/nov/sun[1]} + hours{1} + minutes{15}};
+            assert(false);
+        }
+        catch(const ambiguous_local_time&)
+        {
+            assert(zt.get_local_time() == local_days{2017_y/jul/5});
+            assert(zt.get_time_zone()->name() == "America/New_York");
+        }
+    }
+
+    // explicit operator sys_time<duration>() const;
+    {
+        static_assert(!is_convertible<zoned_seconds, sys_seconds>{}, "");
+        static_assert( is_constructible<sys_seconds, zoned_seconds>{}, "");
+        auto now = floor<seconds>(system_clock::now());
+        const zoned_seconds zt = {"America/New_York", now};
+        assert(sys_seconds{zt} == now);
+    }
+
+    // explicit operator local_time<duration>() const;
+    {
+        static_assert(!is_convertible<zoned_seconds, local_seconds>{}, "");
+        static_assert( is_constructible<local_seconds, zoned_seconds>{}, "");
+        auto now = local_days{2017_y/jul/5} + hours{23} + minutes{1} + seconds{48};
+        const zoned_seconds zt = {"America/New_York", now};
+        assert(local_seconds{zt} == now);
+    }
+
+    // const time_zone* get_time_zone() const;
+    {
+        const zoned_seconds zt{"America/New_York"};
+        assert(zt.get_time_zone() == locate_zone("America/New_York"));
+    }
+
+    // local_time<duration> get_local_time() const;
+    {
+        const zoned_seconds zt{"America/New_York", sys_days{2017_y/jul/6} +
+                                                   hours{3} + minutes{7} + seconds{9}};
+        assert(zt.get_local_time() == local_days{2017_y/jul/5} +
+                                      hours{23} + minutes{7} + seconds{9});
+    }
+
+    // sys_time<duration> get_sys_time() const;
+    {
+        const zoned_seconds zt{"America/New_York", sys_days{2017_y/jul/6} +
+                                                   hours{3} + minutes{7} + seconds{9}};
+        assert(zt.get_sys_time() == sys_days{2017_y/jul/6} +
+                                    hours{3} + minutes{7} + seconds{9});
+    }
+
+    // sys_info get_info() const;
+    {
+        const zoned_seconds zt{"America/New_York", sys_days{2017_y/jul/6} +
+                                                   hours{3} + minutes{7} + seconds{9}};
+        auto info = zt.get_info();
+        assert(info.begin == sys_days{2017_y/mar/12} + hours{7});
+        assert(info.end == sys_days{2017_y/nov/5} + hours{6});
+        assert(info.offset == hours{-4});
+        assert(info.save != minutes{0});
+        assert(info.abbrev == "EDT");
+    }
+
+    // template <class Duration1, class Duration2>
+    // bool
+    // operator==(const zoned_time<Duration1>& x, const zoned_time<Duration2>& y);
+    {
+        const zoned_seconds zt{"America/New_York", sys_days{2017_y/jul/6} +
+                                                   hours{3} + minutes{7} + seconds{9}};
+        const zoned_seconds zt1{"America/New_York", sys_days{2017_y/jul/6} +
+                                                   hours{3} + minutes{7} + seconds{10}};
+        assert(zt == zt);
+        assert(!(zt == zt1));
+    }
+
+    // template <class Duration1, class Duration2>
+    // bool
+    // operator!=(const zoned_time<Duration1>& x, const zoned_time<Duration2>& y);
+    {
+        const zoned_seconds zt{"America/New_York", sys_days{2017_y/jul/6} +
+                                                   hours{3} + minutes{7} + seconds{9}};
+        const zoned_seconds zt1{"America/New_York", sys_days{2017_y/jul/6} +
+                                                   hours{3} + minutes{7} + seconds{10}};
+        assert(!(zt != zt));
+        assert(zt != zt1);
+    }
+
+    // template <class CharT, class Traits, class Duration1>
+    // std::basic_ostream<CharT, Traits>&
+    // operator<<(std::basic_ostream<CharT, Traits>& os, const zoned_time<Duration1>& t);
+    {
+        const zoned_seconds zt{"America/New_York", sys_days{2017_y/jul/6} +
+                                                   hours{3} + minutes{7} + seconds{9}};
+        std::ostringstream test;
+        test << zt;
+        assert(test.str() == "2017-07-05 23:07:09 EDT");
+    }
+}

test/tz_test/zoned_time_deduction.pass.cpp

@@ -0,0 +1,246 @@
+// The MIT License (MIT)
+//
+// Copyright (c) 2019 Tomasz Kamiński
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#include "tz.h"
+#include "OffsetZone.h"
+#include <cassert>
+#include <type_traits>
+#include <string>
+
+#if HAS_DEDUCTION_GUIDES
+#include <string_view>
+
+template<typename TimeZonePtr, typename Source>
+void testDeductionFrom(Source&& s)
+{
+    using namespace date;
+    using namespace std::chrono;
+
+    // No time point
+    {
+        zoned_time zt(std::forward<Source>(s));
+        static_assert(std::is_same<decltype(zt), zoned_time<seconds, TimeZonePtr>>::value, "");
+    }
+
+    // sys_time
+    {
+        sys_days sd(2017_y/feb/20);
+        zoned_time ztd(std::forward<Source>(s), sd);
+        static_assert(std::is_same<decltype(ztd), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        sys_time<seconds> ss(sd);
+        zoned_time zts(std::forward<Source>(s), ss);
+        static_assert(std::is_same<decltype(zts), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        sys_time<milliseconds> sms(ss);
+        zoned_time ztms(std::forward<Source>(s), sms);
+        static_assert(std::is_same<decltype(ztms), zoned_time<milliseconds, TimeZonePtr>>::value, "");
+    }
+
+    // local_time
+    {
+        local_days ld(2017_y/feb/20);
+        zoned_time ztd(std::forward<Source>(s), ld);
+        static_assert(std::is_same<decltype(ztd), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        local_time<seconds> ls(ld);
+        zoned_time zts(std::forward<Source>(s), ls);
+        static_assert(std::is_same<decltype(zts), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        local_time<milliseconds> lms(ls);
+        zoned_time ztms(std::forward<Source>(s), lms);
+        static_assert(std::is_same<decltype(ztms), zoned_time<milliseconds, TimeZonePtr>>::value, "");
+    }
+
+    // local_time, choose
+    {
+        local_days ld(2017_y/feb/20);
+        zoned_time ztd(std::forward<Source>(s), ld, choose::earliest);
+        static_assert(std::is_same<decltype(ztd), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        local_time<seconds> ls(ld);
+        zoned_time zts(std::forward<Source>(s), ls, choose::earliest);
+        static_assert(std::is_same<decltype(zts), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        local_time<milliseconds> lms(ls);
+        zoned_time ztms(std::forward<Source>(s), lms, choose::earliest);
+        static_assert(std::is_same<decltype(ztms), zoned_time<milliseconds, TimeZonePtr>>::value, "");
+    }
+
+    // zoned_time
+    {
+        zoned_time<days> zd(sys_days(2017_y/feb/20));
+        zoned_time ztd(std::forward<Source>(s), zd);
+        static_assert(std::is_same<decltype(ztd), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        zoned_time<seconds> zs(zd);
+        zoned_time zts(std::forward<Source>(s), zs);
+        static_assert(std::is_same<decltype(zts), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        zoned_time<milliseconds> zms(zs);
+        zoned_time ztms(std::forward<Source>(s), zms);
+        static_assert(std::is_same<decltype(ztms), zoned_time<milliseconds, TimeZonePtr>>::value, "");
+    }
+
+    // zoned_time, choose
+    {
+        zoned_time<days> zd(sys_days(2017_y/feb/20));
+        zoned_time ztd(std::forward<Source>(s), zd, choose::earliest);
+        static_assert(std::is_same<decltype(ztd), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        zoned_time<seconds> zs(zd);
+        zoned_time zts(std::forward<Source>(s), zs, choose::earliest);
+        static_assert(std::is_same<decltype(zts), zoned_time<seconds, TimeZonePtr>>::value, "");
+
+        zoned_time<milliseconds> zms(zs);
+        zoned_time ztms(std::forward<Source>(s), zms, choose::earliest);
+        static_assert(std::is_same<decltype(ztms), zoned_time<milliseconds, TimeZonePtr>>::value, "");
+    }
+}
+
+struct MyString
+{
+  MyString(std::string s) : ms(std::move(s)) {}
+
+  operator std::string_view() const { return ms; }
+
+private:
+  std::string ms;
+};
+
+struct OnlyLValueString
+{
+  OnlyLValueString(std::string s) : ms(std::move(s)) {}
+
+  operator std::string_view() & { return ms; }
+
+private:
+  std::string ms;
+};
+
+#endif  // HAS_DEDUCTION_GUIDES
+
+template<typename T>
+T const& to_const(T& t) { return t; }
+
+
+int
+main()
+{
+    using namespace date;
+    using namespace std::chrono;
+
+#if HAS_DEDUCTION_GUIDES
+    //  no arguments
+    {
+        zoned_time zt{};
+        static_assert(std::is_same<decltype(zt), zoned_time<seconds>>::value, "");
+    } 
+
+    // zoned_time
+    {
+        zoned_time<days> zd(sys_days(2017_y/feb/20));
+        zoned_time ztd(zd);
+        static_assert(std::is_same<decltype(ztd), zoned_time<days>>::value, "");
+
+        zoned_time<seconds> zs(zd);
+        zoned_time zts(zs);
+        static_assert(std::is_same<decltype(zts), zoned_time<seconds>>::value, "");
+
+        zoned_time<milliseconds> zms(zs);
+        zoned_time ztms(zms);
+        static_assert(std::is_same<decltype(ztms), zoned_time<milliseconds>>::value, "");
+    }
+
+    // sys_time
+    {
+        sys_days sd(2017_y/feb/20);
+        zoned_time ztd(sd);
+        static_assert(std::is_same<decltype(ztd), zoned_time<seconds>>::value, "");
+
+        sys_time<seconds> ss(sd);
+        zoned_time zts(ss);
+        static_assert(std::is_same<decltype(zts), zoned_time<seconds>>::value, "");
+
+        sys_time<milliseconds> sms(ss);
+        zoned_time ztms(sms);
+        static_assert(std::is_same<decltype(ztms), zoned_time<milliseconds>>::value, "");
+    }
+
+    // time_zone const*
+    {
+       time_zone const* tz = current_zone();
+       testDeductionFrom<time_zone const*>(tz);
+       testDeductionFrom<time_zone const*>(to_const(tz));
+       testDeductionFrom<time_zone const*>(std::move(tz));
+    }
+
+    // char const*
+    {
+       char const* tz = "Europe/Warsaw";
+       testDeductionFrom<time_zone const*>(tz);
+       testDeductionFrom<time_zone const*>(to_const(tz));
+       testDeductionFrom<time_zone const*>(std::move(tz));
+    }
+
+    // std::string
+    {
+       std::string tz = "Europe/Warsaw";
+       testDeductionFrom<time_zone const*>(tz);
+       testDeductionFrom<time_zone const*>(to_const(tz));
+       testDeductionFrom<time_zone const*>(std::move(tz));
+    }
+
+    // std::string_view
+    {
+       std::string_view tz = "Europe/Warsaw";
+       testDeductionFrom<time_zone const*>(tz);
+       testDeductionFrom<time_zone const*>(to_const(tz));
+       testDeductionFrom<time_zone const*>(std::move(tz));
+    }
+
+    // MyString
+    {
+       MyString tz("Europe/Warsaw");
+       testDeductionFrom<time_zone const*>(tz);
+       testDeductionFrom<time_zone const*>(to_const(tz));
+       testDeductionFrom<time_zone const*>(std::move(tz));
+    }
+
+    // custom time zone
+    {
+       OffsetZone tz(minutes(45));
+       testDeductionFrom<OffsetZone>(tz);
+       testDeductionFrom<OffsetZone>(to_const(tz));
+       testDeductionFrom<OffsetZone>(std::move(tz));
+    }
+
+    // OnlyLValue
+    {
+       OnlyLValueString tz("Europe/Warsaw");
+       testDeductionFrom<time_zone const*>(tz);
+       //testDeductionFrom<time_zone const*>(to_const(tz));
+       //testDeductionFrom<time_zone const*>(std::move(tz));
+    }
+
+#endif  // HAS_DEDUCTION_GUIDES
+}

test_fail.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+echo $1
+eval $1
+
+if [ $? -eq 0 ]; then
+	exit 0;
+fi
+exit 1;
+