File 2582-stdlib-Add-RFC-3339-functions-to-module-ca... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 2582-stdlib-Add-RFC-3339-functions-to-module-calendar.patch of Package erlang (Revision ac8eee046d90e3601c6b140b4880b66c)

Currently displaying revision ac8eee046d90e3601c6b140b4880b66c , Show latest

From c650e93aaac225559229968fbbf6dfd7ca5d0cf7 Mon Sep 17 00:00:00 2001
From: Hans Bolinder <hasse@erlang.org>
Date: Thu, 1 Feb 2018 16:35:43 +0100
Subject: [PATCH] stdlib: Add RFC 3339 functions to module calendar

Functions for converting between RFC 3339 strings and system time
are added.

Options are lists, but we are considering using maps instead. If we
change, it will happen after Erlang/OTP 21.0-rc1 is released.
---
 lib/stdlib/doc/src/calendar.xml    |  70 ++++++++++++++++
 lib/stdlib/src/calendar.erl        | 166 +++++++++++++++++++++++++++++++++++--
 lib/stdlib/test/calendar_SUITE.erl | 141 ++++++++++++++++++++++++++++++-
 3 files changed, 369 insertions(+), 8 deletions(-)

diff --git a/lib/stdlib/doc/src/calendar.xml b/lib/stdlib/doc/src/calendar.xml
index 0c4a30ce16..8f2b6b747a 100644
--- a/lib/stdlib/doc/src/calendar.xml
+++ b/lib/stdlib/doc/src/calendar.xml
@@ -316,6 +316,30 @@
       </desc>
     </func>
 
+    <func>
+      <name name="rfc3339_to_system_time" arity="1"/>
+      <name name="rfc3339_to_system_time" arity="2"/>
+      <fsummary>Convert from RFC 3339 timestamp to system time.</fsummary>
+      <type name="rfc3339_string"/>
+      <type name="rfc3339_time_unit"/>
+      <desc>
+	<p>Converts an RFC 3339 timestamp into system time.</p>
+	<p>Valid option:</p>
+	<taglist>
+	  <tag><c>{unit, Unit}</c></tag>
+	  <item><p>The time unit of the return value.
+	    The default is <c>second</c>.</p>
+	  </item>
+	</taglist>
+        <pre>
+1> <input>calendar:rfc3339_to_system_time("2018-02-01T16:17:58+01:00").</input>
+1517498278
+2> <input>calendar:rfc3339_to_system_time("2018-02-01 15:18:02.088Z",
+   [{unit, nanosecond}]).</input>
+1517498282088000000</pre>
+      </desc>
+    </func>
+
     <func>
       <name name="seconds_to_daystime" arity="1"/>
       <fsummary>Compute days and time from seconds.</fsummary>
@@ -346,6 +370,52 @@
       </desc>
     </func>
 
