Adding validation for uniqueness of service_id X date in calendar_dates

python/test/testtransitfeed.py

 #!/usr/bin/python2.5
 
 # Copyright (C) 2007 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
 # Unit tests for the transitfeed module.
 
 import datetime
+from datetime import date
 import dircache
 import os.path
 import re
 import sys
 import tempfile
 import time
 import traceback
 import transitfeed
 import unittest
 from StringIO import StringIO
 import zipfile
 import zlib
 
+import util
 
 def DataPath(path):
   here = os.path.dirname(__file__)
   return os.path.join(here, 'data', path)
 
 def GetDataPathContents():
   here = os.path.dirname(__file__)
   return dircache.listdir(os.path.join(here, 'data'))
 
 
@@ skipping 607 matching lines @@
         "ColorLuminance('FFFFFF') should be 255*7 = 1785")
     RGBmsg = "ColorLuminance('RRGGBB') should be 2*<Red>+4*<Green>+<Blue>"
     self.assertEqual(transitfeed.ColorLuminance('800000'), 2*128, RGBmsg)
     self.assertEqual(transitfeed.ColorLuminance('008000'), 4*128, RGBmsg)
     self.assertEqual(transitfeed.ColorLuminance('000080'), 1*128, RGBmsg)
     self.assertEqual(transitfeed.ColorLuminance('1171B3'), 17*2 + 113*4 + 179*1,
         RGBmsg)
     pass
 
 INVALID_VALUE = Exception()
-class ValidationTestCase(unittest.TestCase):
+class ValidationTestCase(util.TestCaseAsserts):
   def setUp(self):
     self.problems = RecordingProblemReporter(self, ("ExpirationDate",))
-
-  def assertMatchesRegex(self, regex, string):
-    """Assert that regex is found in string."""
-    if not re.search(regex, string):
-      self.fail("string %r did not match regex %r" % (string, regex))
 
   def ExpectNoProblems(self, object):
     self.problems.AssertNoMoreExceptions()
     object.Validate(self.problems)
     self.problems.AssertNoMoreExceptions()
 
   # TODO: Get rid of Expect*Closure methods. With the
   # RecordingProblemReporter it is now possible to replace
   # self.ExpectMissingValueInClosure(lambda: o.method(...), foo)
   # with
@@ skipping 370 matching lines @@
         lambda: transitfeed.StopTime(self.problems, stop,
                                      arrival_time="10:60:00",
                                      departure_time="11:02:00"))
     # The following should work
     transitfeed.StopTime(self.problems, stop, arrival_time="10:00:00",
         departure_time="10:05:00", pickup_type='1', drop_off_type='1')
     transitfeed.StopTime(self.problems, stop, arrival_time="1:00:00",
         departure_time="1:05:00")
     transitfeed.StopTime(self.problems, stop, arrival_time="24:59:00",
         departure_time="25:05:00")
+    transitfeed.StopTime(self.problems, stop, arrival_time="101:01:00",
+        departure_time="101:21:00")
     transitfeed.StopTime(self.problems, stop)
     self.problems.AssertNoMoreExceptions()
 
