GothenburgBitFactory/timewarrior
1
0
Fork 0
mirror of https://github.com/GothenburgBitFactory/timewarrior.git synced 2025-06-26 10:54:28 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Interval: Now has pubic ::range, which has public ::start, ::end

Browse source
This commit is contained in:
Paul Beckingham 2016-04-23 10:35:06 -04:00
parent 7fe116f75a
commit 63a6255412
17 changed files with 413 additions and 506 deletions
Download patch file Download diff file Expand all files Collapse all files

26
src/Database.cpp
View file

@ -112,18 +112,18 @@ void Database::addInterval (const Interval& interval)
// Unless the tags that overlap are allowed to overlap.
validateAddition (interval);
auto intervalRange = interval.range ();
auto intervalRange = interval.range;
for (auto& segment : segmentRange (intervalRange))
{
// Get the index into _files for the appropriate Datafile, which may be
// created on demand.
auto df = getDatafile (segment.start ().year (), segment.start ().month ());
auto df = getDatafile (segment.start.year (), segment.start.month ());
// Intersect the original interval range, and the segment.
Interval segmentedInterval (interval);
segmentedInterval.range (intervalRange.intersect (segment));
if (! interval.isEnded ())
segmentedInterval.end ({0});
segmentedInterval.range = intervalRange.intersect (segment);
if (! interval.range.ended ())
segmentedInterval.range.end = Datetime (0);
_files[df].addInterval (segmentedInterval);
}
@ -132,18 +132,18 @@ void Database::addInterval (const Interval& interval)
////////////////////////////////////////////////////////////////////////////////
void Database::deleteInterval (const Interval& interval)
{
auto intervalRange = interval.range ();
auto intervalRange = interval.range;
for (auto& segment : segmentRange (intervalRange))
{
// Get the index into _files for the appropriate Datafile, which may be
// created on demand.
auto df = getDatafile (segment.start ().year (), segment.start ().month ());
auto df = getDatafile (segment.start.year (), segment.start.month ());
// Intersect the original interval range, and the segment.
Interval segmentedInterval (interval);
segmentedInterval.range (intervalRange.intersect (segment));
if (! interval.isEnded ())
segmentedInterval.end ({0});
segmentedInterval.range = intervalRange.intersect (segment);
if (! interval.range.ended ())
segmentedInterval.range.end = Datetime (0);
_files[df].deleteInterval (segmentedInterval);
}
@ -218,10 +218,10 @@ std::vector <Range> Database::segmentRange (const Range& range)
{
std::vector <Range> segments;
auto start_y = range.start ().year ();
auto start_m = range.start ().month ();
auto start_y = range.start.year ();
auto start_m = range.start.month ();
auto end = range.end ();
auto end = range.end;
if (end.toEpoch () == 0)
end = Datetime ();

8
src/Datafile.cpp
View file

@ -103,7 +103,7 @@ void Datafile::addInterval (const Interval& interval)
{
// Return false if the interval does not belong in this file.
// Note: end date might be zero.
if (_range.overlap (interval.range ()))
if (_range.overlap (interval.range))
{
if (! _lines_loaded)
load_lines ();
@ -125,7 +125,7 @@ void Datafile::deleteInterval (const Interval& interval)
{
// Return false if the interval does not belong in this file.
// Note: end date might be zero.
if (_range.overlap (interval.range ()))
if (_range.overlap (interval.range))
{
if (! _lines_loaded)
load_lines ();
@ -174,8 +174,8 @@ std::string Datafile::dump () const
<< " lines: " << _lines.size () << "\n"
<< " loaded " << (_lines_loaded ? "true" : "false") << "\n"
<< " exclusions: " << _exclusions.size () << "\n"
<< " range: " << _range.start ().toISO () << " - "
<< _range.end ().toISO () << "\n";
<< " range: " << _range.start.toISO () << " - "
<< _range.end.toISO () << "\n";
return out.str ();
}

4
src/Exclusion.cpp
View file

@ -112,8 +112,8 @@ std::vector <Range> Exclusion::ranges (const Range& range) const
else if ((dayOfWeek = Datetime::dayOfWeek (_tokens[1])) != -1)
{
Datetime start = range.start ();
while (start < range.end ())
Datetime start = range.start;
while (start < range.end)
{
if (start.dayOfWeek () == dayOfWeek)
{

78
src/Interval.cpp
View file

@ -53,7 +53,7 @@ void Interval::initialize (const std::string& line)
if (tokens.size () > 1 &&
tokens[1].length () == 16)
{
_range.start (Datetime (tokens[1]));
range.start = Datetime (tokens[1]);
offset = 1;
// Optional '-' <iso>
@ -61,7 +61,7 @@ void Interval::initialize (const std::string& line)
tokens[2] == "-" &&
tokens[3].length () == 16)
{
_range.end (Datetime (tokens[3]));
range.end = Datetime (tokens[3]);
offset = 3;
}
}
@ -84,59 +84,11 @@ void Interval::initialize (const std::string& line)
////////////////////////////////////////////////////////////////////////////////
bool Interval::empty () const
{
return _range.start ().toEpoch () == 0 &&
_range.end ().toEpoch () == 0 &&
return range.start.toEpoch () == 0 &&
range.end.toEpoch () == 0 &&
_tags.size () == 0;
}
////////////////////////////////////////////////////////////////////////////////
Range Interval::range () const
{
return _range;
}
////////////////////////////////////////////////////////////////////////////////
void Interval::range (const Range& range)
{
_range = range;
}
////////////////////////////////////////////////////////////////////////////////
Datetime Interval::start () const
{
return _range.start ();
}
////////////////////////////////////////////////////////////////////////////////
void Interval::start (const Datetime& value)
{
_range.start (value);
}
////////////////////////////////////////////////////////////////////////////////
Datetime Interval::end () const
{
return _range.end ();
}
////////////////////////////////////////////////////////////////////////////////
void Interval::end (const Datetime& value)
{
_range.end (value);
}
////////////////////////////////////////////////////////////////////////////////
bool Interval::isStarted () const
{
return _range.isStarted ();
}
////////////////////////////////////////////////////////////////////////////////
bool Interval::isEnded () const
{
return _range.isEnded ();
}
////////////////////////////////////////////////////////////////////////////////
bool Interval::hasTag (const std::string& tag) const
{
@ -168,11 +120,11 @@ std::string Interval::serialize () const
std::stringstream out;
out << "inc";
if (_range.start ().toEpoch ())
out << " " << _range.start ().toISO ();
if (range.start.toEpoch ())
out << " " << range.start.toISO ();
if (_range.end ().toEpoch ())
out << " - " << _range.end ().toISO ();
if (range.end.toEpoch ())
out << " - " << range.end.toISO ();
if (_tags.size ())
{
@ -190,14 +142,14 @@ std::string Interval::json () const
std::stringstream out;
out << '{';
if (_range.isStarted ())
out << "\"start\":\"" << _range.start ().toISO () << "\"";
if (range.started ())
out << "\"start\":\"" << range.start.toISO () << "\"";
if (_range.isEnded ())
if (range.ended ())
{
if (_range.isStarted ())
if (range.started ())
out << ',';
out << "\"end\":\"" << _range.end ().toISO () << "\"";
out << "\"end\":\"" << range.end.toISO () << "\"";
}
if (_tags.size ())
@ -211,8 +163,8 @@ std::string Interval::json () const
tags += "\"" + tag + "\"";
}
if (_range.start ().toEpoch () ||
_range.end ().toEpoch ())
if (range.start.toEpoch () ||
range.end.toEpoch ())
out << ',';
out << "\"tags\":["

16
src/Interval.h
View file

@ -38,18 +38,6 @@ public:
void initialize (const std::string&);
bool empty () const;
Range range () const;
void range (const Range&);
Datetime start () const;
void start (const Datetime&);
Datetime end () const;
void end (const Datetime&);
bool isStarted () const;
bool isEnded () const;
bool hasTag (const std::string&) const;
std::set <std::string> tags () const;
void tag (const std::string&);
@ -58,8 +46,10 @@ public:
std::string serialize () const;
std::string json () const;
public:
Range range {};
private:
Range _range {};
std::set <std::string> _tags {};
};

91
src/Range.cpp
View file

@ -34,53 +34,29 @@
//
// [start, end)
//
Range::Range (const Datetime& start, const Datetime& end)
Range::Range (const Datetime& start_value, const Datetime& end_value)
{
_start = start;
_end = end;
start = start_value;
end = end_value;
}
////////////////////////////////////////////////////////////////////////////////
bool Range::operator== (const Range& other) const
{
return _start == other._start &&
_end == other._end;
return start == other.start &&
end == other.end;
}
////////////////////////////////////////////////////////////////////////////////
Datetime Range::start () const
bool Range::started () const
{
return _start;
return start.toEpoch () > 0;
}
////////////////////////////////////////////////////////////////////////////////
void Range::start (const Datetime& value)
bool Range::ended () const
{
_start = value;
}
////////////////////////////////////////////////////////////////////////////////
Datetime Range::end () const
{
return _end;
}
////////////////////////////////////////////////////////////////////////////////
void Range::end (const Datetime& value)
{
_end = value;
}
////////////////////////////////////////////////////////////////////////////////
bool Range::isStarted () const
{
return _start.toEpoch () > 0;
}
////////////////////////////////////////////////////////////////////////////////
bool Range::isEnded () const
{
return _end.toEpoch () > 0;
return end.toEpoch () > 0;
}
////////////////////////////////////////////////////////////////////////////////
@ -110,18 +86,15 @@ bool Range::isEnded () const
//
bool Range::overlap (const Range& other) const
{
if (! isStarted () ||
! other.isStarted ())
if (! started () || ! other.started ())
return false;
// Other range ends before this range starts.
if (other.isEnded () &&
other.end () < start ())
if (other.ended () && other.end < start)
return false;
// Other range starts after this range ends.
if (isEnded () &&
other.start () >= end ())
if (ended () && other.start >= end)
return false;
return true;
@ -159,20 +132,20 @@ Range Range::intersect (const Range& other) const
if (overlap (other))
{
// Intersection is choosing the later of the two starts, and the earlier of
// the two ends, of two overlapping ranges.
result.start (start () > other.start () ? start () : other.start ());
// the two ends, provided the two ranges overlap.
result.start = start > other.start ? start : other.start;
if (isEnded ())
if (ended ())
{
if (other.isEnded ())
result.end (end () < other.end () ? end () : other.end ());
if (other.ended ())
result.end = end < other.end ? end : other.end;
else
result.end (end ());
result.end = end;
}
else
{
if (other.isEnded ())
result.end (other.end ());
if (other.ended ())
result.end = other.end;
}
}
@ -210,28 +183,28 @@ std::vector <Range> Range::subtract (const Range& other) const
if (overlap (other))
{
if (start () < other.start ())
if (start < other.start)
{
results.push_back (Range (start (), other.start ()));
results.push_back (Range (start, other.start));
if (other.isEnded () &&
(! isEnded () || end () > other.end ()))
if (other.ended () &&
(! ended () || end > other.end))
{
results.push_back (Range (other.end (), end ()));
results.push_back (Range (other.end, end));
}
}
else
{
if (other.isEnded ())
if (other.ended ())
{
if (isEnded ())
if (ended ())
{
if (end () > other.end ())
results.push_back (Range (other.end (), end ()));
if (end > other.end)
results.push_back (Range (other.end, end));
}
else
{
results.push_back (Range (other.end (), end ()));
results.push_back (Range (other.end, end));
}
}
}
@ -251,9 +224,9 @@ std::string Range::dump () const
{
std::stringstream out;
out << "Range "
<< (_start.toEpoch () ? _start.toISOLocalExtended () : "n/a")
<< (start.toEpoch () ? start.toISOLocalExtended () : "n/a")
<< " - "
<< (_end.toEpoch () ? _end.toISOLocalExtended () : "n/a");
<< (end.toEpoch () ? end.toISOLocalExtended () : "n/a");
return out.str ();
}

16
src/Range.h
View file

@ -37,23 +37,17 @@ public:
Range (const Datetime&, const Datetime&);
bool operator== (const Range&) const;
Datetime start () const;
void start (const Datetime&);
Datetime end () const;
void end (const Datetime&);
bool isStarted () const;
bool isEnded () const;
bool started () const;
bool ended () const;
bool overlap (const Range&) const;
Range intersect (const Range&) const;
std::vector <Range> subtract (const Range&) const;
std::string dump () const;
private:
Datetime _start {0};
Datetime _end {0};
public:
Datetime start {0};
Datetime end {0};
};
#endif

8
src/Timeline.cpp
View file

@ -73,8 +73,8 @@ std::vector <Interval> Timeline::tracked (Rules& rules) const
// Create a range representing the whole timeline.
// If no range is defined, then assume the full range of all the inclusions.
Range overallRange {_range};
if (! overallRange.isStarted () &&
! overallRange.isEnded ())
if (! overallRange.started () &&
! overallRange.ended ())
overallRange = overallRangeFromIntervals (_inclusions);
// Cobmine all the non-trackable time.
@ -83,7 +83,7 @@ std::vector <Interval> Timeline::tracked (Rules& rules) const
std::vector <Interval> combined;
for (auto& interval : _inclusions)
{
std::vector <Range> intervalFragments {interval.range ()};
std::vector <Range> intervalFragments {interval.range};
for (auto& exclusion : nonTrackable)
{
@ -99,7 +99,7 @@ std::vector <Interval> Timeline::tracked (Rules& rules) const
{
// Clone the interval, set the new range.
Interval clipped {interval};
clipped.range (fragment);
clipped.range = fragment;
combined.push_back (clipped);
}
}

8
src/commands/CmdContinue.cpp
View file

@ -37,12 +37,12 @@ int CmdContinue (
auto latest = getLatestInterval (database);
if (! latest.empty ())
{
if (latest.isStarted () &&
latest.isEnded ())
if (latest.range.started () &&
latest.range.ended ())
{
// Open an identical interval.
latest.start ({});
latest.end ({0});
latest.range.start = Datetime ();
latest.range.end = Datetime (0);
// Update database.
database.addInterval (latest);

2
src/commands/CmdDefault.cpp
View file

@ -37,7 +37,7 @@ int CmdDefault (Rules& rules, Database& database)
// Load the most recent interval, summarize and display.
auto interval = getLatestInterval (database);
if (interval.isStarted () && ! interval.isEnded ())
if (interval.range.started () && ! interval.range.ended ())
{
if (rules.getBoolean ("verbose"))
std::cout << intervalSummarize (rules, interval);

4
src/commands/CmdReport.cpp
View file

@ -84,8 +84,8 @@ int CmdReport (
auto intervals = timeline.tracked (rules);
// Compose Header info.
rules.set ("temp.report.start", filter.range ().start ().toEpoch () > 0 ? filter.range ().start ().toISO () : "");
rules.set ("temp.report.end", filter.range ().end ().toEpoch () > 0 ? filter.range ().end ().toISO () : "");
rules.set ("temp.report.start", filter.range.start.toEpoch () > 0 ? filter.range.start.toISO () : "");
rules.set ("temp.report.end", filter.range.end.toEpoch () > 0 ? filter.range.end.toISO () : "");
std::string combinedTags;
for (auto& tag : filter.tags ())
{

9
src/commands/CmdStart.cpp
View file

@ -40,13 +40,12 @@ int CmdStart (
auto latest = getLatestInterval (database);
// If the latest interval is open, close it.
if ( latest.isStarted () &&
! latest.isEnded ())
if ( latest.range.started () &&
! latest.range.ended ())
{
// Stop it.
Interval modified {latest};
Datetime now;
modified.end (now);
modified.range.end = Datetime ();
// Update database.
database.modifyInterval (latest, modified);
@ -58,7 +57,7 @@ int CmdStart (
// Create a new interval.
Interval now;
now.start (Datetime ());
now.range.start = Datetime ();
// Apply tags.
auto words = cli.getWords ();

11
src/commands/CmdStop.cpp
View file

@ -41,13 +41,12 @@ int CmdStop (
auto latest = getLatestInterval (database);
// Verify the interval is open.
if ( latest.isStarted () &&
! latest.isEnded ())
if ( latest.range.started () &&
! latest.range.ended ())
{
// Stop it.
Interval modified {latest};
Datetime now;
modified.end (now);
modified.range.end = Datetime ();
database.modifyInterval (latest, modified);
// User feedback.
@ -65,8 +64,8 @@ int CmdStop (
latest.tags ().size ())
{
// Contiguous with previous interval.
latest.start (modified.end ());
latest.end ({0});
latest.range.start = modified.range.end;
latest.range.end = Datetime (0);
database.addInterval (latest);

78
src/helper.cpp
View file

@ -51,7 +51,7 @@ Color tagColor (const Rules& rules, const std::string& tag)
std::string intervalSummarize (const Rules& rules, const Interval& interval)
{
std::stringstream out;
if (interval.isStarted ())
if (interval.range.started ())
{
// Combine and colorize tags.
std::string tags;
@ -64,21 +64,21 @@ std::string intervalSummarize (const Rules& rules, const Interval& interval)
}
// Interval closed.
if (interval.isEnded ())
if (interval.range.ended ())
{
Duration dur (Datetime (interval.end ()) - Datetime (interval.start ()));
Duration dur (Datetime (interval.range.end) - Datetime (interval.range.start));
out << "Recorded " << tags << "\n"
<< " Started " << interval.start ().toISOLocalExtended () << "\n"
<< " Ended " << interval.end ().toISOLocalExtended () << "\n"
<< " Started " << interval.range.start.toISOLocalExtended () << "\n"
<< " Ended " << interval.range.end.toISOLocalExtended () << "\n"
<< " Elapsed " << std::setw (19) << std::setfill (' ') << dur.format () << "\n";
}
// Interval open.
else
{
Duration dur (Datetime () - interval.start ());
Duration dur (Datetime () - interval.range.start);
out << "Tracking " << tags << "\n"
<< " Started " << interval.start ().toISOLocalExtended () << "\n";
<< " Started " << interval.range.start.toISOLocalExtended () << "\n";
if (dur.toTime_t () > 10)
out << " Elapsed " << std::setw (19) << std::setfill (' ') << dur.format () << "\n";
@ -182,8 +182,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
if (args.size () == 1 &&
args[0] == "<date>")
{
range.start (Datetime (start));
range.end (Datetime ("now"));
range.start = Datetime (start);
range.end = Datetime ("now");
}
// from <date>
@ -191,8 +191,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[0] == "from" &&
args[1] == "<date>")
{
range.start (Datetime (start));
range.end (Datetime ("now"));
range.start = Datetime (start);
range.end = Datetime ("now");
}
// <date> to/- <date>
@ -201,8 +201,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
(args[1] == "to" || args[1] == "-") &&
args[2] == "<date>")
{
range.start (Datetime (start));
range.end (Datetime (end));
range.start = Datetime (start);
range.end = Datetime (end);
}
// from/since <date> to/- <date>
@ -212,8 +212,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
(args[2] == "to" || args[2] == "-") &&
args[3] == "<date>")
{
range.start (Datetime (start));
range.end (Datetime (end));
range.start = Datetime (start);
range.end = Datetime (end);
}
// <date> for <duration>
@ -222,8 +222,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[1] == "for" &&
args[2] == "<duration>")
{
range.start (Datetime (start));
range.end (Datetime (start) + Duration (duration).toTime_t ());
range.start = Datetime (start);
range.end = Datetime (start) + Duration (duration).toTime_t ();
}
// from/since <date> for <duration>
@ -233,8 +233,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[2] == "for" &&
args[3] == "<duration>")
{
range.start (Datetime (start));
range.end (Datetime (start) + Duration (duration).toTime_t ());
range.start = Datetime (start);
range.end = Datetime (start) + Duration (duration).toTime_t ();
}
// <duration> before <date>
@ -243,8 +243,8 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[1] == "before" &&
args[2] == "<date>")
{
range.start (Datetime (start) - Duration (duration).toTime_t ());
range.end (Datetime (start));
range.start = Datetime (start) - Duration (duration).toTime_t ();
range.end = Datetime (start);
}
// <duration> after <date>
@ -253,16 +253,16 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
args[1] == "after" &&
args[2] == "<date>")
{
range.start (Datetime (start));
range.end (Datetime (start) + Duration (duration).toTime_t ());
range.start = Datetime (start);
range.end = Datetime (start) + Duration (duration).toTime_t ();
}
// <duration>
else if (args.size () == 1 &&
args[0] == "<duration>")
{
range.start (Datetime ("now") - Duration (duration).toTime_t ());
range.end (Datetime ("now"));
range.start = Datetime ("now") - Duration (duration).toTime_t ();
range.end = Datetime ("now");
}
// Unrecognized date range construct.
@ -271,7 +271,7 @@ Interval createFilterIntervalFromCLI (const CLI& cli)
throw std::string ("Unrecognized date range: '") + join (" ", args) + "'.";
}
filter.range (range);
filter.range = range;
return filter;
}
@ -296,7 +296,7 @@ Timeline createTimelineFromData (
const Interval& filter)
{
Timeline t;
t.range (filter.range ());
t.range (filter.range);
// Add filtered intervals.
for (auto& line : database.allLines ())
@ -340,13 +340,13 @@ Interval getLatestInterval (Database& database)
// filter interval tags are found in the interval.
bool intervalMatchesFilterInterval (const Interval& interval, const Interval& filter)
{
if ((filter.start ().toEpoch () == 0 &&
filter.end ().toEpoch () == 0)
if ((filter.range.start.toEpoch () == 0 &&
filter.range.end.toEpoch () == 0)
||
(interval.end () > filter.start () &&
interval.start () < filter.end ()))
(interval.range.end > filter.range.start &&
interval.range.start < filter.range.end))
{
for (auto& tag : filter.tags ())
if (! interval.hasTag (tag))
@ -404,9 +404,9 @@ std::vector <Range> rangesFromHolidays (const Rules& rules)
{
Range r;
Datetime d (holiday.substr (lastDot + 1), "Y_M_D");
r.start (d);
r.start = d;
++d;
r.end (d);
r.end = d;
results.push_back (r);
}
}
@ -463,15 +463,15 @@ Range overallRangeFromIntervals (const std::vector <Interval>& intervals)
for (auto& interval : intervals)
{
if (interval.start () < overall.start () || overall.start ().toEpoch () == 0)
overall.start (interval.start ());
if (interval.range.start < overall.start || overall.start.toEpoch () == 0)
overall.start = interval.range.start;
// Deliberately mixed start/end.
if (interval.start () > overall.end ())
overall.end (interval.start ());
if (interval.range.start > overall.end)
overall.end = interval.range.start;
if (interval.end () > overall.end ())
overall.end (interval.end ());
if (interval.range.end > overall.end)
overall.end = interval.range.end;
}
return overall;

380
test/exclusion.t.cpp
View file

@ -63,33 +63,33 @@ int main (int, char**)
auto ranges = e.ranges (r);
t.ok (ranges.size () == 12, "Exclusion ranges --> [12]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-21T00:00:00", "Exclusion range[0].start() --> 2015-12-21T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-21T08:00:00", "Exclusion range[0].end() --> 2015-12-21T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-21T12:00:00", "Exclusion range[1].start() --> 2015-12-21T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-21T12:45:00", "Exclusion range[1].end() --> 2015-12-21T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-21T17:30:00", "Exclusion range[2].start() --> 2015-12-21T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-22T00:00:00", "Exclusion range[2].end() --> 2015-12-22T00:00:00");
t.is (ranges[0].start.toISOLocalExtended (), "2015-12-21T00:00:00", "Exclusion range[0].start() --> 2015-12-21T00:00:00");
t.is (ranges[0].end.toISOLocalExtended (), "2015-12-21T08:00:00", "Exclusion range[0].end() --> 2015-12-21T08:00:00");
t.is (ranges[1].start.toISOLocalExtended (), "2015-12-21T12:00:00", "Exclusion range[1].start() --> 2015-12-21T12:00:00");
t.is (ranges[1].end.toISOLocalExtended (), "2015-12-21T12:45:00", "Exclusion range[1].end() --> 2015-12-21T12:45:00");
t.is (ranges[2].start.toISOLocalExtended (), "2015-12-21T17:30:00", "Exclusion range[2].start() --> 2015-12-21T17:30:00");
t.is (ranges[2].end.toISOLocalExtended (), "2015-12-22T00:00:00", "Exclusion range[2].end() --> 2015-12-22T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-28T00:00:00", "Exclusion range[3].start() --> 2015-12-28T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-28T08:00:00", "Exclusion range[3].end() --> 2015-12-28T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-28T12:00:00", "Exclusion range[4].start() --> 2015-12-28T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-28T12:45:00", "Exclusion range[4].end() --> 2015-12-28T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-28T17:30:00", "Exclusion range[5].start() --> 2015-12-28T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-29T00:00:00", "Exclusion range[5].end() --> 2015-12-29T00:00:00");
t.is (ranges[3].start.toISOLocalExtended (), "2015-12-28T00:00:00", "Exclusion range[3].start() --> 2015-12-28T00:00:00");
t.is (ranges[3].end.toISOLocalExtended (), "2015-12-28T08:00:00", "Exclusion range[3].end() --> 2015-12-28T08:00:00");
t.is (ranges[4].start.toISOLocalExtended (), "2015-12-28T12:00:00", "Exclusion range[4].start() --> 2015-12-28T12:00:00");
t.is (ranges[4].end.toISOLocalExtended (), "2015-12-28T12:45:00", "Exclusion range[4].end() --> 2015-12-28T12:45:00");
t.is (ranges[5].start.toISOLocalExtended (), "2015-12-28T17:30:00", "Exclusion range[5].start() --> 2015-12-28T17:30:00");
t.is (ranges[5].end.toISOLocalExtended (), "2015-12-29T00:00:00", "Exclusion range[5].end() --> 2015-12-29T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2016-01-04T00:00:00", "Exclusion range[6].start() --> 2016-01-04T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2016-01-04T08:00:00", "Exclusion range[6].end() --> 2016-01-04T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2016-01-04T12:00:00", "Exclusion range[7].start() --> 2016-01-04T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2016-01-04T12:45:00", "Exclusion range[7].end() --> 2016-01-04T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2016-01-04T17:30:00", "Exclusion range[8].start() --> 2016-01-04T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-05T00:00:00", "Exclusion range[8].end() --> 2016-01-05T00:00:00");
t.is (ranges[6].start.toISOLocalExtended (), "2016-01-04T00:00:00", "Exclusion range[6].start() --> 2016-01-04T00:00:00");
t.is (ranges[6].end.toISOLocalExtended (), "2016-01-04T08:00:00", "Exclusion range[6].end() --> 2016-01-04T08:00:00");
t.is (ranges[7].start.toISOLocalExtended (), "2016-01-04T12:00:00", "Exclusion range[7].start() --> 2016-01-04T12:00:00");
t.is (ranges[7].end.toISOLocalExtended (), "2016-01-04T12:45:00", "Exclusion range[7].end() --> 2016-01-04T12:45:00");
t.is (ranges[8].start.toISOLocalExtended (), "2016-01-04T17:30:00", "Exclusion range[8].start() --> 2016-01-04T17:30:00");
t.is (ranges[8].end.toISOLocalExtended (), "2016-01-05T00:00:00", "Exclusion range[8].end() --> 2016-01-05T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-11T00:00:00", "Exclusion range[9].start() --> 2016-01-11T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-11T08:00:00", "Exclusion range[9].end() --> 2016-01-11T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-11T12:00:00", "Exclusion range[10].start() --> 2016-01-11T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-11T12:45:00", "Exclusion range[10].end() --> 2016-01-11T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-11T17:30:00", "Exclusion range[11].start() --> 2016-01-11T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-12T00:00:00", "Exclusion range[11].end() --> 2016-01-12T00:00:00");
t.is (ranges[9].start.toISOLocalExtended (), "2016-01-11T00:00:00", "Exclusion range[9].start() --> 2016-01-11T00:00:00");
t.is (ranges[9].end.toISOLocalExtended (), "2016-01-11T08:00:00", "Exclusion range[9].end() --> 2016-01-11T08:00:00");
t.is (ranges[10].start.toISOLocalExtended (), "2016-01-11T12:00:00", "Exclusion range[10].start() --> 2016-01-11T12:00:00");
t.is (ranges[10].end.toISOLocalExtended (), "2016-01-11T12:45:00", "Exclusion range[10].end() --> 2016-01-11T12:45:00");
t.is (ranges[11].start.toISOLocalExtended (), "2016-01-11T17:30:00", "Exclusion range[11].start() --> 2016-01-11T17:30:00");
t.is (ranges[11].end.toISOLocalExtended (), "2016-01-12T00:00:00", "Exclusion range[11].end() --> 2016-01-12T00:00:00");
e.initialize ("exc tuesday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens ();
@ -102,40 +102,40 @@ int main (int, char**)
ranges = e.ranges (r);
t.ok (ranges.size () == 15, "Exclusion ranges --> [15]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-15T00:00:00", "Exclusion range[0].start() --> 2015-12-15T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-15T08:00:00", "Exclusion range[0].end() --> 2015-12-15T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-15T12:00:00", "Exclusion range[1].start() --> 2015-12-15T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-15T12:45:00", "Exclusion range[1].end() --> 2015-12-15T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-15T17:30:00", "Exclusion range[2].start() --> 2015-12-15T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-16T00:00:00", "Exclusion range[2].end() --> 2015-12-16T00:00:00");
t.is (ranges[0].start.toISOLocalExtended (), "2015-12-15T00:00:00", "Exclusion range[0].start() --> 2015-12-15T00:00:00");
t.is (ranges[0].end.toISOLocalExtended (), "2015-12-15T08:00:00", "Exclusion range[0].end() --> 2015-12-15T08:00:00");
t.is (ranges[1].start.toISOLocalExtended (), "2015-12-15T12:00:00", "Exclusion range[1].start() --> 2015-12-15T12:00:00");
t.is (ranges[1].end.toISOLocalExtended (), "2015-12-15T12:45:00", "Exclusion range[1].end() --> 2015-12-15T12:45:00");
t.is (ranges[2].start.toISOLocalExtended (), "2015-12-15T17:30:00", "Exclusion range[2].start() --> 2015-12-15T17:30:00");
t.is (ranges[2].end.toISOLocalExtended (), "2015-12-16T00:00:00", "Exclusion range[2].end() --> 2015-12-16T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-22T00:00:00", "Exclusion range[3].start() --> 2015-12-22T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-22T08:00:00", "Exclusion range[3].end() --> 2015-12-22T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-22T12:00:00", "Exclusion range[4].start() --> 2015-12-22T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-22T12:45:00", "Exclusion range[4].end() --> 2015-12-22T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-22T17:30:00", "Exclusion range[5].start() --> 2015-12-22T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-23T00:00:00", "Exclusion range[5].end() --> 2015-12-23T00:00:00");
t.is (ranges[3].start.toISOLocalExtended (), "2015-12-22T00:00:00", "Exclusion range[3].start() --> 2015-12-22T00:00:00");
t.is (ranges[3].end.toISOLocalExtended (), "2015-12-22T08:00:00", "Exclusion range[3].end() --> 2015-12-22T08:00:00");
t.is (ranges[4].start.toISOLocalExtended (), "2015-12-22T12:00:00", "Exclusion range[4].start() --> 2015-12-22T12:00:00");
t.is (ranges[4].end.toISOLocalExtended (), "2015-12-22T12:45:00", "Exclusion range[4].end() --> 2015-12-22T12:45:00");
t.is (ranges[5].start.toISOLocalExtended (), "2015-12-22T17:30:00", "Exclusion range[5].start() --> 2015-12-22T17:30:00");
t.is (ranges[5].end.toISOLocalExtended (), "2015-12-23T00:00:00", "Exclusion range[5].end() --> 2015-12-23T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2015-12-29T00:00:00", "Exclusion range[6].start() --> 2015-12-29T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2015-12-29T08:00:00", "Exclusion range[6].end() --> 2015-12-29T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2015-12-29T12:00:00", "Exclusion range[7].start() --> 2015-12-29T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2015-12-29T12:45:00", "Exclusion range[7].end() --> 2015-12-29T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2015-12-29T17:30:00", "Exclusion range[8].start() --> 2015-12-29T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2015-12-30T00:00:00", "Exclusion range[8].end() --> 2015-12-30T00:00:00");
t.is (ranges[6].start.toISOLocalExtended (), "2015-12-29T00:00:00", "Exclusion range[6].start() --> 2015-12-29T00:00:00");
t.is (ranges[6].end.toISOLocalExtended (), "2015-12-29T08:00:00", "Exclusion range[6].end() --> 2015-12-29T08:00:00");
t.is (ranges[7].start.toISOLocalExtended (), "2015-12-29T12:00:00", "Exclusion range[7].start() --> 2015-12-29T12:00:00");
t.is (ranges[7].end.toISOLocalExtended (), "2015-12-29T12:45:00", "Exclusion range[7].end() --> 2015-12-29T12:45:00");
t.is (ranges[8].start.toISOLocalExtended (), "2015-12-29T17:30:00", "Exclusion range[8].start() --> 2015-12-29T17:30:00");
t.is (ranges[8].end.toISOLocalExtended (), "2015-12-30T00:00:00", "Exclusion range[8].end() --> 2015-12-30T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-05T00:00:00", "Exclusion range[9].start() --> 2016-01-05T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-05T08:00:00", "Exclusion range[9].end() --> 2016-01-05T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-05T12:00:00", "Exclusion range[10].start() --> 2016-01-05T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-05T12:45:00", "Exclusion range[10].end() --> 2016-01-05T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-05T17:30:00", "Exclusion range[11].start() --> 2016-01-05T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-06T00:00:00", "Exclusion range[11].end() --> 2016-01-06T00:00:00");
t.is (ranges[9].start.toISOLocalExtended (), "2016-01-05T00:00:00", "Exclusion range[9].start() --> 2016-01-05T00:00:00");
t.is (ranges[9].end.toISOLocalExtended (), "2016-01-05T08:00:00", "Exclusion range[9].end() --> 2016-01-05T08:00:00");
t.is (ranges[10].start.toISOLocalExtended (), "2016-01-05T12:00:00", "Exclusion range[10].start() --> 2016-01-05T12:00:00");
t.is (ranges[10].end.toISOLocalExtended (), "2016-01-05T12:45:00", "Exclusion range[10].end() --> 2016-01-05T12:45:00");
t.is (ranges[11].start.toISOLocalExtended (), "2016-01-05T17:30:00", "Exclusion range[11].start() --> 2016-01-05T17:30:00");
t.is (ranges[11].end.toISOLocalExtended (), "2016-01-06T00:00:00", "Exclusion range[11].end() --> 2016-01-06T00:00:00");
t.is (ranges[12].start ().toISOLocalExtended (), "2016-01-12T00:00:00", "Exclusion range[12].start() --> 2016-01-12T00:00:00");
t.is (ranges[12].end ().toISOLocalExtended (), "2016-01-12T08:00:00", "Exclusion range[12].end() --> 2016-01-12T08:00:00");
t.is (ranges[13].start ().toISOLocalExtended (), "2016-01-12T12:00:00", "Exclusion range[13].start() --> 2016-01-12T12:00:00");
t.is (ranges[13].end ().toISOLocalExtended (), "2016-01-12T12:45:00", "Exclusion range[13].end() --> 2016-01-12T12:45:00");
t.is (ranges[14].start ().toISOLocalExtended (), "2016-01-12T17:30:00", "Exclusion range[14].start() --> 2016-01-12T17:30:00");
t.is (ranges[14].end ().toISOLocalExtended (), "2016-01-13T00:00:00", "Exclusion range[14].end() --> 2016-01-13T00:00:00");
t.is (ranges[12].start.toISOLocalExtended (), "2016-01-12T00:00:00", "Exclusion range[12].start() --> 2016-01-12T00:00:00");
t.is (ranges[12].end.toISOLocalExtended (), "2016-01-12T08:00:00", "Exclusion range[12].end() --> 2016-01-12T08:00:00");
t.is (ranges[13].start.toISOLocalExtended (), "2016-01-12T12:00:00", "Exclusion range[13].start() --> 2016-01-12T12:00:00");
t.is (ranges[13].end.toISOLocalExtended (), "2016-01-12T12:45:00", "Exclusion range[13].end() --> 2016-01-12T12:45:00");
t.is (ranges[14].start.toISOLocalExtended (), "2016-01-12T17:30:00", "Exclusion range[14].start() --> 2016-01-12T17:30:00");
t.is (ranges[14].end.toISOLocalExtended (), "2016-01-13T00:00:00", "Exclusion range[14].end() --> 2016-01-13T00:00:00");
e.initialize ("exc wednesday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens ();
@ -148,40 +148,40 @@ int main (int, char**)
ranges = e.ranges (r);
t.ok (ranges.size () == 15, "Exclusion ranges --> [15]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-16T00:00:00", "Exclusion range[0].start() --> 2015-12-16T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-16T08:00:00", "Exclusion range[0].end() --> 2015-12-16T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-16T12:00:00", "Exclusion range[1].start() --> 2015-12-16T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-16T12:45:00", "Exclusion range[1].end() --> 2015-12-16T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-16T17:30:00", "Exclusion range[2].start() --> 2015-12-16T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-17T00:00:00", "Exclusion range[2].end() --> 2015-12-17T00:00:00");
t.is (ranges[0].start.toISOLocalExtended (), "2015-12-16T00:00:00", "Exclusion range[0].start() --> 2015-12-16T00:00:00");
t.is (ranges[0].end.toISOLocalExtended (), "2015-12-16T08:00:00", "Exclusion range[0].end() --> 2015-12-16T08:00:00");
t.is (ranges[1].start.toISOLocalExtended (), "2015-12-16T12:00:00", "Exclusion range[1].start() --> 2015-12-16T12:00:00");
t.is (ranges[1].end.toISOLocalExtended (), "2015-12-16T12:45:00", "Exclusion range[1].end() --> 2015-12-16T12:45:00");
t.is (ranges[2].start.toISOLocalExtended (), "2015-12-16T17:30:00", "Exclusion range[2].start() --> 2015-12-16T17:30:00");
t.is (ranges[2].end.toISOLocalExtended (), "2015-12-17T00:00:00", "Exclusion range[2].end() --> 2015-12-17T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-23T00:00:00", "Exclusion range[3].start() --> 2015-12-23T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-23T08:00:00", "Exclusion range[3].end() --> 2015-12-23T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-23T12:00:00", "Exclusion range[4].start() --> 2015-12-23T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-23T12:45:00", "Exclusion range[4].end() --> 2015-12-23T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-23T17:30:00", "Exclusion range[5].start() --> 2015-12-23T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-24T00:00:00", "Exclusion range[5].end() --> 2015-12-24T00:00:00");
t.is (ranges[3].start.toISOLocalExtended (), "2015-12-23T00:00:00", "Exclusion range[3].start() --> 2015-12-23T00:00:00");
t.is (ranges[3].end.toISOLocalExtended (), "2015-12-23T08:00:00", "Exclusion range[3].end() --> 2015-12-23T08:00:00");
t.is (ranges[4].start.toISOLocalExtended (), "2015-12-23T12:00:00", "Exclusion range[4].start() --> 2015-12-23T12:00:00");
t.is (ranges[4].end.toISOLocalExtended (), "2015-12-23T12:45:00", "Exclusion range[4].end() --> 2015-12-23T12:45:00");
t.is (ranges[5].start.toISOLocalExtended (), "2015-12-23T17:30:00", "Exclusion range[5].start() --> 2015-12-23T17:30:00");
t.is (ranges[5].end.toISOLocalExtended (), "2015-12-24T00:00:00", "Exclusion range[5].end() --> 2015-12-24T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2015-12-30T00:00:00", "Exclusion range[6].start() --> 2015-12-30T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2015-12-30T08:00:00", "Exclusion range[6].end() --> 2015-12-30T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2015-12-30T12:00:00", "Exclusion range[7].start() --> 2015-12-30T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2015-12-30T12:45:00", "Exclusion range[7].end() --> 2015-12-30T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2015-12-30T17:30:00", "Exclusion range[8].start() --> 2015-12-30T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2015-12-31T00:00:00", "Exclusion range[8].end() --> 2015-12-31T00:00:00");
t.is (ranges[6].start.toISOLocalExtended (), "2015-12-30T00:00:00", "Exclusion range[6].start() --> 2015-12-30T00:00:00");
t.is (ranges[6].end.toISOLocalExtended (), "2015-12-30T08:00:00", "Exclusion range[6].end() --> 2015-12-30T08:00:00");
t.is (ranges[7].start.toISOLocalExtended (), "2015-12-30T12:00:00", "Exclusion range[7].start() --> 2015-12-30T12:00:00");
t.is (ranges[7].end.toISOLocalExtended (), "2015-12-30T12:45:00", "Exclusion range[7].end() --> 2015-12-30T12:45:00");
t.is (ranges[8].start.toISOLocalExtended (), "2015-12-30T17:30:00", "Exclusion range[8].start() --> 2015-12-30T17:30:00");
t.is (ranges[8].end.toISOLocalExtended (), "2015-12-31T00:00:00", "Exclusion range[8].end() --> 2015-12-31T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-06T00:00:00", "Exclusion range[9].start() --> 2016-01-06T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-06T08:00:00", "Exclusion range[9].end() --> 2016-01-06T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-06T12:00:00", "Exclusion range[10].start() --> 2016-01-06T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-06T12:45:00", "Exclusion range[10].end() --> 2016-01-06T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-06T17:30:00", "Exclusion range[11].start() --> 2016-01-06T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-07T00:00:00", "Exclusion range[11].end() --> 2016-01-07T00:00:00");
t.is (ranges[9].start.toISOLocalExtended (), "2016-01-06T00:00:00", "Exclusion range[9].start() --> 2016-01-06T00:00:00");
t.is (ranges[9].end.toISOLocalExtended (), "2016-01-06T08:00:00", "Exclusion range[9].end() --> 2016-01-06T08:00:00");
t.is (ranges[10].start.toISOLocalExtended (), "2016-01-06T12:00:00", "Exclusion range[10].start() --> 2016-01-06T12:00:00");
t.is (ranges[10].end.toISOLocalExtended (), "2016-01-06T12:45:00", "Exclusion range[10].end() --> 2016-01-06T12:45:00");
t.is (ranges[11].start.toISOLocalExtended (), "2016-01-06T17:30:00", "Exclusion range[11].start() --> 2016-01-06T17:30:00");
t.is (ranges[11].end.toISOLocalExtended (), "2016-01-07T00:00:00", "Exclusion range[11].end() --> 2016-01-07T00:00:00");
t.is (ranges[12].start ().toISOLocalExtended (), "2016-01-13T00:00:00", "Exclusion range[12].start() --> 2016-01-13T00:00:00");
t.is (ranges[12].end ().toISOLocalExtended (), "2016-01-13T08:00:00", "Exclusion range[12].end() --> 2016-01-13T08:00:00");
t.is (ranges[13].start ().toISOLocalExtended (), "2016-01-13T12:00:00", "Exclusion range[13].start() --> 2016-01-13T12:00:00");
t.is (ranges[13].end ().toISOLocalExtended (), "2016-01-13T12:45:00", "Exclusion range[13].end() --> 2016-01-13T12:45:00");
t.is (ranges[14].start ().toISOLocalExtended (), "2016-01-13T17:30:00", "Exclusion range[14].start() --> 2016-01-13T17:30:00");
t.is (ranges[14].end ().toISOLocalExtended (), "2016-01-14T00:00:00", "Exclusion range[14].end() --> 2016-01-14T00:00:00");
t.is (ranges[12].start.toISOLocalExtended (), "2016-01-13T00:00:00", "Exclusion range[12].start() --> 2016-01-13T00:00:00");
t.is (ranges[12].end.toISOLocalExtended (), "2016-01-13T08:00:00", "Exclusion range[12].end() --> 2016-01-13T08:00:00");
t.is (ranges[13].start.toISOLocalExtended (), "2016-01-13T12:00:00", "Exclusion range[13].start() --> 2016-01-13T12:00:00");
t.is (ranges[13].end.toISOLocalExtended (), "2016-01-13T12:45:00", "Exclusion range[13].end() --> 2016-01-13T12:45:00");
t.is (ranges[14].start.toISOLocalExtended (), "2016-01-13T17:30:00", "Exclusion range[14].start() --> 2016-01-13T17:30:00");
t.is (ranges[14].end.toISOLocalExtended (), "2016-01-14T00:00:00", "Exclusion range[14].end() --> 2016-01-14T00:00:00");
e.initialize ("exc thursday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens ();
@ -194,40 +194,40 @@ int main (int, char**)
ranges = e.ranges (r);
t.ok (ranges.size () == 15, "Exclusion ranges --> [15]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-17T00:00:00", "Exclusion range[0].start() --> 2015-12-17T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-17T08:00:00", "Exclusion range[0].end() --> 2015-12-17T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-17T12:00:00", "Exclusion range[1].start() --> 2015-12-17T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-17T12:45:00", "Exclusion range[1].end() --> 2015-12-17T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-17T17:30:00", "Exclusion range[2].start() --> 2015-12-17T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-18T00:00:00", "Exclusion range[2].end() --> 2015-12-18T00:00:00");
t.is (ranges[0].start.toISOLocalExtended (), "2015-12-17T00:00:00", "Exclusion range[0].start() --> 2015-12-17T00:00:00");
t.is (ranges[0].end.toISOLocalExtended (), "2015-12-17T08:00:00", "Exclusion range[0].end() --> 2015-12-17T08:00:00");
t.is (ranges[1].start.toISOLocalExtended (), "2015-12-17T12:00:00", "Exclusion range[1].start() --> 2015-12-17T12:00:00");
t.is (ranges[1].end.toISOLocalExtended (), "2015-12-17T12:45:00", "Exclusion range[1].end() --> 2015-12-17T12:45:00");
t.is (ranges[2].start.toISOLocalExtended (), "2015-12-17T17:30:00", "Exclusion range[2].start() --> 2015-12-17T17:30:00");
t.is (ranges[2].end.toISOLocalExtended (), "2015-12-18T00:00:00", "Exclusion range[2].end() --> 2015-12-18T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-24T00:00:00", "Exclusion range[3].start() --> 2015-12-24T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-24T08:00:00", "Exclusion range[3].end() --> 2015-12-24T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-24T12:00:00", "Exclusion range[4].start() --> 2015-12-24T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-24T12:45:00", "Exclusion range[4].end() --> 2015-12-24T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-24T17:30:00", "Exclusion range[5].start() --> 2015-12-24T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-25T00:00:00", "Exclusion range[5].end() --> 2015-12-25T00:00:00");
t.is (ranges[3].start.toISOLocalExtended (), "2015-12-24T00:00:00", "Exclusion range[3].start() --> 2015-12-24T00:00:00");
t.is (ranges[3].end.toISOLocalExtended (), "2015-12-24T08:00:00", "Exclusion range[3].end() --> 2015-12-24T08:00:00");
t.is (ranges[4].start.toISOLocalExtended (), "2015-12-24T12:00:00", "Exclusion range[4].start() --> 2015-12-24T12:00:00");
t.is (ranges[4].end.toISOLocalExtended (), "2015-12-24T12:45:00", "Exclusion range[4].end() --> 2015-12-24T12:45:00");
t.is (ranges[5].start.toISOLocalExtended (), "2015-12-24T17:30:00", "Exclusion range[5].start() --> 2015-12-24T17:30:00");
t.is (ranges[5].end.toISOLocalExtended (), "2015-12-25T00:00:00", "Exclusion range[5].end() --> 2015-12-25T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2015-12-31T00:00:00", "Exclusion range[6].start() --> 2015-12-31T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2015-12-31T08:00:00", "Exclusion range[6].end() --> 2015-12-31T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2015-12-31T12:00:00", "Exclusion range[7].start() --> 2015-12-31T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2015-12-31T12:45:00", "Exclusion range[7].end() --> 2015-12-31T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2015-12-31T17:30:00", "Exclusion range[8].start() --> 2015-12-31T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-01T00:00:00", "Exclusion range[8].end() --> 2016-01-01T00:00:00");
t.is (ranges[6].start.toISOLocalExtended (), "2015-12-31T00:00:00", "Exclusion range[6].start() --> 2015-12-31T00:00:00");
t.is (ranges[6].end.toISOLocalExtended (), "2015-12-31T08:00:00", "Exclusion range[6].end() --> 2015-12-31T08:00:00");
t.is (ranges[7].start.toISOLocalExtended (), "2015-12-31T12:00:00", "Exclusion range[7].start() --> 2015-12-31T12:00:00");
t.is (ranges[7].end.toISOLocalExtended (), "2015-12-31T12:45:00", "Exclusion range[7].end() --> 2015-12-31T12:45:00");
t.is (ranges[8].start.toISOLocalExtended (), "2015-12-31T17:30:00", "Exclusion range[8].start() --> 2015-12-31T17:30:00");
t.is (ranges[8].end.toISOLocalExtended (), "2016-01-01T00:00:00", "Exclusion range[8].end() --> 2016-01-01T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-07T00:00:00", "Exclusion range[9].start() --> 2016-01-07T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-07T08:00:00", "Exclusion range[9].end() --> 2016-01-07T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-07T12:00:00", "Exclusion range[10].start() --> 2016-01-07T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-07T12:45:00", "Exclusion range[10].end() --> 2016-01-07T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-07T17:30:00", "Exclusion range[11].start() --> 2016-01-07T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-08T00:00:00", "Exclusion range[11].end() --> 2016-01-08T00:00:00");
t.is (ranges[9].start.toISOLocalExtended (), "2016-01-07T00:00:00", "Exclusion range[9].start() --> 2016-01-07T00:00:00");
t.is (ranges[9].end.toISOLocalExtended (), "2016-01-07T08:00:00", "Exclusion range[9].end() --> 2016-01-07T08:00:00");
t.is (ranges[10].start.toISOLocalExtended (), "2016-01-07T12:00:00", "Exclusion range[10].start() --> 2016-01-07T12:00:00");
t.is (ranges[10].end.toISOLocalExtended (), "2016-01-07T12:45:00", "Exclusion range[10].end() --> 2016-01-07T12:45:00");
t.is (ranges[11].start.toISOLocalExtended (), "2016-01-07T17:30:00", "Exclusion range[11].start() --> 2016-01-07T17:30:00");
t.is (ranges[11].end.toISOLocalExtended (), "2016-01-08T00:00:00", "Exclusion range[11].end() --> 2016-01-08T00:00:00");
t.is (ranges[12].start ().toISOLocalExtended (), "2016-01-14T00:00:00", "Exclusion range[12].start() --> 2016-01-14T00:00:00");
t.is (ranges[12].end ().toISOLocalExtended (), "2016-01-14T08:00:00", "Exclusion range[12].end() --> 2016-01-14T08:00:00");
t.is (ranges[13].start ().toISOLocalExtended (), "2016-01-14T12:00:00", "Exclusion range[13].start() --> 2016-01-14T12:00:00");
t.is (ranges[13].end ().toISOLocalExtended (), "2016-01-14T12:45:00", "Exclusion range[13].end() --> 2016-01-14T12:45:00");
t.is (ranges[14].start ().toISOLocalExtended (), "2016-01-14T17:30:00", "Exclusion range[14].start() --> 2016-01-14T17:30:00");
t.is (ranges[14].end ().toISOLocalExtended (), "2016-01-15T00:00:00", "Exclusion range[14].end() --> 2016-01-15T00:00:00");
t.is (ranges[12].start.toISOLocalExtended (), "2016-01-14T00:00:00", "Exclusion range[12].start() --> 2016-01-14T00:00:00");
t.is (ranges[12].end.toISOLocalExtended (), "2016-01-14T08:00:00", "Exclusion range[12].end() --> 2016-01-14T08:00:00");
t.is (ranges[13].start.toISOLocalExtended (), "2016-01-14T12:00:00", "Exclusion range[13].start() --> 2016-01-14T12:00:00");
t.is (ranges[13].end.toISOLocalExtended (), "2016-01-14T12:45:00", "Exclusion range[13].end() --> 2016-01-14T12:45:00");
t.is (ranges[14].start.toISOLocalExtended (), "2016-01-14T17:30:00", "Exclusion range[14].start() --> 2016-01-14T17:30:00");
t.is (ranges[14].end.toISOLocalExtended (), "2016-01-15T00:00:00", "Exclusion range[14].end() --> 2016-01-15T00:00:00");
e.initialize ("exc friday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens ();
@ -240,33 +240,33 @@ int main (int, char**)
ranges = e.ranges (r);
t.ok (ranges.size () == 12, "Exclusion ranges --> [12]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-18T00:00:00", "Exclusion range[0].start() --> 2015-12-18T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-18T08:00:00", "Exclusion range[0].end() --> 2015-12-18T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-18T12:00:00", "Exclusion range[1].start() --> 2015-12-18T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-18T12:45:00", "Exclusion range[1].end() --> 2015-12-18T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-18T17:30:00", "Exclusion range[2].start() --> 2015-12-18T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-19T00:00:00", "Exclusion range[2].end() --> 2015-12-19T00:00:00");
t.is (ranges[0].start.toISOLocalExtended (), "2015-12-18T00:00:00", "Exclusion range[0].start() --> 2015-12-18T00:00:00");
t.is (ranges[0].end.toISOLocalExtended (), "2015-12-18T08:00:00", "Exclusion range[0].end() --> 2015-12-18T08:00:00");
t.is (ranges[1].start.toISOLocalExtended (), "2015-12-18T12:00:00", "Exclusion range[1].start() --> 2015-12-18T12:00:00");
t.is (ranges[1].end.toISOLocalExtended (), "2015-12-18T12:45:00", "Exclusion range[1].end() --> 2015-12-18T12:45:00");
t.is (ranges[2].start.toISOLocalExtended (), "2015-12-18T17:30:00", "Exclusion range[2].start() --> 2015-12-18T17:30:00");
t.is (ranges[2].end.toISOLocalExtended (), "2015-12-19T00:00:00", "Exclusion range[2].end() --> 2015-12-19T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-25T00:00:00", "Exclusion range[3].start() --> 2015-12-25T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-25T08:00:00", "Exclusion range[3].end() --> 2015-12-25T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-25T12:00:00", "Exclusion range[4].start() --> 2015-12-25T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-25T12:45:00", "Exclusion range[4].end() --> 2015-12-25T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-25T17:30:00", "Exclusion range[5].start() --> 2015-12-25T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-26T00:00:00", "Exclusion range[5].end() --> 2015-12-26T00:00:00");
t.is (ranges[3].start.toISOLocalExtended (), "2015-12-25T00:00:00", "Exclusion range[3].start() --> 2015-12-25T00:00:00");
t.is (ranges[3].end.toISOLocalExtended (), "2015-12-25T08:00:00", "Exclusion range[3].end() --> 2015-12-25T08:00:00");
t.is (ranges[4].start.toISOLocalExtended (), "2015-12-25T12:00:00", "Exclusion range[4].start() --> 2015-12-25T12:00:00");
t.is (ranges[4].end.toISOLocalExtended (), "2015-12-25T12:45:00", "Exclusion range[4].end() --> 2015-12-25T12:45:00");
t.is (ranges[5].start.toISOLocalExtended (), "2015-12-25T17:30:00", "Exclusion range[5].start() --> 2015-12-25T17:30:00");
t.is (ranges[5].end.toISOLocalExtended (), "2015-12-26T00:00:00", "Exclusion range[5].end() --> 2015-12-26T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2016-01-01T00:00:00", "Exclusion range[6].start() --> 2016-01-01T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2016-01-01T08:00:00", "Exclusion range[6].end() --> 2016-01-01T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2016-01-01T12:00:00", "Exclusion range[7].start() --> 2016-01-01T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2016-01-01T12:45:00", "Exclusion range[7].end() --> 2016-01-01T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2016-01-01T17:30:00", "Exclusion range[8].start() --> 2016-01-01T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-02T00:00:00", "Exclusion range[8].end() --> 2016-01-02T00:00:00");
t.is (ranges[6].start.toISOLocalExtended (), "2016-01-01T00:00:00", "Exclusion range[6].start() --> 2016-01-01T00:00:00");
t.is (ranges[6].end.toISOLocalExtended (), "2016-01-01T08:00:00", "Exclusion range[6].end() --> 2016-01-01T08:00:00");
t.is (ranges[7].start.toISOLocalExtended (), "2016-01-01T12:00:00", "Exclusion range[7].start() --> 2016-01-01T12:00:00");
t.is (ranges[7].end.toISOLocalExtended (), "2016-01-01T12:45:00", "Exclusion range[7].end() --> 2016-01-01T12:45:00");
t.is (ranges[8].start.toISOLocalExtended (), "2016-01-01T17:30:00", "Exclusion range[8].start() --> 2016-01-01T17:30:00");
t.is (ranges[8].end.toISOLocalExtended (), "2016-01-02T00:00:00", "Exclusion range[8].end() --> 2016-01-02T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-08T00:00:00", "Exclusion range[9].start() --> 2016-01-08T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-08T08:00:00", "Exclusion range[9].end() --> 2016-01-08T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-08T12:00:00", "Exclusion range[10].start() --> 2016-01-08T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-08T12:45:00", "Exclusion range[10].end() --> 2016-01-08T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-08T17:30:00", "Exclusion range[11].start() --> 2016-01-08T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-09T00:00:00", "Exclusion range[11].end() --> 2016-01-09T00:00:00");
t.is (ranges[9].start.toISOLocalExtended (), "2016-01-08T00:00:00", "Exclusion range[9].start() --> 2016-01-08T00:00:00");
t.is (ranges[9].end.toISOLocalExtended (), "2016-01-08T08:00:00", "Exclusion range[9].end() --> 2016-01-08T08:00:00");
t.is (ranges[10].start.toISOLocalExtended (), "2016-01-08T12:00:00", "Exclusion range[10].start() --> 2016-01-08T12:00:00");
t.is (ranges[10].end.toISOLocalExtended (), "2016-01-08T12:45:00", "Exclusion range[10].end() --> 2016-01-08T12:45:00");
t.is (ranges[11].start.toISOLocalExtended (), "2016-01-08T17:30:00", "Exclusion range[11].start() --> 2016-01-08T17:30:00");
t.is (ranges[11].end.toISOLocalExtended (), "2016-01-09T00:00:00", "Exclusion range[11].end() --> 2016-01-09T00:00:00");
e.initialize ("exc saturday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens ();
@ -279,33 +279,33 @@ int main (int, char**)
ranges = e.ranges (r);
t.ok (ranges.size () == 12, "Exclusion ranges --> [12]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-19T00:00:00", "Exclusion range[0].start() --> 2015-12-19T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-19T08:00:00", "Exclusion range[0].end() --> 2015-12-19T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-19T12:00:00", "Exclusion range[1].start() --> 2015-12-19T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-19T12:45:00", "Exclusion range[1].end() --> 2015-12-19T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-19T17:30:00", "Exclusion range[2].start() --> 2015-12-19T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-20T00:00:00", "Exclusion range[2].end() --> 2015-12-20T00:00:00");
t.is (ranges[0].start.toISOLocalExtended (), "2015-12-19T00:00:00", "Exclusion range[0].start() --> 2015-12-19T00:00:00");
t.is (ranges[0].end.toISOLocalExtended (), "2015-12-19T08:00:00", "Exclusion range[0].end() --> 2015-12-19T08:00:00");
t.is (ranges[1].start.toISOLocalExtended (), "2015-12-19T12:00:00", "Exclusion range[1].start() --> 2015-12-19T12:00:00");
t.is (ranges[1].end.toISOLocalExtended (), "2015-12-19T12:45:00", "Exclusion range[1].end() --> 2015-12-19T12:45:00");
t.is (ranges[2].start.toISOLocalExtended (), "2015-12-19T17:30:00", "Exclusion range[2].start() --> 2015-12-19T17:30:00");
t.is (ranges[2].end.toISOLocalExtended (), "2015-12-20T00:00:00", "Exclusion range[2].end() --> 2015-12-20T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-26T00:00:00", "Exclusion range[3].start() --> 2015-12-26T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-26T08:00:00", "Exclusion range[3].end() --> 2015-12-26T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-26T12:00:00", "Exclusion range[4].start() --> 2015-12-26T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-26T12:45:00", "Exclusion range[4].end() --> 2015-12-26T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-26T17:30:00", "Exclusion range[5].start() --> 2015-12-26T17:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-27T00:00:00", "Exclusion range[5].end() --> 2015-12-27T00:00:00");
t.is (ranges[3].start.toISOLocalExtended (), "2015-12-26T00:00:00", "Exclusion range[3].start() --> 2015-12-26T00:00:00");
t.is (ranges[3].end.toISOLocalExtended (), "2015-12-26T08:00:00", "Exclusion range[3].end() --> 2015-12-26T08:00:00");
t.is (ranges[4].start.toISOLocalExtended (), "2015-12-26T12:00:00", "Exclusion range[4].start() --> 2015-12-26T12:00:00");
t.is (ranges[4].end.toISOLocalExtended (), "2015-12-26T12:45:00", "Exclusion range[4].end() --> 2015-12-26T12:45:00");
t.is (ranges[5].start.toISOLocalExtended (), "2015-12-26T17:30:00", "Exclusion range[5].start() --> 2015-12-26T17:30:00");
t.is (ranges[5].end.toISOLocalExtended (), "2015-12-27T00:00:00", "Exclusion range[5].end() --> 2015-12-27T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2016-01-02T00:00:00", "Exclusion range[6].start() --> 2016-01-02T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2016-01-02T08:00:00", "Exclusion range[6].end() --> 2016-01-02T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2016-01-02T12:00:00", "Exclusion range[7].start() --> 2016-01-02T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2016-01-02T12:45:00", "Exclusion range[7].end() --> 2016-01-02T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2016-01-02T17:30:00", "Exclusion range[8].start() --> 2016-01-02T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-03T00:00:00", "Exclusion range[8].end() --> 2016-01-03T00:00:00");
t.is (ranges[6].start.toISOLocalExtended (), "2016-01-02T00:00:00", "Exclusion range[6].start() --> 2016-01-02T00:00:00");
t.is (ranges[6].end.toISOLocalExtended (), "2016-01-02T08:00:00", "Exclusion range[6].end() --> 2016-01-02T08:00:00");
t.is (ranges[7].start.toISOLocalExtended (), "2016-01-02T12:00:00", "Exclusion range[7].start() --> 2016-01-02T12:00:00");
t.is (ranges[7].end.toISOLocalExtended (), "2016-01-02T12:45:00", "Exclusion range[7].end() --> 2016-01-02T12:45:00");
t.is (ranges[8].start.toISOLocalExtended (), "2016-01-02T17:30:00", "Exclusion range[8].start() --> 2016-01-02T17:30:00");
t.is (ranges[8].end.toISOLocalExtended (), "2016-01-03T00:00:00", "Exclusion range[8].end() --> 2016-01-03T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-09T00:00:00", "Exclusion range[9].start() --> 2016-01-09T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-09T08:00:00", "Exclusion range[9].end() --> 2016-01-09T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-09T12:00:00", "Exclusion range[10].start() --> 2016-01-09T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-09T12:45:00", "Exclusion range[10].end() --> 2016-01-09T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-09T17:30:00", "Exclusion range[11].start() --> 2016-01-09T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-10T00:00:00", "Exclusion range[11].end() --> 2016-01-10T00:00:00");
t.is (ranges[9].start.toISOLocalExtended (), "2016-01-09T00:00:00", "Exclusion range[9].start() --> 2016-01-09T00:00:00");
t.is (ranges[9].end.toISOLocalExtended (), "2016-01-09T08:00:00", "Exclusion range[9].end() --> 2016-01-09T08:00:00");
t.is (ranges[10].start.toISOLocalExtended (), "2016-01-09T12:00:00", "Exclusion range[10].start() --> 2016-01-09T12:00:00");
t.is (ranges[10].end.toISOLocalExtended (), "2016-01-09T12:45:00", "Exclusion range[10].end() --> 2016-01-09T12:45:00");
t.is (ranges[11].start.toISOLocalExtended (), "2016-01-09T17:30:00", "Exclusion range[11].start() --> 2016-01-09T17:30:00");
t.is (ranges[11].end.toISOLocalExtended (), "2016-01-10T00:00:00", "Exclusion range[11].end() --> 2016-01-10T00:00:00");
e.initialize ("exc sunday <8:00:00 12:00:00-12:45:00 >17:30:00");
tokens = e.tokens ();
@ -318,33 +318,33 @@ int main (int, char**)
ranges = e.ranges (r);
t.ok (ranges.size () == 12, "Exclusion ranges --> [12]");
t.is (ranges[0].start ().toISOLocalExtended (), "2015-12-20T00:00:00", "Exclusion range[0].start() --> 2015-12-20T00:00:00");
t.is (ranges[0].end ().toISOLocalExtended (), "2015-12-20T08:00:00", "Exclusion range[0].end() --> 2015-12-20T08:00:00");
t.is (ranges[1].start ().toISOLocalExtended (), "2015-12-20T12:00:00", "Exclusion range[1].start() --> 2015-12-20T12:00:00");
t.is (ranges[1].end ().toISOLocalExtended (), "2015-12-20T12:45:00", "Exclusion range[1].end() --> 2015-12-20T12:45:00");
t.is (ranges[2].start ().toISOLocalExtended (), "2015-12-20T17:30:00", "Exclusion range[2].start() --> 2015-12-20T17:30:00");
t.is (ranges[2].end ().toISOLocalExtended (), "2015-12-21T00:00:00", "Exclusion range[2].end() --> 2015-12-21T00:00:00");
t.is (ranges[0].start.toISOLocalExtended (), "2015-12-20T00:00:00", "Exclusion range[0].start() --> 2015-12-20T00:00:00");
t.is (ranges[0].end.toISOLocalExtended (), "2015-12-20T08:00:00", "Exclusion range[0].end() --> 2015-12-20T08:00:00");
t.is (ranges[1].start.toISOLocalExtended (), "2015-12-20T12:00:00", "Exclusion range[1].start() --> 2015-12-20T12:00:00");
t.is (ranges[1].end.toISOLocalExtended (), "2015-12-20T12:45:00", "Exclusion range[1].end() --> 2015-12-20T12:45:00");
t.is (ranges[2].start.toISOLocalExtended (), "2015-12-20T17:30:00", "Exclusion range[2].start() --> 2015-12-20T17:30:00");
t.is (ranges[2].end.toISOLocalExtended (), "2015-12-21T00:00:00", "Exclusion range[2].end() --> 2015-12-21T00:00:00");
t.is (ranges[3].start ().toISOLocalExtended (), "2015-12-27T00:00:00", "Exclusion range[3].start() --> 2015-12-27T00:00:00");
t.is (ranges[3].end ().toISOLocalExtended (), "2015-12-27T08:00:00", "Exclusion range[3].end() --> 2015-12-27T08:00:00");
t.is (ranges[4].start ().toISOLocalExtended (), "2015-12-27T12:00:00", "Exclusion range[4].start() --> 2015-12-27T12:00:00");
t.is (ranges[4].end ().toISOLocalExtended (), "2015-12-27T12:45:00", "Exclusion range[4].end() --> 2015-12-27T12:45:00");
t.is (ranges[5].start ().toISOLocalExtended (), "2015-12-27T17:30:00", "Exclusion range[5].start() --> 2015-12-22717:30:00");
t.is (ranges[5].end ().toISOLocalExtended (), "2015-12-28T00:00:00", "Exclusion range[5].end() --> 2015-12-28T00:00:00");
t.is (ranges[3].start.toISOLocalExtended (), "2015-12-27T00:00:00", "Exclusion range[3].start() --> 2015-12-27T00:00:00");
t.is (ranges[3].end.toISOLocalExtended (), "2015-12-27T08:00:00", "Exclusion range[3].end() --> 2015-12-27T08:00:00");
t.is (ranges[4].start.toISOLocalExtended (), "2015-12-27T12:00:00", "Exclusion range[4].start() --> 2015-12-27T12:00:00");
t.is (ranges[4].end.toISOLocalExtended (), "2015-12-27T12:45:00", "Exclusion range[4].end() --> 2015-12-27T12:45:00");
t.is (ranges[5].start.toISOLocalExtended (), "2015-12-27T17:30:00", "Exclusion range[5].start() --> 2015-12-22717:30:00");
t.is (ranges[5].end.toISOLocalExtended (), "2015-12-28T00:00:00", "Exclusion range[5].end() --> 2015-12-28T00:00:00");
t.is (ranges[6].start ().toISOLocalExtended (), "2016-01-03T00:00:00", "Exclusion range[6].start() --> 2016-01-03T00:00:00");
t.is (ranges[6].end ().toISOLocalExtended (), "2016-01-03T08:00:00", "Exclusion range[6].end() --> 2016-01-03T08:00:00");
t.is (ranges[7].start ().toISOLocalExtended (), "2016-01-03T12:00:00", "Exclusion range[7].start() --> 2016-01-03T12:00:00");
t.is (ranges[7].end ().toISOLocalExtended (), "2016-01-03T12:45:00", "Exclusion range[7].end() --> 2016-01-03T12:45:00");
t.is (ranges[8].start ().toISOLocalExtended (), "2016-01-03T17:30:00", "Exclusion range[8].start() --> 2016-01-03T17:30:00");
t.is (ranges[8].end ().toISOLocalExtended (), "2016-01-04T00:00:00", "Exclusion range[8].end() --> 2016-01-04T00:00:00");
t.is (ranges[6].start.toISOLocalExtended (), "2016-01-03T00:00:00", "Exclusion range[6].start() --> 2016-01-03T00:00:00");
t.is (ranges[6].end.toISOLocalExtended (), "2016-01-03T08:00:00", "Exclusion range[6].end() --> 2016-01-03T08:00:00");
t.is (ranges[7].start.toISOLocalExtended (), "2016-01-03T12:00:00", "Exclusion range[7].start() --> 2016-01-03T12:00:00");
t.is (ranges[7].end.toISOLocalExtended (), "2016-01-03T12:45:00", "Exclusion range[7].end() --> 2016-01-03T12:45:00");
t.is (ranges[8].start.toISOLocalExtended (), "2016-01-03T17:30:00", "Exclusion range[8].start() --> 2016-01-03T17:30:00");
t.is (ranges[8].end.toISOLocalExtended (), "2016-01-04T00:00:00", "Exclusion range[8].end() --> 2016-01-04T00:00:00");
t.is (ranges[9].start ().toISOLocalExtended (), "2016-01-10T00:00:00", "Exclusion range[9].start() --> 2016-01-10T00:00:00");
t.is (ranges[9].end ().toISOLocalExtended (), "2016-01-10T08:00:00", "Exclusion range[9].end() --> 2016-01-10T08:00:00");
t.is (ranges[10].start ().toISOLocalExtended (), "2016-01-10T12:00:00", "Exclusion range[10].start() --> 2016-01-10T12:00:00");
t.is (ranges[10].end ().toISOLocalExtended (), "2016-01-10T12:45:00", "Exclusion range[10].end() --> 2016-01-10T12:45:00");
t.is (ranges[11].start ().toISOLocalExtended (), "2016-01-10T17:30:00", "Exclusion range[11].start() --> 2016-01-10T17:30:00");
t.is (ranges[11].end ().toISOLocalExtended (), "2016-01-11T00:00:00", "Exclusion range[11].end() --> 2016-01-11T00:00:00");
t.is (ranges[9].start.toISOLocalExtended (), "2016-01-10T00:00:00", "Exclusion range[9].start() --> 2016-01-10T00:00:00");
t.is (ranges[9].end.toISOLocalExtended (), "2016-01-10T08:00:00", "Exclusion range[9].end() --> 2016-01-10T08:00:00");
t.is (ranges[10].start.toISOLocalExtended (), "2016-01-10T12:00:00", "Exclusion range[10].start() --> 2016-01-10T12:00:00");
t.is (ranges[10].end.toISOLocalExtended (), "2016-01-10T12:45:00", "Exclusion range[10].end() --> 2016-01-10T12:45:00");
t.is (ranges[11].start.toISOLocalExtended (), "2016-01-10T17:30:00", "Exclusion range[11].start() --> 2016-01-10T17:30:00");
t.is (ranges[11].end.toISOLocalExtended (), "2016-01-11T00:00:00", "Exclusion range[11].end() --> 2016-01-11T00:00:00");
// exc day on 2016-01-01
e.initialize ("exc day on 2016-01-01");
@ -357,8 +357,8 @@ int main (int, char**)
ranges = e.ranges (r);
t.ok (ranges.size () == 1, "Exclusion ranges --> [1]");
t.is (ranges[0].start ().toString ("Y-M-D"), "2016-01-01", "Exclusion range[0].start() --> 2016-01-01");
t.is (ranges[0].end ().toString ("Y-M-D"), "2016-01-02", "Exclusion range[0].end() --> 2016-01-02");
t.is (ranges[0].start.toString ("Y-M-D"), "2016-01-01", "Exclusion range[0].start() --> 2016-01-01");
t.is (ranges[0].end.toString ("Y-M-D"), "2016-01-02", "Exclusion range[0].end() --> 2016-01-02");
t.ok (e.additive (), "Exclusion 'day on ...' --> additive");
// exc day off 2016-01-01
@ -372,8 +372,8 @@ int main (int, char**)
ranges = e.ranges (r);
t.ok (ranges.size () == 1, "Exclusion ranges --> [1]");
t.is (ranges[0].start ().toString ("Y-M-D"), "2016-01-01", "Exclusion range[0].start() --> 2016-01-01");
t.is (ranges[0].end ().toString ("Y-M-D"), "2016-01-02", "Exclusion range[0].end() --> 2016-01-02");
t.is (ranges[0].start.toString ("Y-M-D"), "2016-01-01", "Exclusion range[0].start() --> 2016-01-01");
t.is (ranges[0].end.toString ("Y-M-D"), "2016-01-02", "Exclusion range[0].end() --> 2016-01-02");
t.notok (e.additive (), "Exclusion 'day off ...' --> !additive");
}

24
test/interval.t.cpp
View file

@ -33,23 +33,23 @@ int main (int, char**)
{
UnitTest t (38);
// bool isStarted () const;
// bool isEnded () const;
// bool started () const;
// bool ended () const;
Interval i1;
t.is (i1.empty (), true, "Interval().empty -> true");
t.is (i1.isStarted (), false, "Interval().isStarted -> false");
t.is (i1.isEnded (), false, "Interval().isEnded -> false");
t.is (i1.range.started (), false, "Interval().started -> false");
t.is (i1.range.ended (), false, "Interval().ended -> false");
// void start (Datetime);
i1.start (Datetime ());
i1.range.start = Datetime ();
t.is (i1.empty (), false, "Interval().empty -> false");
t.is (i1.isStarted (), true, "Interval(start=now).isStarted -> true");
t.is (i1.isEnded (), false, "Interval(start=now).isEnded -> false");
t.is (i1.range.started (), true, "Interval(start=now).started -> true");
t.is (i1.range.ended (), false, "Interval(start=now).ended -> false");
// void end (Datetime);
i1.end (Datetime ());
t.is (i1.isStarted (), true, "Interval(start=now,end=now).isStarted -> true");
t.is (i1.isEnded (), true, "Interval(start=now,end=now).isEnded -> true");
i1.range.end = Datetime ();
t.is (i1.range.started (), true, "Interval(start=now,end=now).started -> true");
t.is (i1.range.ended (), true, "Interval(start=now,end=now).ended -> true");
// std::set <std::string> tags () const;
// void tag (const std::string&);
@ -73,9 +73,9 @@ int main (int, char**)
t.is (i3.serialize (), "inc # foo", "Interval().serialize -> 'inc # foo'");
i3.tag ("bar");
t.is (i3.serialize (), "inc # bar foo", "Interval().serialize -> 'inc # bar foo'");
i3.start (Datetime(1));
i3.range.start = Datetime(1);
t.is (i3.serialize (), "inc 19700101T000001Z # bar foo", "Interval(Datetime(1)).serialize -> 'inc 19700101T000001Z # bar foo'");
i3.end (Datetime(2));
i3.range.end = Datetime(2);
t.is (i3.serialize (), "inc 19700101T000001Z - 19700101T000002Z # bar foo", "Interval(Datetime(1)).serialize -> 'inc 19700101T000001Z - 19700101T000002Z # bar foo'");
i3.tag ("Trans-Europe Express");
t.is (i3.serialize (), "inc 19700101T000001Z - 19700101T000002Z # \"Trans-Europe Express\" bar foo", "Interval(Datetime(1)).serialize -> 'inc 19700101T000001Z - 19700101T000002Z # \"Trans-Europe Express\" bar foo'");

106
test/range.t.cpp
View file

@ -33,21 +33,21 @@ int main (int, char**)
{
UnitTest t (60);
// bool isStarted () const;
// bool isEnded () const;
// bool started () const;
// bool ended () const;
Range i1;
t.is (i1.isStarted (), false, "Range().isStarted -> false");
t.is (i1.isEnded (), false, "Range().isEnded -> false");
t.is (i1.started (), false, "Range().started -> false");
t.is (i1.ended (), false, "Range().ended -> false");
// void start (Datetime);
i1.start (Datetime ());
t.is (i1.isStarted (), true, "Range(start=now).isStarted -> true");
t.is (i1.isEnded (), false, "Range(start=now).isEnded -> false");
i1.start = Datetime ();
t.is (i1.started (), true, "Range(start=now).started -> true");
t.is (i1.ended (), false, "Range(start=now).ended -> false");
// void end (Datetime);
i1.end (Datetime ());
t.is (i1.isStarted (), true, "Range(start=now,end=now).isStarted -> true");
t.is (i1.isEnded (), true, "Range(start=now,end=now).isEnded -> true");
i1.end = Datetime ();
t.is (i1.started (), true, "Range(start=now,end=now).started -> true");
t.is (i1.ended (), true, "Range(start=now,end=now).ended -> true");
// this [--------)
// A [--------)
@ -60,18 +60,18 @@ int main (int, char**)
// H [...
// I [...
Range refClosed;
refClosed.start (Datetime (6, 1, 2016));
refClosed.end (Datetime (6, 30, 2016));
refClosed.start = Datetime (6, 1, 2016);
refClosed.end = Datetime (6, 30, 2016);
Range testA; testA.start (Datetime (4, 1, 2016)); testA.end (Datetime (4, 30, 2016));
Range testB; testB.start (Datetime (5, 15, 2016)); testB.end (Datetime (6, 15, 2016));
Range testC; testC.start (Datetime (6, 10, 2016)); testC.end (Datetime (6, 20, 2016));
Range testD; testD.start (Datetime (6, 15, 2016)); testD.end (Datetime (7, 15, 2016));
Range testE; testE.start (Datetime (8, 1, 2016)); testE.end (Datetime (8, 31, 2016));
Range testF; testF.start (Datetime (5, 15, 2016)); testF.end (Datetime (7, 15, 2016));
Range testG; testG.start (Datetime (5, 15, 2016));
Range testH; testH.start (Datetime (6, 15, 2016));
Range testI; testI.start (Datetime (7, 15, 2016));
Range testA; testA.start = Datetime (4, 1, 2016); testA.end = Datetime (4, 30, 2016);
Range testB; testB.start = Datetime (5, 15, 2016); testB.end = Datetime (6, 15, 2016);
Range testC; testC.start = Datetime (6, 10, 2016); testC.end = Datetime (6, 20, 2016);
Range testD; testD.start = Datetime (6, 15, 2016); testD.end = Datetime (7, 15, 2016);
Range testE; testE.start = Datetime (8, 1, 2016); testE.end = Datetime (8, 31, 2016);
Range testF; testF.start = Datetime (5, 15, 2016); testF.end = Datetime (7, 15, 2016);
Range testG; testG.start = Datetime (5, 15, 2016);
Range testH; testH.start = Datetime (6, 15, 2016);
Range testI; testI.start = Datetime (7, 15, 2016);
t.notok (refClosed.overlap (testA), "Range: ! refClosed.overlap(testA)");
t.ok (refClosed.overlap (testB), "Range: refClosed.overlap(testB)");
@ -94,7 +94,7 @@ int main (int, char**)
// H [...
// I [...
Range refOpen;
refOpen.start (Datetime (6, 1, 2016));
refOpen.start = Datetime (6, 1, 2016);
t.notok (refOpen.overlap (testA), "Range: ! refOpen.overlap(testA)");
t.ok (refOpen.overlap (testB), "Range: refOpen.overlap(testB)");
@ -118,13 +118,13 @@ int main (int, char**)
// I [...
Range empty;
t.ok (refClosed.intersect (testA) == empty, "Range: refClosed.intersect(testA) == empty");
t.ok (refClosed.intersect (testB) == Range (refClosed.start (), testB.end ()), "Range: refClosed.intersect(testB) == Range(refClosed.start(),testB.end())");
t.ok (refClosed.intersect (testB) == Range (refClosed.start, testB.end), "Range: refClosed.intersect(testB) == Range(refClosed.start,testB.end)");
t.ok (refClosed.intersect (testC) == testC, "Range: refClosed.intersect(testB) == testC");
t.ok (refClosed.intersect (testD) == Range (testD.start (), refClosed.end ()), "Range: refClosed.intersect(testB) == Range(testD.start(),refClosed.end())");
t.ok (refClosed.intersect (testD) == Range (testD.start, refClosed.end), "Range: refClosed.intersect(testB) == Range(testD.start,refClosed.end)");
t.ok (refClosed.intersect (testE) == empty, "Range: refClosed.intersect(testE) == empty");
t.ok (refClosed.intersect (testF) == refClosed, "Range: refClosed.intersect(testF) == refClosed");
t.ok (refClosed.intersect (testG) == refClosed, "Range: refClosed.intersect(testG) == refClosed");
t.ok (refClosed.intersect (testH) == Range (testH.start (), refClosed.end ()), "Range: refClosed.intersect(testH) == Range(testH.start(),refClosed.end())");
t.ok (refClosed.intersect (testH) == Range (testH.start, refClosed.end), "Range: refClosed.intersect(testH) == Range(testH.start,refClosed.end)");
t.ok (refClosed.intersect (testI) == empty, "Range: refClosed.intersect(testI) == empty");
// this [...
@ -138,11 +138,11 @@ int main (int, char**)
// H [...
// I [...
t.ok (refOpen.intersect (testA) == empty, "Range: refOpen.intersect(testA) == empty");
t.ok (refOpen.intersect (testB) == Range (refOpen.start (), testB.end ()), "Range: refOpen.intersect(testB) == Range(refOpen.start(),testB.end())");
t.ok (refOpen.intersect (testB) == Range (refOpen.start, testB.end), "Range: refOpen.intersect(testB) == Range(refOpen.start,testB.end)");
t.ok (refOpen.intersect (testC) == testC, "Range: refOpen.intersect(testC) == testC");
t.ok (refOpen.intersect (testD) == testD, "Range: refOpen.intersect(testD) == testD");
t.ok (refOpen.intersect (testE) == testE, "Range: refOpen.intersect(testE) == testE");
t.ok (refOpen.intersect (testF) == Range (refOpen.start (), testF.end ()), "Range: refOpen.intersect(testF) == Range(refOpen.start(),testF.end()");
t.ok (refOpen.intersect (testF) == Range (refOpen.start, testF.end), "Range: refOpen.intersect(testF) == Range(refOpen.start,testF.end");
t.ok (refOpen.intersect (testG) == refOpen, "Range: refOpen.intersect(testG) == refOpen");
t.ok (refOpen.intersect (testH) == testH, "Range: refOpen.intersect(testH) == testH");
t.ok (refOpen.intersect (testI) == testI, "Range: refOpen.intersect(testI) == testI");
@ -158,24 +158,24 @@ int main (int, char**)
// H [...
// I [...
std::vector <Range> closedSubtractA {refClosed};
std::vector <Range> closedSubtractB {Range (testB.end (), refClosed.end ())};
std::vector <Range> closedSubtractC {Range (refClosed.start (), testC.start ()), Range (testC.end (), refClosed.end ())};
std::vector <Range> closedSubtractD {Range (refClosed.start (), testD.start ())};
std::vector <Range> closedSubtractB {Range (testB.end, refClosed.end)};
std::vector <Range> closedSubtractC {Range (refClosed.start, testC.start), Range (testC.end, refClosed.end)};
std::vector <Range> closedSubtractD {Range (refClosed.start, testD.start)};
std::vector <Range> closedSubtractE {refClosed};
std::vector <Range> closedSubtractF {};
std::vector <Range> closedSubtractG {};
std::vector <Range> closedSubtractH {Range (refClosed.start (), testH.start ())};
std::vector <Range> closedSubtractH {Range (refClosed.start, testH.start)};
std::vector <Range> closedSubtractI {refClosed};
t.ok (refClosed.subtract (testA) == closedSubtractA, "Range: refClosed.subtract(testA) == {refClosed}");
t.ok (refClosed.subtract (testB) == closedSubtractB, "Range: refClosed.subtract(testB) == {Range(testB.end(),refClosed.end())}");
t.ok (refClosed.subtract (testC) == closedSubtractC, "Range: refClosed.subtract(testC) == {Range(refClosed.start(),testC.start()),"
"Range(testC.end(),refClosed.end()}");
t.ok (refClosed.subtract (testD) == closedSubtractD, "Range: refClosed.subtract(testD) == {Range(refClosed.start(),testD.start())}");
t.ok (refClosed.subtract (testB) == closedSubtractB, "Range: refClosed.subtract(testB) == {Range(testB.end,refClosed.end)}");
t.ok (refClosed.subtract (testC) == closedSubtractC, "Range: refClosed.subtract(testC) == {Range(refClosed.start,testC.start),"
"Range(testC.end,refClosed.end}");
t.ok (refClosed.subtract (testD) == closedSubtractD, "Range: refClosed.subtract(testD) == {Range(refClosed.start,testD.start)}");
t.ok (refClosed.subtract (testE) == closedSubtractE, "Range: refClosed.subtract(testE) == {refClosed}");
t.ok (refClosed.subtract (testF) == closedSubtractF, "Range: refClosed.subtract(testF) == {}");
t.ok (refClosed.subtract (testG) == closedSubtractG, "Range: refClosed.subtract(testG) == {}");
t.ok (refClosed.subtract (testH) == closedSubtractH, "Range: refClosed.subtract(testH) == {refClosed.start(),testH.start()}");
t.ok (refClosed.subtract (testH) == closedSubtractH, "Range: refClosed.subtract(testH) == {refClosed.start,testH.start}");
t.ok (refClosed.subtract (testI) == closedSubtractI, "Range: refClosed.subtract(testI) == {refClosed}");
// this [...
@ -189,27 +189,27 @@ int main (int, char**)
// H [...
// I [...
std::vector <Range> openSubtractA {refOpen};
std::vector <Range> openSubtractB {Range (testB.end (), refOpen.end ())};
std::vector <Range> openSubtractC {Range (refOpen.start (), testC.start ()), Range (testC.end (), refOpen.end ())};
std::vector <Range> openSubtractD {Range (refOpen.start (), testD.start ()), Range (testD.end (), refOpen.end ())};
std::vector <Range> openSubtractE {Range (refOpen.start (), testE.start ()), Range (testE.end (), refOpen.end ())};
std::vector <Range> openSubtractF {Range (testF.end (), refOpen.end ())};
std::vector <Range> openSubtractB {Range (testB.end, refOpen.end)};
std::vector <Range> openSubtractC {Range (refOpen.start, testC.start), Range (testC.end, refOpen.end)};
std::vector <Range> openSubtractD {Range (refOpen.start, testD.start), Range (testD.end, refOpen.end)};
std::vector <Range> openSubtractE {Range (refOpen.start, testE.start), Range (testE.end, refOpen.end)};
std::vector <Range> openSubtractF {Range (testF.end, refOpen.end)};
std::vector <Range> openSubtractG {};
std::vector <Range> openSubtractH {Range (refOpen.start (), testH.start ())};
std::vector <Range> openSubtractI {Range (refOpen.start (), testI.start ())};
std::vector <Range> openSubtractH {Range (refOpen.start, testH.start)};
std::vector <Range> openSubtractI {Range (refOpen.start, testI.start)};
t.ok (refOpen.subtract (testA) == openSubtractA, "Range: refOpen.subtract(testA) == {refOpen}");
t.ok (refOpen.subtract (testB) == openSubtractB, "Range: refOpen.subtract(testB) == {Range(testB.end(),refOpen.end()}");
t.ok (refOpen.subtract (testC) == openSubtractC, "Range: refOpen.subtract(testC) == {Range(refOpen.start(),testC.start()),"
"Range(testC.end(),refOpen.end()}");
t.ok (refOpen.subtract (testD) == openSubtractD, "Range: refOpen.subtract(testD) == {Range(refOpen.start(),testD.start()),"
"Range(testD.end(),refOpen.end()}");
t.ok (refOpen.subtract (testE) == openSubtractE, "Range: refOpen.subtract(testE) == {Range(refOpen.start(),testE.start()),"
"Range(testE.end(),refOpen.end()}");
t.ok (refOpen.subtract (testF) == openSubtractF, "Range: refOpen.subtract(testF) == {Range(testF.end(),refOpen.end()}");
t.ok (refOpen.subtract (testB) == openSubtractB, "Range: refOpen.subtract(testB) == {Range(testB.end,refOpen.end}");
t.ok (refOpen.subtract (testC) == openSubtractC, "Range: refOpen.subtract(testC) == {Range(refOpen.start,testC.start),"
"Range(testC.end,refOpen.end}");
t.ok (refOpen.subtract (testD) == openSubtractD, "Range: refOpen.subtract(testD) == {Range(refOpen.start,testD.start),"
"Range(testD.end,refOpen.end}");
t.ok (refOpen.subtract (testE) == openSubtractE, "Range: refOpen.subtract(testE) == {Range(refOpen.start,testE.start),"
"Range(testE.end,refOpen.end}");
t.ok (refOpen.subtract (testF) == openSubtractF, "Range: refOpen.subtract(testF) == {Range(testF.end,refOpen.end}");
t.ok (refOpen.subtract (testG) == openSubtractG, "Range: refOpen.subtract(testG) == {}");
t.ok (refOpen.subtract (testH) == openSubtractH, "Range: refOpen.subtract(testH) == {Range(refOpen.start(),testH.start()}");
t.ok (refOpen.subtract (testI) == openSubtractI, "Range: refOpen.subtract(testI) == {Range(refOpen.start(),testI.start()}");
t.ok (refOpen.subtract (testH) == openSubtractH, "Range: refOpen.subtract(testH) == {Range(refOpen.start,testH.start}");
t.ok (refOpen.subtract (testI) == openSubtractI, "Range: refOpen.subtract(testI) == {Range(refOpen.start,testI.start}");
return 0;
}