+    <func>
+      <name name="system_time_to_rfc3339" arity="1"/>
+      <name name="system_time_to_rfc3339" arity="2"/>
+      <fsummary>Convert from system to RFC 3339 timestamp.</fsummary>
+      <type name="offset"/>
+      <type name="rfc3339_string"/>
+      <type name="rfc3339_time_unit"/>
+      <desc>
+	<p>Converts a system time into RFC 3339 timestamp.</p>
+	<p>Valid options:</p>
+	<taglist>
+	  <tag><c>{offset, Offset}</c></tag>
+	  <item><p>The offset, either a string or an integer, to be
+	    included in the formatted string.
+	    An empty string, which is the default, is interpreted
+	    as local time. A non-empty string is included as is.
+	    The time unit of the integer is the same as the one
+	    of <c><anno>Time</anno></c>.</p>
+	  </item>
+	  <tag><c>{time_designator, Character}</c></tag>
+	  <item><p>The character used as time designator, that is,
+	    the date and time separator. The default is <c>$T</c>.</p>
+	  </item>
+	  <tag><c>{unit, Unit}</c></tag>
+	  <item><p>The time unit of <c><anno>Time</anno></c>. The
+	    default is <c>second</c>. If some other unit is given
+	    (<c>millisecond</c>, <c>microsecond</c>, or
+	    <c>nanosecond</c>), the formatted string includes a
+	    fraction of a second.</p>
+	  </item>
+	</taglist>
+        <pre>
+1> <input>calendar:system_time_to_rfc3339(erlang:system_time(second)).</input>
+"2018-04-23T14:56:28+02:00"
+2> <input>calendar:system_time_to_rfc3339(erlang:system_time(second),
+   [{offset, "-02:00"}]).</input>
+"2018-04-23T10:56:52-02:00"
+3> <input>calendar:system_time_to_rfc3339(erlang:system_time(second),
+   [{offset, -7200}]).</input>
+"2018-04-23T10:57:05-02:00"
+4> <input>calendar:system_time_to_rfc3339(erlang:system_time(millisecond),
+   [{unit, millisecond}, {time_designator, $\s}, {offset, "Z"}]).</input>
+"2018-04-23 12:57:20.482Z"</pre>
+      </desc>
+    </func>
+
     <func>
       <name name="system_time_to_universal_time" arity="2"/>
       <fsummary>Convert system time to universal date and time.</fsummary>
diff --git a/lib/stdlib/src/calendar.erl b/lib/stdlib/src/calendar.erl
index 2e24e8c133..9a600c1972 100644
--- a/lib/stdlib/src/calendar.erl
+++ b/lib/stdlib/src/calendar.erl
@@ -39,10 +39,14 @@
 	 now_to_datetime/1,			% = now_to_universal_time/1
 	 now_to_local_time/1,
 	 now_to_universal_time/1,
+         rfc3339_to_system_time/1,
+         rfc3339_to_system_time/2,
 	 seconds_to_daystime/1,
 	 seconds_to_time/1,
          system_time_to_local_time/2,
          system_time_to_universal_time/2,
+         system_time_to_rfc3339/1,
+         system_time_to_rfc3339/2,
 	 time_difference/2,
 	 time_to_seconds/1,
 	 universal_time/0,
@@ -57,11 +61,13 @@
 -define(SECONDS_PER_DAY, 86400).
 -define(DAYS_PER_YEAR, 365).
 -define(DAYS_PER_LEAP_YEAR, 366).
--define(DAYS_PER_4YEARS, 1461).
--define(DAYS_PER_100YEARS, 36524).
--define(DAYS_PER_400YEARS, 146097).
+%% -define(DAYS_PER_4YEARS, 1461).
+%% -define(DAYS_PER_100YEARS, 36524).
+%% -define(DAYS_PER_400YEARS, 146097).
 -define(DAYS_FROM_0_TO_1970, 719528).
+-define(DAYS_FROM_0_TO_10000, 2932897).
 -define(SECONDS_FROM_0_TO_1970, (?DAYS_FROM_0_TO_1970*?SECONDS_PER_DAY)).
+-define(SECONDS_FROM_0_TO_10000, (?DAYS_FROM_0_TO_10000*?SECONDS_PER_DAY)).
 
 %%----------------------------------------------------------------------
 %% Types
@@ -86,6 +92,13 @@
 -type datetime1970()   :: {{year1970(),month(),day()},time()}.
 -type yearweeknum()    :: {year(),weeknum()}.
 
+-type rfc3339_string() :: [byte(), ...].
+%% By design 'native' is not supported:
+-type rfc3339_time_unit() :: 'microsecond'
+                           | 'millisecond'
+                           | 'nanosecond'
+                           | 'second'.
+
 %%----------------------------------------------------------------------
 
 %% All dates are according the the Gregorian calendar. In this module
@@ -312,8 +325,7 @@ local_time_to_universal_time_dst(DateTime) ->
 -spec now_to_datetime(Now) -> datetime1970() when
       Now :: erlang:timestamp().
 now_to_datetime({MSec, Sec, _uSec}) ->
