Tcl Library Source Code

Check-in [472c75a7bc]
Login
Bounty program for improvements to Tcl and certain Tcl packages.
Tcl 2019 Conference, Houston/TX, US, Nov 4-8
Send your abstracts to [email protected]
or submit via the online form by Sep 9.

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:Merged the clock fixes into the release.
Timelines: family | ancestors | descendants | both | tcllib-1-15-rc
Files: files | file ages | folders
SHA1: 472c75a7bc7b7b06c6035a95f191c3d73c03789f
User & Date: aku 2013-02-06 05:16:44
Context
2013-02-06
05:46
Tcllib 1.15 Release check-in: 411c419016 user: aku tags: trunk, tcllib-1-15, release
05:16
Merged the clock fixes into the release. Closed-Leaf check-in: 472c75a7bc user: aku tags: tcllib-1-15-rc
05:16
Implemented the YYYY-Www and YYYYWww formats, with test cases. Closed-Leaf check-in: 730be11a05 user: aku tags: new-module-clock
2013-02-01
19:14
Tcllib 1.15 Release Candidate 1 check-in: 3f8bd0ca3d user: andreask tags: tcllib-1-15-rc-1, tcllib-1-15-rc
Changes
Hide Diffs Unified Diffs Ignore Whitespace Patch

Changes to modules/clock/iso8601.man.

13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
[para]

[list_begin definitions]

[call [cmd {::clock::iso8601 parse_date}] \
     [arg date] [arg options...]]

This command parses an ISO8601 date/time string in an unknown
variant and returns the given date/time in seconds since epoch.

[para] The acceptable options are
[option -base],
[option -gmt],
[option -locale], and
[option -timezone]
of the builtin command [cmd {clock scan}].

[call [cmd {::clock::iso8601 parse_time}] \
     [arg time] [arg options...]]

This command parses an ISO8601 timestamp string in an unknown
variant and returns the given timee in seconds since epoch.

[para] The acceptable options are
[option -base],
[option -gmt],
[option -locale], and
[option -timezone]
of the builtin command [cmd {clock scan}].






|
|











|
|







13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
[para]

[list_begin definitions]

[call [cmd {::clock::iso8601 parse_date}] \
     [arg date] [arg options...]]

This command parses an ISO8601 date string in an unknown variant and
returns the given date/time in seconds since epoch.

[para] The acceptable options are
[option -base],
[option -gmt],
[option -locale], and
[option -timezone]
of the builtin command [cmd {clock scan}].

[call [cmd {::clock::iso8601 parse_time}] \
     [arg time] [arg options...]]

This command parses a full ISO8601 timestamp string (date and time) in
an unknown variant and returns the given time in seconds since epoch.

[para] The acceptable options are
[option -base],
[option -gmt],
[option -locale], and
[option -timezone]
of the builtin command [cmd {clock scan}].

Changes to modules/clock/iso8601.tcl.

24
25
26
27
28
29
30

31
32














33
34
35
36
37
38
39
..
46
47
48
49
50
51
52

53
54
55
56



57
58
59
60
61
62







63
64



65
66







67
68


69

70




71




72
73

74
75
76

77
78


































79
80
81
82
83
84
85
..
91
92
93
94
95
96
97

98
99
100
101
102
103
104
105
106
107
108


109
110
111










112
113
114
115
116
117
118
...
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165



166
167
168
169
170
171
172
#               the '-base', '-gmt', '-locale' or '-timezone options.
#
# Results:
#       Returns the given date in seconds from the Posix epoch.

proc ::clock::iso8601::parse_date { string args } {
    variable DatePatterns

    foreach { regex interpretation } $DatePatterns {
	if { [regexp "^$regex\$" $string] } {














	    return [clock scan $string -format $interpretation {*}$args]
	}
    }
    return -code error "not an iso8601 date string"
}

# iso8601::parse_time --
................................................................................
#               the '-base', '-gmt', '-locale' or '-timezone options.
#
# Results:
#       Returns the given time in seconds from the Posix epoch.

