def proportion(self):
test_data = CsvReader('Tests/Data/just_age.csv').data
test_result = CsvReader('Test/Data/Age_Results.csv').data
for row in test_data:
self.assertEqual(self.statistics.p_value, float(row['Proportion']))
self.assertEqual(self.statistics.result,
test_result(row['Proportion']))
def test_psd(self):
test_data = CsvReader("/Tests/Data/datapoints.csv")
answers = CsvReader("/Tests/Data/answers.csv").data
values = fetchRawdata(test_data, 'value')
for column in answers:
self.assertEqual(round(self.statistics.psd(values), 4),
float((column['PSD'])))
def setUp(self) -> None:
#random.seed(5)
self.testData = []
dataset_reader = CsvReader('Tests/Dataset.csv').data
for row in dataset_reader:
self.testData.append(int(row['DataSet']))
self.srs = []
srs_reader = CsvReader('Tests/UnitTestSrsAnswers.csv').data
for row in srs_reader:
self.srs.append(int(row['srs']))
stat_answers = CsvReader('Tests/UnitTestSamplingInputs.csv').data
for row in stat_answers:
self.n = int(row['n'])
self.seed = int(row['seed'])
self.conf = float(row['conf'])
self.prop = float(row['prop'])
self.width = float(row['width'])
stat_answers = CsvReader('Tests/UnitTestSamplingAnswers.csv').data
for row in stat_answers:
self.mean = float(row['mean'])
self.moe = float(row['moe'])
self.cochrans_n = float(row['cochrans'])
self.sample_n = float(row['find_n'])
self.sampling = Sampling()
def pop_standard_dev(self):
test_data = CsvReader('Tests/Data/just_age.csv').data
test_result = CsvReader('Test/Data/Age_Results.csv').data
for row in test_data:
self.assertEqual(self.statistics.p_value, float(row['Sample SD']))
self.assertEqual(self.statistics.result,
test_result(row['Sample SD']))
def test_median(self):
test_data = CsvReader("/Tests/Data/datapoints.csv")
answers = CsvReader("/Tests/Data/answers.csv").data
values = fetchRawdata(test_data, 'value')
for column in answers:
self.assertEqual(self.statistics.median(values),
float((column['median'])))
def test_Mode_calculator(self):
test_data = CsvReader('Tests/Data/StatCalcData.csv').data
answer = CsvReader('Tests/Data/StatAnswers.csv').data
lst = data_add(test_data)
for column in answer:
self.assertEqual(self.statistics.mod(lst), float((column['mode'])))
self.assertNotEqual(self.statistics.mod(lst),
float((column['mode'])) - 2, "Incorrect Mode")
def test_zscore(self):
test_data = CsvReader("/Tests/Data/datapoints.csv")
answers = CsvReader("/Tests/Data/answers.csv").data
values = fetchRawdata(test_data, 'value')
# pprint(values)
for column in answers:
self.assertEqual(self.statistics.z_score(values),
float((column['zscore'])))
def test_population_variance_calculator(self):
test_data = CsvReader('Tests/Data/StatCalcData.csv').data
answer = CsvReader('Tests/Data/StatAnswers.csv').data
lst = data_add(test_data)
for column in answer:
self.assertEqual(self.statistics.pvariance(lst),
float((column['pop_variance'])))
self.assertNotEqual(self.statistics.pvariance(lst),
float((column['pop_variance'])) - 3,
"Wrong Pop Var")
def test_Population_Standard_Deviation_calculator(self):
test_data = CsvReader('Tests/Data/StatCalcData.csv').data
answer = CsvReader('Tests/Data/StatAnswers.csv').data
lst = data_add(test_data)
for column in answer:
self.assertEqual(self.statistics.stddev(lst),
float((column['stdev'])))
self.assertNotEqual(self.statistics.stddev(lst),
float((column['stdev'])) * 3,
"Wrong Pop Std Deviation")
def test_Population_Mean_calculator(self):
test_data = CsvReader('Tests/Data/StatCalcData.csv').data
answer = CsvReader('Tests/Data/StatAnswers.csv').data
lst = data_add(test_data)
for column in answer:
self.assertEqual(self.statistics.mean(lst), float(
(column['mean'])))
self.assertNotEqual(self.statistics.mean(lst),
float((column['mean'])) * 2,
"Mean does not match")
def test_proportion_calculator(self):
test_data = CsvReader('Tests/Data/StatCalcData.csv').data
answer = CsvReader('Tests/Data/StatAnswers.csv').data
lst = data_add(test_data)
for column in answer:
self.assertEqual(self.statistics.proportion(lst),
float((column['proportion'])))
self.assertNotEqual(self.statistics.proportion(lst),
float((column['proportion'])) - 2,
"Wrong Proportion")
def test_variance_population_proportion_calculator(self):
test_data = CsvReader('Tests/Data/StatCalcData.csv').data
answer = CsvReader('Tests/Data/StatAnswers.csv').data
lst = []
for row in test_data:
y = int(row['Value 1'])
lst.append(y)
for column in answer:
result = float((column['var_pop_prop']))
self.assertEqual(self.statistics.vpop_proportion(lst), result)
def test_variance_population_proportion_calculator(self):
test_data = CsvReader('Tests/Data/StatCalcData.csv').data
answer = CsvReader('Tests/Data/StatAnswers.csv').data
lst = data_add(test_data)
for column in answer:
self.assertEqual(self.statistics.vpop_proportion(lst),
float((column['var_pop_prop'])))
self.assertNotEqual(self.statistics.vpop_proportion(lst),
float((column['var_pop_prop'])) - 2,
"WrongResult")
def test_zscore_calculator(self):
test_data = CsvReader('Tests/Data/StatCalcData.csv').data
answer = CsvReader('Tests/Data/StatAnswers.csv').data
lst = []
for row in test_data:
y = int(row['Value 1'])
lst.append(y)
for column in answer:
result = float((column['zscore']))
self.assertEqual(self.statistics.z_score(lst), result)
def test_Population_Standard_Deviation_calculator(self):
test_data = CsvReader('Tests/Data/StatCalcData.csv').data
answer = CsvReader('Tests/Data/StatAnswers.csv').data
lst = []
for row in test_data:
y = int(row['Value 1'])
lst.append(y)
for column in answer:
result = float((column['stdev']))
self.assertEqual(self.statistics.stddev(lst), result)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics()
test_data = CsvReader('Tests/CSVFiles/TestCaseData.csv').data
test_answer = CsvReader('Tests/CSVFiles/TestAnswers.csv').data
zscore_ans = CsvReader('Tests/CSVFiles/ZScores.csv').data
zdata = [float(row['zscore']) for row in zscore_ans]
column1 = [int(row['Value 1']) for row in test_data]
column2 = [int(row['Value 2']) for row in test_data]
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_statistics(self):
global row
for row in self.test_answer:
pprint(row["mean"])
self.assertEqual(self.statistics.mean(self.column1), float(row['mean']))
self.assertEqual(self.statistics.result, float(row['mean']))
def test_median_statistics(self):
global row
for row in self.test_answer:
pprint(row["median"])
self.assertEqual(self.statistics.median(self.column1), float(row['median']))
self.assertEqual(self.statistics.result, float(row['median']))
def test_mode_statistics(self):
for row in self.test_answer:
pprint(row["mode"])
self.assertEqual(self.statistics.mode(self.column1), float(row['mode']))
self.assertEqual(self.statistics.result, float(row['mode']))
def test_standard_deviation_statistics(self):
for row in self.test_answer:
pprint(row["stddev"])
self.assertEqual(self.statistics.stddev(self.column1), float(row['stddev']))
self.assertEqual(self.statistics.result, float(row['stddev']))
def test_variance_statistics(self):
for row in self.test_answer:
pprint(row['variance'])
self.assertEqual(self.statistics.variance(self.column1), float(row['variance']))
self.assertEqual(self.statistics.result, float(row['variance']))
def test_correlation_statistics(self):
for row in self.test_answer:
pprint(row['correlation'])
self.assertEqual(self.statistics.correlation(self.column1, self.column2),
float(row['correlation']))
self.assertEqual(self.statistics.result, float(row['correlation']))
def test_Population_Variance_calculator(self):
test_data = CsvReader('Tests/Data/population_list.csv').data
test_result = CsvReader('Tests/Data/result_data.csv').data
list1 = []
for column in test_result:
result_test = float((column['Population_Variance']))
for row in test_data:
result = int(row['List1'])
list1.append(result)
self.assertEqual(round(self.Statistics.population_variance(list1)),
round(result_test))
def test_mode(self):
test_data = CsvReader('Tests/Data/population_list.csv').data
result_data = CsvReader('Tests/Data/result_data.csv').data
for column in result_data:
mode_value = float(column['Mode'])
data = []
for row in test_data:
result = float(row['List1'])
data.append(result)
self.Statistics.mode(data)
self.assertEqual(round(self.Statistics.result), round(mode_value))
def test_standard_deviation(self):
test_data = CsvReader('Tests/Data/population_list.csv').data
test_result = CsvReader('Tests/Data/result_data.csv').data
for column in test_result:
result_test = float(column['Standard Deviation'])
list1 = []
for row in test_data:
result = float(row['List1'])
list1.append(result)
self.Statistics.standard_deviation(list1)
self.assertEqual(round(self.Statistics.result), round(result_test))
def test_multiplication(self):
test_data = CsvReader('Tests/Data/multiplication.csv').data
for row in test_data:
self.assertEqual(
self.calculator.multiple(row['Value 1'], row['Value 2']),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
def test_division(self):
test_data = CsvReader('Tests/Data/division.csv').data
for row in test_data:
self.assertEqual(
self.calculator.div(row['Value 1'], row['Value 2']),
float(row['Result']))
self.assertEqual(self.calculator.result, float(row['Result']))
def test_mode_statistics(self):
test_data_mode = CsvReader("Tests/Data/descriptive_stats.csv").data
for row in test_data_mode:
input_data = ast.literal_eval(row['input'])
mode_data = ast.literal_eval(row['mode'])
self.assertEqual(self.statistics.mode(input_data), mode_data)
self.assertEqual(self.statistics.result, mode_data)
def test_sample_mean(self):
try:
mean_data = CsvReader('Data/unit_test_median.csv').data
for d in mean_data:
data_list = []
first_val = int(d['Value 1'])
data_list.append(first_val)
second_val = int(d['Value 2'])
data_list.append(second_val)
third_val = int(d['Value 3'])
data_list.append(third_val)
fourth_val = int(d['Value 4'])
data_list.append(fourth_val)
fifth_val = int(d['Value 5'])
data_list.append(fifth_val)
six_val = int(d['Value 6'])
data_list.append(six_val)
seven_val = int(d['Value 7'])
data_list.append(seven_val)
eight_val = int(d['Value 8'])
data_list.append(eight_val)
nine_val = int(d['Value 9'])
data_list.append(nine_val)
self.assertAlmostEqual(self.statistics.median(data_list), int(d['Result']))
self.assertAlmostEqual(self.statistics.result, int(d['Result']))
except:
FileNotFoundError("Error. File was not found")
def test_square_rt_method_calculator(self):
test_data = CsvReader("Tests/Data/square_root.csv").data
for row in test_data:
y = float(row['Result'])
self.assertEqual(self.calculator.square_rt(int(row['Value 1'])),
round(y, 7))
self.assertEqual(self.calculator.result, round(y, 7))
def test_mean(self):
test_data = CsvReader("/Tests/Data/Mean.csv").data
for row in test_data:
self.assertEqual(
self.statistics.mean(row['Value 1'], row['Value 2']),
float(row['Result']))
self.assertEqual(self.statistics.result, float(row['Result']))
def correlation_coefficient(self):
test_data = CsvReader("/Tests/Data/correlationcoefficient.csv").data
for row in test_data:
self.assertEqual(
self.statistics.correlation_coefficient(row['Value 1']),
float(row['Result']))
self.assertEqual(self.statistics.result, float(row['Result']))
def test_zscore(self):
test_data = CsvReader("/Tests/Data/zscore.csv").data
for row in test_data:
self.assertEqual(
self.statistics.zscore(row['Value 1'], row['Value 2'],
row['Value 3']), float(row['Result']))
self.assertEqual(self.statistics.result, float(row['Result']))
def test_squareroot(self):
test_data = CsvReader("Tests/Data/squareroot.csv").data
for row in test_data:
result = float(row['Result'])
self.assertAlmostEqual(self.calculator.squareroot(row['Value 1']),
result)
self.assertAlmostEqual(self.calculator.result, result)
def test_sample_mean(self):
try:
mean_data = CsvReader(
'Data/unit_test_confidence_interval.csv').data
for d in mean_data:
data_list = []
first_val = int(d['Value 1'])
data_list.append(first_val)
second_val = int(d['Value 2'])
data_list.append(second_val)
third_val = int(d['Value 3'])
data_list.append(third_val)
fourth_val = int(d['Value 4'])
data_list.append(fourth_val)
fifth_val = int(d['Value 5'])
data_list.append(fifth_val)
six_val = int(d['Value 6'])
self.assertAlmostEqual(
self.statistics.confidence_interval(data_list, six_val),
int(d['Result']))
self.assertAlmostEqual(self.statistics.result,
int(d['Result']))
except:
FileNotFoundError("Error. File was not found")
def test_add_method_calculator(self):
test_data = CsvReader("Tests/Data/addition.csv").data
for row in test_data:
self.assertEqual(
self.calculator.add(int(row['Value 1']), int(row['Value 2'])),
int(row['Result']))
self.assertEqual(self.calculator.result, int(row['Result']))
