def test_rivers_by_station_number(): #test the type of the elements of the list assert rivers_by_station_number(stations, 4)[1][0] == 'River Great Ouse' #test the length of the list when N=9 assert len(rivers_by_station_number(stations, 9)) == 11
def test_rivers_station_number(): stations = build_station_list() N = randint(0, 2000) assert len(rivers_by_station_number(stations, N)) > 0 assert type(rivers_by_station_number(stations, N)) == list for item in rivers_by_station_number(stations, N): assert type(item[0]) == str assert type(item[1]) == int
def test_rivers_by_station_number(): '''Test that the function works as required''' stations = generate_test_station() assert rivers_by_station_number(stations, 1) == [('River Y', 3)] assert rivers_by_station_number(stations, 2) == [('River Y', 3), ('River X', 2), ('River Z', 2) ] or [('River Y', 3), ('River Z', 2), ('River X', 2)]
def run(): #Test sample of some station stations = build_station_list() # Running the function to get a list called result result = rivers_by_station_number(stations,6) # Printing the result print(result)
def run(): """Requrement for Task 1E""" stations = build_station_list() first_N_rivers = rivers_by_station_number(stations, 9) print(first_N_rivers)
def rivers_by_station_number(): s_id = "test-s-id" m_id = "test-m-id" label = "some station" coord = (6.0, 4.0) trange = None river = "River X" town = "My Town" s = MonitoringStation(s_id, m_id, label, coord, trange, river, town) river = "River X" s1 = MonitoringStation(s_id, m_id, label, coord, trange, river, town) river = "River Y" s2 = MonitoringStation(s_id, m_id, label, coord, trange, river, town) river = "River Y" s3 = MonitoringStation(s_id, m_id, label, coord, trange, river, town) river = "River Z" s4 = MonitoringStation(s_id, m_id, label, coord, trange, river, town) stations = [s, s1, s2, s3, s4] N = 2 output_list = geo.rivers_by_station_number(stations, N) assert len(output_list) == 3 for i in range(1, len(output_list)): assert output_list[i][1] >= output_list[i - 1][1]
def run(): """Requirements for Task 1E""" # Build list of stations stations = build_station_list() list_of_rivers_numbers = rivers_by_station_number(stations, 9) print("Rivers with greatest number of stations: {}".format( list_of_rivers_numbers))
def run(): """Requirements for Task 1E""" # Build list of stations stations = build_station_list() N = 6 x = rivers_by_station_number(stations, N) print(x)
def test_rivers_by_station_number(): # make a station list station_list = stationdata.build_station_list() for N in [5, 10, 20]: rivers = geo.rivers_by_station_number(station_list, N) assert (len(rivers) >= N) if len(rivers) > N: # check for a true tie condition tie_val = rivers[N - 1][1] for river in rivers[N:]: assert (river[1] == tie_val) # check that all tied rivers were returned rivers_one_more = geo.rivers_by_station_number(station_list, len(rivers) + 1) assert (rivers_one_more[-1][1] < tie_val)
def run(): #builds list of stations stations = stationdata.build_station_list(use_cache=True) #gets rivers with the 9 most stations top_rivers = geo.rivers_by_station_number(stations, 9) print(top_rivers)
def test_rivers_by_station_number(): stations = build_station_list() #try for 6 days N=6 x=rivers_by_station_number(stations,N) assert len(x)>=N for a in x: #check that elements of list are tuples assert type(a)==tuple
def test_rivers_by_station_number(): stations = build_station_list() tuple_list = rivers_by_station_number(stations, 50) assert isinstance(tuple_list, list) == True assert isinstance(tuple_list[0], tuple) == True i = 0 for i in range(len(tuple_list) - 1): assert tuple_list[i][1] >= tuple_list[i + 1][1] assert len(tuple_list) == 60
def run(): ''' Test for function: rivers_by_station_number ''' stations = build_station_list() output = rivers_by_station_number(stations, 12) print(output) return output
def run(): """Requirements for Task 1D""" # Build list of stations stations = build_station_list() test_case_1=rivers_by_station_number(stations,N=10) print(test_case_1)
def run(): """Requirement for Task 1E""" stations = build_station_list() # Build dictionary relating rivers (key) to stations (value) maxstationlist = rivers_by_station_number(stations,10) print(maxstationlist)
def run(): #build station list stations = build_station_list() #N=int(input('Enter a number of rivers' )) N = 9 #runs function print(rivers_by_station_number(stations, N))
def run(): """Requirements for Task 1E""" print("*** Task 1E: CUED Part IA Flood Warning System ***") #Build list of stations stations = build_station_list() print( "Top 12 rivers by number of stations, and all other rivers with equal number of stations:" ) print(rivers_by_station_number(stations, 12))
def run(): """Requirements for Task 1E""" # Build list of stations stations = build_station_list() # Get the top 9 rivers by station number by_station_number = rivers_by_station_number(stations, 9) # When testing, this only gives 9 rivers, as the current list of stations differs from the original list. # N=10 gives 11 items. print(by_station_number)
def test_rivers_by_station_number(): #Initialise variables stations = build_station_list() N = 9 first_N_rivers = geo.rivers_by_station_number(stations, N) #River with expected greatest number of stations test_river = "Thames" #Checks that at least as many stations that are called for are returned if len(first_N_rivers) < N: raise ValueError( "First {} rivers called for but only {} returned".format( N, len(first_N_rivers))) #Checks if test river has the greatest number of stations if first_N_rivers[0][0] != test_river: raise ValueError( "{} does not have the greatest number of staions - data may be incomplete" .format(test_river))
def test_rivers_by_station_number(): N = 9 result = rivers_by_station_number(stations, N) assert len(result) >= 9 if len(result) == N: for n in range(len(result) - 1): x = result[n] y = result[n + 1] assert x[1] >= y[1] elif len(result) > N: for n in range(N - 1): x = result[n] y = result[n + 1] assert x[1] >= y[1] for n in range(N, len(result) - 1): x = result[n] y = result[n + 1] assert x == y
def test_rivers_by_station_number(): stations = build_station_list() l = rivers_with_station(stations) N = len(l) output = rivers_by_station_number(stations, N) assert type(output) == list for t in output: assert type(t) == tuple assert len(t) == 2 assert type(t[0]) == str assert type(t[1]) == int # Check if list of river tuples is in descending order list_of_lists = [] # Convert list of tuples to list of lists list_of_lists.append(list(t)) for n in range(len(list_of_lists) - 1): assert list_of_lists[n][1] <= list_of_lists[n + 1][1]
def test_rivers_by_station_number(): s_id = "test-s-id" m_id = "test-m-id" label = "Station 1" coord = (-2.0, 4.0) trange = (-2.3, 3.4445) river = "River X" town = "My Town" s = MonitoringStation(s_id, m_id, label, coord, trange, river, town) s_id = "test-s-id2" m_id = "test-m-id2" label = "Station 2" coord = (2.0, -4.05) trange = (-2.3, 3.4445) river = "River Y" town = "My Town B" t = MonitoringStation(s_id, m_id, label, coord, trange, river, town) s_id = "test-s-id3" m_id = "test-m-id3" label = "Station 3" coord = (-2.0, 4.0) trange = (-2.3, 3.4445) river = "River X" town = "My Town" u = MonitoringStation(s_id, m_id, label, coord, trange, river, town) #Build an empty list for storing tuples later Example_build_list = [] Example_build_list.append(s) Example_build_list.append(t) Example_build_list.append(u) a = rivers_by_station_number(Example_build_list, 1) assert a == [('River X', 2)]
def test_rivers_by_station_number_returns_a_list_of_river_names_with_the_number_of_stations_in_each( ): stations = [] rivers = ["A", "B", "C", "A", "B", "D", "E", "B", "A", "C", "B", "D"] for i in range(len(rivers)): # Create stations s_id = "test-s-id-" + str(i) m_id = "test-m-id-" + str(i) label = "some station " + str(i) coord = (0.0, 0.0) trange = (-2.3, 3.4445) river = rivers[i] town = "My Town " + str(i) stations.append( MonitoringStation(s_id, m_id, label, coord, trange, river, town)) actual_rivers_by_station_number = geo.rivers_by_station_number(stations, 3) expected_rivers_by_station_number = [("B", 4), ("A", 3), ("C", 2), ("D", 2)] print(actual_rivers_by_station_number) assert actual_rivers_by_station_number == expected_rivers_by_station_number
from floodsystem.geo import stations_by_river from floodsystem.flood import stations_level_over_threshold stations = build_station_list() update_water_levels(stations) severe = [] high = [] moderate = [] low = [] '''If river has is in top 20 rivers in terms of how many stations it has on it, the station severity will be increased by one level for otherwise moderate and high levels due to potential risk of stations on that river being flooded as well''' top_twenty = rivers_by_station_number(stations, 20) for station in stations: river = str(station.river) for i in top_twenty: if i[0] == river: in_top_twenty = True else: in_top_twenty = False station_level = station.relative_water_level() if station_level != 0: if station.typical_range_consistent() == True: if station.latest_level is not None: if station_level > 1.5:
def test_geo_5(): stations = build_station_list() assert rivers_by_station_number(stations, 12)[0] == ('River Thames', 55) assert len(rivers_by_station_number(stations, 800)) != 800
def test_rivers_by_station_number(): g = rivers_by_station_number(stations, 9) assert type(g) == list for i in g: assert type(i) == tuple
def run(): stations = build_station_list() print(rivers_by_station_number(stations, 9))
def test_rivers_by_station_number(): stations = build_station_list() x = rivers_by_station_number(stations, 10) assert ('Thames', 55) in x
def run(): # Put code here that demonstrates functionality print (rivers_by_station_number(stations, 9))
def test_rivers_by_staion_number(): # Build a list of staions stations = build_station_list() ans = geo.rivers_by_station_number(stations, 9) assert len(ans) >= 9