proc ::clock::iso8601::parse_time { string args } {
    variable DatePatterns

    if {![MatchTime $string field]} {
	return -code error "not an iso8601 time string"
    }




    set pattern {}
    foreach {regex interpretation} $DatePatterns {
	if { $field($interpretation) ne {} } {
	    append pattern $interpretation
	}
    }







    append pattern $field(T)
    if { $field(%H) ne {} } {



	append pattern %H $field(Hcolon)
	if { $field(%M) ne {} } {







	    append pattern %M $field(Mcolon)
	    if { $field(%S) ne {} } {


		append pattern %S

	    }




	}




    }
    if { $field(%Z) ne {} } {

	append pattern %Z
    }


    return [clock scan $string -format $pattern {*}$args]
}



































# # ## ### ##### ######## ############# #####################
## State

namespace eval ::clock::iso8601 {

    namespace export parse_date parse_time
................................................................................

    variable DatePatterns {
	{\d\d\d\d-\d\d-\d\d}            {%Y-%m-%d}
	{\d\d\d\d\d\d\d\d}              {%Y%m%d}
	{\d\d\d\d-\d\d\d}               {%Y-%j}
	{\d\d\d\d\d\d\d}                {%Y%j}
	{\d\d-\d\d-\d\d}                {%y-%m-%d}

	{\d\d\d\d\d\d}                  {%y%m%d}
	{\d\d-\d\d\d}                   {%y-%j}
	{\d\d\d\d\d}                    {%y%j}
	{--\d\d-\d\d}                   {--%m-%d}
	{--\d\d\d\d}                    {--%m%d}
	{--\d\d\d}                      {--%j}
	{---\d\d}                       {---%d}
	{\d\d\d\d-W\d\d-\d}             {%G-W%V-%u}
	{\d\d\d\dW\d\d\d}               {%GW%V%u}
	{\d\d-W\d\d-\d}                 {%g-W%V-%u}
	{\d\dW\d\d\d}                   {%gW%V%u}


	{-W\d\d-\d}                     {-W%V-%u}
	{-W\d\d\d}                      {-W%V%u}
	{-W-\d}                         {%u}










    }
}

# # ## ### ##### ######## ############# #####################
## Initialization

apply {{} {
................................................................................
    #             T preceding the time, a colon following the hour, or
    #             a colon following the minute.
    #           - %H, %M, %S, and %Z indicate the presence of the
    #             corresponding parts of the time.

    variable DatePatterns

    set cmd {regexp -expanded -nocase -- {PATTERN} $timeString ->}
    set re \(?:\(?:
    set sep {}
    foreach {regex interpretation} $DatePatterns {
	append re $sep \( $regex \)
	append cmd " " [list field($interpretation)]
	set sep |
    }
    append re \) {(T|[[:space:]]+)} \)?
    append cmd { field(T)}
    append re {(\d\d)(?:(:?)(\d\d)(?:(:?)(\d\d)))}
    append cmd { field(%H) field(Hcolon) } \
	{field(%M) field(Mcolon) field(%S)}
    append re {[[:space:]]*(Z|[-+]\d\d\d\d)?}
    append cmd { field(%Z)}
    set cmd [string map [list {{PATTERN}} [list $re]] \
		 $cmd]

    proc MatchTime { timeString fieldArray } "
             upvar 1 \$fieldArray field
             $cmd
         "



} ::clock::iso8601}

# # ## ### ##### ######## ############# #####################

return
# Usage examples, disabled.







>


>
>
>
>
>
>
>
>
>
>
>
>
>
>







 







>




>
>
>


|



>
>
>
>
>
>
>
|
<
>
>
>
|
<
>
>
>
>
>
>
>
|
<
>
>

>

>
>
>
>

>
>
>
>

<
>



>


>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>







 







>











>
>



>
>
>
>
>
>
>
>
>
>







 







|









|
|
<
|








>
>
>







24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
..
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

90
91
92
93

94
95
96
97
98
99
100
101

102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
...
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
...
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247

248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
#               the '-base', '-gmt', '-locale' or '-timezone options.
#
# Results:
#       Returns the given date in seconds from the Posix epoch.

proc ::clock::iso8601::parse_date { string args } {
    variable DatePatterns
    variable Repattern
    foreach { regex interpretation } $DatePatterns {
	if { [regexp "^$regex\$" $string] } {
	    #puts A|$string|\t|$regex|\t|$interpretation|

	    # For incomplete dates (month and/or day missing), we have
	    # to set our own default values to overcome clock scan's
	    # settings. We do this by switching to a different pattern
	    # and extending the input properly for that pattern.

	    if {[dict exists $Repattern $interpretation]} {
		lassign [dict get $Repattern $interpretation] interpretation adjust modifier
		{*}$modifier
		# adjust irrelevant here, see parse_time for use.
	    }

	    #puts B|$string|\t|$regex|\t|$interpretation|
	    return [clock scan $string -format $interpretation {*}$args]
	}
    }
    return -code error "not an iso8601 date string"
}

