diff --git a/src/Duration.cpp b/src/Duration.cpp index 550fa6554..45385c00f 100644 --- a/src/Duration.cpp +++ b/src/Duration.cpp @@ -35,14 +35,14 @@ //////////////////////////////////////////////////////////////////////////////// Duration::Duration () -: mDays (0) +: mSecs (0) { } //////////////////////////////////////////////////////////////////////////////// Duration::Duration (time_t input) { - mDays = input; + mSecs = input; } //////////////////////////////////////////////////////////////////////////////// @@ -54,27 +54,92 @@ Duration::Duration (const std::string& input) //////////////////////////////////////////////////////////////////////////////// Duration::operator time_t () { - return mDays; + return mSecs; } //////////////////////////////////////////////////////////////////////////////// Duration::operator std::string () { std::stringstream s; - s << mDays; + s << mSecs; return s.str (); } +//////////////////////////////////////////////////////////////////////////////// +Duration& Duration::operator= (const Duration& other) +{ + if (this != &other) + mSecs = other.mSecs; + + return *this; +} + +//////////////////////////////////////////////////////////////////////////////// +std::string Duration::format () const +{ + char formatted[24]; + float days = (float) mSecs / 86400.0; + + if (mSecs >= 86400 * 365) + sprintf (formatted, "%.1f yrs", (days / 365)); + else if (mSecs > 86400 * 84) + sprintf (formatted, "%1d mth%s", + (int) (float) (days / 30.6), + ((int) (float) (days / 30.6) == 1 ? "" : "s")); + else if (mSecs > 86400 * 13) + sprintf (formatted, "%d wk%s", + (int) (float) (days / 7.0), + ((int) (float) (days / 7.0) == 1 ? "" : "s")); + else if (mSecs >= 86400) + sprintf (formatted, "%d day%s", + (int) days, + ((int) days == 1 ? "" : "s")); + else if (mSecs >= 3600) + sprintf (formatted, "%d hr%s", + (int) (float) (mSecs / 3600), + ((int) (float) (mSecs / 3600) == 1 ? "" : "s")); + else if (mSecs >= 60) + sprintf (formatted, "%d min%s", + (int) (float) (mSecs / 60), + ((int) (float) (mSecs / 60) == 1 ? "" : "s")); + else if (mSecs >= 1) + sprintf (formatted, "%d sec%s", + (int) mSecs, + ((int) mSecs == 1 ? "" : "s")); + else + strcpy (formatted, "-"); // no i18n + + return std::string (formatted); +} + +//////////////////////////////////////////////////////////////////////////////// +std::string Duration::formatCompact () const +{ + char formatted[24]; + float days = (float) mSecs / 86400.0; + + if (mSecs >= 86400 * 365) sprintf (formatted, "%.1fy", (days / 365)); + else if (mSecs >= 86400 * 84) sprintf (formatted, "%1dmo", (int) (float) (days / 30.6)); + else if (mSecs >= 86400 * 13) sprintf (formatted, "%dwk", (int) (float) (days / 7.0)); + else if (mSecs >= 86400) sprintf (formatted, "%dd", (int) days); + else if (mSecs >= 3600) sprintf (formatted, "%dh", (int) (float) (mSecs / 3600)); + else if (mSecs >= 60) sprintf (formatted, "%dm", (int) (float) (mSecs / 60)); + else if (mSecs >= 1) sprintf (formatted, "%ds", (int) mSecs); + else strcpy (formatted, "-"); + + return std::string (formatted); +} + //////////////////////////////////////////////////////////////////////////////// bool Duration::operator< (const Duration& other) { - return mDays < other.mDays; + return mSecs < other.mSecs; } //////////////////////////////////////////////////////////////////////////////// bool Duration::operator> (const Duration& other) { - return mDays > other.mDays; + return mSecs > other.mSecs; } //////////////////////////////////////////////////////////////////////////////// @@ -182,16 +247,16 @@ void Duration::parse (const std::string& input) { std::string found = matches[0]; - if (found == "daily" || found == "day") mDays = 1; // TODO i18n - else if (found == "weekdays") mDays = 1; // TODO i18n - else if (found == "weekly" || found == "sennight") mDays = 7; // TODO i18n - else if (found == "biweekly" || found == "fortnight") mDays = 14; // TODO i18n - else if (found == "monthly") mDays = 30; // TODO i18n - else if (found == "bimonthly") mDays = 61; // TODO i18n - else if (found == "quarterly") mDays = 91; // TODO i18n - else if (found == "semiannual") mDays = 183; // TODO i18n - else if (found == "yearly" || found == "annual") mDays = 365; // TODO i18n - else if (found == "biannual" || found == "biyearly") mDays = 730; // TODO i18n + if (found == "daily" || found == "day") mSecs = 86400 * 1; // TODO i18n + else if (found == "weekdays") mSecs = 86400 * 1; // TODO i18n + else if (found == "weekly" || found == "sennight") mSecs = 86400 * 7; // TODO i18n + else if (found == "biweekly" || found == "fortnight") mSecs = 86400 * 14; // TODO i18n + else if (found == "monthly") mSecs = 86400 * 30; // TODO i18n + else if (found == "bimonthly") mSecs = 86400 * 61; // TODO i18n + else if (found == "quarterly") mSecs = 86400 * 91; // TODO i18n + else if (found == "semiannual") mSecs = 86400 * 183; // TODO i18n + else if (found == "yearly" || found == "annual") mSecs = 86400 * 365; // TODO i18n + else if (found == "biannual" || found == "biyearly") mSecs = 86400 * 730; // TODO i18n } // Support \d+ \s? s|secs?|m|mins?|h|hrs?|d|days?|wks?|mo|mths?|y|yrs?|- @@ -205,43 +270,43 @@ void Duration::parse (const std::string& input) { n.skip (' '); - if (n.getLiteral ("yrs") && n.depleted ()) mDays = value * 365; - else if (n.getLiteral ("yr") && n.depleted ()) mDays = value * 365; - else if (n.getLiteral ("y") && n.depleted ()) mDays = value * 365; + if (n.getLiteral ("yrs") && n.depleted ()) mSecs = value * 86400 * 365; + else if (n.getLiteral ("yr") && n.depleted ()) mSecs = value * 86400 * 365; + else if (n.getLiteral ("y") && n.depleted ()) mSecs = value * 86400 * 365; - else if (n.getLiteral ("qtrs") && n.depleted ()) mDays = value * 91; - else if (n.getLiteral ("qtr") && n.depleted ()) mDays = value * 91; - else if (n.getLiteral ("q") && n.depleted ()) mDays = value * 91; + else if (n.getLiteral ("qtrs") && n.depleted ()) mSecs = value * 86400 * 91; + else if (n.getLiteral ("qtr") && n.depleted ()) mSecs = value * 86400 * 91; + else if (n.getLiteral ("q") && n.depleted ()) mSecs = value * 86400 * 91; - else if (n.getLiteral ("mths") && n.depleted ()) mDays = value * 30; - else if (n.getLiteral ("mth") && n.depleted ()) mDays = value * 30; - else if (n.getLiteral ("mo") && n.depleted ()) mDays = value * 30; + else if (n.getLiteral ("mths") && n.depleted ()) mSecs = value * 86400 * 30; + else if (n.getLiteral ("mth") && n.depleted ()) mSecs = value * 86400 * 30; + else if (n.getLiteral ("mo") && n.depleted ()) mSecs = value * 86400 * 30; - else if (n.getLiteral ("wks") && n.depleted ()) mDays = value * 7; - else if (n.getLiteral ("wk") && n.depleted ()) mDays = value * 7; - else if (n.getLiteral ("w") && n.depleted ()) mDays = value * 7; + else if (n.getLiteral ("wks") && n.depleted ()) mSecs = value * 86400 * 7; + else if (n.getLiteral ("wk") && n.depleted ()) mSecs = value * 86400 * 7; + else if (n.getLiteral ("w") && n.depleted ()) mSecs = value * 86400 * 7; - else if (n.getLiteral ("days") && n.depleted ()) mDays = value * 1; - else if (n.getLiteral ("day") && n.depleted ()) mDays = value * 1; - else if (n.getLiteral ("d") && n.depleted ()) mDays = value * 1; + else if (n.getLiteral ("days") && n.depleted ()) mSecs = value * 86400; + else if (n.getLiteral ("day") && n.depleted ()) mSecs = value * 86400; + else if (n.getLiteral ("d") && n.depleted ()) mSecs = value * 86400; - else if (n.getLiteral ("hrs") && n.depleted ()) mDays = 0; - else if (n.getLiteral ("hr") && n.depleted ()) mDays = 0; - else if (n.getLiteral ("h") && n.depleted ()) mDays = 0; + else if (n.getLiteral ("hrs") && n.depleted ()) mSecs = value * 3600; + else if (n.getLiteral ("hr") && n.depleted ()) mSecs = value * 3600; + else if (n.getLiteral ("h") && n.depleted ()) mSecs = value * 3600; - else if (n.getLiteral ("mins") && n.depleted ()) mDays = 0; - else if (n.getLiteral ("min") && n.depleted ()) mDays = 0; - else if (n.getLiteral ("m") && n.depleted ()) mDays = 0; + else if (n.getLiteral ("mins") && n.depleted ()) mSecs = value * 60; + else if (n.getLiteral ("min") && n.depleted ()) mSecs = value * 60; + else if (n.getLiteral ("m") && n.depleted ()) mSecs = value * 60; - else if (n.getLiteral ("secs") && n.depleted ()) mDays = 0; - else if (n.getLiteral ("sec") && n.depleted ()) mDays = 0; - else if (n.getLiteral ("s") && n.depleted ()) mDays = 0; + else if (n.getLiteral ("secs") && n.depleted ()) mSecs = value; + else if (n.getLiteral ("sec") && n.depleted ()) mSecs = value; + else if (n.getLiteral ("s") && n.depleted ()) mSecs = value; - else if (n.getLiteral ("-") && n.depleted ()) mDays = 0; + else if (n.getLiteral ("-") && n.depleted ()) mSecs = 0; } } - if (mDays == 0) + if (mSecs == 0) throw std::string ("The duration '") + input + "' was not recognized."; // TODO i18n } diff --git a/src/Duration.h b/src/Duration.h index 5b1b82a17..139a3a50c 100644 --- a/src/Duration.h +++ b/src/Duration.h @@ -38,16 +38,20 @@ public: Duration (const std::string&); // Parse bool operator< (const Duration&); bool operator> (const Duration&); + Duration& operator= (const Duration&); ~Duration (); // Destructor operator time_t (); operator std::string (); + std::string format () const; + std::string formatCompact () const; + bool valid (const std::string&) const; void parse (const std::string&); private: - time_t mDays; + time_t mSecs; }; #endif diff --git a/src/custom.cpp b/src/custom.cpp index eb264db60..60e86ad46 100644 --- a/src/custom.cpp +++ b/src/custom.cpp @@ -37,6 +37,7 @@ #include "Context.h" #include "Date.h" +#include "Duration.h" #include "Table.h" #include "text.h" #include "util.h" @@ -435,9 +436,13 @@ int runCustomReport ( { Date dt (::atoi (due.c_str ())); time_t cntdwn = (time_t) (now - dt); - countdown = formatSeconds ( cntdwn < 0 ? cntdwn * -1 : cntdwn ); - if ( cntdwn < 0 ) - countdown = std::string("-") + countdown; + Duration du (cntdwn < 0 ? -cntdwn : cntdwn); + + if (cntdwn < 0) + countdown = std::string ("-") + du.format (); + else + countdown = du.format (); + context.hooks.trigger ("format-countdown", "countdown", countdown); table.addCell (row, columnCount, countdown); } @@ -460,9 +465,13 @@ int runCustomReport ( { Date dt (::atoi (due.c_str ())); time_t cntdwn = (time_t) (now - dt); - countdown = formatSecondsCompact ( cntdwn < 0 ? cntdwn * -1 : cntdwn ); - if ( cntdwn < 0 ) - countdown = std::string("-") + countdown; + Duration du (cntdwn < 0 ? -cntdwn : cntdwn); + + if (cntdwn < 0) + countdown = std::string ("-") + du.formatCompact (); + else + countdown = du.formatCompact (); + context.hooks.trigger ("format-countdown_compact", "countdown_compact", countdown); table.addCell (row, columnCount, countdown); } @@ -484,7 +493,7 @@ int runCustomReport ( if (created.length ()) { Date dt (::atoi (created.c_str ())); - age = formatSeconds ((time_t) (now - dt)); + age = Duration (now - dt).format (); context.hooks.trigger ("format-age", "age", age); table.addCell (row, columnCount, age); } @@ -506,7 +515,8 @@ int runCustomReport ( if (created.length ()) { Date dt (::atoi (created.c_str ())); - age = formatSecondsCompact ((time_t) (now - dt)); + age = Duration (now - dt).formatCompact (); + context.hooks.trigger ("format-age_compact", "age_compact", age); table.addCell (row, columnCount, age); } diff --git a/src/recur.cpp b/src/recur.cpp index 81e5bfd10..ba3787f12 100644 --- a/src/recur.cpp +++ b/src/recur.cpp @@ -323,11 +323,11 @@ Date getNextRecurrence (Date& current, std::string& period) } // If the period is an 'easy' one, add it to current, and we're done. - int days = 0; - try { Duration du (period); days = du; } - catch (...) { days = 0; } + int secs = 0; + try { Duration du (period); secs = du; } + catch (...) { secs = 0; } - return current + (days * 86400); + return current + secs; } //////////////////////////////////////////////////////////////////////////////// diff --git a/src/report.cpp b/src/report.cpp index c57b8d10a..48db64be7 100644 --- a/src/report.cpp +++ b/src/report.cpp @@ -39,6 +39,7 @@ #include "Directory.h" #include "File.h" #include "Date.h" +#include "Duration.h" #include "Table.h" #include "text.h" #include "util.h" @@ -549,7 +550,7 @@ int handleInfo (std::string &outs) if (created.length ()) { Date dt (atoi (created.c_str ())); - age = formatSeconds ((time_t) (now - dt)); + age = Duration (now - dt).format (); } context.hooks.trigger ("format-entry", "entry", entry); @@ -695,11 +696,7 @@ int handleReportSummary (std::string &outs) table.addCell (row, 0, (i->first == "" ? "(none)" : i->first)); table.addCell (row, 1, countPending[i->first]); if (counter[i->first]) - { - std::string age; - age = formatSeconds ((time_t) (sumEntry[i->first] / counter[i->first])); - table.addCell (row, 2, age); - } + table.addCell (row, 2, Duration (sumEntry[i->first] / counter[i->first]).format ()); int c = countCompleted[i->first]; int p = countPending[i->first]; @@ -2517,35 +2514,35 @@ int handleReportStats (std::string &outs) row = table.addRow (); table.addCell (row, 0, "Task used for"); - table.addCell (row, 1, formatSeconds (latest - earliest)); + table.addCell (row, 1, Duration (latest - earliest).format ()); } if (totalT) { row = table.addRow (); table.addCell (row, 0, "Task added every"); - table.addCell (row, 1, formatSeconds ((latest - earliest) / totalT)); + table.addCell (row, 1, Duration (((latest - earliest) / totalT)).format ()); } if (completedT) { row = table.addRow (); table.addCell (row, 0, "Task completed every"); - table.addCell (row, 1, formatSeconds ((latest - earliest) / completedT)); + table.addCell (row, 1, Duration ((latest - earliest) / completedT).format ()); } if (deletedT) { row = table.addRow (); table.addCell (row, 0, "Task deleted every"); - table.addCell (row, 1, formatSeconds ((latest - earliest) / deletedT)); + table.addCell (row, 1, Duration ((latest - earliest) / deletedT).format ()); } if (pendingT || completedT) { row = table.addRow (); table.addCell (row, 0, "Average time pending"); - table.addCell (row, 1, formatSeconds ((int) ((daysPending / (pendingT + completedT)) * 86400))); + table.addCell (row, 1, Duration ((int) ((daysPending / (pendingT + completedT)) * 86400)).format ()); } if (totalT) diff --git a/src/tests/benchmark2.t b/src/tests/benchmark2.t index d556a8bc4..327b8e93c 100755 --- a/src/tests/benchmark2.t +++ b/src/tests/benchmark2.t @@ -117,7 +117,7 @@ sub report $data{'Context::initialize'}, $data{'Context::parse'}, $data{'TDB::loadPending'}, - $data{'TDB::loadCompleted'}, + $data{'TDB::loadCompleted'} || 0, $data{'TDB::gc'}, $data{'TDB::commit'}, $data{'Table::render'}; diff --git a/src/tests/duration.t.cpp b/src/tests/duration.t.cpp index 195195f4c..c7ab3e4e9 100644 --- a/src/tests/duration.t.cpp +++ b/src/tests/duration.t.cpp @@ -41,17 +41,471 @@ Context context; int convertDuration (const std::string& input) { - try { Duration d (input); return (int) d; } + try { Duration d (input); return ((int) d) / 86400; } catch (...) {} return 0; } int main (int argc, char** argv) { - UnitTest t (148); + UnitTest t (559); Duration d; + // std::string format (); + d = Duration (0); t.is (d.format (), "-", "0 -> -"); + d = Duration (1); t.is (d.format (), "1 sec", "1 -> 1 sec"); + d = Duration (2); t.is (d.format (), "2 secs", "2 -> 2 secs"); + d = Duration (59); t.is (d.format (), "59 secs", "59 -> 59 secs"); + d = Duration (60); t.is (d.format (), "1 min", "60 -> 1 min"); + d = Duration (119); t.is (d.format (), "1 min", "119 -> 1 min"); + d = Duration (120); t.is (d.format (), "2 mins", "120 -> 2 mins"); + d = Duration (121); t.is (d.format (), "2 mins", "121 -> 2 mins"); + d = Duration (3599); t.is (d.format (), "59 mins", "3599 -> 59 mins"); + d = Duration (3600); t.is (d.format (), "1 hr", "3600 -> 1 hr"); + d = Duration (3601); t.is (d.format (), "1 hr", "3601 -> 1 hr"); + d = Duration (86399); t.is (d.format (), "23 hrs", "86399 -> 23 hrs"); + d = Duration (86400); t.is (d.format (), "1 day", "86400 -> 1 day"); + d = Duration (86401); t.is (d.format (), "1 day", "86401 -> 1 day"); + d = Duration (14 * 86400 - 1); t.is (d.format (), "1 wk", "14 days - 1 sec -> 1 wk"); + d = Duration (14 * 86400); t.is (d.format (), "2 wks", "14 days -> 2 wks"); + d = Duration (14 * 86400 + 1); t.is (d.format (), "2 wks", "14 days + 1 sec -> 2 wks"); + d = Duration (85 * 86400 - 1); t.is (d.format (), "2 mths", "85 days - 1 sec -> 2 mths"); + d = Duration (85 * 86400); t.is (d.format (), "2 mths", "85 days -> 2 mths"); + d = Duration (85 * 86400 + 1); t.is (d.format (), "2 mths", "85 days + 1 sec -> 2 mths"); + d = Duration (365 * 86400 - 1); t.is (d.format (), "11 mths", "365 days - 1 sec -> 11 mths"); + d = Duration (365 * 86400); t.is (d.format (), "1.0 yrs", "365 days -> 1.0 yrs"); + d = Duration (365 * 86400 + 1); t.is (d.format (), "1.0 yrs", "365 days + 1 sec -> 1.0 yrs"); + + // std::string formatCompact (); + d = Duration (0), t.is (d.formatCompact (), "-", "0 -> -"); + d = Duration (1), t.is (d.formatCompact (), "1s", "1 -> 1s"); + d = Duration (2), t.is (d.formatCompact (), "2s", "2 -> 2s"); + d = Duration (59), t.is (d.formatCompact (), "59s", "59 -> 59s"); + d = Duration (60), t.is (d.formatCompact (), "1m", "60 -> 1m"); + d = Duration (119), t.is (d.formatCompact (), "1m", "119 -> 1m"); + d = Duration (120), t.is (d.formatCompact (), "2m", "120 -> 2m"); + d = Duration (121), t.is (d.formatCompact (), "2m", "121 -> 2m"); + d = Duration (3599), t.is (d.formatCompact (), "59m", "3599 -> 59m"); + d = Duration (3600), t.is (d.formatCompact (), "1h", "3600 -> 1h"); + d = Duration (3601), t.is (d.formatCompact (), "1h", "3601 -> 1h"); + d = Duration (86399), t.is (d.formatCompact (), "23h", "86399 -> 23h"); + d = Duration (86400), t.is (d.formatCompact (), "1d", "86400 -> 1d"); + d = Duration (86401), t.is (d.formatCompact (), "1d", "86401 -> 1d"); + d = Duration (14 * 86400 - 1), t.is (d.formatCompact (), "1wk", "14 days - 1 sec -> 1wk"); + d = Duration (14 * 86400), t.is (d.formatCompact (), "2wk", "14 days -> 2wk"); + d = Duration (14 * 86400 + 1), t.is (d.formatCompact (), "2wk", "14 days + 1 sec -> 2wk"); + d = Duration (85 * 86400 - 1), t.is (d.formatCompact (), "2mo", "85 days - 1 sec -> 2mo"); + d = Duration (85 * 86400), t.is (d.formatCompact (), "2mo", "85 days -> 2mo"); + d = Duration (85 * 86400 + 1), t.is (d.formatCompact (), "2mo", "85 days + 1 sec -> 2mo"); + d = Duration (365 * 86400 - 1), t.is (d.formatCompact (), "11mo", "365 days - 1 sec -> 11mo"); + d = Duration (365 * 86400), t.is (d.formatCompact (), "1.0y", "365 days -> 1.0y"); + d = Duration (365 * 86400 + 1), t.is (d.formatCompact (), "1.0y", "365 days + 1 sec -> 1.0y"); + + // Iterate for a whole year. Why? Just to see where the boundaries are, + // so that changes can be made with some reference point. + d = Duration ( 1*86400), t.is (d.formatCompact (), "1d", "1*86400 -> 1d"); + d = Duration ( 2*86400), t.is (d.formatCompact (), "2d", "2*86400 -> 2d"); + d = Duration ( 3*86400), t.is (d.formatCompact (), "3d", "3*86400 -> 3d"); + d = Duration ( 4*86400), t.is (d.formatCompact (), "4d", "4*86400 -> 4d"); + d = Duration ( 5*86400), t.is (d.formatCompact (), "5d", "5*86400 -> 5d"); + d = Duration ( 6*86400), t.is (d.formatCompact (), "6d", "6*86400 -> 6d"); + d = Duration ( 7*86400), t.is (d.formatCompact (), "7d", "7*86400 -> 7d"); + d = Duration ( 8*86400), t.is (d.formatCompact (), "8d", "8*86400 -> 8d"); + d = Duration ( 9*86400), t.is (d.formatCompact (), "9d", "9*86400 -> 9d"); + d = Duration ( 10*86400), t.is (d.formatCompact (), "10d", "10*86400 -> 10d"); + + d = Duration ( 11*86400), t.is (d.formatCompact (), "11d", "11*86400 -> 11d"); + d = Duration ( 12*86400), t.is (d.formatCompact (), "12d", "12*86400 -> 12d"); + d = Duration ( 13*86400), t.is (d.formatCompact (), "1wk", "13*86400 -> 1wk"); + d = Duration ( 14*86400), t.is (d.formatCompact (), "2wk", "14*86400 -> 2wk"); + d = Duration ( 15*86400), t.is (d.formatCompact (), "2wk", "15*86400 -> 2wk"); + d = Duration ( 16*86400), t.is (d.formatCompact (), "2wk", "16*86400 -> 2wk"); + d = Duration ( 17*86400), t.is (d.formatCompact (), "2wk", "17*86400 -> 2wk"); + d = Duration ( 18*86400), t.is (d.formatCompact (), "2wk", "18*86400 -> 2wk"); + d = Duration ( 19*86400), t.is (d.formatCompact (), "2wk", "19*86400 -> 2wk"); + d = Duration ( 20*86400), t.is (d.formatCompact (), "2wk", "20*86400 -> 2wk"); + + d = Duration ( 21*86400), t.is (d.formatCompact (), "3wk", "21*86400 -> 3wk"); + d = Duration ( 22*86400), t.is (d.formatCompact (), "3wk", "22*86400 -> 3wk"); + d = Duration ( 23*86400), t.is (d.formatCompact (), "3wk", "23*86400 -> 3wk"); + d = Duration ( 24*86400), t.is (d.formatCompact (), "3wk", "24*86400 -> 3wk"); + d = Duration ( 25*86400), t.is (d.formatCompact (), "3wk", "25*86400 -> 3wk"); + d = Duration ( 26*86400), t.is (d.formatCompact (), "3wk", "26*86400 -> 3wk"); + d = Duration ( 27*86400), t.is (d.formatCompact (), "3wk", "27*86400 -> 3wk"); + d = Duration ( 28*86400), t.is (d.formatCompact (), "4wk", "28*86400 -> 4wk"); + d = Duration ( 29*86400), t.is (d.formatCompact (), "4wk", "29*86400 -> 4wk"); + d = Duration ( 30*86400), t.is (d.formatCompact (), "4wk", "30*86400 -> 4wk"); + + d = Duration ( 31*86400), t.is (d.formatCompact (), "4wk", "31*86400 -> 4wk"); + d = Duration ( 32*86400), t.is (d.formatCompact (), "4wk", "32*86400 -> 4wk"); + d = Duration ( 33*86400), t.is (d.formatCompact (), "4wk", "33*86400 -> 4wk"); + d = Duration ( 34*86400), t.is (d.formatCompact (), "4wk", "34*86400 -> 4wk"); + d = Duration ( 35*86400), t.is (d.formatCompact (), "5wk", "35*86400 -> 5wk"); + d = Duration ( 36*86400), t.is (d.formatCompact (), "5wk", "36*86400 -> 5wk"); + d = Duration ( 37*86400), t.is (d.formatCompact (), "5wk", "37*86400 -> 5wk"); + d = Duration ( 38*86400), t.is (d.formatCompact (), "5wk", "38*86400 -> 5wk"); + d = Duration ( 39*86400), t.is (d.formatCompact (), "5wk", "39*86400 -> 5wk"); + d = Duration ( 40*86400), t.is (d.formatCompact (), "5wk", "40*86400 -> 5wk"); + + d = Duration ( 41*86400), t.is (d.formatCompact (), "5wk", "41*86400 -> 5wk"); + d = Duration ( 42*86400), t.is (d.formatCompact (), "6wk", "42*86400 -> 6wk"); + d = Duration ( 43*86400), t.is (d.formatCompact (), "6wk", "43*86400 -> 6wk"); + d = Duration ( 44*86400), t.is (d.formatCompact (), "6wk", "44*86400 -> 6wk"); + d = Duration ( 45*86400), t.is (d.formatCompact (), "6wk", "45*86400 -> 6wk"); + d = Duration ( 46*86400), t.is (d.formatCompact (), "6wk", "46*86400 -> 6wk"); + d = Duration ( 47*86400), t.is (d.formatCompact (), "6wk", "47*86400 -> 6wk"); + d = Duration ( 48*86400), t.is (d.formatCompact (), "6wk", "48*86400 -> 6wk"); + d = Duration ( 49*86400), t.is (d.formatCompact (), "7wk", "49*86400 -> 7wk"); + d = Duration ( 50*86400), t.is (d.formatCompact (), "7wk", "50*86400 -> 7wk"); + + d = Duration ( 51*86400), t.is (d.formatCompact (), "7wk", "51*86400 -> 7wk"); + d = Duration ( 52*86400), t.is (d.formatCompact (), "7wk", "52*86400 -> 7wk"); + d = Duration ( 53*86400), t.is (d.formatCompact (), "7wk", "53*86400 -> 7wk"); + d = Duration ( 54*86400), t.is (d.formatCompact (), "7wk", "54*86400 -> 7wk"); + d = Duration ( 55*86400), t.is (d.formatCompact (), "7wk", "55*86400 -> 7wk"); + d = Duration ( 56*86400), t.is (d.formatCompact (), "8wk", "56*86400 -> 8wk"); + d = Duration ( 57*86400), t.is (d.formatCompact (), "8wk", "57*86400 -> 8wk"); + d = Duration ( 58*86400), t.is (d.formatCompact (), "8wk", "58*86400 -> 8wk"); + d = Duration ( 59*86400), t.is (d.formatCompact (), "8wk", "59*86400 -> 8wk"); + d = Duration ( 60*86400), t.is (d.formatCompact (), "8wk", "60*86400 -> 8wk"); + + d = Duration ( 61*86400), t.is (d.formatCompact (), "8wk", "61*86400 -> 8wk"); + d = Duration ( 62*86400), t.is (d.formatCompact (), "8wk", "62*86400 -> 8wk"); + d = Duration ( 63*86400), t.is (d.formatCompact (), "9wk", "63*86400 -> 9wk"); + d = Duration ( 64*86400), t.is (d.formatCompact (), "9wk", "64*86400 -> 9wk"); + d = Duration ( 65*86400), t.is (d.formatCompact (), "9wk", "65*86400 -> 9wk"); + d = Duration ( 66*86400), t.is (d.formatCompact (), "9wk", "66*86400 -> 9wk"); + d = Duration ( 67*86400), t.is (d.formatCompact (), "9wk", "67*86400 -> 9wk"); + d = Duration ( 68*86400), t.is (d.formatCompact (), "9wk", "68*86400 -> 9wk"); + d = Duration ( 69*86400), t.is (d.formatCompact (), "9wk", "69*86400 -> 9wk"); + d = Duration ( 70*86400), t.is (d.formatCompact (), "10wk", "70*86400 -> 10wk"); + + d = Duration ( 71*86400), t.is (d.formatCompact (), "10wk", "71*86400 -> 10wk"); + d = Duration ( 72*86400), t.is (d.formatCompact (), "10wk", "72*86400 -> 10wk"); + d = Duration ( 73*86400), t.is (d.formatCompact (), "10wk", "73*86400 -> 10wk"); + d = Duration ( 74*86400), t.is (d.formatCompact (), "10wk", "74*86400 -> 10wk"); + d = Duration ( 75*86400), t.is (d.formatCompact (), "10wk", "75*86400 -> 10wk"); + d = Duration ( 76*86400), t.is (d.formatCompact (), "10wk", "76*86400 -> 10wk"); + d = Duration ( 77*86400), t.is (d.formatCompact (), "11wk", "77*86400 -> 11wk"); + d = Duration ( 78*86400), t.is (d.formatCompact (), "11wk", "78*86400 -> 11wk"); + d = Duration ( 79*86400), t.is (d.formatCompact (), "11wk", "79*86400 -> 11wk"); + d = Duration ( 80*86400), t.is (d.formatCompact (), "11wk", "80*86400 -> 11wk"); + + d = Duration ( 81*86400), t.is (d.formatCompact (), "11wk", "81*86400 -> 11wk"); + d = Duration ( 82*86400), t.is (d.formatCompact (), "11wk", "82*86400 -> 11wk"); + d = Duration ( 83*86400), t.is (d.formatCompact (), "11wk", "83*86400 -> 11wk"); + d = Duration ( 84*86400), t.is (d.formatCompact (), "2mo", "84*86400 -> 2mo"); + d = Duration ( 85*86400), t.is (d.formatCompact (), "2mo", "85*86400 -> 2mo"); + d = Duration ( 86*86400), t.is (d.formatCompact (), "2mo", "86*86400 -> 2mo"); + d = Duration ( 87*86400), t.is (d.formatCompact (), "2mo", "87*86400 -> 2mo"); + d = Duration ( 88*86400), t.is (d.formatCompact (), "2mo", "88*86400 -> 2mo"); + d = Duration ( 89*86400), t.is (d.formatCompact (), "2mo", "89*86400 -> 2mo"); + d = Duration ( 90*86400), t.is (d.formatCompact (), "2mo", "90*86400 -> 2mo"); + + d = Duration ( 91*86400), t.is (d.formatCompact (), "2mo", "91*86400 -> 2mo"); + d = Duration ( 92*86400), t.is (d.formatCompact (), "3mo", "92*86400 -> 3mo"); + d = Duration ( 93*86400), t.is (d.formatCompact (), "3mo", "93*86400 -> 3mo"); + d = Duration ( 94*86400), t.is (d.formatCompact (), "3mo", "94*86400 -> 3mo"); + d = Duration ( 95*86400), t.is (d.formatCompact (), "3mo", "95*86400 -> 3mo"); + d = Duration ( 96*86400), t.is (d.formatCompact (), "3mo", "96*86400 -> 3mo"); + d = Duration ( 97*86400), t.is (d.formatCompact (), "3mo", "97*86400 -> 3mo"); + d = Duration ( 98*86400), t.is (d.formatCompact (), "3mo", "98*86400 -> 3mo"); + d = Duration ( 99*86400), t.is (d.formatCompact (), "3mo", "99*86400 -> 3mo"); + d = Duration (100*86400), t.is (d.formatCompact (), "3mo", "100*86400 -> 3mo"); + + d = Duration (101*86400), t.is (d.formatCompact (), "3mo", "101*86400 -> 3mo"); + d = Duration (102*86400), t.is (d.formatCompact (), "3mo", "102*86400 -> 3mo"); + d = Duration (103*86400), t.is (d.formatCompact (), "3mo", "103*86400 -> 3mo"); + d = Duration (104*86400), t.is (d.formatCompact (), "3mo", "104*86400 -> 3mo"); + d = Duration (105*86400), t.is (d.formatCompact (), "3mo", "105*86400 -> 3mo"); + d = Duration (106*86400), t.is (d.formatCompact (), "3mo", "106*86400 -> 3mo"); + d = Duration (107*86400), t.is (d.formatCompact (), "3mo", "107*86400 -> 3mo"); + d = Duration (108*86400), t.is (d.formatCompact (), "3mo", "108*86400 -> 3mo"); + d = Duration (109*86400), t.is (d.formatCompact (), "3mo", "109*86400 -> 3mo"); + d = Duration (110*86400), t.is (d.formatCompact (), "3mo", "110*86400 -> 3mo"); + + d = Duration (111*86400), t.is (d.formatCompact (), "3mo", "111*86400 -> 3mo"); + d = Duration (112*86400), t.is (d.formatCompact (), "3mo", "112*86400 -> 3mo"); + d = Duration (113*86400), t.is (d.formatCompact (), "3mo", "113*86400 -> 3mo"); + d = Duration (114*86400), t.is (d.formatCompact (), "3mo", "114*86400 -> 3mo"); + d = Duration (115*86400), t.is (d.formatCompact (), "3mo", "115*86400 -> 3mo"); + d = Duration (116*86400), t.is (d.formatCompact (), "3mo", "116*86400 -> 3mo"); + d = Duration (117*86400), t.is (d.formatCompact (), "3mo", "117*86400 -> 3mo"); + d = Duration (118*86400), t.is (d.formatCompact (), "3mo", "118*86400 -> 3mo"); + d = Duration (119*86400), t.is (d.formatCompact (), "3mo", "119*86400 -> 3mo"); + d = Duration (120*86400), t.is (d.formatCompact (), "3mo", "120*86400 -> 3mo"); + + d = Duration (121*86400), t.is (d.formatCompact (), "3mo", "121*86400 -> 3mo"); + d = Duration (122*86400), t.is (d.formatCompact (), "3mo", "122*86400 -> 3mo"); + d = Duration (123*86400), t.is (d.formatCompact (), "4mo", "123*86400 -> 4mo"); + d = Duration (124*86400), t.is (d.formatCompact (), "4mo", "124*86400 -> 4mo"); + d = Duration (125*86400), t.is (d.formatCompact (), "4mo", "125*86400 -> 4mo"); + d = Duration (126*86400), t.is (d.formatCompact (), "4mo", "126*86400 -> 4mo"); + d = Duration (127*86400), t.is (d.formatCompact (), "4mo", "127*86400 -> 4mo"); + d = Duration (128*86400), t.is (d.formatCompact (), "4mo", "128*86400 -> 4mo"); + d = Duration (129*86400), t.is (d.formatCompact (), "4mo", "129*86400 -> 4mo"); + d = Duration (130*86400), t.is (d.formatCompact (), "4mo", "130*86400 -> 4mo"); + + d = Duration (131*86400), t.is (d.formatCompact (), "4mo", "131*86400 -> 4mo"); + d = Duration (132*86400), t.is (d.formatCompact (), "4mo", "132*86400 -> 4mo"); + d = Duration (133*86400), t.is (d.formatCompact (), "4mo", "133*86400 -> 4mo"); + d = Duration (134*86400), t.is (d.formatCompact (), "4mo", "134*86400 -> 4mo"); + d = Duration (135*86400), t.is (d.formatCompact (), "4mo", "135*86400 -> 4mo"); + d = Duration (136*86400), t.is (d.formatCompact (), "4mo", "136*86400 -> 4mo"); + d = Duration (137*86400), t.is (d.formatCompact (), "4mo", "137*86400 -> 4mo"); + d = Duration (138*86400), t.is (d.formatCompact (), "4mo", "138*86400 -> 4mo"); + d = Duration (139*86400), t.is (d.formatCompact (), "4mo", "139*86400 -> 4mo"); + d = Duration (140*86400), t.is (d.formatCompact (), "4mo", "140*86400 -> 4mo"); + + d = Duration (141*86400), t.is (d.formatCompact (), "4mo", "141*86400 -> 4mo"); + d = Duration (142*86400), t.is (d.formatCompact (), "4mo", "142*86400 -> 4mo"); + d = Duration (143*86400), t.is (d.formatCompact (), "4mo", "143*86400 -> 4mo"); + d = Duration (144*86400), t.is (d.formatCompact (), "4mo", "144*86400 -> 4mo"); + d = Duration (145*86400), t.is (d.formatCompact (), "4mo", "145*86400 -> 4mo"); + d = Duration (146*86400), t.is (d.formatCompact (), "4mo", "146*86400 -> 4mo"); + d = Duration (147*86400), t.is (d.formatCompact (), "4mo", "147*86400 -> 4mo"); + d = Duration (148*86400), t.is (d.formatCompact (), "4mo", "148*86400 -> 4mo"); + d = Duration (149*86400), t.is (d.formatCompact (), "4mo", "149*86400 -> 4mo"); + d = Duration (150*86400), t.is (d.formatCompact (), "4mo", "150*86400 -> 4mo"); + + d = Duration (151*86400), t.is (d.formatCompact (), "4mo", "151*86400 -> 4mo"); + d = Duration (152*86400), t.is (d.formatCompact (), "4mo", "152*86400 -> 4mo"); + d = Duration (153*86400), t.is (d.formatCompact (), "5mo", "153*86400 -> 5mo"); + d = Duration (154*86400), t.is (d.formatCompact (), "5mo", "154*86400 -> 5mo"); + d = Duration (155*86400), t.is (d.formatCompact (), "5mo", "155*86400 -> 5mo"); + d = Duration (156*86400), t.is (d.formatCompact (), "5mo", "156*86400 -> 5mo"); + d = Duration (157*86400), t.is (d.formatCompact (), "5mo", "157*86400 -> 5mo"); + d = Duration (158*86400), t.is (d.formatCompact (), "5mo", "158*86400 -> 5mo"); + d = Duration (159*86400), t.is (d.formatCompact (), "5mo", "159*86400 -> 5mo"); + d = Duration (160*86400), t.is (d.formatCompact (), "5mo", "160*86400 -> 5mo"); + + d = Duration (161*86400), t.is (d.formatCompact (), "5mo", "161*86400 -> 5mo"); + d = Duration (162*86400), t.is (d.formatCompact (), "5mo", "162*86400 -> 5mo"); + d = Duration (163*86400), t.is (d.formatCompact (), "5mo", "163*86400 -> 5mo"); + d = Duration (164*86400), t.is (d.formatCompact (), "5mo", "164*86400 -> 5mo"); + d = Duration (165*86400), t.is (d.formatCompact (), "5mo", "165*86400 -> 5mo"); + d = Duration (166*86400), t.is (d.formatCompact (), "5mo", "166*86400 -> 5mo"); + d = Duration (167*86400), t.is (d.formatCompact (), "5mo", "167*86400 -> 5mo"); + d = Duration (168*86400), t.is (d.formatCompact (), "5mo", "168*86400 -> 5mo"); + d = Duration (169*86400), t.is (d.formatCompact (), "5mo", "169*86400 -> 5mo"); + d = Duration (170*86400), t.is (d.formatCompact (), "5mo", "170*86400 -> 5mo"); + + d = Duration (171*86400), t.is (d.formatCompact (), "5mo", "171*86400 -> 5mo"); + d = Duration (172*86400), t.is (d.formatCompact (), "5mo", "172*86400 -> 5mo"); + d = Duration (173*86400), t.is (d.formatCompact (), "5mo", "173*86400 -> 5mo"); + d = Duration (174*86400), t.is (d.formatCompact (), "5mo", "174*86400 -> 5mo"); + d = Duration (175*86400), t.is (d.formatCompact (), "5mo", "175*86400 -> 5mo"); + d = Duration (176*86400), t.is (d.formatCompact (), "5mo", "176*86400 -> 5mo"); + d = Duration (177*86400), t.is (d.formatCompact (), "5mo", "177*86400 -> 5mo"); + d = Duration (178*86400), t.is (d.formatCompact (), "5mo", "178*86400 -> 5mo"); + d = Duration (179*86400), t.is (d.formatCompact (), "5mo", "179*86400 -> 5mo"); + d = Duration (180*86400), t.is (d.formatCompact (), "5mo", "180*86400 -> 5mo"); + + d = Duration (181*86400), t.is (d.formatCompact (), "5mo", "181*86400 -> 5mo"); + d = Duration (182*86400), t.is (d.formatCompact (), "5mo", "182*86400 -> 5mo"); + d = Duration (183*86400), t.is (d.formatCompact (), "5mo", "183*86400 -> 5mo"); + d = Duration (184*86400), t.is (d.formatCompact (), "6mo", "184*86400 -> 6mo"); + d = Duration (185*86400), t.is (d.formatCompact (), "6mo", "185*86400 -> 6mo"); + d = Duration (186*86400), t.is (d.formatCompact (), "6mo", "186*86400 -> 6mo"); + d = Duration (187*86400), t.is (d.formatCompact (), "6mo", "187*86400 -> 6mo"); + d = Duration (188*86400), t.is (d.formatCompact (), "6mo", "188*86400 -> 6mo"); + d = Duration (189*86400), t.is (d.formatCompact (), "6mo", "189*86400 -> 6mo"); + d = Duration (190*86400), t.is (d.formatCompact (), "6mo", "190*86400 -> 6mo"); + + d = Duration (191*86400), t.is (d.formatCompact (), "6mo", "191*86400 -> 6mo"); + d = Duration (192*86400), t.is (d.formatCompact (), "6mo", "192*86400 -> 6mo"); + d = Duration (193*86400), t.is (d.formatCompact (), "6mo", "193*86400 -> 6mo"); + d = Duration (194*86400), t.is (d.formatCompact (), "6mo", "194*86400 -> 6mo"); + d = Duration (195*86400), t.is (d.formatCompact (), "6mo", "195*86400 -> 6mo"); + d = Duration (196*86400), t.is (d.formatCompact (), "6mo", "196*86400 -> 6mo"); + d = Duration (197*86400), t.is (d.formatCompact (), "6mo", "197*86400 -> 6mo"); + d = Duration (198*86400), t.is (d.formatCompact (), "6mo", "198*86400 -> 6mo"); + d = Duration (199*86400), t.is (d.formatCompact (), "6mo", "199*86400 -> 6mo"); + d = Duration (200*86400), t.is (d.formatCompact (), "6mo", "200*86400 -> 6mo"); + + d = Duration (201*86400), t.is (d.formatCompact (), "6mo", "201*86400 -> 6mo"); + d = Duration (202*86400), t.is (d.formatCompact (), "6mo", "202*86400 -> 6mo"); + d = Duration (203*86400), t.is (d.formatCompact (), "6mo", "203*86400 -> 6mo"); + d = Duration (204*86400), t.is (d.formatCompact (), "6mo", "204*86400 -> 6mo"); + d = Duration (205*86400), t.is (d.formatCompact (), "6mo", "205*86400 -> 6mo"); + d = Duration (206*86400), t.is (d.formatCompact (), "6mo", "206*86400 -> 6mo"); + d = Duration (207*86400), t.is (d.formatCompact (), "6mo", "207*86400 -> 6mo"); + d = Duration (208*86400), t.is (d.formatCompact (), "6mo", "208*86400 -> 6mo"); + d = Duration (209*86400), t.is (d.formatCompact (), "6mo", "209*86400 -> 6mo"); + d = Duration (210*86400), t.is (d.formatCompact (), "6mo", "210*86400 -> 6mo"); + + d = Duration (211*86400), t.is (d.formatCompact (), "6mo", "211*86400 -> 6mo"); + d = Duration (212*86400), t.is (d.formatCompact (), "6mo", "212*86400 -> 6mo"); + d = Duration (213*86400), t.is (d.formatCompact (), "6mo", "213*86400 -> 6mo"); + d = Duration (214*86400), t.is (d.formatCompact (), "6mo", "214*86400 -> 6mo"); + d = Duration (215*86400), t.is (d.formatCompact (), "7mo", "215*86400 -> 7mo"); + d = Duration (216*86400), t.is (d.formatCompact (), "7mo", "216*86400 -> 7mo"); + d = Duration (217*86400), t.is (d.formatCompact (), "7mo", "217*86400 -> 7mo"); + d = Duration (218*86400), t.is (d.formatCompact (), "7mo", "218*86400 -> 7mo"); + d = Duration (219*86400), t.is (d.formatCompact (), "7mo", "219*86400 -> 7mo"); + d = Duration (220*86400), t.is (d.formatCompact (), "7mo", "220*86400 -> 7mo"); + + d = Duration (221*86400), t.is (d.formatCompact (), "7mo", "221*86400 -> 7mo"); + d = Duration (222*86400), t.is (d.formatCompact (), "7mo", "222*86400 -> 7mo"); + d = Duration (223*86400), t.is (d.formatCompact (), "7mo", "223*86400 -> 7mo"); + d = Duration (224*86400), t.is (d.formatCompact (), "7mo", "224*86400 -> 7mo"); + d = Duration (225*86400), t.is (d.formatCompact (), "7mo", "225*86400 -> 7mo"); + d = Duration (226*86400), t.is (d.formatCompact (), "7mo", "226*86400 -> 7mo"); + d = Duration (227*86400), t.is (d.formatCompact (), "7mo", "227*86400 -> 7mo"); + d = Duration (228*86400), t.is (d.formatCompact (), "7mo", "228*86400 -> 7mo"); + d = Duration (229*86400), t.is (d.formatCompact (), "7mo", "229*86400 -> 7mo"); + d = Duration (230*86400), t.is (d.formatCompact (), "7mo", "230*86400 -> 7mo"); + + d = Duration (231*86400), t.is (d.formatCompact (), "7mo", "231*86400 -> 7mo"); + d = Duration (232*86400), t.is (d.formatCompact (), "7mo", "232*86400 -> 7mo"); + d = Duration (233*86400), t.is (d.formatCompact (), "7mo", "233*86400 -> 7mo"); + d = Duration (234*86400), t.is (d.formatCompact (), "7mo", "234*86400 -> 7mo"); + d = Duration (235*86400), t.is (d.formatCompact (), "7mo", "235*86400 -> 7mo"); + d = Duration (236*86400), t.is (d.formatCompact (), "7mo", "236*86400 -> 7mo"); + d = Duration (237*86400), t.is (d.formatCompact (), "7mo", "237*86400 -> 7mo"); + d = Duration (238*86400), t.is (d.formatCompact (), "7mo", "238*86400 -> 7mo"); + d = Duration (239*86400), t.is (d.formatCompact (), "7mo", "239*86400 -> 7mo"); + d = Duration (240*86400), t.is (d.formatCompact (), "7mo", "240*86400 -> 7mo"); + + d = Duration (241*86400), t.is (d.formatCompact (), "7mo", "241*86400 -> 7mo"); + d = Duration (242*86400), t.is (d.formatCompact (), "7mo", "242*86400 -> 7mo"); + d = Duration (243*86400), t.is (d.formatCompact (), "7mo", "243*86400 -> 7mo"); + d = Duration (244*86400), t.is (d.formatCompact (), "7mo", "244*86400 -> 7mo"); + d = Duration (245*86400), t.is (d.formatCompact (), "8mo", "245*86400 -> 8mo"); + d = Duration (246*86400), t.is (d.formatCompact (), "8mo", "246*86400 -> 8mo"); + d = Duration (247*86400), t.is (d.formatCompact (), "8mo", "247*86400 -> 8mo"); + d = Duration (248*86400), t.is (d.formatCompact (), "8mo", "248*86400 -> 8mo"); + d = Duration (249*86400), t.is (d.formatCompact (), "8mo", "249*86400 -> 8mo"); + d = Duration (250*86400), t.is (d.formatCompact (), "8mo", "250*86400 -> 8mo"); + + d = Duration (251*86400), t.is (d.formatCompact (), "8mo", "251*86400 -> 8mo"); + d = Duration (252*86400), t.is (d.formatCompact (), "8mo", "252*86400 -> 8mo"); + d = Duration (253*86400), t.is (d.formatCompact (), "8mo", "253*86400 -> 8mo"); + d = Duration (254*86400), t.is (d.formatCompact (), "8mo", "254*86400 -> 8mo"); + d = Duration (255*86400), t.is (d.formatCompact (), "8mo", "255*86400 -> 8mo"); + d = Duration (256*86400), t.is (d.formatCompact (), "8mo", "256*86400 -> 8mo"); + d = Duration (257*86400), t.is (d.formatCompact (), "8mo", "257*86400 -> 8mo"); + d = Duration (258*86400), t.is (d.formatCompact (), "8mo", "258*86400 -> 8mo"); + d = Duration (259*86400), t.is (d.formatCompact (), "8mo", "259*86400 -> 8mo"); + d = Duration (260*86400), t.is (d.formatCompact (), "8mo", "260*86400 -> 8mo"); + + d = Duration (261*86400), t.is (d.formatCompact (), "8mo", "261*86400 -> 8mo"); + d = Duration (262*86400), t.is (d.formatCompact (), "8mo", "262*86400 -> 8mo"); + d = Duration (263*86400), t.is (d.formatCompact (), "8mo", "263*86400 -> 8mo"); + d = Duration (264*86400), t.is (d.formatCompact (), "8mo", "264*86400 -> 8mo"); + d = Duration (265*86400), t.is (d.formatCompact (), "8mo", "265*86400 -> 8mo"); + d = Duration (266*86400), t.is (d.formatCompact (), "8mo", "266*86400 -> 8mo"); + d = Duration (267*86400), t.is (d.formatCompact (), "8mo", "267*86400 -> 8mo"); + d = Duration (268*86400), t.is (d.formatCompact (), "8mo", "268*86400 -> 8mo"); + d = Duration (269*86400), t.is (d.formatCompact (), "8mo", "269*86400 -> 8mo"); + d = Duration (270*86400), t.is (d.formatCompact (), "8mo", "270*86400 -> 8mo"); + + d = Duration (271*86400), t.is (d.formatCompact (), "8mo", "271*86400 -> 8mo"); + d = Duration (272*86400), t.is (d.formatCompact (), "8mo", "272*86400 -> 8mo"); + d = Duration (273*86400), t.is (d.formatCompact (), "8mo", "273*86400 -> 8mo"); + d = Duration (274*86400), t.is (d.formatCompact (), "8mo", "274*86400 -> 8mo"); + d = Duration (275*86400), t.is (d.formatCompact (), "8mo", "275*86400 -> 8mo"); + d = Duration (276*86400), t.is (d.formatCompact (), "9mo", "276*86400 -> 9mo"); + d = Duration (277*86400), t.is (d.formatCompact (), "9mo", "277*86400 -> 9mo"); + d = Duration (278*86400), t.is (d.formatCompact (), "9mo", "278*86400 -> 9mo"); + d = Duration (279*86400), t.is (d.formatCompact (), "9mo", "279*86400 -> 9mo"); + d = Duration (280*86400), t.is (d.formatCompact (), "9mo", "280*86400 -> 9mo"); + + d = Duration (281*86400), t.is (d.formatCompact (), "9mo", "281*86400 -> 9mo"); + d = Duration (282*86400), t.is (d.formatCompact (), "9mo", "282*86400 -> 9mo"); + d = Duration (283*86400), t.is (d.formatCompact (), "9mo", "283*86400 -> 9mo"); + d = Duration (284*86400), t.is (d.formatCompact (), "9mo", "284*86400 -> 9mo"); + d = Duration (285*86400), t.is (d.formatCompact (), "9mo", "285*86400 -> 9mo"); + d = Duration (286*86400), t.is (d.formatCompact (), "9mo", "286*86400 -> 9mo"); + d = Duration (287*86400), t.is (d.formatCompact (), "9mo", "287*86400 -> 9mo"); + d = Duration (288*86400), t.is (d.formatCompact (), "9mo", "288*86400 -> 9mo"); + d = Duration (289*86400), t.is (d.formatCompact (), "9mo", "289*86400 -> 9mo"); + d = Duration (290*86400), t.is (d.formatCompact (), "9mo", "290*86400 -> 9mo"); + + d = Duration (291*86400), t.is (d.formatCompact (), "9mo", "291*86400 -> 9mo"); + d = Duration (292*86400), t.is (d.formatCompact (), "9mo", "292*86400 -> 9mo"); + d = Duration (293*86400), t.is (d.formatCompact (), "9mo", "293*86400 -> 9mo"); + d = Duration (294*86400), t.is (d.formatCompact (), "9mo", "294*86400 -> 9mo"); + d = Duration (295*86400), t.is (d.formatCompact (), "9mo", "295*86400 -> 9mo"); + d = Duration (296*86400), t.is (d.formatCompact (), "9mo", "296*86400 -> 9mo"); + d = Duration (297*86400), t.is (d.formatCompact (), "9mo", "297*86400 -> 9mo"); + d = Duration (298*86400), t.is (d.formatCompact (), "9mo", "298*86400 -> 9mo"); + d = Duration (299*86400), t.is (d.formatCompact (), "9mo", "299*86400 -> 9mo"); + d = Duration (300*86400), t.is (d.formatCompact (), "9mo", "300*86400 -> 9mo"); + + d = Duration (301*86400), t.is (d.formatCompact (), "9mo", "301*86400 -> 9mo"); + d = Duration (302*86400), t.is (d.formatCompact (), "9mo", "302*86400 -> 9mo"); + d = Duration (303*86400), t.is (d.formatCompact (), "9mo", "303*86400 -> 9mo"); + d = Duration (304*86400), t.is (d.formatCompact (), "9mo", "304*86400 -> 9mo"); + d = Duration (305*86400), t.is (d.formatCompact (), "9mo", "305*86400 -> 9mo"); + d = Duration (306*86400), t.is (d.formatCompact (), "10mo", "306*86400 -> 10mo"); + d = Duration (307*86400), t.is (d.formatCompact (), "10mo", "307*86400 -> 10mo"); + d = Duration (308*86400), t.is (d.formatCompact (), "10mo", "308*86400 -> 10mo"); + d = Duration (309*86400), t.is (d.formatCompact (), "10mo", "309*86400 -> 10mo"); + d = Duration (310*86400), t.is (d.formatCompact (), "10mo", "310*86400 -> 10mo"); + + d = Duration (311*86400), t.is (d.formatCompact (), "10mo", "311*86400 -> 10mo"); + d = Duration (312*86400), t.is (d.formatCompact (), "10mo", "312*86400 -> 10mo"); + d = Duration (313*86400), t.is (d.formatCompact (), "10mo", "313*86400 -> 10mo"); + d = Duration (314*86400), t.is (d.formatCompact (), "10mo", "314*86400 -> 10mo"); + d = Duration (315*86400), t.is (d.formatCompact (), "10mo", "315*86400 -> 10mo"); + d = Duration (316*86400), t.is (d.formatCompact (), "10mo", "316*86400 -> 10mo"); + d = Duration (317*86400), t.is (d.formatCompact (), "10mo", "317*86400 -> 10mo"); + d = Duration (318*86400), t.is (d.formatCompact (), "10mo", "318*86400 -> 10mo"); + d = Duration (319*86400), t.is (d.formatCompact (), "10mo", "319*86400 -> 10mo"); + d = Duration (320*86400), t.is (d.formatCompact (), "10mo", "320*86400 -> 10mo"); + + d = Duration (321*86400), t.is (d.formatCompact (), "10mo", "321*86400 -> 10mo"); + d = Duration (322*86400), t.is (d.formatCompact (), "10mo", "322*86400 -> 10mo"); + d = Duration (323*86400), t.is (d.formatCompact (), "10mo", "323*86400 -> 10mo"); + d = Duration (324*86400), t.is (d.formatCompact (), "10mo", "324*86400 -> 10mo"); + d = Duration (325*86400), t.is (d.formatCompact (), "10mo", "325*86400 -> 10mo"); + d = Duration (326*86400), t.is (d.formatCompact (), "10mo", "326*86400 -> 10mo"); + d = Duration (327*86400), t.is (d.formatCompact (), "10mo", "327*86400 -> 10mo"); + d = Duration (328*86400), t.is (d.formatCompact (), "10mo", "328*86400 -> 10mo"); + d = Duration (329*86400), t.is (d.formatCompact (), "10mo", "329*86400 -> 10mo"); + d = Duration (330*86400), t.is (d.formatCompact (), "10mo", "330*86400 -> 10mo"); + + d = Duration (331*86400), t.is (d.formatCompact (), "10mo", "331*86400 -> 10mo"); + d = Duration (332*86400), t.is (d.formatCompact (), "10mo", "332*86400 -> 10mo"); + d = Duration (333*86400), t.is (d.formatCompact (), "10mo", "333*86400 -> 10mo"); + d = Duration (334*86400), t.is (d.formatCompact (), "10mo", "334*86400 -> 10mo"); + d = Duration (335*86400), t.is (d.formatCompact (), "10mo", "335*86400 -> 10mo"); + d = Duration (336*86400), t.is (d.formatCompact (), "10mo", "336*86400 -> 10mo"); + d = Duration (337*86400), t.is (d.formatCompact (), "11mo", "337*86400 -> 11mo"); + d = Duration (338*86400), t.is (d.formatCompact (), "11mo", "338*86400 -> 11mo"); + d = Duration (339*86400), t.is (d.formatCompact (), "11mo", "339*86400 -> 11mo"); + d = Duration (340*86400), t.is (d.formatCompact (), "11mo", "340*86400 -> 11mo"); + + d = Duration (341*86400), t.is (d.formatCompact (), "11mo", "341*86400 -> 11mo"); + d = Duration (342*86400), t.is (d.formatCompact (), "11mo", "342*86400 -> 11mo"); + d = Duration (343*86400), t.is (d.formatCompact (), "11mo", "343*86400 -> 11mo"); + d = Duration (344*86400), t.is (d.formatCompact (), "11mo", "344*86400 -> 11mo"); + d = Duration (345*86400), t.is (d.formatCompact (), "11mo", "345*86400 -> 11mo"); + d = Duration (346*86400), t.is (d.formatCompact (), "11mo", "346*86400 -> 11mo"); + d = Duration (347*86400), t.is (d.formatCompact (), "11mo", "347*86400 -> 11mo"); + d = Duration (348*86400), t.is (d.formatCompact (), "11mo", "348*86400 -> 11mo"); + d = Duration (349*86400), t.is (d.formatCompact (), "11mo", "349*86400 -> 11mo"); + d = Duration (350*86400), t.is (d.formatCompact (), "11mo", "350*86400 -> 11mo"); + + d = Duration (351*86400), t.is (d.formatCompact (), "11mo", "351*86400 -> 11mo"); + d = Duration (352*86400), t.is (d.formatCompact (), "11mo", "352*86400 -> 11mo"); + d = Duration (353*86400), t.is (d.formatCompact (), "11mo", "353*86400 -> 11mo"); + d = Duration (354*86400), t.is (d.formatCompact (), "11mo", "354*86400 -> 11mo"); + d = Duration (355*86400), t.is (d.formatCompact (), "11mo", "355*86400 -> 11mo"); + d = Duration (356*86400), t.is (d.formatCompact (), "11mo", "356*86400 -> 11mo"); + d = Duration (357*86400), t.is (d.formatCompact (), "11mo", "357*86400 -> 11mo"); + d = Duration (358*86400), t.is (d.formatCompact (), "11mo", "358*86400 -> 11mo"); + d = Duration (359*86400), t.is (d.formatCompact (), "11mo", "359*86400 -> 11mo"); + d = Duration (360*86400), t.is (d.formatCompact (), "11mo", "360*86400 -> 11mo"); + + d = Duration (361*86400), t.is (d.formatCompact (), "11mo", "361*86400 -> 11mo"); + d = Duration (362*86400), t.is (d.formatCompact (), "11mo", "362*86400 -> 11mo"); + d = Duration (363*86400), t.is (d.formatCompact (), "11mo", "363*86400 -> 11mo"); + d = Duration (364*86400), t.is (d.formatCompact (), "11mo", "364*86400 -> 11mo"); + d = Duration (365*86400), t.is (d.formatCompact (), "1.0y", "365*86400 -> 1.0y"); + t.ok (d.valid ("daily"), "valid duration daily = 1"); t.ok (d.valid ("day"), "valid duration day = 1"); t.ok (d.valid ("weekly"), "valid duration weekly = 7"); diff --git a/src/tests/util.t.cpp b/src/tests/util.t.cpp index 946eddbdc..5a96a76c3 100644 --- a/src/tests/util.t.cpp +++ b/src/tests/util.t.cpp @@ -34,467 +34,13 @@ Context context; //////////////////////////////////////////////////////////////////////////////// int main (int argc, char** argv) { - UnitTest t (430); + UnitTest t (19); // TODO bool confirm (const std::string&); // TODO int confirm3 (const std::string&); // TODO int confirm4 (const std::string&); // TODO void delay (float); - // std::string formatSeconds (time_t); - t.is (formatSeconds (0), "-", "0 -> -"); - t.is (formatSeconds (1), "1 sec", "1 -> 1 sec"); - t.is (formatSeconds (2), "2 secs", "2 -> 2 secs"); - t.is (formatSeconds (59), "59 secs", "59 -> 59 secs"); - t.is (formatSeconds (60), "1 min", "60 -> 1 min"); - t.is (formatSeconds (119), "1 min", "119 -> 1 min"); - t.is (formatSeconds (120), "2 mins", "120 -> 2 mins"); - t.is (formatSeconds (121), "2 mins", "121 -> 2 mins"); - t.is (formatSeconds (3599), "59 mins", "3599 -> 59 mins"); - t.is (formatSeconds (3600), "1 hr", "3600 -> 1 hr"); - t.is (formatSeconds (3601), "1 hr", "3601 -> 1 hr"); - t.is (formatSeconds (86399), "23 hrs", "86399 -> 23 hrs"); - t.is (formatSeconds (86400), "1 day", "86400 -> 1 day"); - t.is (formatSeconds (86401), "1 day", "86401 -> 1 day"); - t.is (formatSeconds (14 * 86400 - 1), "1 wk", "14 days - 1 sec -> 1 wk"); - t.is (formatSeconds (14 * 86400), "2 wks", "14 days -> 2 wks"); - t.is (formatSeconds (14 * 86400 + 1), "2 wks", "14 days + 1 sec -> 2 wks"); - t.is (formatSeconds (85 * 86400 - 1), "2 mths", "85 days - 1 sec -> 2 mths"); - t.is (formatSeconds (85 * 86400), "2 mths", "85 days -> 2 mths"); - t.is (formatSeconds (85 * 86400 + 1), "2 mths", "85 days + 1 sec -> 2 mths"); - t.is (formatSeconds (365 * 86400 - 1), "11 mths", "365 days - 1 sec -> 11 mths"); - t.is (formatSeconds (365 * 86400), "1.0 yrs", "365 days -> 1.0 yrs"); - t.is (formatSeconds (365 * 86400 + 1), "1.0 yrs", "365 days + 1 sec -> 1.0 yrs"); - - // std::string formatSecondsCompact (time_t); - t.is (formatSecondsCompact (0), "-", "0 -> -"); - t.is (formatSecondsCompact (1), "1s", "1 -> 1s"); - t.is (formatSecondsCompact (2), "2s", "2 -> 2s"); - t.is (formatSecondsCompact (59), "59s", "59 -> 59s"); - t.is (formatSecondsCompact (60), "1m", "60 -> 1m"); - t.is (formatSecondsCompact (119), "1m", "119 -> 1m"); - t.is (formatSecondsCompact (120), "2m", "120 -> 2m"); - t.is (formatSecondsCompact (121), "2m", "121 -> 2m"); - t.is (formatSecondsCompact (3599), "59m", "3599 -> 59m"); - t.is (formatSecondsCompact (3600), "1h", "3600 -> 1h"); - t.is (formatSecondsCompact (3601), "1h", "3601 -> 1h"); - t.is (formatSecondsCompact (86399), "23h", "86399 -> 23h"); - t.is (formatSecondsCompact (86400), "1d", "86400 -> 1d"); - t.is (formatSecondsCompact (86401), "1d", "86401 -> 1d"); - t.is (formatSecondsCompact (14 * 86400 - 1), "1wk", "14 days - 1 sec -> 1wk"); - t.is (formatSecondsCompact (14 * 86400), "2wk", "14 days -> 2wk"); - t.is (formatSecondsCompact (14 * 86400 + 1), "2wk", "14 days + 1 sec -> 2wk"); - t.is (formatSecondsCompact (85 * 86400 - 1), "2mo", "85 days - 1 sec -> 2mo"); - t.is (formatSecondsCompact (85 * 86400), "2mo", "85 days -> 2mo"); - t.is (formatSecondsCompact (85 * 86400 + 1), "2mo", "85 days + 1 sec -> 2mo"); - t.is (formatSecondsCompact (365 * 86400 - 1), "11mo", "365 days - 1 sec -> 11mo"); - t.is (formatSecondsCompact (365 * 86400), "1.0y", "365 days -> 1.0y"); - t.is (formatSecondsCompact (365 * 86400 + 1), "1.0y", "365 days + 1 sec -> 1.0y"); - - // Iterate for a whole year. Why? Just to see where the boundaries are, - // so that changes can be made with some reference point. - t.is (formatSecondsCompact ( 1*86400), "1d", "1*86400 -> 1d"); - t.is (formatSecondsCompact ( 2*86400), "2d", "2*86400 -> 2d"); - t.is (formatSecondsCompact ( 3*86400), "3d", "3*86400 -> 3d"); - t.is (formatSecondsCompact ( 4*86400), "4d", "4*86400 -> 4d"); - t.is (formatSecondsCompact ( 5*86400), "5d", "5*86400 -> 5d"); - t.is (formatSecondsCompact ( 6*86400), "6d", "6*86400 -> 6d"); - t.is (formatSecondsCompact ( 7*86400), "7d", "7*86400 -> 7d"); - t.is (formatSecondsCompact ( 8*86400), "8d", "8*86400 -> 8d"); - t.is (formatSecondsCompact ( 9*86400), "9d", "9*86400 -> 9d"); - t.is (formatSecondsCompact ( 10*86400), "10d", "10*86400 -> 10d"); - - t.is (formatSecondsCompact ( 11*86400), "11d", "11*86400 -> 11d"); - t.is (formatSecondsCompact ( 12*86400), "12d", "12*86400 -> 12d"); - t.is (formatSecondsCompact ( 13*86400), "1wk", "13*86400 -> 1wk"); - t.is (formatSecondsCompact ( 14*86400), "2wk", "14*86400 -> 2wk"); - t.is (formatSecondsCompact ( 15*86400), "2wk", "15*86400 -> 2wk"); - t.is (formatSecondsCompact ( 16*86400), "2wk", "16*86400 -> 2wk"); - t.is (formatSecondsCompact ( 17*86400), "2wk", "17*86400 -> 2wk"); - t.is (formatSecondsCompact ( 18*86400), "2wk", "18*86400 -> 2wk"); - t.is (formatSecondsCompact ( 19*86400), "2wk", "19*86400 -> 2wk"); - t.is (formatSecondsCompact ( 20*86400), "2wk", "20*86400 -> 2wk"); - - t.is (formatSecondsCompact ( 21*86400), "3wk", "21*86400 -> 3wk"); - t.is (formatSecondsCompact ( 22*86400), "3wk", "22*86400 -> 3wk"); - t.is (formatSecondsCompact ( 23*86400), "3wk", "23*86400 -> 3wk"); - t.is (formatSecondsCompact ( 24*86400), "3wk", "24*86400 -> 3wk"); - t.is (formatSecondsCompact ( 25*86400), "3wk", "25*86400 -> 3wk"); - t.is (formatSecondsCompact ( 26*86400), "3wk", "26*86400 -> 3wk"); - t.is (formatSecondsCompact ( 27*86400), "3wk", "27*86400 -> 3wk"); - t.is (formatSecondsCompact ( 28*86400), "4wk", "28*86400 -> 4wk"); - t.is (formatSecondsCompact ( 29*86400), "4wk", "29*86400 -> 4wk"); - t.is (formatSecondsCompact ( 30*86400), "4wk", "30*86400 -> 4wk"); - - t.is (formatSecondsCompact ( 31*86400), "4wk", "31*86400 -> 4wk"); - t.is (formatSecondsCompact ( 32*86400), "4wk", "32*86400 -> 4wk"); - t.is (formatSecondsCompact ( 33*86400), "4wk", "33*86400 -> 4wk"); - t.is (formatSecondsCompact ( 34*86400), "4wk", "34*86400 -> 4wk"); - t.is (formatSecondsCompact ( 35*86400), "5wk", "35*86400 -> 5wk"); - t.is (formatSecondsCompact ( 36*86400), "5wk", "36*86400 -> 5wk"); - t.is (formatSecondsCompact ( 37*86400), "5wk", "37*86400 -> 5wk"); - t.is (formatSecondsCompact ( 38*86400), "5wk", "38*86400 -> 5wk"); - t.is (formatSecondsCompact ( 39*86400), "5wk", "39*86400 -> 5wk"); - t.is (formatSecondsCompact ( 40*86400), "5wk", "40*86400 -> 5wk"); - - t.is (formatSecondsCompact ( 41*86400), "5wk", "41*86400 -> 5wk"); - t.is (formatSecondsCompact ( 42*86400), "6wk", "42*86400 -> 6wk"); - t.is (formatSecondsCompact ( 43*86400), "6wk", "43*86400 -> 6wk"); - t.is (formatSecondsCompact ( 44*86400), "6wk", "44*86400 -> 6wk"); - t.is (formatSecondsCompact ( 45*86400), "6wk", "45*86400 -> 6wk"); - t.is (formatSecondsCompact ( 46*86400), "6wk", "46*86400 -> 6wk"); - t.is (formatSecondsCompact ( 47*86400), "6wk", "47*86400 -> 6wk"); - t.is (formatSecondsCompact ( 48*86400), "6wk", "48*86400 -> 6wk"); - t.is (formatSecondsCompact ( 49*86400), "7wk", "49*86400 -> 7wk"); - t.is (formatSecondsCompact ( 50*86400), "7wk", "50*86400 -> 7wk"); - - t.is (formatSecondsCompact ( 51*86400), "7wk", "51*86400 -> 7wk"); - t.is (formatSecondsCompact ( 52*86400), "7wk", "52*86400 -> 7wk"); - t.is (formatSecondsCompact ( 53*86400), "7wk", "53*86400 -> 7wk"); - t.is (formatSecondsCompact ( 54*86400), "7wk", "54*86400 -> 7wk"); - t.is (formatSecondsCompact ( 55*86400), "7wk", "55*86400 -> 7wk"); - t.is (formatSecondsCompact ( 56*86400), "8wk", "56*86400 -> 8wk"); - t.is (formatSecondsCompact ( 57*86400), "8wk", "57*86400 -> 8wk"); - t.is (formatSecondsCompact ( 58*86400), "8wk", "58*86400 -> 8wk"); - t.is (formatSecondsCompact ( 59*86400), "8wk", "59*86400 -> 8wk"); - t.is (formatSecondsCompact ( 60*86400), "8wk", "60*86400 -> 8wk"); - - t.is (formatSecondsCompact ( 61*86400), "8wk", "61*86400 -> 8wk"); - t.is (formatSecondsCompact ( 62*86400), "8wk", "62*86400 -> 8wk"); - t.is (formatSecondsCompact ( 63*86400), "9wk", "63*86400 -> 9wk"); - t.is (formatSecondsCompact ( 64*86400), "9wk", "64*86400 -> 9wk"); - t.is (formatSecondsCompact ( 65*86400), "9wk", "65*86400 -> 9wk"); - t.is (formatSecondsCompact ( 66*86400), "9wk", "66*86400 -> 9wk"); - t.is (formatSecondsCompact ( 67*86400), "9wk", "67*86400 -> 9wk"); - t.is (formatSecondsCompact ( 68*86400), "9wk", "68*86400 -> 9wk"); - t.is (formatSecondsCompact ( 69*86400), "9wk", "69*86400 -> 9wk"); - t.is (formatSecondsCompact ( 70*86400), "10wk", "70*86400 -> 10wk"); - - t.is (formatSecondsCompact ( 71*86400), "10wk", "71*86400 -> 10wk"); - t.is (formatSecondsCompact ( 72*86400), "10wk", "72*86400 -> 10wk"); - t.is (formatSecondsCompact ( 73*86400), "10wk", "73*86400 -> 10wk"); - t.is (formatSecondsCompact ( 74*86400), "10wk", "74*86400 -> 10wk"); - t.is (formatSecondsCompact ( 75*86400), "10wk", "75*86400 -> 10wk"); - t.is (formatSecondsCompact ( 76*86400), "10wk", "76*86400 -> 10wk"); - t.is (formatSecondsCompact ( 77*86400), "11wk", "77*86400 -> 11wk"); - t.is (formatSecondsCompact ( 78*86400), "11wk", "78*86400 -> 11wk"); - t.is (formatSecondsCompact ( 79*86400), "11wk", "79*86400 -> 11wk"); - t.is (formatSecondsCompact ( 80*86400), "11wk", "80*86400 -> 11wk"); - - t.is (formatSecondsCompact ( 81*86400), "11wk", "81*86400 -> 11wk"); - t.is (formatSecondsCompact ( 82*86400), "11wk", "82*86400 -> 11wk"); - t.is (formatSecondsCompact ( 83*86400), "11wk", "83*86400 -> 11wk"); - t.is (formatSecondsCompact ( 84*86400), "2mo", "84*86400 -> 2mo"); - t.is (formatSecondsCompact ( 85*86400), "2mo", "85*86400 -> 2mo"); - t.is (formatSecondsCompact ( 86*86400), "2mo", "86*86400 -> 2mo"); - t.is (formatSecondsCompact ( 87*86400), "2mo", "87*86400 -> 2mo"); - t.is (formatSecondsCompact ( 88*86400), "2mo", "88*86400 -> 2mo"); - t.is (formatSecondsCompact ( 89*86400), "2mo", "89*86400 -> 2mo"); - t.is (formatSecondsCompact ( 90*86400), "2mo", "90*86400 -> 2mo"); - - t.is (formatSecondsCompact ( 91*86400), "2mo", "91*86400 -> 2mo"); - t.is (formatSecondsCompact ( 92*86400), "3mo", "92*86400 -> 3mo"); - t.is (formatSecondsCompact ( 93*86400), "3mo", "93*86400 -> 3mo"); - t.is (formatSecondsCompact ( 94*86400), "3mo", "94*86400 -> 3mo"); - t.is (formatSecondsCompact ( 95*86400), "3mo", "95*86400 -> 3mo"); - t.is (formatSecondsCompact ( 96*86400), "3mo", "96*86400 -> 3mo"); - t.is (formatSecondsCompact ( 97*86400), "3mo", "97*86400 -> 3mo"); - t.is (formatSecondsCompact ( 98*86400), "3mo", "98*86400 -> 3mo"); - t.is (formatSecondsCompact ( 99*86400), "3mo", "99*86400 -> 3mo"); - t.is (formatSecondsCompact (100*86400), "3mo", "100*86400 -> 3mo"); - - t.is (formatSecondsCompact (101*86400), "3mo", "101*86400 -> 3mo"); - t.is (formatSecondsCompact (102*86400), "3mo", "102*86400 -> 3mo"); - t.is (formatSecondsCompact (103*86400), "3mo", "103*86400 -> 3mo"); - t.is (formatSecondsCompact (104*86400), "3mo", "104*86400 -> 3mo"); - t.is (formatSecondsCompact (105*86400), "3mo", "105*86400 -> 3mo"); - t.is (formatSecondsCompact (106*86400), "3mo", "106*86400 -> 3mo"); - t.is (formatSecondsCompact (107*86400), "3mo", "107*86400 -> 3mo"); - t.is (formatSecondsCompact (108*86400), "3mo", "108*86400 -> 3mo"); - t.is (formatSecondsCompact (109*86400), "3mo", "109*86400 -> 3mo"); - t.is (formatSecondsCompact (110*86400), "3mo", "110*86400 -> 3mo"); - - t.is (formatSecondsCompact (111*86400), "3mo", "111*86400 -> 3mo"); - t.is (formatSecondsCompact (112*86400), "3mo", "112*86400 -> 3mo"); - t.is (formatSecondsCompact (113*86400), "3mo", "113*86400 -> 3mo"); - t.is (formatSecondsCompact (114*86400), "3mo", "114*86400 -> 3mo"); - t.is (formatSecondsCompact (115*86400), "3mo", "115*86400 -> 3mo"); - t.is (formatSecondsCompact (116*86400), "3mo", "116*86400 -> 3mo"); - t.is (formatSecondsCompact (117*86400), "3mo", "117*86400 -> 3mo"); - t.is (formatSecondsCompact (118*86400), "3mo", "118*86400 -> 3mo"); - t.is (formatSecondsCompact (119*86400), "3mo", "119*86400 -> 3mo"); - t.is (formatSecondsCompact (120*86400), "3mo", "120*86400 -> 3mo"); - - t.is (formatSecondsCompact (121*86400), "3mo", "121*86400 -> 3mo"); - t.is (formatSecondsCompact (122*86400), "3mo", "122*86400 -> 3mo"); - t.is (formatSecondsCompact (123*86400), "4mo", "123*86400 -> 4mo"); - t.is (formatSecondsCompact (124*86400), "4mo", "124*86400 -> 4mo"); - t.is (formatSecondsCompact (125*86400), "4mo", "125*86400 -> 4mo"); - t.is (formatSecondsCompact (126*86400), "4mo", "126*86400 -> 4mo"); - t.is (formatSecondsCompact (127*86400), "4mo", "127*86400 -> 4mo"); - t.is (formatSecondsCompact (128*86400), "4mo", "128*86400 -> 4mo"); - t.is (formatSecondsCompact (129*86400), "4mo", "129*86400 -> 4mo"); - t.is (formatSecondsCompact (130*86400), "4mo", "130*86400 -> 4mo"); - - t.is (formatSecondsCompact (131*86400), "4mo", "131*86400 -> 4mo"); - t.is (formatSecondsCompact (132*86400), "4mo", "132*86400 -> 4mo"); - t.is (formatSecondsCompact (133*86400), "4mo", "133*86400 -> 4mo"); - t.is (formatSecondsCompact (134*86400), "4mo", "134*86400 -> 4mo"); - t.is (formatSecondsCompact (135*86400), "4mo", "135*86400 -> 4mo"); - t.is (formatSecondsCompact (136*86400), "4mo", "136*86400 -> 4mo"); - t.is (formatSecondsCompact (137*86400), "4mo", "137*86400 -> 4mo"); - t.is (formatSecondsCompact (138*86400), "4mo", "138*86400 -> 4mo"); - t.is (formatSecondsCompact (139*86400), "4mo", "139*86400 -> 4mo"); - t.is (formatSecondsCompact (140*86400), "4mo", "140*86400 -> 4mo"); - - t.is (formatSecondsCompact (141*86400), "4mo", "141*86400 -> 4mo"); - t.is (formatSecondsCompact (142*86400), "4mo", "142*86400 -> 4mo"); - t.is (formatSecondsCompact (143*86400), "4mo", "143*86400 -> 4mo"); - t.is (formatSecondsCompact (144*86400), "4mo", "144*86400 -> 4mo"); - t.is (formatSecondsCompact (145*86400), "4mo", "145*86400 -> 4mo"); - t.is (formatSecondsCompact (146*86400), "4mo", "146*86400 -> 4mo"); - t.is (formatSecondsCompact (147*86400), "4mo", "147*86400 -> 4mo"); - t.is (formatSecondsCompact (148*86400), "4mo", "148*86400 -> 4mo"); - t.is (formatSecondsCompact (149*86400), "4mo", "149*86400 -> 4mo"); - t.is (formatSecondsCompact (150*86400), "4mo", "150*86400 -> 4mo"); - - t.is (formatSecondsCompact (151*86400), "4mo", "151*86400 -> 4mo"); - t.is (formatSecondsCompact (152*86400), "4mo", "152*86400 -> 4mo"); - t.is (formatSecondsCompact (153*86400), "5mo", "153*86400 -> 5mo"); - t.is (formatSecondsCompact (154*86400), "5mo", "154*86400 -> 5mo"); - t.is (formatSecondsCompact (155*86400), "5mo", "155*86400 -> 5mo"); - t.is (formatSecondsCompact (156*86400), "5mo", "156*86400 -> 5mo"); - t.is (formatSecondsCompact (157*86400), "5mo", "157*86400 -> 5mo"); - t.is (formatSecondsCompact (158*86400), "5mo", "158*86400 -> 5mo"); - t.is (formatSecondsCompact (159*86400), "5mo", "159*86400 -> 5mo"); - t.is (formatSecondsCompact (160*86400), "5mo", "160*86400 -> 5mo"); - - t.is (formatSecondsCompact (161*86400), "5mo", "161*86400 -> 5mo"); - t.is (formatSecondsCompact (162*86400), "5mo", "162*86400 -> 5mo"); - t.is (formatSecondsCompact (163*86400), "5mo", "163*86400 -> 5mo"); - t.is (formatSecondsCompact (164*86400), "5mo", "164*86400 -> 5mo"); - t.is (formatSecondsCompact (165*86400), "5mo", "165*86400 -> 5mo"); - t.is (formatSecondsCompact (166*86400), "5mo", "166*86400 -> 5mo"); - t.is (formatSecondsCompact (167*86400), "5mo", "167*86400 -> 5mo"); - t.is (formatSecondsCompact (168*86400), "5mo", "168*86400 -> 5mo"); - t.is (formatSecondsCompact (169*86400), "5mo", "169*86400 -> 5mo"); - t.is (formatSecondsCompact (170*86400), "5mo", "170*86400 -> 5mo"); - - t.is (formatSecondsCompact (171*86400), "5mo", "171*86400 -> 5mo"); - t.is (formatSecondsCompact (172*86400), "5mo", "172*86400 -> 5mo"); - t.is (formatSecondsCompact (173*86400), "5mo", "173*86400 -> 5mo"); - t.is (formatSecondsCompact (174*86400), "5mo", "174*86400 -> 5mo"); - t.is (formatSecondsCompact (175*86400), "5mo", "175*86400 -> 5mo"); - t.is (formatSecondsCompact (176*86400), "5mo", "176*86400 -> 5mo"); - t.is (formatSecondsCompact (177*86400), "5mo", "177*86400 -> 5mo"); - t.is (formatSecondsCompact (178*86400), "5mo", "178*86400 -> 5mo"); - t.is (formatSecondsCompact (179*86400), "5mo", "179*86400 -> 5mo"); - t.is (formatSecondsCompact (180*86400), "5mo", "180*86400 -> 5mo"); - - t.is (formatSecondsCompact (181*86400), "5mo", "181*86400 -> 5mo"); - t.is (formatSecondsCompact (182*86400), "5mo", "182*86400 -> 5mo"); - t.is (formatSecondsCompact (183*86400), "5mo", "183*86400 -> 5mo"); - t.is (formatSecondsCompact (184*86400), "6mo", "184*86400 -> 6mo"); - t.is (formatSecondsCompact (185*86400), "6mo", "185*86400 -> 6mo"); - t.is (formatSecondsCompact (186*86400), "6mo", "186*86400 -> 6mo"); - t.is (formatSecondsCompact (187*86400), "6mo", "187*86400 -> 6mo"); - t.is (formatSecondsCompact (188*86400), "6mo", "188*86400 -> 6mo"); - t.is (formatSecondsCompact (189*86400), "6mo", "189*86400 -> 6mo"); - t.is (formatSecondsCompact (190*86400), "6mo", "190*86400 -> 6mo"); - - t.is (formatSecondsCompact (191*86400), "6mo", "191*86400 -> 6mo"); - t.is (formatSecondsCompact (192*86400), "6mo", "192*86400 -> 6mo"); - t.is (formatSecondsCompact (193*86400), "6mo", "193*86400 -> 6mo"); - t.is (formatSecondsCompact (194*86400), "6mo", "194*86400 -> 6mo"); - t.is (formatSecondsCompact (195*86400), "6mo", "195*86400 -> 6mo"); - t.is (formatSecondsCompact (196*86400), "6mo", "196*86400 -> 6mo"); - t.is (formatSecondsCompact (197*86400), "6mo", "197*86400 -> 6mo"); - t.is (formatSecondsCompact (198*86400), "6mo", "198*86400 -> 6mo"); - t.is (formatSecondsCompact (199*86400), "6mo", "199*86400 -> 6mo"); - t.is (formatSecondsCompact (200*86400), "6mo", "200*86400 -> 6mo"); - - t.is (formatSecondsCompact (201*86400), "6mo", "201*86400 -> 6mo"); - t.is (formatSecondsCompact (202*86400), "6mo", "202*86400 -> 6mo"); - t.is (formatSecondsCompact (203*86400), "6mo", "203*86400 -> 6mo"); - t.is (formatSecondsCompact (204*86400), "6mo", "204*86400 -> 6mo"); - t.is (formatSecondsCompact (205*86400), "6mo", "205*86400 -> 6mo"); - t.is (formatSecondsCompact (206*86400), "6mo", "206*86400 -> 6mo"); - t.is (formatSecondsCompact (207*86400), "6mo", "207*86400 -> 6mo"); - t.is (formatSecondsCompact (208*86400), "6mo", "208*86400 -> 6mo"); - t.is (formatSecondsCompact (209*86400), "6mo", "209*86400 -> 6mo"); - t.is (formatSecondsCompact (210*86400), "6mo", "210*86400 -> 6mo"); - - t.is (formatSecondsCompact (211*86400), "6mo", "211*86400 -> 6mo"); - t.is (formatSecondsCompact (212*86400), "6mo", "212*86400 -> 6mo"); - t.is (formatSecondsCompact (213*86400), "6mo", "213*86400 -> 6mo"); - t.is (formatSecondsCompact (214*86400), "6mo", "214*86400 -> 6mo"); - t.is (formatSecondsCompact (215*86400), "7mo", "215*86400 -> 7mo"); - t.is (formatSecondsCompact (216*86400), "7mo", "216*86400 -> 7mo"); - t.is (formatSecondsCompact (217*86400), "7mo", "217*86400 -> 7mo"); - t.is (formatSecondsCompact (218*86400), "7mo", "218*86400 -> 7mo"); - t.is (formatSecondsCompact (219*86400), "7mo", "219*86400 -> 7mo"); - t.is (formatSecondsCompact (220*86400), "7mo", "220*86400 -> 7mo"); - - t.is (formatSecondsCompact (221*86400), "7mo", "221*86400 -> 7mo"); - t.is (formatSecondsCompact (222*86400), "7mo", "222*86400 -> 7mo"); - t.is (formatSecondsCompact (223*86400), "7mo", "223*86400 -> 7mo"); - t.is (formatSecondsCompact (224*86400), "7mo", "224*86400 -> 7mo"); - t.is (formatSecondsCompact (225*86400), "7mo", "225*86400 -> 7mo"); - t.is (formatSecondsCompact (226*86400), "7mo", "226*86400 -> 7mo"); - t.is (formatSecondsCompact (227*86400), "7mo", "227*86400 -> 7mo"); - t.is (formatSecondsCompact (228*86400), "7mo", "228*86400 -> 7mo"); - t.is (formatSecondsCompact (229*86400), "7mo", "229*86400 -> 7mo"); - t.is (formatSecondsCompact (230*86400), "7mo", "230*86400 -> 7mo"); - - t.is (formatSecondsCompact (231*86400), "7mo", "231*86400 -> 7mo"); - t.is (formatSecondsCompact (232*86400), "7mo", "232*86400 -> 7mo"); - t.is (formatSecondsCompact (233*86400), "7mo", "233*86400 -> 7mo"); - t.is (formatSecondsCompact (234*86400), "7mo", "234*86400 -> 7mo"); - t.is (formatSecondsCompact (235*86400), "7mo", "235*86400 -> 7mo"); - t.is (formatSecondsCompact (236*86400), "7mo", "236*86400 -> 7mo"); - t.is (formatSecondsCompact (237*86400), "7mo", "237*86400 -> 7mo"); - t.is (formatSecondsCompact (238*86400), "7mo", "238*86400 -> 7mo"); - t.is (formatSecondsCompact (239*86400), "7mo", "239*86400 -> 7mo"); - t.is (formatSecondsCompact (240*86400), "7mo", "240*86400 -> 7mo"); - - t.is (formatSecondsCompact (241*86400), "7mo", "241*86400 -> 7mo"); - t.is (formatSecondsCompact (242*86400), "7mo", "242*86400 -> 7mo"); - t.is (formatSecondsCompact (243*86400), "7mo", "243*86400 -> 7mo"); - t.is (formatSecondsCompact (244*86400), "7mo", "244*86400 -> 7mo"); - t.is (formatSecondsCompact (245*86400), "8mo", "245*86400 -> 8mo"); - t.is (formatSecondsCompact (246*86400), "8mo", "246*86400 -> 8mo"); - t.is (formatSecondsCompact (247*86400), "8mo", "247*86400 -> 8mo"); - t.is (formatSecondsCompact (248*86400), "8mo", "248*86400 -> 8mo"); - t.is (formatSecondsCompact (249*86400), "8mo", "249*86400 -> 8mo"); - t.is (formatSecondsCompact (250*86400), "8mo", "250*86400 -> 8mo"); - - t.is (formatSecondsCompact (251*86400), "8mo", "251*86400 -> 8mo"); - t.is (formatSecondsCompact (252*86400), "8mo", "252*86400 -> 8mo"); - t.is (formatSecondsCompact (253*86400), "8mo", "253*86400 -> 8mo"); - t.is (formatSecondsCompact (254*86400), "8mo", "254*86400 -> 8mo"); - t.is (formatSecondsCompact (255*86400), "8mo", "255*86400 -> 8mo"); - t.is (formatSecondsCompact (256*86400), "8mo", "256*86400 -> 8mo"); - t.is (formatSecondsCompact (257*86400), "8mo", "257*86400 -> 8mo"); - t.is (formatSecondsCompact (258*86400), "8mo", "258*86400 -> 8mo"); - t.is (formatSecondsCompact (259*86400), "8mo", "259*86400 -> 8mo"); - t.is (formatSecondsCompact (260*86400), "8mo", "260*86400 -> 8mo"); - - t.is (formatSecondsCompact (261*86400), "8mo", "261*86400 -> 8mo"); - t.is (formatSecondsCompact (262*86400), "8mo", "262*86400 -> 8mo"); - t.is (formatSecondsCompact (263*86400), "8mo", "263*86400 -> 8mo"); - t.is (formatSecondsCompact (264*86400), "8mo", "264*86400 -> 8mo"); - t.is (formatSecondsCompact (265*86400), "8mo", "265*86400 -> 8mo"); - t.is (formatSecondsCompact (266*86400), "8mo", "266*86400 -> 8mo"); - t.is (formatSecondsCompact (267*86400), "8mo", "267*86400 -> 8mo"); - t.is (formatSecondsCompact (268*86400), "8mo", "268*86400 -> 8mo"); - t.is (formatSecondsCompact (269*86400), "8mo", "269*86400 -> 8mo"); - t.is (formatSecondsCompact (270*86400), "8mo", "270*86400 -> 8mo"); - - t.is (formatSecondsCompact (271*86400), "8mo", "271*86400 -> 8mo"); - t.is (formatSecondsCompact (272*86400), "8mo", "272*86400 -> 8mo"); - t.is (formatSecondsCompact (273*86400), "8mo", "273*86400 -> 8mo"); - t.is (formatSecondsCompact (274*86400), "8mo", "274*86400 -> 8mo"); - t.is (formatSecondsCompact (275*86400), "8mo", "275*86400 -> 8mo"); - t.is (formatSecondsCompact (276*86400), "9mo", "276*86400 -> 9mo"); - t.is (formatSecondsCompact (277*86400), "9mo", "277*86400 -> 9mo"); - t.is (formatSecondsCompact (278*86400), "9mo", "278*86400 -> 9mo"); - t.is (formatSecondsCompact (279*86400), "9mo", "279*86400 -> 9mo"); - t.is (formatSecondsCompact (280*86400), "9mo", "280*86400 -> 9mo"); - - t.is (formatSecondsCompact (281*86400), "9mo", "281*86400 -> 9mo"); - t.is (formatSecondsCompact (282*86400), "9mo", "282*86400 -> 9mo"); - t.is (formatSecondsCompact (283*86400), "9mo", "283*86400 -> 9mo"); - t.is (formatSecondsCompact (284*86400), "9mo", "284*86400 -> 9mo"); - t.is (formatSecondsCompact (285*86400), "9mo", "285*86400 -> 9mo"); - t.is (formatSecondsCompact (286*86400), "9mo", "286*86400 -> 9mo"); - t.is (formatSecondsCompact (287*86400), "9mo", "287*86400 -> 9mo"); - t.is (formatSecondsCompact (288*86400), "9mo", "288*86400 -> 9mo"); - t.is (formatSecondsCompact (289*86400), "9mo", "289*86400 -> 9mo"); - t.is (formatSecondsCompact (290*86400), "9mo", "290*86400 -> 9mo"); - - t.is (formatSecondsCompact (291*86400), "9mo", "291*86400 -> 9mo"); - t.is (formatSecondsCompact (292*86400), "9mo", "292*86400 -> 9mo"); - t.is (formatSecondsCompact (293*86400), "9mo", "293*86400 -> 9mo"); - t.is (formatSecondsCompact (294*86400), "9mo", "294*86400 -> 9mo"); - t.is (formatSecondsCompact (295*86400), "9mo", "295*86400 -> 9mo"); - t.is (formatSecondsCompact (296*86400), "9mo", "296*86400 -> 9mo"); - t.is (formatSecondsCompact (297*86400), "9mo", "297*86400 -> 9mo"); - t.is (formatSecondsCompact (298*86400), "9mo", "298*86400 -> 9mo"); - t.is (formatSecondsCompact (299*86400), "9mo", "299*86400 -> 9mo"); - t.is (formatSecondsCompact (300*86400), "9mo", "300*86400 -> 9mo"); - - t.is (formatSecondsCompact (301*86400), "9mo", "301*86400 -> 9mo"); - t.is (formatSecondsCompact (302*86400), "9mo", "302*86400 -> 9mo"); - t.is (formatSecondsCompact (303*86400), "9mo", "303*86400 -> 9mo"); - t.is (formatSecondsCompact (304*86400), "9mo", "304*86400 -> 9mo"); - t.is (formatSecondsCompact (305*86400), "9mo", "305*86400 -> 9mo"); - t.is (formatSecondsCompact (306*86400), "10mo", "306*86400 -> 10mo"); - t.is (formatSecondsCompact (307*86400), "10mo", "307*86400 -> 10mo"); - t.is (formatSecondsCompact (308*86400), "10mo", "308*86400 -> 10mo"); - t.is (formatSecondsCompact (309*86400), "10mo", "309*86400 -> 10mo"); - t.is (formatSecondsCompact (310*86400), "10mo", "310*86400 -> 10mo"); - - t.is (formatSecondsCompact (311*86400), "10mo", "311*86400 -> 10mo"); - t.is (formatSecondsCompact (312*86400), "10mo", "312*86400 -> 10mo"); - t.is (formatSecondsCompact (313*86400), "10mo", "313*86400 -> 10mo"); - t.is (formatSecondsCompact (314*86400), "10mo", "314*86400 -> 10mo"); - t.is (formatSecondsCompact (315*86400), "10mo", "315*86400 -> 10mo"); - t.is (formatSecondsCompact (316*86400), "10mo", "316*86400 -> 10mo"); - t.is (formatSecondsCompact (317*86400), "10mo", "317*86400 -> 10mo"); - t.is (formatSecondsCompact (318*86400), "10mo", "318*86400 -> 10mo"); - t.is (formatSecondsCompact (319*86400), "10mo", "319*86400 -> 10mo"); - t.is (formatSecondsCompact (320*86400), "10mo", "320*86400 -> 10mo"); - - t.is (formatSecondsCompact (321*86400), "10mo", "321*86400 -> 10mo"); - t.is (formatSecondsCompact (322*86400), "10mo", "322*86400 -> 10mo"); - t.is (formatSecondsCompact (323*86400), "10mo", "323*86400 -> 10mo"); - t.is (formatSecondsCompact (324*86400), "10mo", "324*86400 -> 10mo"); - t.is (formatSecondsCompact (325*86400), "10mo", "325*86400 -> 10mo"); - t.is (formatSecondsCompact (326*86400), "10mo", "326*86400 -> 10mo"); - t.is (formatSecondsCompact (327*86400), "10mo", "327*86400 -> 10mo"); - t.is (formatSecondsCompact (328*86400), "10mo", "328*86400 -> 10mo"); - t.is (formatSecondsCompact (329*86400), "10mo", "329*86400 -> 10mo"); - t.is (formatSecondsCompact (330*86400), "10mo", "330*86400 -> 10mo"); - - t.is (formatSecondsCompact (331*86400), "10mo", "331*86400 -> 10mo"); - t.is (formatSecondsCompact (332*86400), "10mo", "332*86400 -> 10mo"); - t.is (formatSecondsCompact (333*86400), "10mo", "333*86400 -> 10mo"); - t.is (formatSecondsCompact (334*86400), "10mo", "334*86400 -> 10mo"); - t.is (formatSecondsCompact (335*86400), "10mo", "335*86400 -> 10mo"); - t.is (formatSecondsCompact (336*86400), "10mo", "336*86400 -> 10mo"); - t.is (formatSecondsCompact (337*86400), "11mo", "337*86400 -> 11mo"); - t.is (formatSecondsCompact (338*86400), "11mo", "338*86400 -> 11mo"); - t.is (formatSecondsCompact (339*86400), "11mo", "339*86400 -> 11mo"); - t.is (formatSecondsCompact (340*86400), "11mo", "340*86400 -> 11mo"); - - t.is (formatSecondsCompact (341*86400), "11mo", "341*86400 -> 11mo"); - t.is (formatSecondsCompact (342*86400), "11mo", "342*86400 -> 11mo"); - t.is (formatSecondsCompact (343*86400), "11mo", "343*86400 -> 11mo"); - t.is (formatSecondsCompact (344*86400), "11mo", "344*86400 -> 11mo"); - t.is (formatSecondsCompact (345*86400), "11mo", "345*86400 -> 11mo"); - t.is (formatSecondsCompact (346*86400), "11mo", "346*86400 -> 11mo"); - t.is (formatSecondsCompact (347*86400), "11mo", "347*86400 -> 11mo"); - t.is (formatSecondsCompact (348*86400), "11mo", "348*86400 -> 11mo"); - t.is (formatSecondsCompact (349*86400), "11mo", "349*86400 -> 11mo"); - t.is (formatSecondsCompact (350*86400), "11mo", "350*86400 -> 11mo"); - - t.is (formatSecondsCompact (351*86400), "11mo", "351*86400 -> 11mo"); - t.is (formatSecondsCompact (352*86400), "11mo", "352*86400 -> 11mo"); - t.is (formatSecondsCompact (353*86400), "11mo", "353*86400 -> 11mo"); - t.is (formatSecondsCompact (354*86400), "11mo", "354*86400 -> 11mo"); - t.is (formatSecondsCompact (355*86400), "11mo", "355*86400 -> 11mo"); - t.is (formatSecondsCompact (356*86400), "11mo", "356*86400 -> 11mo"); - t.is (formatSecondsCompact (357*86400), "11mo", "357*86400 -> 11mo"); - t.is (formatSecondsCompact (358*86400), "11mo", "358*86400 -> 11mo"); - t.is (formatSecondsCompact (359*86400), "11mo", "359*86400 -> 11mo"); - t.is (formatSecondsCompact (360*86400), "11mo", "360*86400 -> 11mo"); - - t.is (formatSecondsCompact (361*86400), "11mo", "361*86400 -> 11mo"); - t.is (formatSecondsCompact (362*86400), "11mo", "362*86400 -> 11mo"); - t.is (formatSecondsCompact (363*86400), "11mo", "363*86400 -> 11mo"); - t.is (formatSecondsCompact (364*86400), "11mo", "364*86400 -> 11mo"); - t.is (formatSecondsCompact (365*86400), "1.0y", "365*86400 -> 1.0y"); - // std::string formatBytes (size_t); t.is (formatBytes (0), "0 B", "0 -> 0 B"); diff --git a/src/util.cpp b/src/util.cpp index a10e9289c..75c659a68 100644 --- a/src/util.cpp +++ b/src/util.cpp @@ -157,64 +157,6 @@ void delay (float f) select (0, NULL, NULL, NULL, &t); } -//////////////////////////////////////////////////////////////////////////////// -// Convert a quantity in seconds to a more readable format. -std::string formatSeconds (time_t delta) -{ - char formatted[24]; - float days = (float) delta / 86400.0; - - if (delta >= 86400 * 365) - sprintf (formatted, "%.1f yrs", (days / 365)); // TODO i18n - else if (delta > 86400 * 84) - sprintf (formatted, "%1d mth%s", // TODO i18n - (int) (float) (days / 30.6), - ((int) (float) (days / 30.6) == 1 ? "" : "s")); // TODO i18n - else if (delta > 86400 * 13) - sprintf (formatted, "%d wk%s", // TODO i18n - (int) (float) (days / 7.0), - ((int) (float) (days / 7.0) == 1 ? "" : "s")); // TODO i18n - else if (delta >= 86400) - sprintf (formatted, "%d day%s", // TODO i18n - (int) days, - ((int) days == 1 ? "" : "s")); // TODO i18n - else if (delta >= 3600) - sprintf (formatted, "%d hr%s", // TODO i18n - (int) (float) (delta / 3600), - ((int) (float) (delta / 3600) == 1 ? "" : "s")); // TODO i18n - else if (delta >= 60) - sprintf (formatted, "%d min%s", // TODO i18n - (int) (float) (delta / 60), - ((int) (float) (delta / 60) == 1 ? "" : "s")); // TODO i18n - else if (delta >= 1) - sprintf (formatted, "%d sec%s", // TODO i18n - (int) delta, - ((int) delta == 1 ? "" : "s")); // TODO i18n - else - strcpy (formatted, "-"); // no i18n - - return std::string (formatted); -} - -//////////////////////////////////////////////////////////////////////////////// -// Convert a quantity in seconds to a more readable format. -std::string formatSecondsCompact (time_t delta) -{ - char formatted[24]; - float days = (float) delta / 86400.0; - - if (delta >= 86400 * 365) sprintf (formatted, "%.1fy", (days / 365)); // TODO i18n - else if (delta >= 86400 * 84) sprintf (formatted, "%1dmo", (int) (float) (days / 30.6)); // TODO i18n - else if (delta >= 86400 * 13) sprintf (formatted, "%dwk", (int) (float) (days / 7.0)); // TODO i18n - else if (delta >= 86400) sprintf (formatted, "%dd", (int) days); // TODO i18n - else if (delta >= 3600) sprintf (formatted, "%dh", (int) (float) (delta / 3600)); // TODO i18n - else if (delta >= 60) sprintf (formatted, "%dm", (int) (float) (delta / 60)); // TODO i18n - else if (delta >= 1) sprintf (formatted, "%ds", (int) delta); // TODO i18n - else strcpy (formatted, "-"); - - return std::string (formatted); -} - //////////////////////////////////////////////////////////////////////////////// // Convert a quantity in seconds to a more readable format. std::string formatBytes (size_t bytes) diff --git a/src/util.h b/src/util.h index 50fef817e..4819ec9f0 100644 --- a/src/util.h +++ b/src/util.h @@ -55,8 +55,6 @@ bool confirm (const std::string&); int confirm3 (const std::string&); int confirm4 (const std::string&); void delay (float); -std::string formatSeconds (time_t); -std::string formatSecondsCompact (time_t); std::string formatBytes (size_t); int autoComplete (const std::string&, const std::vector&, std::vector&); const std::string uuid ();