+class TravelSpeedTestCase(ValidationTestCase):
+  def runTest(self):
+    schedule = transitfeed.Schedule(problem_reporter=self.problems)
+    schedule.NewDefaultAgency(agency_name="Test Agency",
+                              agency_url="http://example.com",
+                              agency_timezone="America/Los_Angeles")
+    route = schedule.AddRoute(short_name="54C", long_name="Polish Hill", route_type=3)
+
+    service_period = schedule.GetDefaultServicePeriod()
+    service_period.SetDateHasService("20070101")
+
+    trip = route.AddTrip(schedule, 'via Polish Hill')
+
+    stop1 = schedule.AddStop(36.425288, -117.133162, "Demo Stop 1")
+    stop2 = schedule.AddStop(36.440466, -117.132463, "Demo Stop 2")
+    stop3 = schedule.AddStop(36.425999, -117.133999, "Demo Stop 3")
+
+    trip.AddStopTime(stop1, stop_time="12:00:00")
+    trip.AddStopTime(stop2, stop_time="12:01:00")
+    trip.AddStopTime(stop3, stop_time="12:02:00")
+    trip.AddStopTime(stop1, stop_time="12:02:00")
+
+    trip.Validate(self.problems)
+    e = self.problems.PopException('TooFastTravel')
+    self.assertTrue(e.FormatProblem().find('High speed travel detected') != -1)
+    self.assertTrue(e.FormatProblem().find('Stop 1 to Demo Stop 2') != -1)
+    self.assertTrue(e.FormatProblem().find('1690 meters in 60 seconds') != -1)
+    self.assertTrue(e.FormatProblem().find('(101.445967 km/h)') != -1)
+    self.assertEqual(e.type, transitfeed.TYPE_WARNING)
+    e = self.problems.PopException('TooFastTravel')
+    self.assertTrue(e.FormatProblem().find('High speed travel detected') != -1)
+    self.assertTrue(e.FormatProblem().find('Stop 3 to Demo Stop 1') != -1)
+    self.assertTrue(e.FormatProblem().find('109 meters in 0 seconds') != -1)
+    self.assertEqual(e.type, transitfeed.TYPE_WARNING)
+    self.problems.AssertNoMoreExceptions()
+
+    # Run test without a route_type
+    route.route_type = None
+    trip.Validate(self.problems)
+    e = self.problems.PopException('TooFastTravel')
+    self.assertTrue(e.FormatProblem().find('High speed travel detected') != -1)
+    self.assertTrue(e.FormatProblem().find('Stop 1 to Demo Stop 2') != -1)
+    self.assertTrue(e.FormatProblem().find('1690 meters in 60 seconds') != -1)
+    self.assertTrue(e.FormatProblem().find('(101.445967 km/h)') != -1)
+    self.assertEqual(e.type, transitfeed.TYPE_WARNING)
+    e = self.problems.PopException('TooFastTravel')
+    self.assertTrue(e.FormatProblem().find('High speed travel detected') != -1)
+    self.assertTrue(e.FormatProblem().find('Stop 2 to Demo Stop 3') != -1)
+    self.assertTrue(e.FormatProblem().find('1616 meters in 60 seconds') != -1)
+    self.assertTrue(e.FormatProblem().find('(96.979408 km/h)') != -1)
+    self.assertEqual(e.type, transitfeed.TYPE_WARNING)
+    e = self.problems.PopException('TooFastTravel')
+    self.assertTrue(e.FormatProblem().find('High speed travel detected') != -1)
+    self.assertTrue(e.FormatProblem().find('Stop 3 to Demo Stop 1') != -1)
+    self.assertTrue(e.FormatProblem().find('109 meters in 0 seconds') != -1)
+    self.assertEqual(e.type, transitfeed.TYPE_WARNING)
+    self.problems.AssertNoMoreExceptions()
 
 class MemoryZipTestCase(unittest.TestCase):
   def setUp(self):
     self.problems = RecordingProblemReporter(self, ("ExpirationDate",))
     self.zipfile = StringIO()
     self.zip = zipfile.ZipFile(self.zipfile, 'a')
     self.zip.writestr(
         "agency.txt",
         "agency_id,agency_name,agency_url,agency_timezone\n"
         "DTA,Demo Agency,http://google.com,America/Los_Angeles\n")
@@ skipping 360 matching lines @@
     self.assertEquals("parent_station", e.column_name)
     self.assertTrue(e.FormatProblem().find("location_type=1") != -1)
     self.problems.AssertNoMoreExceptions()
 
   def testStationWithParent(self):
     self.zip.writestr(
         "stops.txt",
         "stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n"
         "BEATTY_AIRPORT,Airport,36.868446,-116.784582,,STATION\n"
         "STATION,Airport,36.868446,-116.784582,1,STATION2\n"
-        "STATION2,Airport 2,40.868446,-116.784582,1,\n"
-        "BULLFROG,Bullfrog,36.88108,-116.81797,,STATION2\n"
+        "STATION2,Airport 2,36.868000,-116.784000,1,\n"
+        "BULLFROG,Bullfrog,36.868088,-116.784797,,STATION2\n"
         "STAGECOACH,Stagecoach Hotel,36.915682,-116.751677,,\n")
     schedule = self.loader.Load()
     e = self.problems.PopException("InvalidValue")
     self.assertEquals("parent_station", e.column_name)
     self.assertEquals(3, e.row_num)
     self.problems.AssertNoMoreExceptions()
 
   def testStationWithSelfParent(self):
     self.zip.writestr(
         "stops.txt",
         "stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n"
         "BEATTY_AIRPORT,Airport,36.868446,-116.784582,,STATION\n"
         "STATION,Airport,36.868446,-116.784582,1,STATION\n"
         "BULLFROG,Bullfrog,36.88108,-116.81797,,\n"
         "STAGECOACH,Stagecoach Hotel,36.915682,-116.751677,,\n")
     schedule = self.loader.Load()
     e = self.problems.PopException("InvalidValue")
     self.assertEquals("parent_station", e.column_name)
     self.assertEquals(3, e.row_num)