# iso8601::parse_time --
................................................................................
#               the '-base', '-gmt', '-locale' or '-timezone options.
#
# Results:
#       Returns the given time in seconds from the Posix epoch.

proc ::clock::iso8601::parse_time { string args } {
    variable DatePatterns
    variable Repattern
    if {![MatchTime $string field]} {
	return -code error "not an iso8601 time string"
    }

    #parray field
    #puts A|$string|

    set pattern {}
    foreach {regex interpretation} $DatePatterns {
	if {[Has $interpretation tstart]} {
	    append pattern $interpretation
	}
    }

    if {[dict exists $Repattern $pattern]} {
	lassign [dict get $Repattern $pattern] interpretation adjust modifier
	{*}$modifier
	incr tstart $adjust
    }

    append pattern [Get T len]

    incr tstart $len

    if {[Has %H tstart]} {
	append pattern %H [Get Hcolon len]

	incr tstart $len

	if {[Has %M tstart]} {
	    append pattern %M [Get Mcolon len]
	    incr tstart $len

	    if {[Has %S tstart]} {
		append pattern %S

	    } else {
		# No seconds, default to start of minute.
		append pattern %S
		Insert string $tstart 00
	    }
	} else {
	    # No minutes, nor seconds, default to start of hour.
	    append pattern %M%S
	    Insert string $tstart 0000
	}
    } else {
	# No time information, default to midnight.
	append pattern %H%M%S
	Insert string $tstart 000000
    }

    if {[Has %Z _]} {
	append pattern %Z
    }

    #puts B|$string|\t|$pattern|
    return [clock scan $string -format $pattern {*}$args]
}

# # ## ### ##### ######## ############# #####################

proc ::clock::iso8601::Get {x lv} {
    upvar 1 field field string string $lv len
    lassign $field($x) s e
    if {($s >= 0) && ($e >= 0)} {
	set len [expr {$e - $s + 1}]
	return [string range $string $s $e]
    }
    set len 0
    return ""

}

proc ::clock::iso8601::Has {x nv} {
    upvar 1 field field string string $nv next
    lassign $field($x) s e
    if {($s >= 0) && ($e >= 0)} {
	set  next $e
	incr next
	return 1
    }
    return 0
}

proc ::clock::iso8601::Insert {sv index str} {
    upvar 1 $sv string
    append r [string range $string 0 ${index}-1]
    append r $str
    append r [string range $string $index end]
    set string $r
    return
}

# # ## ### ##### ######## ############# #####################
## State

namespace eval ::clock::iso8601 {

    namespace export parse_date parse_time
................................................................................

    variable DatePatterns {
	{\d\d\d\d-\d\d-\d\d}            {%Y-%m-%d}
	{\d\d\d\d\d\d\d\d}              {%Y%m%d}
	{\d\d\d\d-\d\d\d}               {%Y-%j}
	{\d\d\d\d\d\d\d}                {%Y%j}
	{\d\d-\d\d-\d\d}                {%y-%m-%d}
	{\d\d\d\d-\d\d}                 {%Y-%m}
	{\d\d\d\d\d\d}                  {%y%m%d}
	{\d\d-\d\d\d}                   {%y-%j}
	{\d\d\d\d\d}                    {%y%j}
	{--\d\d-\d\d}                   {--%m-%d}
	{--\d\d\d\d}                    {--%m%d}
	{--\d\d\d}                      {--%j}
	{---\d\d}                       {---%d}
	{\d\d\d\d-W\d\d-\d}             {%G-W%V-%u}
	{\d\d\d\dW\d\d\d}               {%GW%V%u}
	{\d\d-W\d\d-\d}                 {%g-W%V-%u}
	{\d\dW\d\d\d}                   {%gW%V%u}
	{\d\d\d\d-W\d\d}                {%G-W%V}
	{\d\d\d\dW\d\d}                 {%GW%V}
	{-W\d\d-\d}                     {-W%V-%u}
	{-W\d\d\d}                      {-W%V%u}
	{-W-\d}                         {%u}
	{\d\d\d\d}                      {%Y}
    }

