libc++: Don't let time_put test use implementation dependent constructs

[ed]

Summary

The time_put test doesn't seem to work on Linux and CloudABI. For Linux we already have an XFAIL. Closer inspection seems to reveal that this test does not pass for a couple of reasons.

First of all, the tm_yday field is set to an invalid value. The strftime() function doesn't behave consistently across platforms in case the values in the tm structure are incoherent. Fix up this field to have the value 121, which corresponds with tm_mday and tm_year. This of course affects the output of time_put for some modifiers, so update the tests accordingly.

Second, some of the tests actually use modifiers that are only present on BSD derived systems. They are not part of the C standard/POSIX. Simply remove them.

Finally, some of the tests actually use invalid modifiers, causing a malformed format string to be passed to strftime(). Remove these tests as well.

[jroelofs]

Second, some of the tests actually use modifiers that are only present on BSD derived systems. They are not part of the C standard/POSIX. Simply remove them.

They're probably still useful on those platforms... perhaps put them under an #ifdef for that platform, along with a comment saying that they're a bsd extension?

test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp

186

Can you point to the docs saying that these modifiers are invalid?

[jroelofs]

Jonathan, Marshall, do you happen to use Linux? If so, could you please test this on Linux for me? Thanks!

I'm usually on OS X, but I've got an ubuntu vm I can try it on... I'll check this evening.

[ed]

In D8349#141306, @jroelofs wrote:

Second, some of the tests actually use modifiers that are only present on BSD derived systems. They are not part of the C standard/POSIX. Simply remove them.

They're probably still useful on those platforms... perhaps put them under an #ifdef for that platform, along with a comment saying that they're a bsd extension?

We could consider doing this, but in my opinion this would only make sense if there is something actionable on our side in case one of these tests starts to fail. Right now time_put::put() calls strftime() directly without pre-processing the arguments in any way. If FreeBSD or Mac OS X would suddenly decide to remove support for the non-standard %v modifier, is there a chance that we would add a workaround for it by adding pre-processing to time_put::put()? My assumption is that we wouldn't bother, so I would rather remove these tests.

That said, if someone really cares about these tests, we could consider putting them in a separate test, so it remains clear which behavior is standard and which is not.

test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp

186

Sure!

C++14 N3797, section 22.4.5.3.2, the description of time_put::put():

"Formatting is controlled by the parameters format and modifier, interpreted identically as the format
specifiers in the string argument to the standard library function strftime()."

ISO/IEC 9899:2011, section 7.27.3.5, the description of strftime():

The %OB, %k, %l, %s, %v, %J and %J% modifiers are not listed in the table.

That said, POSIX has made some extensions to strftime: http://pubs.opengroup.org/onlinepubs/9699919799/functions/strftime.html

This table also doesn't list these modifiers.

[EricWF]

Attaching a related code review. This way my attempt to fix these tests. (yours seems more thorough).

http://reviews.llvm.org/D4999

[EricWF]

Also I'll test this on Linux. I have test machines for Ubuntu, FreeBSD 10 and OS X.

[EricWF]

The changes work for me on linux.

[ed]

In D8349#141356, @EricWF wrote:

The changes work for me on linux.

Awesome! Thanks for letting me know. Jonathan, shall I go ahead and push this change in?

test/std/localization/locale.categories/category.time/locale.time.put/locale.time.put.members/put2.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // class time_put<charT, OutputIterator>
 
 // iter_type put(iter_type s, ios_base& str, char_type fill, const tm* t,
 //               char format, char modifier = 0) const;
 