+    self.problems.AssertNoMoreExceptions()
+
+  def testStopNearToNonParentStation(self):
+    self.zip.writestr(
+        "stops.txt",
+        "stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n"
+        "BEATTY_AIRPORT,Airport,36.868446,-116.784582,,\n"
+        "BULLFROG,Bullfrog,36.868446,-116.784582,,\n"
+        "BULLFROG_ST,Bullfrog,36.868446,-116.784582,1,\n"
+        "STAGECOACH,Stagecoach Hotel,36.915682,-116.751677,,\n")
+    schedule = self.loader.Load()
+    e = self.problems.PopException("OtherProblem")
+    self.assertTrue(e.FormatProblem().find(
+        "The parent_station of stop \"Bullfrog\"") != -1)
+    e = self.problems.PopException("OtherProblem")
+    e = self.problems.PopException("OtherProblem")
+    self.assertTrue(e.FormatProblem().find(
+        "The parent_station of stop \"Airport\"") != -1)
+    self.problems.AssertNoMoreExceptions()
+
+  def testStopTooFarFromParentStation(self):
+    self.zip.writestr(
+        "stops.txt",
+        "stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n"
+        "BULLFROG_ST,Bullfrog,36.880,-116.817,1,\n"   # Parent station of all.
+        "BEATTY_AIRPORT,Airport,36.880,-116.816,,BULLFROG_ST\n"   # ~ 90m far
+        "BULLFROG,Bullfrog,36.881,-116.818,,BULLFROG_ST\n"        # ~ 150m far
+        "STAGECOACH,Stagecoach,36.915,-116.751,,BULLFROG_ST\n")   # > 3km far
+    schedule = self.loader.Load()
+    e = self.problems.PopException("StopTooFarFromParentStation")
+    self.assertEqual(1, e.type)  # Warning
+    self.assertTrue(e.FormatProblem().find(
+        "Bullfrog (ID BULLFROG) is too far from its parent"
+        " station Bullfrog (ID BULLFROG_ST)") != -1)
+    e = self.problems.PopException("StopTooFarFromParentStation")
+    self.assertEqual(0, e.type)  # Error
+    self.assertTrue(e.FormatProblem().find(
+        "Stagecoach (ID STAGECOACH) is too far from its parent"
+        " station Bullfrog (ID BULLFROG_ST)") != -1)
     self.problems.AssertNoMoreExceptions()
 
   #Uncomment once validation is implemented
   #def testStationWithoutReference(self):
   #  self.zip.writestr(
   #      "stops.txt",
   #      "stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n"
   #      "BEATTY_AIRPORT,Airport,36.868446,-116.784582,,\n"
   #      "STATION,Airport,36.868446,-116.784582,1,\n"
   #      "BULLFROG,Bullfrog,36.88108,-116.81797,,\n"
@@ skipping 75 matching lines @@
     self.problems.AssertNoMoreExceptions()
 
 
 class StopsNearEachOther(MemoryZipTestCase):
   def testTooNear(self):
     self.zip.writestr(
         "stops.txt",
         "stop_id,stop_name,stop_lat,stop_lon\n"
         "BEATTY_AIRPORT,Airport,48.20000,140\n"
         "BULLFROG,Bullfrog,48.20001,140\n"
-        "STAGECOACH,Stagecoach Hotel,36.915682,-116.751677\n")
+        "STAGECOACH,Stagecoach Hotel,48.20016,140\n")
     schedule = self.loader.Load()
     e = self.problems.PopException('OtherProblem')
     self.assertTrue(e.FormatProblem().find("1.11m apart") != -1)
     self.problems.AssertNoMoreExceptions()
 
   def testJustFarEnough(self):
     self.zip.writestr(
         "stops.txt",
         "stop_id,stop_name,stop_lat,stop_lon\n"
         "BEATTY_AIRPORT,Airport,48.20000,140\n"
         "BULLFROG,Bullfrog,48.20002,140\n"
-        "STAGECOACH,Stagecoach Hotel,36.915682,-116.751677\n")
+        "STAGECOACH,Stagecoach Hotel,48.20016,140\n")
     schedule = self.loader.Load()
     # Stops are 2.2m apart
     self.problems.AssertNoMoreExceptions()
 
   def testSameLocation(self):
     self.zip.writestr(
         "stops.txt",
         "stop_id,stop_name,stop_lat,stop_lon\n"
         "BEATTY_AIRPORT,Airport,48.2,140\n"
         "BULLFROG,Bullfrog,48.2,140\n"
-        "STAGECOACH,Stagecoach Hotel,36.915682,-116.751677\n")
+        "STAGECOACH,Stagecoach Hotel,48.20016,140\n")
     schedule = self.loader.Load()
     e = self.problems.PopException('OtherProblem')
     self.assertTrue(e.FormatProblem().find("0.00m apart") != -1)
     self.problems.AssertNoMoreExceptions()
 
   def testStationsTooNear(self):
     self.zip.writestr(
         "stops.txt",
         "stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n"
         "BEATTY_AIRPORT,Airport,48.20000,140,,BEATTY_AIRPORT_STATION\n"
         "BULLFROG,Bullfrog,48.20003,140,,BULLFROG_STATION\n"
         "BEATTY_AIRPORT_STATION,Airport,48.20001,140,1,\n"
         "BULLFROG_STATION,Bullfrog,48.20002,140,1,\n"
-        "STAGECOACH,Stagecoach Hotel,36.915682,-116.751677,,\n")
+        "STAGECOACH,Stagecoach Hotel,48.20016,140,,\n")
     schedule = self.loader.Load()
     e = self.problems.PopException('OtherProblem')
     self.assertTrue(e.FormatProblem().find("1.11m apart") != -1)
     self.assertTrue(e.FormatProblem().find("BEATTY_AIRPORT_STATION") != -1)
     self.problems.AssertNoMoreExceptions()
 
   def testStopNearNonParentStation(self):
     self.zip.writestr(
         "stops.txt",
         "stop_id,stop_name,stop_lat,stop_lon,location_type,parent_station\n"
         "BEATTY_AIRPORT,Airport,48.20000,140,,\n"
         "BULLFROG,Bullfrog,48.20005,140,,\n"
         "BULLFROG_STATION,Bullfrog,48.20006,140,1,\n"
-        "STAGECOACH,Stagecoach Hotel,36.915682,-116.751677,,\n")
+        "STAGECOACH,Stagecoach Hotel,48.20016,140,,\n")
     schedule = self.loader.Load()
     e = self.problems.PopException('OtherProblem')
     fmt = e.FormatProblem()
     self.assertTrue(re.search(
       r"parent_station of.*BULLFROG.*station.*BULLFROG_STATION.* 1.11m apart",
       fmt), fmt)
     self.problems.AssertNoMoreExceptions()
 
 
 class BadLatLonInStopUnitTest(ValidationTestCase):
@@ skipping 724 matching lines @@
     self.assertFalse(period_no_end.IsActiveOn('20071231'))
     self.assertEquals(period_no_end.ActiveDates(), [])
     period_no_start = transitfeed.ServicePeriod()
     period_no_start.end_date = '20071230'
     self.assertFalse(period_no_start.IsActiveOn('20071229'))
     self.assertEquals(period_no_start.ActiveDates(), [])
 
     period_empty = transitfeed.ServicePeriod()
     self.assertFalse(period_empty.IsActiveOn('20071231'))
     self.assertEquals(period_empty.ActiveDates(), [])