    # Dictionary of the patterns requiring modifications to the input
    # for proper month and/or day defaults.
    variable Repattern {
	%Y-%m  {%Y-%m-%d  3 {Insert string 7 -01}}
	%Y     {%Y-%m-%d  5 {Insert string 4 -01-01}}
	%G-W%V {%G-W%V-%u 1 {Insert string 8 -1}}
	%GW%V  {%GW%V%u   1 {Insert string 6 1}}
    }
}

# # ## ### ##### ######## ############# #####################
## Initialization

apply {{} {
................................................................................
    #             T preceding the time, a colon following the hour, or
    #             a colon following the minute.
    #           - %H, %M, %S, and %Z indicate the presence of the
    #             corresponding parts of the time.

    variable DatePatterns

    set cmd {regexp -indices -expanded -nocase -- {PATTERN} $timeString ->}
    set re \(?:\(?:
    set sep {}
    foreach {regex interpretation} $DatePatterns {
	append re $sep \( $regex \)
	append cmd " " [list field($interpretation)]
	set sep |
    }
    append re \) {(T|[[:space:]]+)} \)?
    append cmd { field(T)}
    append re {(\d\d)(?:(:?)(\d\d)(?:(:?)(\d\d)?))?}
    append cmd { field(%H) field(Hcolon) } {field(%M) field(Mcolon) field(%S)}

    append re {[[:space:]]*(Z|[-+]\d\d:?\d\d)?}
    append cmd { field(%Z)}
    set cmd [string map [list {{PATTERN}} [list $re]] \
		 $cmd]

    proc MatchTime { timeString fieldArray } "
             upvar 1 \$fieldArray field
             $cmd
         "

    #puts [info body MatchTime]

} ::clock::iso8601}

# # ## ### ##### ######## ############# #####################

return
# Usage examples, disabled.

Changes to modules/clock/iso8601.test.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
..
41
42
43
44
45
46
47
48





























































































49
50
51
52
53
54
55
56
57
58
59
60
61
62










































63
64
65
66
67
68
69
70
71
72
73
74

75
76
77
78
79
80
81
# -------------------------------------------------------------------------
# iso8601.test -*- tcl -*-
# (C) 2013 Andreas Kupries. BSD licensed.
# -------------------------------------------------------------------------

source [file join \
	[file dirname [file dirname [file join [pwd] [info script]]]] \
	devtools testutilities.tcl]

testsNeedTcl     8.5
testsNeedTcltest 2.0

testing {
    useLocal iso8601.tcl clock::iso8601
}
................................................................................

test clock-iso8601-2.1 {parse_date} -body {
    clock::iso8601 parse_date 1994-11-05
    # It is unclear if this is influenced by TZ.
} -result 784022400

# -------------------------------------------------------------------------






























































