-    Sec0 = MSec*1000000 + Sec + ?SECONDS_FROM_0_TO_1970,
-    gregorian_seconds_to_datetime(Sec0).
+    system_time_to_datetime(MSec*1000000 + Sec).
 
 -spec now_to_universal_time(Now) -> datetime1970() when
       Now :: erlang:timestamp().
@@ -331,6 +343,33 @@ now_to_local_time({MSec, Sec, _uSec}) ->
     erlang:universaltime_to_localtime(
       now_to_universal_time({MSec, Sec, _uSec})).
 
+-spec rfc3339_to_system_time(DateTimeString) -> integer() when
+      DateTimeString :: rfc3339_string().
+
+rfc3339_to_system_time(DateTimeString) ->
+    rfc3339_to_system_time(DateTimeString, []).
+
+-spec rfc3339_to_system_time(DateTimeString, Options) -> integer() when
+      DateTimeString :: rfc3339_string(),
+      Options :: [Option],
+      Option :: {'unit', rfc3339_time_unit()}.
+
+rfc3339_to_system_time(DateTimeString, Options) ->
+    Unit = proplists:get_value(unit, Options, second),
+    %% _T is the character separating the date and the time:
+    {DateStr, [_T|TimeStr]} = lists:split(10, DateTimeString),
+    {TimeStr2, TimeStr3} = lists:split(8, TimeStr),
+    {ok, [Hour, Min, Sec], []} = io_lib:fread("~d:~d:~d", TimeStr2),
+    {ok, [Year, Month, Day], []} = io_lib:fread("~d-~d-~d", DateStr),
+    DateTime = {{Year, Month, Day}, {Hour, Min, Sec}},
+    IsFractionChar = fun(C) -> C >= $0 andalso C =< $9 orelse C =:= $. end,
+    {FractionStr, UtcOffset} = lists:splitwith(IsFractionChar, TimeStr3),
+    Time = datetime_to_system_time(DateTime),
+    Secs = Time - offset_adjustment(Time, second, UtcOffset),
+    check(DateTimeString, Options, Secs),
+    ScaledEpoch = erlang:convert_time_unit(Secs, second, Unit),
+    ScaledEpoch + copy_sign(fraction(Unit, FractionStr), ScaledEpoch).
+
 
 
 %% seconds_to_daystime(Secs) = {Days, {Hour, Minute, Second}}
@@ -380,7 +419,40 @@ system_time_to_local_time(Time, TimeUnit) ->
 
 system_time_to_universal_time(Time, TimeUnit) ->
     Secs = erlang:convert_time_unit(Time, TimeUnit, second),
-    gregorian_seconds_to_datetime(Secs + ?SECONDS_FROM_0_TO_1970).
+    system_time_to_datetime(Secs).
+
+-spec system_time_to_rfc3339(Time) -> DateTimeString when
+      Time :: integer(),
+      DateTimeString :: rfc3339_string().
+
+system_time_to_rfc3339(Time) ->
+    system_time_to_rfc3339(Time, []).
+
+-type offset() :: [byte()] | (Time :: integer()).
+-spec system_time_to_rfc3339(Time, Options) -> DateTimeString when
+      Time :: integer(), % Since Epoch
+      Options :: [Option],
+      Option :: {'offset', offset()}
+              | {'time_designator', byte()}
+              | {'unit', rfc3339_time_unit()},
+      DateTimeString :: rfc3339_string().
+
+system_time_to_rfc3339(Time, Options) ->
+    Unit = proplists:get_value(unit, Options, second),
+    OffsetOption = proplists:get_value(offset, Options, ""),
+    T = proplists:get_value(time_designator, Options, $T),
+    AdjustmentSecs = offset_adjustment(Time, Unit, OffsetOption),
+    Offset = offset(OffsetOption, AdjustmentSecs),
+    Adjustment = erlang:convert_time_unit(AdjustmentSecs, second, Unit),
+    AdjustedTime = Time + Adjustment,
+    Factor = factor(Unit),
+    Secs = AdjustedTime div Factor,
+    check(Time, Options, Secs),
+    DateTime = system_time_to_datetime(Secs),
+    {{Year, Month, Day}, {Hour, Min, Sec}} = DateTime,
+    FractionStr = fraction_str(Factor, AdjustedTime),
+    flat_fwrite("~4.10.0B-~2.10.0B-~2.10.0B~c~2.10.0B:~2.10.0B:~2.10.0B~s~s",
+                [Year, Month, Day, T, Hour, Min, Sec, FractionStr, Offset]).
 
 %% time_difference(T1, T2) = Tdiff
 %%
@@ -569,3 +641,85 @@ df(Year, _) ->
 	true -> 1;
 	false  -> 0
     end.
+
+check(_Arg, _Options, Secs) when Secs >= - ?SECONDS_FROM_0_TO_1970,
+                                 Secs < ?SECONDS_FROM_0_TO_10000 ->
+    ok;
+check(Arg, Options, _Secs) ->
+    erlang:error({badarg, [Arg, Options]}).
+
+datetime_to_system_time(DateTime) ->
+    datetime_to_gregorian_seconds(DateTime) - ?SECONDS_FROM_0_TO_1970.
+
+system_time_to_datetime(Seconds) ->
+    gregorian_seconds_to_datetime(Seconds + ?SECONDS_FROM_0_TO_1970).
+
+offset(OffsetOption, Secs0) when OffsetOption =:= "";
+                                 is_integer(OffsetOption) ->
+    Sign = case Secs0 < 0 of
+               true -> $-;
+               false -> $+
+           end,
+    Secs = abs(Secs0),
+    Hour = Secs div 3600,
+    Min = (Secs rem 3600) div 60,
+    io_lib:fwrite("~c~2.10.0B:~2.10.0B", [Sign, Hour, Min]);
+offset(OffsetOption, _Secs) ->
+    OffsetOption.
+
+offset_adjustment(Time, Unit, OffsetString) when is_list(OffsetString) ->
+    offset_string_adjustment(Time, Unit, OffsetString);
+offset_adjustment(_Time, Unit, Offset) when is_integer(Offset) ->
+    erlang:convert_time_unit(Offset, Unit, second).
+
+offset_string_adjustment(Time, Unit, "") ->
+    local_offset(Time, Unit);
+offset_string_adjustment(_Time, _Unit, "Z") ->
+    0;
+offset_string_adjustment(_Time, _Unit, "z") ->
+    0;
+offset_string_adjustment(_Time, _Unit, [Sign|Tz]) ->
+    {ok, [Hour, Min], []} = io_lib:fread("~d:~d", Tz),
+    Adjustment = 3600 * Hour + 60 * Min,
+    case Sign of
+        $- -> -Adjustment;
+        $+ -> Adjustment
+    end.
+
+local_offset(SystemTime, Unit) ->
+    LocalTime = system_time_to_local_time(SystemTime, Unit),
+    UniversalTime = system_time_to_universal_time(SystemTime, Unit),
+    LocalSecs = datetime_to_gregorian_seconds(LocalTime),
+    UniversalSecs = datetime_to_gregorian_seconds(UniversalTime),
+    LocalSecs - UniversalSecs.
+
+fraction_str(Factor, Time) ->
+    case Time rem Factor of
+        0 ->
+            "";
+        Fraction ->
+            FS = io_lib:fwrite(".~*..0B", [log10(Factor), abs(Fraction)]),
+            string:strip(lists:flatten(FS), right, $0)
+    end.
+
+fraction(second, _) ->
+    0;
+fraction(_, "") ->
+    0;
+fraction(Unit, FractionStr) ->
+    round(factor(Unit) * list_to_float([$0|FractionStr])).
+
+copy_sign(N1, N2) when N2 < 0 -> -N1;
+copy_sign(N1, _N2) -> N1.
+
+factor(second)      -> 1;
+factor(millisecond) -> 1000;
+factor(microsecond) -> 1000000;
+factor(nanosecond)  -> 1000000000.
+
+log10(1000) -> 3;
+log10(1000000) -> 6;
+log10(1000000000) -> 9.
+
+flat_fwrite(F, S) ->
+    lists:flatten(io_lib:fwrite(F, S)).
diff --git a/lib/stdlib/test/calendar_SUITE.erl b/lib/stdlib/test/calendar_SUITE.erl
index 52c3cc68eb..55118e251c 100644
--- a/lib/stdlib/test/calendar_SUITE.erl
+++ b/lib/stdlib/test/calendar_SUITE.erl
@@ -31,7 +31,7 @@
 	 last_day_of_the_month/1,
 	 local_time_to_universal_time_dst/1,
 	 iso_week_number/1,
