def test_combine_spectra(): """ Test function that confirms that the two compounds from shoyu_data_dict.p were combined sucessfully, that the output data has the correct shape, and that the output range is within the overall range of the two individual compounds. """ compound_1 = SHOYU_DATA_DICT['WATER'] compound_2 = SHOYU_DATA_DICT['CARBON MONOXIDE'] data = shoyu.combine_spectra(compound_1, compound_2) assert len(data[0]) == len(data[1]), 'lengths of x and y data do not match' assert len(data) == 2, 'shape of output data different than expected' ranges = [ max(compound_1['x']), min(compound_1['x']), max(compound_2['x']), min(compound_2['x']) ] assert min(ranges) <= min(data[0]), """ output data contains values below the minimum range of either compound""" assert max(ranges) >= max(data[0]), """ output data contains values above the maximum range of either compound""" try: shoyu.combine_spectra([1, 2, 3, 4], compound_2) except TypeError: print( 'A list was passed to the function, and it was handled well with a TypeError.' ) try: shoyu.combine_spectra(compound_1, [1, 2, 3, 4]) except TypeError: print( 'A list was passed to the function, and it was handled well with a TypeError.' )
def test_peak_assignment(): """This function tests the operation of the peak_assignment function in peakidentify.py""" #First, generate a testing dataset. shoyu_data_dict = pickle.load(open('raman_spectra/shoyu_data_dict.p', 'rb')) compound_1 = shoyu_data_dict['WATER'] compound_2 = shoyu_data_dict['CARBON MONOXIDE'] compound_3 = shoyu_data_dict['CARBON DIOXIDE'] unknown_x, unknown_y = shoyu.combine_spectra(compound_1, compound_2, plot=False) unknown_x = np.asarray(unknown_x) unknown_y = np.asarray(unknown_y) known_compound_list = [compound_1, compound_2, compound_3] precision = 0.03 #Various try statements to make sure that bad inputs are handled correctly. try: peakidentify.peak_assignment(1, unknown_y, known_compound_list, precision, False) except TypeError: print("An invalid unknown_x was passed to the function, and it was" " handled well with a TypeError.") try: peakidentify.peak_assignment(unknown_x, 2, known_compound_list, precision, False) except TypeError: print("An invalid unknown_y was passed to the function, and it was " "handled well with a TypeError.") try: peakidentify.peak_assignment(unknown_x, unknown_y, 'string', precision, False) except TypeError: print("An invalid known_compound_list was passed to the function, " "and it was handled well with a TypeError.") try: peakidentify.peak_assignment(unknown_x, unknown_y, [1, 3, 6], precision, False) except TypeError: print("An invalid element inside known_compound_list was passed to " "the function, and it was handled well with a TypeError.") try: peakidentify.peak_assignment(unknown_x, unknown_y, known_compound_list, 'precision', False) except TypeError: print("An invalid precision value was passed to the function, and " "it was handled well with a TypeError.") try: peakidentify.peak_assignment(1, unknown_y, known_compound_list, precision, 'False') except TypeError: print("An invalid plot value was passed to the function, and it " "was handled well with a TypeError.")
def test_compare_unknown_to_known(): """This function tests the operation of the compare_unknown_to_known function in peakidentify.py""" #Build our test dataset. shoyu_data_dict = pickle.load(open('raman_spectra/shoyu_data_dict.p', 'rb')) compound_1 = shoyu_data_dict['WATER'] compound_2 = shoyu_data_dict['CARBON MONOXIDE'] compound_3 = shoyu_data_dict['CARBON DIOXIDE'] unknown_x, unknown_y = shoyu.combine_spectra(compound_1, compound_2, plot=False) unknown_x = np.asarray(unknown_x) unknown_y = np.asarray(unknown_y) known_compound_list = [compound_1, compound_2, compound_3] precision = 0.03 known_peaks = [] for i, _ in enumerate(known_compound_list): known_peaks.append( spectrafit.compound_report(known_compound_list[i])[0]) unknown_peaks = spectrafit.data_report(unknown_x, unknown_y)[0] try: peakidentify.compare_unknown_to_known(1, known_peaks[0], precision) except TypeError: print("An invalid unknown_peaks value was passed to the function, " "and was handled correctly.") try: peakidentify.compare_unknown_to_known(unknown_peaks, 'known_peaks', precision) except TypeError: print("An invalid known_peaks value was passed to the function, " "and was handled correctly.") try: peakidentify.compare_unknown_to_known(unknown_peaks, known_peaks[0], 'precision') except TypeError: print("An invalid precision value was passed to the function, and " "was handled correctly.") #After testing for resilience to unexpected inputs, now ensure outputs are performing correctly #First, make sure function is returning the list. assert isinstance( peakidentify.compare_unknown_to_known(unknown_peaks, known_peaks[0], precision), np.ndarray), ("" "Function is not returning list") #Compare one set of peaks to itself. The full association matrix should have all values = 1. self_comp = np.mean( peakidentify.compare_unknown_to_known(known_peaks[0], known_peaks[0], precision)) assert self_comp == 1, ("Peak Assignment Error. Comparison of compound " "against itself should find all peaks.") dif_comp = np.mean( peakidentify.compare_unknown_to_known([1, 3, 6], [1000, 2000, 5000], precision)) assert dif_comp == 0, ("Peak Assignment Error. Passed values should " "have no matching assignments.")
def test_plotting_peak_assignments(): """This function tests the operation of the peak_assignment function in peakidentify.py""" #First, generate good data. shoyu_data_dict = pickle.load(open('raman_spectra/shoyu_data_dict.p', 'rb')) compound_1 = shoyu_data_dict['WATER'] compound_2 = shoyu_data_dict['CARBON MONOXIDE'] compound_3 = shoyu_data_dict['CARBON DIOXIDE'] unknown_x, unknown_y = shoyu.combine_spectra(compound_1, compound_2, plot=False) unknown_x = np.asarray(unknown_x) unknown_y = np.asarray(unknown_y) known_compound_list = [compound_1, compound_2, compound_3] precision = 0.03 unknown_peaks = spectrafit.data_report(unknown_x, unknown_y)[0] known_peaks = [] association_matrix = [] for i, _ in enumerate(known_compound_list): known_peaks.append( spectrafit.compound_report(known_compound_list[i])[0]) association_matrix.append( peakidentify.compare_unknown_to_known(unknown_peaks, known_peaks[i], precision)) unknown_peak_assignments = peakidentify.peak_position_comparisons( unknown_peaks, known_peaks, known_compound_list, association_matrix) #Test for input error handling. try: peakidentify.plotting_peak_assignments(1, unknown_y, unknown_peaks, unknown_peak_assignments) except TypeError: print("""The function correctly handled the error when an int was input instead of the unknown_x list""") try: peakidentify.plotting_peak_assignments(unknown_x, 3, unknown_peaks, unknown_peak_assignments) except TypeError: print("""The function correctly handled the error when an int was input instead of the unknown_y list""") try: peakidentify.plotting_peak_assignments(unknown_x, unknown_y, 'unknown_peaks', unknown_peak_assignments) except TypeError: print("""The function correctly handled the error when a string was input instead of the unknown_peaks list""") try: peakidentify.plotting_peak_assignments(unknown_x, unknown_y, unknown_peaks, 3) except TypeError: print("""The function correctly handled the error when an int was input instead of the unknown_peak_assignments""") try: peakidentify.plotting_peak_assignments(unknown_x, unknown_y, unknown_peaks, ['WATER', 23, 'CO']) except TypeError: print("""The function correctly handled the case when an int was passed in the unknown_peak_assignment list""")
def test_percentage_of_peaks_found(): """This function tests the operation of the percentage_of_peaks_found function in peakidentify.py""" #First, generate good data. shoyu_data_dict = pickle.load(open('raman_spectra/shoyu_data_dict.p', 'rb')) compound_1 = shoyu_data_dict['WATER'] compound_2 = shoyu_data_dict['CARBON MONOXIDE'] compound_3 = shoyu_data_dict['CARBON DIOXIDE'] unknown_x, unknown_y = shoyu.combine_spectra(compound_1, compound_2, plot=False) unknown_x = np.asarray(unknown_x) unknown_y = np.asarray(unknown_y) known_compound_list = [compound_1, compound_2, compound_3] unknown_peaks = spectrafit.data_report(unknown_x, unknown_y)[0] known_peaks = [] association_matrix = [] for i, _ in enumerate(known_compound_list): known_peaks.append( spectrafit.compound_report(known_compound_list[i])[0]) association_matrix.append( peakidentify.compare_unknown_to_known(unknown_peaks, known_peaks[i], 0.03)) #Test for input error handling. try: peakidentify.percentage_of_peaks_found(1, association_matrix, known_compound_list) except TypeError: print("""The function correctly handled the error when an int was input instead of the known_peaks list""") try: peakidentify.percentage_of_peaks_found(known_peaks, 1, known_compound_list) except TypeError: print("""The function correctly handled the error when an int was input instead of the association matrix""") try: peakidentify.percentage_of_peaks_found(known_peaks, association_matrix, 'known_compound_list') except TypeError: print("""The function correctly handled the error when a string was input instead of the known_compound_list""") try: peakidentify.percentage_of_peaks_found( known_peaks, association_matrix, [compound_1, compound_2, 'compound_3']) except TypeError: print("""The function correctly handled the case where the compound list contains something that is not a compound""") #Test to make sure function returns a dictionary. assert isinstance( peakidentify.percentage_of_peaks_found(known_peaks, association_matrix, known_compound_list), dict), """The function is not returning a dictionary.""" #Test for function output. water_peaks = spectrafit.compound_report(compound_1)[0] water_dict_0 = peakidentify.percentage_of_peaks_found([water_peaks], [[0, 0, 0]], [compound_1]) assert water_dict_0['WATER'] == 0, """The function is not correctly calculating percentages when no peaks are found""" water_dict_1 = peakidentify.percentage_of_peaks_found([water_peaks], [[1, 1, 1]], [compound_1]) assert water_dict_1['WATER'] == 100, """The function is not correctly
def test_peak_position_comparisons(): """This function tests the operation of the peak_position_comparisons function in peakidentify. Said function returns a list of strings that contain text assignments of each peak in the unknown spectrum.""" #First, generate good data. shoyu_data_dict = pickle.load(open('raman_spectra/shoyu_data_dict.p', 'rb')) compound_1 = shoyu_data_dict['WATER'] compound_2 = shoyu_data_dict['CARBON MONOXIDE'] compound_3 = shoyu_data_dict['CARBON DIOXIDE'] unknown_x, unknown_y = shoyu.combine_spectra(compound_1, compound_2, plot=False) unknown_x = np.asarray(unknown_x) unknown_y = np.asarray(unknown_y) known_compound_list = [compound_1, compound_2, compound_3] unknown_peaks = spectrafit.data_report(unknown_x, unknown_y)[0] known_peaks = [] association_matrix = [] for i, _ in enumerate(known_compound_list): known_peaks.append( spectrafit.compound_report(known_compound_list[i])[0]) association_matrix.append( peakidentify.compare_unknown_to_known(unknown_peaks, known_peaks[i], 0.03)) #Then, test error handling of bad inputs for the function. try: peakidentify.peak_position_comparisons(1, known_peaks, known_compound_list, association_matrix) except TypeError: print("An invalid unknown_peaks value was passed to the function, " "and was handled correctly.") try: peakidentify.peak_position_comparisons(unknown_peaks, 'known_peaks', known_compound_list, association_matrix) except TypeError: print("An invalid known_peaks value was passed to the function, " "and was handled correctly.") try: peakidentify.peak_position_comparisons(unknown_peaks, known_peaks, 'known_compound_list', association_matrix) except TypeError: print( "An invalid known_compound_list value was passed to the function," "and was handled correctly.") try: peakidentify.peak_position_comparisons(unknown_peaks, known_peaks, known_compound_list, 'association_matrix') except TypeError: print("An invalid association_matrix value was passed to the function," "and was handled correctly.") #Check to make sure the function is returning a list. assert isinstance( peakidentify.peak_position_comparisons(unknown_peaks, known_peaks, known_compound_list, association_matrix), list), "The function is not returning a list." #Test a call that says that no peaks have associations association_matrix_0 = [] association_matrix_0.append( peakidentify.compare_unknown_to_known(known_peaks[0], known_peaks[1], 0.03)) zero_output = peakidentify.peak_position_comparisons( known_peaks[0], [known_peaks[1]], [compound_1], association_matrix_0)[0] assert zero_output[0] == 'Unassigned', """The function is not properly handling unassigned peaks.""" #Test the function to make sure that it has the right functionality association_matrix = [] #Generate a matrix with all associations equal to 1 association_matrix.append( peakidentify.compare_unknown_to_known(known_peaks[0], known_peaks[0], 0.03)) #change the middle index to 0 association_matrix[0][1] = 0 test_peak_labels = peakidentify.peak_position_comparisons( known_peaks[0], [known_peaks[0]], [compound_1], association_matrix) assert test_peak_labels[0][0] == 'WATER', """The function is not correctly assigning peaks when association matrix = 1""" assert test_peak_labels[1][0] == 'Unassigned', """The function is not correctly handling a lack of peak assignments""" assert test_peak_labels[2][0] == 'WATER', """The funciton is