-// TODO: investigation needed
-// XFAIL: linux-gnu
-
 #include <locale>
 #include <cassert>
 #include "test_iterators.h"
 
 typedef std::time_put<char, output_iterator<char*> > F;
 
 class my_facet
     : public F
 {
 public:
     explicit my_facet(std::size_t refs = 0)
         : F(refs) {}
 };
 
 int main()
 {
     const my_facet f(1);
     char str[200];
     output_iterator<char*> iter;
-    tm t = {0};
+    tm t = {};
     t.tm_sec = 6;
     t.tm_min = 3;
     t.tm_hour = 13;
     t.tm_mday = 2;
     t.tm_mon = 4;
     t.tm_year = 109;
     t.tm_wday = 6;
-    t.tm_yday = -1;
+    t.tm_yday = 121;
     t.tm_isdst = 1;
     std::ios ios(0);
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'A');
         std::string ex(str, iter.base());
         assert(ex == "Saturday");
     }
     {
int main()
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'u', 'O');
         std::string ex(str, iter.base());
         assert(ex == "6");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'U', 'O');
         std::string ex(str, iter.base());
-        assert(ex == "00");
+        assert(ex == "17");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'V', 'O');
         std::string ex(str, iter.base());
-        assert(ex == "52");
+        assert(ex == "18");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'w', 'O');
         std::string ex(str, iter.base());
         assert(ex == "6");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'W', 'O');
         std::string ex(str, iter.base());
-        assert(ex == "00");
+        assert(ex == "17");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'y', 'O');
         std::string ex(str, iter.base());
         assert(ex == "09");
     }
     {
-        iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'B', 'O');
-        std::string ex(str, iter.base());
-        assert(ex == "May");
-    }
-    {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'e');
         std::string ex(str, iter.base());
         assert(ex == " 2");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'F');
         std::string ex(str, iter.base());
         assert(ex == "2009-05-02");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'G');
         std::string ex(str, iter.base());
-        assert(ex == "2008");
+        assert(ex == "2009");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'g');
         std::string ex(str, iter.base());
-        assert(ex == "08");
+        assert(ex == "09");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'H');
         std::string ex(str, iter.base());
         assert(ex == "13");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'h');
         std::string ex(str, iter.base());
         assert(ex == "May");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'I');
         std::string ex(str, iter.base());
         assert(ex == "01");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'j');
         std::string ex(str, iter.base());
-        assert(ex == "000");
-    }
-    {
-        iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'k');
-        std::string ex(str, iter.base());
-        assert(ex == "13");
-    }
-    {
-        iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'l');
-        std::string ex(str, iter.base());
-        assert(ex == " 1");
+        assert(ex == "122");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'M');
         std::string ex(str, iter.base());
         assert(ex == "03");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'm');
std::ios ios(0);
         assert(ex == "01:03:06 PM");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'S');
         std::string ex(str, iter.base());
         assert(ex == "06");
     }
     {
-        iter = f.put(output_iterator<char*>(str), ios, '*', &t, 's');
-        std::string ex(str, iter.base());
-//        assert(ex == "1241283786");  depends on time zone
-    }
-    {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'T');
         std::string ex(str, iter.base());
         assert(ex == "13:03:06");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 't');
         std::string ex(str, iter.base());
         assert(ex == "\t");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'U');
         std::string ex(str, iter.base());
-        assert(ex == "00");
+        assert(ex == "17");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'u');
         std::string ex(str, iter.base());
         assert(ex == "6");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'V');
         std::string ex(str, iter.base());
-        assert(ex == "52");
-    }
-    {
-        iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'v');
-        std::string ex(str, iter.base());
-        assert(ex == " 2-May-2009");
+        assert(ex == "18");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'W');
         std::string ex(str, iter.base());
-        assert(ex == "00");
+        assert(ex == "17");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'w');
         std::string ex(str, iter.base());
         assert(ex == "6");
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'X');
//        assert(ex == "-0400");  depends on time zone
         std::string ex(str, iter.base());
 //        assert(ex == "Sat May  2 13:03:06 EDT 2009");  depends on time zone
     }
     {
         iter = f.put(output_iterator<char*>(str), ios, '*', &t, '%');
         std::string ex(str, iter.base());
         assert(ex == "%");
     }
-    {
-        iter = f.put(output_iterator<char*>(str), ios, '*', &t, '%', 'J');
-        std::string ex(str, iter.base());
-        assert(ex == "J%");
-    }
-    {
-        iter = f.put(output_iterator<char*>(str), ios, '*', &t, 'J');
-        std::string ex(str, iter.base());
-        assert(ex == "J");
-    }
 }