-         system_time/1]).
+         system_time/1, rfc3339/1]).
 
 -define(START_YEAR, 1947).			
 -define(END_YEAR, 2012).
@@ -42,7 +42,7 @@ all() ->
     [gregorian_days, gregorian_seconds, day_of_the_week,
      day_of_the_week_calibrate, leap_years,
      last_day_of_the_month, local_time_to_universal_time_dst,
-     iso_week_number, system_time].
+     iso_week_number, system_time, rfc3339].
 
 groups() -> 
     [].
@@ -175,10 +175,147 @@ system_time(Config) when is_list(Config) ->
 
     ok.
 
+rfc3339(Config) when is_list(Config) ->
+    Ms = [{unit, millisecond}],
+    Mys = [{unit, microsecond}],
+    Ns = [{unit, nanosecond}],
+    S = [{unit, second}],
+    D = [{time_designator, $\s}],
+    Z = [{offset, "Z"}],
+
+    "1985-04-12T23:20:50.52Z" = test_parse("1985-04-12T23:20:50.52Z", Ms),
+    "1985-04-12T23:20:50.52Z" = test_parse("1985-04-12t23:20:50.52z", Ms),
+    "1985-04-12T21:20:50.52Z" =
+        test_parse("1985-04-12T23:20:50.52+02:00", Ms),
+    "1985-04-12T23:20:50Z" = test_parse("1985-04-12T23:20:50.52Z", S),
+    "1985-04-12T23:20:50.52Z" = test_parse("1985-04-12T23:20:50.52Z", Ms),
+    "1985-04-12T23:20:50.52Z" = test_parse("1985-04-12t23:20:50.52z", Mys),
+    "1985-04-12 21:20:50.52Z" =
+        test_parse("1985-04-12 23:20:50.52+02:00", Ns++D),
+    "1985-04-12T23:20:50Z" = test_parse("1985-04-12T23:20:50.52Z"),
+    "1996-12-20T00:39:57Z" = test_parse("1996-12-19T16:39:57-08:00"),
+    "1991-01-01T00:00:00Z" = test_parse("1990-12-31T23:59:60Z"),
+    "1991-01-01T08:00:00Z" = test_parse("1990-12-31T23:59:60-08:00"),
+
+    "1996-12-20T00:39:57Z" = test_parse("1996-12-19T16:39:57-08:00"),
+    %% The leap second is not handled:
+    "1991-01-01T00:00:00Z" = test_parse("1990-12-31T23:59:60Z"),
+
+    "9999-12-31T23:59:59Z" = do_format_z(253402300799, []),
+    "9999-12-31T23:59:59.999Z" = do_format_z(253402300799*1000+999, Ms),
+    "9999-12-31T23:59:59.999999Z" =
+        do_format_z(253402300799*1000000+999999, Mys),
+    "9999-12-31T23:59:59.999999999Z" =
+        do_format_z(253402300799*1000000000+999999999, Ns),
+    {'EXIT', _} = (catch do_format_z(253402300799+1, [])),
+    {'EXIT', _} = (catch do_parse("9999-12-31T23:59:60Z", [])),
+    {'EXIT', _} = (catch do_format_z(253402300799*1000000000+999999999+1, Ns)),
+    253402300799 = do_parse("9999-12-31T23:59:59Z", []),
+
+    "0000-01-01T00:00:00Z" = test_parse("0000-01-01T00:00:00.0+00:00"),
+    "9999-12-31T00:00:00Z" = test_parse("9999-12-31T00:00:00.0+00:00"),
+    "1584-03-04T00:00:00Z" = test_parse("1584-03-04T00:00:00.0+00:00"),
+    "1900-01-01T00:00:00Z" = test_parse("1900-01-01T00:00:00.0+00:00"),
+    "2016-01-24T00:00:00Z" = test_parse("2016-01-24T00:00:00.0+00:00"),
+    "1970-01-01T00:00:00Z" = test_parse("1970-01-01T00:00:00Z"),
+    "1970-01-02T00:00:00Z" = test_parse("1970-01-01T23:59:60Z"),
+    "1970-01-02T00:00:00Z" = test_parse("1970-01-01T23:59:60.5Z"),
+    "1970-01-02T00:00:00Z" = test_parse("1970-01-01T23:59:60.55Z"),
+    "1970-01-02T00:00:00.55Z" = test_parse("1970-01-01T23:59:60.55Z", Ms),
+    "1970-01-02T00:00:00.55Z" = test_parse("1970-01-01T23:59:60.55Z", Mys),
+    "1970-01-02T00:00:00.55Z" = test_parse("1970-01-01T23:59:60.55Z", Ns),
+    "1970-01-02T00:00:00.999999Z" =
+        test_parse("1970-01-01T23:59:60.999999Z", Mys),
+    "1970-01-02T00:00:01Z" =
+        test_parse("1970-01-01T23:59:60.999999Z", Ms),
+    "1970-01-01T00:00:00Z" = test_parse("1970-01-01T00:00:00+00:00"),
+    "1970-01-01T00:00:00Z" = test_parse("1970-01-01T00:00:00-00:00"),
+    "1969-12-31T00:01:00Z" = test_parse("1970-01-01T00:00:00+23:59"),
+    "1918-11-11T09:00:00Z" = test_parse("1918-11-11T11:00:00+02:00", Mys),
+    "1970-01-01T00:00:00.000001Z" =
+        test_parse("1970-01-01T00:00:00.000001Z", Mys),
+
+    test_time(erlang:system_time(second), []),
+    test_time(erlang:system_time(second), Z),
+    test_time(erlang:system_time(second), Z ++ S),
+    test_time(erlang:system_time(second), [{offset, "+02:20"}]),
+    test_time(erlang:system_time(millisecond), Ms),
+    test_time(erlang:system_time(microsecond), Mys++[{offset, "-02:20"}]),
+
+    T = erlang:system_time(second),
+    TS = do_format(T, []),
+    TS = do_format(T * 1000, Ms),
+    TS = do_format(T * 1000 * 1000, Mys),
+    TS = do_format(T * 1000 * 1000 * 1000, Ns),
+
+    946720800 = TO = do_parse("2000-01-01 10:00:00Z", []),
+    Str = "2000-01-01T10:02:00+00:02",
+    Str = do_format(TO, [{offset, 120}]),
+    Str = do_format(TO * 1000, [{offset, 120 * 1000}]++Ms),
+    Str = do_format(TO * 1000 * 1000, [{offset, 120 * 1000 * 1000}]++Mys),
+    Str = do_format(TO * 1000 * 1000 * 1000,
+                    [{offset, 120 * 1000 * 1000 * 1000}]++Ns),
+
+    NStr = "2000-01-01T09:58:00-00:02",
+    NStr = do_format(TO, [{offset, -120}]),
+    NStr = do_format(TO * 1000, [{offset, -120 * 1000}]++Ms),
+    NStr = do_format(TO * 1000 * 1000, [{offset, -120 * 1000 * 1000}]++Mys),
+    NStr = do_format(TO * 1000 * 1000 * 1000,
+                     [{offset, -120 * 1000 * 1000 * 1000}]++Ns),
+
+    543210000 = do_parse("1970-01-01T00:00:00.54321Z", Ns),
+    54321000 = do_parse("1970-01-01T00:00:00.054321Z", Ns),
+    543210 = do_parse("1970-01-01T00:00:00.54321Z", Mys),
+    543 = do_parse("1970-01-01T00:00:00.54321Z", Ms),
+    0 = do_parse("1970-01-01T00:00:00.000001Z", Ms),
+    1 = do_parse("1970-01-01T00:00:00.000001Z", Mys),
+    1000 = do_parse("1970-01-01T00:00:00.000001Z", Ns),
+    0 = do_parse("1970-01-01Q00:00:00.00049Z", Ms),
+    1 = do_parse("1970-01-01Q00:00:00.0005Z", Ms),
+    6543210 = do_parse("1970-01-01T00:00:06.54321Z", Mys),
+    298815132000000 = do_parse("1979-06-21T12:12:12Z", Mys),
+    -1613826000000000 = do_parse("1918-11-11T11:00:00Z", Mys),
+    -1613833200000000 = do_parse("1918-11-11T11:00:00+02:00", Mys),
+    -1613833200000000 = do_parse("1918-11-11T09:00:00Z", Mys),
+
+    "1970-01-01T00:00:00Z" = do_format_z(0, Mys),
+    "1970-01-01T00:00:01Z" = do_format_z(1, S),
+    "1970-01-01T00:00:00.001Z" = do_format_z(1, Ms),
+    "1970-01-01T00:00:00.000001Z" = do_format_z(1, Mys),
+    "1970-01-01T00:00:00.000000001Z" = do_format_z(1, Ns),
+    "1970-01-01T00:00:01Z" = do_format_z(1000000, Mys),
+    "1970-01-01T00:00:00.54321Z" = do_format_z(543210, Mys),
+    "1970-01-01T00:00:00.543Z" = do_format_z(543, Ms),
+    "1970-01-01T00:00:00.54321Z" = do_format_z(543210000, Ns),
+    "1970-01-01T00:00:06.54321Z" = do_format_z(6543210, Mys),
+    "1979-06-21T12:12:12Z" = do_format_z(298815132000000, Mys),
+    "1918-11-11T13:00:00Z" = do_format_z(-1613818800000000, Mys),
+    ok.
+
 %%
 %% LOCAL FUNCTIONS
 %%
 
+test_parse(String) ->
+    test_parse(String, []).
+
+test_parse(String, Options) ->
+    T = do_parse(String, Options),
+    calendar:system_time_to_rfc3339(T, [{offset, "Z"} | Options]).
+
+do_parse(String, Options) ->
+    calendar:rfc3339_to_system_time(String, Options).
+
+test_time(Time, Options) ->
+    F = calendar:system_time_to_rfc3339(Time, Options),
+    Time = calendar:rfc3339_to_system_time(F, Options).
+
+do_format_z(Time, Options) ->
+    do_format(Time, [{offset, "Z"}|Options]).
+
+do_format(Time, Options) ->
+    calendar:system_time_to_rfc3339(Time, Options).
+
 %% check_gregorian_days
 %% 
 check_gregorian_days(Days, MaxDays) when Days < MaxDays ->
-- 
2.16.3

Places

File 2582-stdlib-Add-RFC-3339-functions-to-module-calendar.patch of Package erlang (Revision ac8eee046d90e3601c6b140b4880b66c)

Places