+
+
+class GetServicePeriodsActiveEachDateTestCase(unittest.TestCase):
+  def testEmpty(self):
+    schedule = transitfeed.Schedule()
+    self.assertEquals(
+        [],
+        schedule.GetServicePeriodsActiveEachDate(date(2009, 1, 1),
+                                                 date(2009, 1, 1)))
+    self.assertEquals(
+        [(date(2008, 12, 31), []), (date(2009, 1, 1), [])],
+        schedule.GetServicePeriodsActiveEachDate(date(2008, 12, 31),
+                                                 date(2009, 1, 2)))
+  def testOneService(self):
+    schedule = transitfeed.Schedule()
+    sp1 = transitfeed.ServicePeriod()
+    sp1.service_id = "sp1"
+    sp1.SetDateHasService("20090101")
+    sp1.SetDateHasService("20090102")
+    schedule.AddServicePeriodObject(sp1)
+    self.assertEquals(
+        [],
+        schedule.GetServicePeriodsActiveEachDate(date(2009, 1, 1),
+                                                 date(2009, 1, 1)))
+    self.assertEquals(
+        [(date(2008, 12, 31), []), (date(2009, 1, 1), [sp1])],
+        schedule.GetServicePeriodsActiveEachDate(date(2008, 12, 31),
+                                                 date(2009, 1, 2)))
+
+  def testTwoService(self):
+    schedule = transitfeed.Schedule()
+    sp1 = transitfeed.ServicePeriod()
+    sp1.service_id = "sp1"
+    sp1.SetDateHasService("20081231")
+    sp1.SetDateHasService("20090101")
+
+    schedule.AddServicePeriodObject(sp1)
+    sp2 = transitfeed.ServicePeriod()
+    sp2.service_id = "sp2"
+    sp2.SetStartDate("20081201")
+    sp2.SetEndDate("20081231")
+    sp2.SetWeekendService()
+    sp2.SetWeekdayService()
+    schedule.AddServicePeriodObject(sp2)
+    self.assertEquals(
+        [],
+        schedule.GetServicePeriodsActiveEachDate(date(2009, 1, 1),
+                                                 date(2009, 1, 1)))
+    date_services = schedule.GetServicePeriodsActiveEachDate(date(2008, 12, 31),
+                                                             date(2009, 1, 2))
+    self.assertEquals(
+        [date(2008, 12, 31), date(2009, 1, 1)], [d for d, _ in date_services])
+    self.assertEquals(set([sp1, sp2]), set(date_services[0][1]))
+    self.assertEquals([sp1], date_services[1][1])
 
 
 class TripMemoryZipTestCase(MemoryZipTestCase):
   def assertLoadAndCheckExtraValues(self, schedule_file):
     """Load file-like schedule_file and check for extra trip columns."""
     load_problems = TestFailureProblemReporter(
         self, ("ExpirationDate", "UnrecognizedColumn"))
     loaded_schedule = transitfeed.Loader(schedule_file,
                                          problems=load_problems,
                                          extra_validation=True).Load()
@@ skipping 459 matching lines @@
     stop2 = transitfeed.Stop(36.424288, -117.158142, "Demo Stop 2", "STOP2")
     schedule.AddStopObject(stop2)
     trip1.AddStopTime(stop2, arrival_time="5:15:00", departure_time="5:16:00",
                       stop_sequence=1, shape_dist_traveled=1)
     trip2.AddStopTime(stop2, arrival_time="5:25:00", departure_time="5:26:00",
                       stop_sequence=1, shape_dist_traveled=1)
     trip3.AddStopTime(stop2, arrival_time="6:15:00", departure_time="6:16:00",
                       stop_sequence=0, shape_dist_traveled=0)
     
     schedule.Validate(self.problems)
-    e = self.problems.PopException('OtherProblem')
+    e = self.problems.PopException('DuplicateTrip')
     self.assertTrue(e.FormatProblem().find('t1 of route') != -1)
     self.assertTrue(e.FormatProblem().find('t2 of route') != -1)
     self.problems.AssertNoMoreExceptions()