test clock-iso8601-5.0.0 {parse_time wrong\#args} -constraints {tcl8.5plus tcl8.5minus} -body {
    clock::iso8601 parse_time
} -returnCodes error -result {wrong # args: should be "clock::iso8601 parse_time string ..."}

test clock-iso8601-5.0.1 {parse_time wrong\#args} -constraints {tcl8.6plus} -body {
    clock::iso8601 parse_time
} -returnCodes error -result {wrong # args: should be "clock::iso8601 parse_time string ?arg ...?"}

test clock-iso8601-6.1 {parse_time, bad option} -body {
       clock::iso8601 parse_time A -foo x
} -returnCodes error -result {not an iso8601 time string}

# -------------------------------------------------------------------------











































test clock-iso8601-7.0 {parse_time, bad input} -body {
       clock::iso8601 parse_time A
} -returnCodes error -result {not an iso8601 time string}

test clock-iso8601-7.1 {parse_time} -body {
    # The difference to midnight is constant.
    # The day part is not, and there is TZ.
    expr {[clock::iso8601 parse_time 08:15:30] -
          [clock::iso8601 parse_time 00:00:00]}
} -result 29730

# -------------------------------------------------------------------------

testsuiteCleanup
return

# Local Variables:
#  mode: tcl
#  indent-tabs-mode: nil
# End:





|
|







 








>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>








|
|




>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>

|










>







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
..
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
# -------------------------------------------------------------------------
# iso8601.test -*- tcl -*-
# (C) 2013 Andreas Kupries. BSD licensed.
# -------------------------------------------------------------------------

source [file join \
            [file dirname [file dirname [file join [pwd] [info script]]]] \
            devtools testutilities.tcl]

testsNeedTcl     8.5
testsNeedTcltest 2.0

testing {
    useLocal iso8601.tcl clock::iso8601
}
................................................................................

test clock-iso8601-2.1 {parse_date} -body {
    clock::iso8601 parse_date 1994-11-05
    # It is unclear if this is influenced by TZ.
} -result 784022400

# -------------------------------------------------------------------------

test clock-iso8601-2.0.0 {parse_date, format: 19700102, reformatted with clock format -format {%D}} -body {
    clock format [clock::iso8601 parse_date {19700102}] -format {%D}
} -result {01/02/1970}

test clock-iso8601-2.0.1 {parse_date, format: 1970-W01-5, reformatted with clock format -format {%D}} -body {
    clock format [clock::iso8601 parse_date {1970-W01-5}] -format {%D}
} -result {01/02/1970}

test clock-iso8601-2.1.0 {parse_date, format: 19700102, using -timezone :UTC} -body {
    clock::iso8601 parse_date {19700102} -timezone :UTC
} -result {86400}

test clock-iso8601-2.1.1 {parse_date, format: 1970-W01-5, using -timezone :UTC} -body {
    clock::iso8601 parse_date {1970-W01-5} -timezone :UTC
} -result {86400}

test clock-iso8601-2.2.0 {parse_date, format: 970701 (yymmdd), reformatted with clock format -format {%D}} -body {
    clock format [clock::iso8601 parse_date {970701}] -format {%D}
} -result {07/01/1997}

test clock-iso8601-2.2.1 {parse_date, format: 1997-07, reformatted with clock format -format {%D}} -body {
    clock format [clock::iso8601 parse_date {1997-07}] -format {%D}
} -result {07/01/1997}

test clock-iso8601-2.3.0 {parse_date, format: 970701 (yymmdd), using -timezone :UTC} -body {
    clock::iso8601 parse_date {970701} -timezone :UTC
} -result {867715200}

test clock-iso8601-2.3.1 {parse_date, format: 1997-07, using -timezone :UTC} -body {
    clock::iso8601 parse_date {1997-07} -timezone :UTC
} -result {867715200}

test clock-iso8601-2.4.0 {parse_date, format: 1997, reformatted with clock format -format {%D}} -body {
    clock format [clock::iso8601 parse_date {1997}] -format {%D}
} -result {01/01/1997}

test clock-iso8601-2.4.1 {parse_date, format: 1997, reformatted with clock format -format {%D}} -body {
    clock format [clock::iso8601 parse_date {1997}] -format {%D}
} -result {01/01/1997}

test clock-iso8601-2.5.0 {parse_date, format: 1997, using -timezone :UTC} -body {
    clock::iso8601 parse_date {1997} -timezone :UTC
} -result {852076800}

test clock-iso8601-2.5.1 {parse_date, format: 1997-, using -timezone :UTC} -body {
    clock::iso8601 parse_date {1997} -timezone :UTC
} -result {852076800}

# -------------------------------------------------------------------------

foreach {n iso week} {
    00 01/01/2005 2004-W53-6 	
    01 01/02/2005 2004-W53-7
    02 12/31/2005 2005-W52-6
    03 01/01/2007 2007-W01-1
    04 12/30/2007 2007-W52-7 	
    05 12/31/2007 2008-W01-1
    06 01/01/2008 2008-W01-2
    07 12/28/2008 2008-W52-7
    08 12/29/2008 2009-W01-1
    09 12/30/2008 2009-W01-2
    10 12/31/2008 2009-W01-3
    11 01/01/2009 2009-W01-4
    12 12/31/2009 2009-W53-4
    13 01/01/2010 2009-W53-5
    14 01/02/2010 2009-W53-6
    15 01/03/2010 2009-W53-7
} {
    test clock-iso8601-2.6.$n {parse_date, format: YYYY-Www-D into %D} -body {
        clock format [clock::iso8601 parse_date $week] -format {%D}
    } -result $iso

    test clock-iso8601-2.7.$n {parse_date, format: YYYYWwwD into %D} -body {
        clock format [clock::iso8601 parse_date [string map {- {}} $week]] -format {%D}
    } -result $iso
}

foreach {n iso week} {
    00 01/01/2007 2007-W01
    01 12/31/2007 2008-W01
    02 12/29/2008 2009-W01
} {
    test clock-iso8601-2.8.$n {parse_date, format: YYYY-Www into %D} -body {
        clock format [clock::iso8601 parse_date $week] -format {%D}
    } -result $iso

    test clock-iso8601-2.9.$n {parse_date, format: YYYYWww into %D} -body {
        clock format [clock::iso8601 parse_date [string map {- {}} $week]] -format {%D}
    } -result $iso
}

# -------------------------------------------------------------------------

test clock-iso8601-5.0.0 {parse_time wrong\#args} -constraints {tcl8.5plus tcl8.5minus} -body {
    clock::iso8601 parse_time
} -returnCodes error -result {wrong # args: should be "clock::iso8601 parse_time string ..."}

test clock-iso8601-5.0.1 {parse_time wrong\#args} -constraints {tcl8.6plus} -body {
    clock::iso8601 parse_time
} -returnCodes error -result {wrong # args: should be "clock::iso8601 parse_time string ?arg ...?"}

test clock-iso8601-5.1 {parse_time, bad option} -body {
    clock::iso8601 parse_time A -foo x
} -returnCodes error -result {not an iso8601 time string}

# -------------------------------------------------------------------------

test clock-iso8601-6.0.0 {parse_time, full date time} -body {
    clock::iso8601 parse_time 2004-W33-2T18:52:24Z
} -result {1092163944}

test clock-iso8601-6.0.1 {parse_time, full time} -body {
    clock format [clock::iso8601 parse_time 18:52:24Z] -format {%X %z} -timezone :UTC
} -result {18:52:24 +0000}

test clock-iso8601-6.1.0 {parse_time, full date time to minute and offset as +/-hh:mm} -body {
    clock::iso8601 parse_time 1997-07-16T19:20+01:00
} -result {869077200}

test clock-iso8601-6.1.1 {parse_time, full date time to minute and offset as +/-hhmm} -body {
    clock::iso8601 parse_time 1997-07-16T19:20+0100
} -result {869077200}

test clock-iso8601-6.2.0 {parse_time, full date time to hour and offset as +/-hh:mm} -body {
    clock::iso8601 parse_time 1997-07-16T19+01:00
} -result {869076000}

test clock-iso8601-6.2.1 {parse_time, full date time to hour and offset as +/-hhmm} -body {
    clock::iso8601 parse_time 1997-07-16T19+0100
} -result {869076000}

test clock-iso8601-6.3.0 {parse_time, full date time to second and offset as +/-hh:mm} -body {
    clock::iso8601 parse_time 1997-07-16T19:20:30+01:00
} -result {869077230}

test clock-iso8601-6.3.1 {parse_time, full date time to second and offset as +/-hhmm} -body {
    clock::iso8601 parse_time 1997-07-16T19:20:30+0100
} -result {869077230}

test clock-iso8601-6.4.0 {parse_time, full date time to minute and offset as +/-hh:mm} -body {
    clock::iso8601 parse_time 1997-07-16T19:20:30.45+01:00
} -returnCodes error -result {input string does not match supplied format}

test clock-iso8601-6.4.1 {parse_time, full date time to minute and offset as +/-hhmm} -body {
    clock::iso8601 parse_time 1997-07-16T19:20:30.45+0100
} -returnCodes error -result {input string does not match supplied format}

# -------------------------------------------------------------------------

test clock-iso8601-7.0 {parse_time, bad input} -body {
    clock::iso8601 parse_time A
} -returnCodes error -result {not an iso8601 time string}

test clock-iso8601-7.1 {parse_time} -body {
    # The difference to midnight is constant.
    # The day part is not, and there is TZ.
    expr {[clock::iso8601 parse_time 08:15:30] -
          [clock::iso8601 parse_time 00:00:00]}
} -result 29730

# -------------------------------------------------------------------------

testsuiteCleanup
return

# Local Variables:
#  mode: tcl
#  indent-tabs-mode: nil
# End: