def runTest(self): accumulator = test_util.RecordingProblemAccumulator(self) problems = ProblemReporter(accumulator) self.assertEqual(0, util.NonNegIntStringToInt("0", problems)) self.assertEqual(0, util.NonNegIntStringToInt(u"0", problems)) self.assertEqual(1, util.NonNegIntStringToInt("1", problems)) self.assertEqual(2, util.NonNegIntStringToInt("2", problems)) self.assertEqual(10, util.NonNegIntStringToInt("10", problems)) self.assertEqual( 1234567890123456789, util.NonNegIntStringToInt("1234567890123456789", problems), ) self.assertRaises(ValueError, util.NonNegIntStringToInt, "", problems) self.assertRaises(ValueError, util.NonNegIntStringToInt, "-1", problems) self.assertRaises(ValueError, util.NonNegIntStringToInt, "0x1", problems) self.assertRaises(ValueError, util.NonNegIntStringToInt, "1.0", problems) self.assertRaises(ValueError, util.NonNegIntStringToInt, "1e1", problems) self.assertRaises(ValueError, util.NonNegIntStringToInt, "0x20", problems) self.assertRaises(ValueError, util.NonNegIntStringToInt, "0b10", problems) self.assertRaises(TypeError, util.NonNegIntStringToInt, 1, problems) self.assertRaises(TypeError, util.NonNegIntStringToInt, None, problems) # These should issue a warning, but otherwise parse successfully self.assertEqual(1, util.NonNegIntStringToInt("+1", problems)) e = accumulator.PopException("InvalidNonNegativeIntegerValue") self.assertEqual(1, util.NonNegIntStringToInt("01", problems)) e = accumulator.PopException("InvalidNonNegativeIntegerValue") self.assertEqual(0, util.NonNegIntStringToInt("00", problems)) e = accumulator.PopException("InvalidNonNegativeIntegerValue") accumulator.AssertNoMoreExceptions()
def runTest(self): accumulator = util.RecordingProblemAccumulator(self, ("NoServiceExceptions")) problems = transitfeed.ProblemReporter(accumulator) 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 accumulator.AssertNoMoreExceptions() service_period.SetEndDate( time.strftime(date_format, two_weeks_from_now)) schedule.Validate() e = accumulator.PopException("ExpirationDate") self.assertTrue(e.FormatProblem().index("will soon expire")) accumulator.AssertNoMoreExceptions() service_period.SetEndDate(time.strftime(date_format, two_weeks_ago)) schedule.Validate() e = accumulator.PopException("ExpirationDate") self.assertTrue(e.FormatProblem().index("expired")) accumulator.AssertNoMoreExceptions()
def runTest(self): accumulator = test_util.RecordingProblemAccumulator(self) problems = ProblemReporter(accumulator) self.assertAlmostEqual(0, util.FloatStringToFloat("0", problems)) self.assertAlmostEqual(0, util.FloatStringToFloat(u"0", problems)) self.assertAlmostEqual(1, util.FloatStringToFloat("1", problems)) self.assertAlmostEqual(1, util.FloatStringToFloat("1.00000", problems)) self.assertAlmostEqual(1.5, util.FloatStringToFloat("1.500", problems)) self.assertAlmostEqual(-2, util.FloatStringToFloat("-2.0", problems)) self.assertAlmostEqual(-2.5, util.FloatStringToFloat("-2.5", problems)) self.assertRaises(ValueError, util.FloatStringToFloat, ".", problems) self.assertRaises(ValueError, util.FloatStringToFloat, "0x20", problems) self.assertRaises(ValueError, util.FloatStringToFloat, "-0x20", problems) self.assertRaises(ValueError, util.FloatStringToFloat, "0b10", problems) # These should issue a warning, but otherwise parse successfully self.assertAlmostEqual(0.001, util.FloatStringToFloat("1E-3", problems)) e = accumulator.PopException("InvalidFloatValue") self.assertAlmostEqual(0.001, util.FloatStringToFloat(".001", problems)) e = accumulator.PopException("InvalidFloatValue") self.assertAlmostEqual(-0.001, util.FloatStringToFloat("-.001", problems)) e = accumulator.PopException("InvalidFloatValue") self.assertAlmostEqual(0, util.FloatStringToFloat("0.", problems)) e = accumulator.PopException("InvalidFloatValue") accumulator.AssertNoMoreExceptions()
def runTest(self): accumulator = util.RecordingProblemAccumulator(self) problems = transitfeed.ProblemReporter(accumulator) 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.get_default_service_period() service_period.set_weekday_service(True) service_period.set_weekend_service(True) service_period.set_end_date(two_months_from_today.strftime("%Y%m%d")) service_period.set_start_date(yesterday.strftime("%Y%m%d")) schedule.validate() accumulator.assert_no_more_exceptions() service_period.set_start_date(today.strftime("%Y%m%d")) schedule.validate() accumulator.assert_no_more_exceptions() service_period.set_start_date(tomorrow.strftime("%Y%m%d")) schedule.validate() accumulator.pop_exception('FutureService') accumulator.assert_no_more_exceptions()
def runTest(self): accumulator = util.RecordingProblemAccumulator(self, "NoServiceExceptions") problems = transitfeed.ProblemReporter(accumulator) 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.get_default_service_period() service_period.set_weekday_service(True) service_period.set_start_date("20070101") service_period.set_end_date( time.strftime(date_format, two_months_from_now)) schedule.validate() # should have no problems accumulator.assert_no_more_exceptions() service_period.set_end_date( time.strftime(date_format, two_weeks_from_now)) schedule.validate() e = accumulator.pop_exception('ExpirationDate') self.assertTrue(e.format_problem().index('will soon expire')) accumulator.assert_no_more_exceptions() service_period.set_end_date(time.strftime(date_format, two_weeks_ago)) schedule.validate() e = accumulator.pop_exception('ExpirationDate') self.assertTrue(e.format_problem().index('expired')) accumulator.assert_no_more_exceptions()
def runTest(self): accumulator = util.RecordingProblemAccumulator(self) problems = transitfeed.ProblemReporter(accumulator) 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() accumulator.AssertNoMoreExceptions() service_period.SetStartDate(today.strftime("%Y%m%d")) schedule.Validate() accumulator.AssertNoMoreExceptions() service_period.SetStartDate(tomorrow.strftime("%Y%m%d")) schedule.Validate() accumulator.PopException("FutureService") accumulator.AssertNoMoreExceptions()
def testNormalRun(self): unused_stop_path = self.GetPath("tests", "data", "unused_stop") # Make sure original data has an unused stop. accumulator = util.RecordingProblemAccumulator(self, ("ExpirationDate")) problem_reporter = transitfeed.ProblemReporter(accumulator) transitfeed.Loader( unused_stop_path, problems=problem_reporter, extra_validation=True ).Load() accumulator.PopException("UnusedStop") accumulator.AssertNoMoreExceptions() (stdout, stderr) = self.CheckCallWithPath( [ self.GetExamplePath("filter_unused_stops.py"), "--list_removed", unused_stop_path, "output.zip", ] ) # Extra stop was listed on stdout self.assertNotEqual(stdout.find("Bogus Stop"), -1) # Make sure unused stop was removed and another stop still exists. schedule = transitfeed.Loader( "output.zip", problems=problem_reporter, extra_validation=True ).Load() schedule.GetStop("STAGECOACH") accumulator.AssertNoMoreExceptions()
def testValidateDate(self): accumulator = test_util.RecordingProblemAccumulator(self) problems = ProblemReporter(accumulator) self.assertTrue(util.ValidateDate("", "col", problems)) accumulator.AssertNoMoreExceptions() self.assertTrue(util.ValidateDate("20100801", "col", problems)) accumulator.AssertNoMoreExceptions() self.assertFalse(util.ValidateDate("20100732", "col", problems)) e = accumulator.PopInvalidValue("col") accumulator.AssertNoMoreExceptions()
def testNormalRun(self): shutil.copyfile(self.GetTestDataPath('one_stop.kml'), 'one_stop.kml') (out, err) = self.CheckCallWithPath( [self.GetPath('kmlparser.py'), 'one_stop.kml', 'one_stop.zip']) # There will be lots of problems, but ignore them accumulator = util.RecordingProblemAccumulator(self) problems = transitfeed.ProblemReporter(accumulator) schedule = transitfeed.Loader('one_stop.zip', problems=problems).Load() self.assertEquals(len(schedule.GetStopList()), 1) self.assertFalse(os.path.exists('transitfeedcrash.txt'))
def testValidateTimezone(self): accumulator = test_util.RecordingProblemAccumulator(self) problems = ProblemReporter(accumulator) self.assertTrue(util.ValidateTimezone("", "col", problems)) accumulator.AssertNoMoreExceptions() self.assertTrue(util.ValidateTimezone("America/Los_Angeles", "col", problems)) accumulator.AssertNoMoreExceptions() self.assertFalse(util.ValidateTimezone("Switzerland/Wil", "col", problems)) e = accumulator.PopInvalidValue("col") accumulator.AssertNoMoreExceptions()
def testValidateLanguageCode(self): accumulator = test_util.RecordingProblemAccumulator(self) problems = ProblemReporter(accumulator) self.assertTrue(util.ValidateLanguageCode("", "col", problems)) accumulator.AssertNoMoreExceptions() self.assertTrue(util.ValidateLanguageCode("de", "col", problems)) accumulator.AssertNoMoreExceptions() self.assertFalse(util.ValidateLanguageCode("Swiss German", "col", problems)) e = accumulator.PopInvalidValue("col") accumulator.AssertNoMoreExceptions()
def testValidateURL(self): accumulator = test_util.RecordingProblemAccumulator(self) problems = ProblemReporter(accumulator) self.assertTrue(util.ValidateURL("", "col", problems)) accumulator.AssertNoMoreExceptions() self.assertTrue(util.ValidateURL("http://www.example.com", "col", problems)) accumulator.AssertNoMoreExceptions() self.assertFalse(util.ValidateURL("ftp://www.example.com", "col", problems)) e = accumulator.PopInvalidValue("col") accumulator.AssertNoMoreExceptions()
def runTest(self): accumulator = util.RecordingProblemAccumulator( self, ("ExpirationDate", "NoServiceExceptions")) problems = transitfeed.ProblemReporter(accumulator) schedule = transitfeed.Schedule(problem_reporter=problems) schedule.Load(util.DataPath('duplicate_stop_sequence'), extra_validation=True) e = accumulator.PopException('InvalidValue') self.assertEqual('stop_sequence', e.column_name) self.assertEqual(10, e.value) accumulator.AssertNoMoreExceptions()
def runTest(self): accumulator = util.RecordingProblemAccumulator( self, ('ExpirationDate', 'NoServiceExceptions')) problems = transitfeed.ProblemReporter(accumulator) schedule = transitfeed.Schedule(problem_reporter=problems) schedule.Load(util.DataPath('missing_endpoint_times'), extra_validation=True) e = accumulator.PopInvalidValue('arrival_time') self.assertEqual('', e.value) e = accumulator.PopInvalidValue('departure_time') self.assertEqual('', e.value)
def testvalidate_date(self): accumulator = test_util.RecordingProblemAccumulator(self) problems_in_test = ProblemReporter(accumulator) self.assertTrue(util.validate_date("", "col", problems_in_test)) accumulator.assert_no_more_exceptions() self.assertTrue(util.validate_date("20100801", "col", problems_in_test)) accumulator.assert_no_more_exceptions() self.assertFalse( util.validate_date("20100732", "col", problems_in_test)) accumulator.pop_invalid_value("col") accumulator.assert_no_more_exceptions()
def runTest(self): feed_name = util.DataPath('unknown_file') self.accumulator = util.RecordingProblemAccumulator( self, ("ExpirationDate")) self.problems = transitfeed.ProblemReporter(self.accumulator) loader = transitfeed.Loader(feed_name, problems=self.problems, extra_validation=True) loader.Load() e = self.accumulator.PopException('UnknownFile') self.assertEqual('frecuencias.txt', e.file_name) self.accumulator.AssertNoMoreExceptions()
def testValidateTimezone(self): accumulator = test_util.RecordingProblemAccumulator(self) problems_in_test = ProblemReporter(accumulator) self.assertTrue(util.validate_timezone("", "col", problems_in_test)) accumulator.assert_no_more_exceptions() self.assertTrue( util.validate_timezone("America/Los_Angeles", "col", problems_in_test)) accumulator.assert_no_more_exceptions() self.assertFalse( util.validate_timezone("Switzerland/Wil", "col", problems_in_test)) accumulator.pop_invalid_value("col") accumulator.assert_no_more_exceptions()
def testValidateLanguageCode(self): accumulator = test_util.RecordingProblemAccumulator(self) problems_in_test = ProblemReporter(accumulator) self.assertTrue( util.validate_language_code("", "col", problems_in_test)) accumulator.assert_no_more_exceptions() self.assertTrue( util.validate_language_code("de", "col", problems_in_test)) accumulator.assert_no_more_exceptions() self.assertFalse( util.validate_language_code("Swiss German", "col", problems_in_test)) accumulator.pop_invalid_value("col") accumulator.assert_no_more_exceptions()
def testValidateURL(self): accumulator = test_util.RecordingProblemAccumulator(self) problems_in_test = ProblemReporter(accumulator) self.assertTrue(util.validate_url("", "col", problems_in_test)) accumulator.assert_no_more_exceptions() self.assertTrue( util.validate_url("http://www.example.com", "col", problems_in_test)) accumulator.assert_no_more_exceptions() self.assertFalse( util.validate_url("ftp://www.example.com", "col", problems_in_test)) accumulator.pop_invalid_value("col") accumulator.assert_no_more_exceptions()
def runTest(self): accumulator = test_util.RecordingProblemAccumulator(self) problems_in_test = ProblemReporter(accumulator) self.assertEqual(0, util.non_neg_int_string_to_int("0", problems_in_test)) self.assertEqual( 0, util.non_neg_int_string_to_int(u"0", problems_in_test)) self.assertEqual(1, util.non_neg_int_string_to_int("1", problems_in_test)) self.assertEqual(2, util.non_neg_int_string_to_int("2", problems_in_test)) self.assertEqual( 10, util.non_neg_int_string_to_int("10", problems_in_test)) self.assertEqual( 1234567890123456789, util.non_neg_int_string_to_int("1234567890123456789", problems_in_test)) self.assertRaises(ValueError, util.non_neg_int_string_to_int, "", problems_in_test) self.assertRaises(ValueError, util.non_neg_int_string_to_int, "-1", problems_in_test) self.assertRaises(ValueError, util.non_neg_int_string_to_int, "0x1", problems_in_test) self.assertRaises(ValueError, util.non_neg_int_string_to_int, "1.0", problems_in_test) self.assertRaises(ValueError, util.non_neg_int_string_to_int, "1e1", problems_in_test) self.assertRaises(ValueError, util.non_neg_int_string_to_int, "0x20", problems_in_test) self.assertRaises(ValueError, util.non_neg_int_string_to_int, "0b10", problems_in_test) self.assertRaises(TypeError, util.non_neg_int_string_to_int, 1, problems_in_test) self.assertRaises(TypeError, util.non_neg_int_string_to_int, None, problems_in_test) # These should issue a warning, but otherwise parse successfully self.assertEqual( 1, util.non_neg_int_string_to_int("+1", problems_in_test)) accumulator.PopException("InvalidNonNegativeIntegerValue") self.assertEqual( 1, util.non_neg_int_string_to_int("01", problems_in_test)) accumulator.PopException("InvalidNonNegativeIntegerValue") self.assertEqual( 0, util.non_neg_int_string_to_int("00", problems_in_test)) accumulator.PopException("InvalidNonNegativeIntegerValue") accumulator.assert_no_more_exceptions()
def setUp(self): self.accumulator = util.RecordingProblemAccumulator( self, ("ExpirationDate", "NoServiceExceptions")) self.problems = transitfeed.ProblemReporter(self.accumulator) schedule = OverlappingBlockSchedule(problem_reporter=self.problems) schedule.AddAgency("Demo Transit Authority", "http://dta.org", "America/Los_Angeles") sp1 = transitfeed.ServicePeriod("SID1") sp1.SetWeekdayService(True) sp1.SetStartDate("20070605") sp1.SetEndDate("20080605") schedule.AddServicePeriodObject(sp1) sp2 = transitfeed.ServicePeriod("SID2") sp2.SetDayOfWeekHasService(0) sp2.SetDayOfWeekHasService(2) sp2.SetDayOfWeekHasService(4) sp2.SetStartDate("20070605") sp2.SetEndDate("20080605") schedule.AddServicePeriodObject(sp2) sp3 = transitfeed.ServicePeriod("SID3") sp3.SetWeekendService(True) sp3.SetStartDate("20070605") sp3.SetEndDate("20080605") schedule.AddServicePeriodObject(sp3) self.stop1 = schedule.AddStop( lng=-116.75167, lat=36.915682, name="Stagecoach Hotel & Casino", stop_id="S1", ) self.stop2 = schedule.AddStop(lng=-116.76218, lat=36.905697, name="E Main St / S Irving St", stop_id="S2") self.route = schedule.AddRoute("", "City", "Bus", route_id="CITY") self.schedule = schedule self.sp1 = sp1 self.sp2 = sp2 self.sp3 = sp3
def runTest(self): accumulator = test_util.RecordingProblemAccumulator(self) problems_in_test = ProblemReporter(accumulator) self.assertAlmostEqual( 0, util.float_string_to_float("0", problems_in_test)) self.assertAlmostEqual( 0, util.float_string_to_float(u"0", problems_in_test)) self.assertAlmostEqual( 1, util.float_string_to_float("1", problems_in_test)) self.assertAlmostEqual( 1, util.float_string_to_float("1.00000", problems_in_test)) self.assertAlmostEqual( 1.5, util.float_string_to_float("1.500", problems_in_test)) self.assertAlmostEqual( -2, util.float_string_to_float("-2.0", problems_in_test)) self.assertAlmostEqual( -2.5, util.float_string_to_float("-2.5", problems_in_test)) self.assertRaises(ValueError, util.float_string_to_float, ".", problems_in_test) self.assertRaises(ValueError, util.float_string_to_float, "0x20", problems_in_test) self.assertRaises(ValueError, util.float_string_to_float, "-0x20", problems_in_test) self.assertRaises(ValueError, util.float_string_to_float, "0b10", problems_in_test) # These should issue a warning, but otherwise parse successfully self.assertAlmostEqual( 0.001, util.float_string_to_float("1E-3", problems_in_test)) accumulator.pop_exception("InvalidFloatValue") self.assertAlmostEqual( 0.001, util.float_string_to_float(".001", problems_in_test)) accumulator.pop_exception("InvalidFloatValue") self.assertAlmostEqual( -0.001, util.float_string_to_float("-.001", problems_in_test)) accumulator.pop_exception("InvalidFloatValue") self.assertAlmostEqual( 0, util.float_string_to_float("0.", problems_in_test)) accumulator.pop_exception("InvalidFloatValue") accumulator.assert_no_more_exceptions()
def setUp(self): # We ignore the lack of service dates ("OtherProblem") self.accumulator = util.RecordingProblemAccumulator( self, ("OtherProblem")) self.problems = transitfeed.ProblemReporter(self.accumulator) self.schedule = transitfeed.Schedule(problem_reporter=self.problems) self.schedule.AddAgency("Demo Transit Authority", "http://dta.org", "America/Los_Angeles") self.stop1 = self.schedule.AddStop(lng=-116.75167, lat=36.915682, name="Stagecoach Hotel & Casino", stop_id="S1") self.stop2 = self.schedule.AddStop(lng=-116.76218, lat=36.905697, name="E Main St / S Irving St", stop_id="S2") route = self.schedule.AddRoute("", "City", "Bus", route_id="CITY") self.trip = route.AddTrip(self.schedule, trip_id="CITY1")
def setUp(self): self.accumulator = util.RecordingProblemAccumulator(self) self.problems = transitfeed.ProblemReporter(self.accumulator) self.zip = zipfile.ZipFile(StringIO(), 'a') self.loader = transitfeed.Loader(problems=self.problems, zip=self.zip)
def setUp(self): self.accumulator = util.RecordingProblemAccumulator( self, ("ExpirationDate")) self.problems = transitfeed.ProblemReporter(self.accumulator)
def __init__(self, test_case): self.accumulator = util.RecordingProblemAccumulator( test_case, ignore_types=("ExpirationDate", )) self.column_errors = []
def setUp(self): self.orig_urlopen = urllib.request.urlopen self.mock = MockURLOpen() self.accumulator = test_util.RecordingProblemAccumulator(self) self.problems = ProblemReporter(self.accumulator)
def setUp(self): self.accumulator = util.RecordingProblemAccumulator(self) self.problems = transitfeed.ProblemReporter(self.accumulator)
def runTest(self): accumulator = util.RecordingProblemAccumulator( self, ignore_types=("ExpirationDate", )) problems = transitfeed.ProblemReporter(accumulator) schedule = transitfeed.Schedule(problem_reporter=problems) agency = transitfeed.Agency() agency.agency_id = "DTA" agency.agency_name = "Demo Transit Authority" agency.agency_url = "http://google.com" agency.agency_timezone = "America/Los_Angeles" agency.agency_lang = 'en' # Test that unknown columns, such as agency_mission, are preserved agency.agency_mission = "Get You There" schedule.AddAgencyObject(agency) routes = [] route_data = [("AB", "DTA", "10", "Airport - Bullfrog", 3), ("BFC", "DTA", "20", "Bullfrog - Furnace Creek Resort", 3), ("STBA", "DTA", "30", "Stagecoach - Airport Shuttle", 3), ("CITY", "DTA", "40", "City", 3), ("AAMV", "DTA", "50", "Airport - Amargosa Valley", 3)] for route_entry in route_data: route = transitfeed.Route() (route.route_id, route.agency_id, route.route_short_name, route.route_long_name, route.route_type) = route_entry routes.append(route) schedule.AddRouteObject(route) shape_data = [ (36.915760, -116.751709), (36.905018, -116.763206), (36.902134, -116.777969), (36.904091, -116.788185), (36.883602, -116.814537), (36.874523, -116.795593), (36.873302, -116.786491), (36.869202, -116.784241), (36.868515, -116.784729), ] shape = transitfeed.Shape("BFC1S") for (lat, lon) in shape_data: shape.AddPoint(lat, lon) schedule.AddShapeObject(shape) week_period = transitfeed.ServicePeriod() week_period.service_id = "FULLW" week_period.start_date = "20070101" week_period.end_date = "20071231" week_period.SetWeekdayService() week_period.SetWeekendService() week_period.SetDateHasService("20070604", False) schedule.AddServicePeriodObject(week_period) weekend_period = transitfeed.ServicePeriod() weekend_period.service_id = "WE" weekend_period.start_date = "20070101" weekend_period.end_date = "20071231" weekend_period.SetWeekendService() schedule.AddServicePeriodObject(weekend_period) stops = [] stop_data = [ ("FUR_CREEK_RES", "Furnace Creek Resort (Demo)", 36.425288, -117.133162, "zone-a", "1234"), ("BEATTY_AIRPORT", "Nye County Airport (Demo)", 36.868446, -116.784682, "zone-a", "1235"), ("BULLFROG", "Bullfrog (Demo)", 36.88108, -116.81797, "zone-b", "1236"), ("STAGECOACH", "Stagecoach Hotel & Casino (Demo)", 36.915682, -116.751677, "zone-c", "1237"), ("NADAV", "North Ave / D Ave N (Demo)", 36.914893, -116.76821, "", ""), ("NANAA", "North Ave / N A Ave (Demo)", 36.914944, -116.761472, "", ""), ("DADAN", "Doing AVe / D Ave N (Demo)", 36.909489, -116.768242, "", ""), ("EMSI", "E Main St / S Irving St (Demo)", 36.905697, -116.76218, "", ""), ("AMV", "Amargosa Valley (Demo)", 36.641496, -116.40094, "", ""), ] for stop_entry in stop_data: stop = transitfeed.Stop() (stop.stop_id, stop.stop_name, stop.stop_lat, stop.stop_lon, stop.zone_id, stop.stop_code) = stop_entry schedule.AddStopObject(stop) stops.append(stop) # Add a value to an unknown column and make sure it is preserved schedule.GetStop("BULLFROG").stop_sound = "croak!" trip_data = [ ("AB", "FULLW", "AB1", "to Bullfrog", "0", "1", None), ("AB", "FULLW", "AB2", "to Airport", "1", "2", None), ("STBA", "FULLW", "STBA", "Shuttle", None, None, None), ("CITY", "FULLW", "CITY1", None, "0", None, None), ("CITY", "FULLW", "CITY2", None, "1", None, None), ("BFC", "FULLW", "BFC1", "to Furnace Creek Resort", "0", "1", "BFC1S"), ("BFC", "FULLW", "BFC2", "to Bullfrog", "1", "2", None), ("AAMV", "WE", "AAMV1", "to Amargosa Valley", "0", None, None), ("AAMV", "WE", "AAMV2", "to Airport", "1", None, None), ("AAMV", "WE", "AAMV3", "to Amargosa Valley", "0", None, None), ("AAMV", "WE", "AAMV4", "to Airport", "1", None, None), ] trips = [] for trip_entry in trip_data: trip = transitfeed.Trip() (trip.route_id, trip.service_id, trip.trip_id, trip.trip_headsign, trip.direction_id, trip.block_id, trip.shape_id) = trip_entry trips.append(trip) schedule.AddTripObject(trip) stop_time_data = { "STBA": [("6:00:00", "6:00:00", "STAGECOACH", None, None, None, None), ("6:20:00", "6:20:00", "BEATTY_AIRPORT", None, None, None, None)], "CITY1": [("6:00:00", "6:00:00", "STAGECOACH", 1.34, 0, 0, "stop 1"), ("6:05:00", "6:07:00", "NANAA", 2.40, 1, 2, "stop 2"), ("6:12:00", "6:14:00", "NADAV", 3.0, 2, 2, "stop 3"), ("6:19:00", "6:21:00", "DADAN", 4, 2, 2, "stop 4"), ("6:26:00", "6:28:00", "EMSI", 5.78, 2, 3, "stop 5")], "CITY2": [("6:28:00", "6:28:00", "EMSI", None, None, None, None), ("6:35:00", "6:37:00", "DADAN", None, None, None, None), ("6:42:00", "6:44:00", "NADAV", None, None, None, None), ("6:49:00", "6:51:00", "NANAA", None, None, None, None), ("6:56:00", "6:58:00", "STAGECOACH", None, None, None, None)], "AB1": [("8:00:00", "8:00:00", "BEATTY_AIRPORT", None, None, None, None), ("8:10:00", "8:15:00", "BULLFROG", None, None, None, None)], "AB2": [("12:05:00", "12:05:00", "BULLFROG", None, None, None, None), ("12:15:00", "12:15:00", "BEATTY_AIRPORT", None, None, None, None) ], "BFC1": [ ("8:20:00", "8:20:00", "BULLFROG", None, None, None, None), ("9:20:00", "9:20:00", "FUR_CREEK_RES", None, None, None, None) ], "BFC2": [("11:00:00", "11:00:00", "FUR_CREEK_RES", None, None, None, None), ("12:00:00", "12:00:00", "BULLFROG", None, None, None, None)], "AAMV1": [("8:00:00", "8:00:00", "BEATTY_AIRPORT", None, None, None, None), ("9:00:00", "9:00:00", "AMV", None, None, None, None)], "AAMV2": [("10:00:00", "10:00:00", "AMV", None, None, None, None), ("11:00:00", "11:00:00", "BEATTY_AIRPORT", None, None, None, None)], "AAMV3": [("13:00:00", "13:00:00", "BEATTY_AIRPORT", None, None, None, None), ("14:00:00", "14:00:00", "AMV", None, None, None, None)], "AAMV4": [("15:00:00", "15:00:00", "AMV", None, None, None, None), ("16:00:00", "16:00:00", "BEATTY_AIRPORT", None, None, None, None)], } for trip_id, stop_time_list in stop_time_data.items(): for stop_time_entry in stop_time_list: (arrival_time, departure_time, stop_id, shape_dist_traveled, pickup_type, drop_off_type, stop_headsign) = stop_time_entry trip = schedule.GetTrip(trip_id) stop = schedule.GetStop(stop_id) trip.AddStopTime(stop, arrival_time=arrival_time, departure_time=departure_time, shape_dist_traveled=shape_dist_traveled, pickup_type=pickup_type, drop_off_type=drop_off_type, stop_headsign=stop_headsign) self.assertEqual( 0, schedule.GetTrip("CITY1").GetStopTimes()[0].pickup_type) self.assertEqual( 1, schedule.GetTrip("CITY1").GetStopTimes()[1].pickup_type) headway_data = [ ("STBA", "6:00:00", "22:00:00", 1800), ("CITY1", "6:00:00", "7:59:59", 1800), ("CITY2", "6:00:00", "7:59:59", 1800), ("CITY1", "8:00:00", "9:59:59", 600), ("CITY2", "8:00:00", "9:59:59", 600), ("CITY1", "10:00:00", "15:59:59", 1800), ("CITY2", "10:00:00", "15:59:59", 1800), ("CITY1", "16:00:00", "18:59:59", 600), ("CITY2", "16:00:00", "18:59:59", 600), ("CITY1", "19:00:00", "22:00:00", 1800), ("CITY2", "19:00:00", "22:00:00", 1800), ] headway_trips = {} for headway_entry in headway_data: (trip_id, start_time, end_time, headway) = headway_entry headway_trips[trip_id] = [] # adding to set to check later trip = schedule.GetTrip(trip_id) trip.AddFrequency(start_time, end_time, headway, 0, problems) for trip_id in headway_trips: headway_trips[trip_id] = \ schedule.GetTrip(trip_id).GetFrequencyTuples() fare_data = [ ("p", 1.25, "USD", 0, 0), ("a", 5.25, "USD", 0, 0), ] fares = [] for fare_entry in fare_data: fare = transitfeed.FareAttribute(fare_entry[0], fare_entry[1], fare_entry[2], fare_entry[3], fare_entry[4]) fares.append(fare) schedule.AddFareAttributeObject(fare) fare_rule_data = [ ("p", "AB", "zone-a", "zone-b", None), ("p", "STBA", "zone-a", None, "zone-c"), ("p", "BFC", None, "zone-b", "zone-a"), ("a", "AAMV", None, None, None), ] for fare_id, route_id, orig_id, dest_id, contains_id in fare_rule_data: rule = transitfeed.FareRule(fare_id=fare_id, route_id=route_id, origin_id=orig_id, destination_id=dest_id, contains_id=contains_id) schedule.AddFareRuleObject(rule, problems) schedule.Validate(problems) accumulator.AssertNoMoreExceptions() schedule.WriteGoogleTransitFeed(self.tempfilepath) read_schedule = \ transitfeed.Loader(self.tempfilepath, problems=problems, extra_validation=True).Load() e = accumulator.PopException("UnrecognizedColumn") self.assertEqual(e.file_name, "agency.txt") self.assertEqual(e.column_name, "agency_mission") e = accumulator.PopException("UnrecognizedColumn") self.assertEqual(e.file_name, "stops.txt") self.assertEqual(e.column_name, "stop_sound") accumulator.AssertNoMoreExceptions() self.assertEqual(1, len(read_schedule.GetAgencyList())) self.assertEqual(agency, read_schedule.GetAgency(agency.agency_id)) self.assertEqual(len(routes), len(read_schedule.GetRouteList())) for route in routes: self.assertEqual(route, read_schedule.GetRoute(route.route_id)) self.assertEqual(2, len(read_schedule.GetServicePeriodList())) self.assertEqual( week_period, read_schedule.GetServicePeriod(week_period.service_id)) self.assertEqual( weekend_period, read_schedule.GetServicePeriod(weekend_period.service_id)) self.assertEqual(len(stops), len(read_schedule.GetStopList())) for stop in stops: self.assertEqual(stop, read_schedule.GetStop(stop.stop_id)) self.assertEqual("croak!", read_schedule.GetStop("BULLFROG").stop_sound) self.assertEqual(len(trips), len(read_schedule.GetTripList())) for trip in trips: self.assertEqual(trip, read_schedule.GetTrip(trip.trip_id)) for trip_id in headway_trips: self.assertEqual( headway_trips[trip_id], read_schedule.GetTrip(trip_id).GetFrequencyTuples()) for trip_id, stop_time_list in stop_time_data.items(): trip = read_schedule.GetTrip(trip_id) read_stoptimes = trip.GetStopTimes() self.assertEqual(len(read_stoptimes), len(stop_time_list)) for stop_time_entry, read_stoptime in zip(stop_time_list, read_stoptimes): (arrival_time, departure_time, stop_id, shape_dist_traveled, pickup_type, drop_off_type, stop_headsign) = stop_time_entry self.assertEqual(stop_id, read_stoptime.stop_id) self.assertEqual(read_schedule.GetStop(stop_id), read_stoptime.stop) self.assertEqualTimeString(arrival_time, read_stoptime.arrival_time) self.assertEqualTimeString(departure_time, read_stoptime.departure_time) self.assertEqual(shape_dist_traveled, read_stoptime.shape_dist_traveled) self.assertEqualWithDefault(pickup_type, read_stoptime.pickup_type, 0) self.assertEqualWithDefault(drop_off_type, read_stoptime.drop_off_type, 0) self.assertEqualWithDefault(stop_headsign, read_stoptime.stop_headsign, '') self.assertEqual(len(fares), len(read_schedule.GetFareAttributeList())) for fare in fares: self.assertEqual(fare, read_schedule.GetFareAttribute(fare.fare_id)) read_fare_rules_data = [] for fare in read_schedule.GetFareAttributeList(): for rule in fare.GetFareRuleList(): self.assertEqual(fare.fare_id, rule.fare_id) read_fare_rules_data.append( (fare.fare_id, rule.route_id, rule.origin_id, rule.destination_id, rule.contains_id)) fare_rule_data.sort() read_fare_rules_data.sort() self.assertEqual(len(read_fare_rules_data), len(fare_rule_data)) for rf, f in zip(read_fare_rules_data, fare_rule_data): self.assertEqual(rf, f) self.assertEqual(1, len(read_schedule.GetShapeList())) self.assertEqual(shape, read_schedule.GetShape(shape.shape_id))