-        
+
+
+class StopBelongsToBothSubwayAndBusTestCase(ValidationTestCase):
+  def runTest(self):
+    schedule = transitfeed.Schedule(self.problems)
+
+    schedule.AddAgency("Demo Agency", "http://example.com", 
+                        "America/Los_Angeles")
+    route1 = schedule.AddRoute(short_name="route1", long_name="route_1", 
+                               route_type=3)
+    route2 = schedule.AddRoute(short_name="route2", long_name="route_2", 
+                               route_type=1)
+    
+    service = schedule.GetDefaultServicePeriod()
+    service.SetDateHasService("20070101")
+    
+    trip1 = route1.AddTrip(schedule, "trip1", service, "t1")
+    trip2 = route2.AddTrip(schedule, "trip2", service, "t2")
+    
+    stop1 = schedule.AddStop(36.425288, -117.133162, "stop1")
+    stop2 = schedule.AddStop(36.424288, -117.133142, "stop2")
+    stop3 = schedule.AddStop(36.423288, -117.134142, "stop3")
+    
+    trip1.AddStopTime(stop1, arrival_time="5:11:00", departure_time="5:12:00")
+    trip1.AddStopTime(stop2, arrival_time="5:21:00", departure_time="5:22:00")
+    
+    trip2.AddStopTime(stop1, arrival_time="6:11:00", departure_time="6:12:00")
+    trip2.AddStopTime(stop3, arrival_time="6:21:00", departure_time="6:22:00")
+    
+    schedule.Validate(self.problems)
+    e = self.problems.PopException("StopWithMultipleRouteTypes")
+    self.assertTrue(e.FormatProblem().find("Stop stop1") != -1)
+    self.assertTrue(e.FormatProblem().find("subway (ID=1)") != -1)
+    self.assertTrue(e.FormatProblem().find("bus line (ID=0)") != -1)
+    self.problems.AssertNoMoreExceptions()
+
+
 class TripReplaceStopTimeObjectTestCase(unittest.TestCase):
   def runTest(self):
     schedule = transitfeed.Schedule()
     schedule.AddAgency("\xc8\x8b Fly Agency", "http://iflyagency.com",
                        "America/Los_Angeles")
     service_period = \
       schedule.GetDefaultServicePeriod().SetDateHasService('20070101')
     stop1 = schedule.AddStop(lng=140, lat=48.2, name="Stop 1")
     route = schedule.AddRoute("B", "Beta", "Bus")
     trip = route.AddTrip(schedule, "bus trip")
@@ skipping 173 matching lines @@
     self.problems.AssertNoMoreExceptions()
     
 
 
 class OnlyCalendarDatesTestCase(LoadTestCase):
   def runTest(self):
     self.Load('only_calendar_dates'),
     self.problems.AssertNoMoreExceptions()
 
 
-class DuplicateServiceIdDateWarningTestCase(LoadTestCase):
-  def runTest(self):
-    self.Load('duplicate_service_id_date')
-    e = self.problems.PopException("DuplicateID")
-    self.assertEquals(2, len(e.column_names))
-    self.assertEquals("service_id", e.column_names[0])
-    self.assertEquals("date", e.column_names[1])
+class DuplicateServiceIdDateWarningTestCase(MemoryZipTestCase):
+  def runTest(self):
+    # Two lines with the same value of service_id and date.
+    # Test for the warning.
+    self.zip.writestr(
+        'calendar_dates.txt',
+        'service_id,date,exception_type\n'
+        'FULLW,20100604,1\n'
+        'FULLW,20100604,2\n')
+    schedule = self.loader.Load()
+    e = self.problems.PopException('DuplicateID')
+    self.assertEquals('(service_id, date)', e.column_name)
+    self.assertEquals('(FULLW, 20100604)', e.value)
+
 
 class AddStopTimeParametersTestCase(unittest.TestCase):
   def runTest(self):
     problem_reporter = TestFailureProblemReporter(self)
     schedule = transitfeed.Schedule(problem_reporter=problem_reporter)
     route = schedule.AddRoute(short_name="10", long_name="", route_type="Bus")
     stop = schedule.AddStop(40, -128, "My stop")
     # Stop must be added to schedule so that the call
     # AddStopTime -> AddStopTimeObject -> GetStopTimes -> GetStop can work
     trip = transitfeed.Trip()
     trip.route_id = route.route_id
     trip.service_id = schedule.GetDefaultServicePeriod().service_id
     trip.trip_id = "SAMPLE_TRIP"
     schedule.AddTripObject(trip)
 
     # First stop must have time
     trip.AddStopTime(stop, arrival_secs=300, departure_secs=360)
     trip.AddStopTime(stop)
     trip.AddStopTime(stop, arrival_time="00:07:00", departure_time="00:07:30")
     trip.Validate(problem_reporter)
 
 
 class ExpirationDateTestCase(unittest.TestCase):
   def runTest(self):
