@eosrio/node-abieos 2.1.0-beta.0 → 2.2.0

package/external/date/test/clock_cast_test/custom_clock.pass.cpp

@@ -1,213 +0,0 @@
-// 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);
-    }
-}

package/external/date/test/clock_cast_test/deprecated.pass.cpp

@@ -1,90 +0,0 @@
-// 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);
-    }
-}

package/external/date/test/clock_cast_test/local_t.pass.cpp

@@ -1,132 +0,0 @@
-// 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);
-   }
-
-}

package/external/date/test/clock_cast_test/noncastable.pass.cpp

@@ -1,251 +0,0 @@
-// 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");
-}