-    schedule = transitfeed.Schedule(
-        problem_reporter=transitfeed.ExceptionProblemReporter(
-            raise_warnings=True))
+    problems = RecordingProblemReporter(self)
+    schedule = transitfeed.Schedule(problem_reporter=problems)
 
     now = time.mktime(time.localtime())
     seconds_per_day = 60 * 60 * 24
     two_weeks_ago = time.localtime(now - 14 * seconds_per_day)
     two_weeks_from_now = time.localtime(now + 14 * seconds_per_day)
     two_months_from_now = time.localtime(now + 60 * seconds_per_day)
     date_format = "%Y%m%d"
 
     service_period = schedule.GetDefaultServicePeriod()
     service_period.SetWeekdayService(True)
     service_period.SetStartDate("20070101")
+
     service_period.SetEndDate(time.strftime(date_format, two_months_from_now))
-
     schedule.Validate()  # should have no problems
+    problems.AssertNoMoreExceptions()
 
     service_period.SetEndDate(time.strftime(date_format, two_weeks_from_now))
-
-    try:
-      schedule.Validate()
-      self.fail('ExpirationDate exception expected')
-    except transitfeed.ExpirationDate, e:
-      # raises exception if not found
-      e.FormatProblem().index('will soon expire')
+    schedule.Validate()
+    e = problems.PopException('ExpirationDate')
+    self.assertTrue(e.FormatProblem().index('will soon expire'))
+    problems.AssertNoMoreExceptions()
 
     service_period.SetEndDate(time.strftime(date_format, two_weeks_ago))
-
-    try:
-      schedule.Validate()
-      self.fail('ExpirationDate exception expected')
-    except transitfeed.ExpirationDate, e:
-      # raises exception if not found
-      e.FormatProblem().index('expired')
+    schedule.Validate()
+    e = problems.PopException('ExpirationDate')
+    self.assertTrue(e.FormatProblem().index('expired'))
+    problems.AssertNoMoreExceptions()
+
+
+class FutureServiceStartDateTestCase(unittest.TestCase):
+  def runTest(self):
+    problems = RecordingProblemReporter(self)
+    schedule = transitfeed.Schedule(problem_reporter=problems)
+
+    today = datetime.date.today()
+    yesterday = today - datetime.timedelta(days=1)
+    tomorrow = today + datetime.timedelta(days=1)
+    two_months_from_today = today + datetime.timedelta(days=60)
+
+    service_period = schedule.GetDefaultServicePeriod()
+    service_period.SetWeekdayService(True)
+    service_period.SetWeekendService(True)
+    service_period.SetEndDate(two_months_from_today.strftime("%Y%m%d"))
+
+    service_period.SetStartDate(yesterday.strftime("%Y%m%d"))
+    schedule.Validate()
+    problems.AssertNoMoreExceptions()
+
+    service_period.SetStartDate(today.strftime("%Y%m%d"))
+    schedule.Validate()
+    problems.AssertNoMoreExceptions()
+
+    service_period.SetStartDate(tomorrow.strftime("%Y%m%d"))
+    schedule.Validate()
+    problems.PopException('FutureService')
+    problems.AssertNoMoreExceptions()
+ 
+
+class CalendarTxtIntegrationTestCase(MemoryZipTestCase):
+  def testBadEndDateFormat(self):
+    # A badly formatted end_date used to generate an InvalidValue report from
+    # Schedule.Validate and ServicePeriod.Validate. Test for the bug.
+    self.zip.writestr(
+        "calendar.txt",
+        "service_id,monday,tuesday,wednesday,thursday,friday,saturday,sunday,"
+        "start_date,end_date\n"
+        "FULLW,1,1,1,1,1,1,1,20070101,20101232\n"
+        "WE,0,0,0,0,0,1,1,20070101,20101231\n")
+    schedule = self.loader.Load()
+    e = self.problems.PopInvalidValue('end_date')
+    self.problems.AssertNoMoreExceptions()
+
+  def testBadStartDateFormat(self):
+    self.zip.writestr(
+        "calendar.txt",
+        "service_id,monday,tuesday,wednesday,thursday,friday,saturday,sunday,"
+        "start_date,end_date\n"
+        "FULLW,1,1,1,1,1,1,1,200701xx,20101231\n"
+        "WE,0,0,0,0,0,1,1,20070101,20101231\n")
+    schedule = self.loader.Load()
+    e = self.problems.PopInvalidValue('start_date')
+    self.problems.AssertNoMoreExceptions()
 
 
 class DuplicateTripIDValidationTestCase(unittest.TestCase):
   def runTest(self):
     schedule = transitfeed.Schedule(
         problem_reporter=ExceptionProblemReporterNoExpiration())
     schedule.AddAgency("Sample Agency", "http://example.com",
                        "America/Los_Angeles")
     route = transitfeed.Route()
     route.route_id = "SAMPLE_ID"
@@ skipping 14 matching lines @@
     schedule.AddTripObject(trip1)
 
     trip2 = transitfeed.Trip()
     trip2.route_id = "SAMPLE_ID"
     trip2.service_id = "WEEK"
     trip2.trip_id = "SAMPLE_TRIP"
     try:
       schedule.AddTripObject(trip2)
       self.fail("Expected Duplicate ID validation failure")
     except transitfeed.DuplicateID, e:
-      self.assertEqual("trip_id", e.column_names[0])
-      self.assertEqual("SAMPLE_TRIP", e.values[0])
+      self.assertEqual("trip_id", e.column_name)
+      self.assertEqual("SAMPLE_TRIP", e.value)
 
 
 class DuplicateStopValidationTestCase(ValidationTestCase):
   def runTest(self):
     schedule = transitfeed.Schedule(problem_reporter=self.problems)
     schedule.AddAgency("Sample Agency", "http://example.com",
                        "America/Los_Angeles")
     route = transitfeed.Route()
     route.route_id = "SAMPLE_ID"
     route.route_type = 3
@@ skipping 321 matching lines @@
     trip = route.AddTrip(schedule, headsign="To The End",
                          service_period=service_period)
     trip_id = trip.trip_id
     self.assertTrue(trip_id)
     trip = schedule.GetTrip(trip_id)
     self.assertEqual("To The End", trip.trip_headsign)
     self.assertEqual(service_period, trip.service_period)
 
     trip.AddStopTime(stop=stop1, arrival_secs=3600*8, departure_secs=3600*8)
     trip.AddStopTime(stop=stop2)
-    trip.AddStopTime(stop=stop3, arrival_secs=3600*8 + 60*15,
-                     departure_secs=3600*8 + 60*15)
-    trip.AddStopTime(stop=stop4, arrival_time="8:25:00",
-                     departure_secs=3600*8 + 60*26, stop_headsign="Last stop",
+    trip.AddStopTime(stop=stop3, arrival_secs=3600*8 + 60*60,
+                     departure_secs=3600*8 + 60*60)
+    trip.AddStopTime(stop=stop4, arrival_time="9:13:00",
+                     departure_secs=3600*8 + 60*103, stop_headsign="Last stop",
                      pickup_type=1, drop_off_type=3)
 
     schedule.Validate()
     self.assertEqual(4, len(trip.GetTimeStops()))
     self.assertEqual(1, len(schedule.GetRouteList()))
     self.assertEqual(4, len(schedule.GetStopList()))
 
 
 class WriteSampleFeedTestCase(TempFileTestCaseBase):
   def assertEqualTimeString(self, a, b):
@@ skipping 668 matching lines @@
     stoptimes = self.trip1.GetStopTimes()
     for stoptimes_clone in stoptimes_list:
       self.assertEqual(len(stoptimes_clone), len(stoptimes))
       for st_clone, st in zip(stoptimes_clone, stoptimes):
         for name in st.__slots__:
           if name not in ('arrival_secs', 'departure_secs'):
             self.assertEqual(getattr(st, name), getattr(st_clone, name))
 
 if __name__ == '__main__':
   unittest.main()