class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics(
filepath='Data/unit_test_confidence_interval.csv')
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")
class MyTestCase(unittest.TestCase):
def setUp(self):
self.statistics = Statistics()
def test_instantiate_statistics(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_method(self):
random.seed(5)
data = rand.seed_list_int(0, 10, 5)
ans = stats.mean(data)
self.assertEqual(self.statistics.mean(data), ans)
def test_mean_method_dec(self):
random.seed(5)
data = rand.seed_list_dec(0, 10, 5)
ans = stats.mean(data)
self.assertEqual(self.statistics.mean(data), ans)
def test_mean_method_empty(self):
data = []
with self.assertRaises(Exception):
self.statistics.mean(data)
def test_mean_method_str(self):
data = [1, 2, "Hello World"]
with self.assertRaises(TypeError):
self.statistics.mean(data)
def test_median_method_odd(self):
random.seed(5)
data = rand.seed_list_int(0, 10, 5)
ans = stats.median(data)
self.assertEqual(self.statistics.median(data), ans)
def test_median_method_even(self):
random.seed(5)
data = rand.seed_list_dec(0, 10, 6)
ans = stats.median(data)
self.assertEqual(self.statistics.median(data), ans)
def test_median_method_empty(self):
data = []
with self.assertRaises(Exception):
self.statistics.median(data)
def test_median_method_str(self):
data = [1, 2, "Hello World"]
with self.assertRaises(TypeError):
self.statistics.median(data)
def test_mode_method(self):
random.seed(5)
data = rand.seed_list_int(0, 10, 20)
ans = stats.mode(data)
self.assertEqual(self.statistics.mode(data), ans)
def test_mode_method_empty(self):
data = []
with self.assertRaises(Exception):
self.statistics.mode(data)
def test_mode_method_str(self):
data = [1, 2, "Hello World"]
with self.assertRaises(TypeError):
self.statistics.mode(data)
def test_simple_sampling_method(self):
data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
size = 3
ans = [5, 6, 7]
self.assertEqual(self.statistics.simple_random_sample(data, size), ans)
def test_confidence_interval_method(self):
self.assertEqual(
self.statistics.confidence_interval(240, 0.95, 25, 10),
[222.1173198317478, 257.8826801682522])
def test_margin_of_error_method(self):
self.assertEqual(self.statistics.margin_of_err(1.645, 0.4, 900),
0.021933333333333336)
def test_cochran_method(self):
self.assertEqual(self.statistics.cochran(1.960, 0.5, 0.5, 0.05),
384.1599999999999)
def test_sample_size_ci_method(self):
self.assertEqual(self.statistics.sample_size_ci(0.95, 0.41, 0.06),
1032.536711111111)
def test_variance_method(self):
data = [600, 470, 170, 430, 300]
ans = stats.variance(data)
self.assertEqual(self.statistics.sample_variance(data), ans)
def test_standard_deviation_method(self):
data = [600, 470, 170, 430, 300]
ans = stats.stdev(data)
self.assertEqual(self.statistics.sample_standard_deviation(data), ans)
def test_z_score_method(self):
self.assertEqual(self.statistics.z_score(190, 150, 25), 1.6)
def test_z_score_list_method(self):
data = [0.7972, 0.0767, 0.4383]
ans = [1.2232121397887195, -1.2262718699883022, 0.0030597301995827185]
self.assertEqual(self.statistics.z_score_list(data), ans)
class MyTestCase(unittest.TestCase):
test_data = CsvReader('Tests/Data/Test_Data.csv').data
column = [int(row['data1']) for row in test_data]
column1 = [int(row['data2']) for row in test_data]
test_answer = CsvReader("Tests/Data/Test_dataAnswer.csv").data
proportion_answer = CsvReader("Tests/Data/Test_proportionAnswer.csv").data
z_scoreAnswer = CsvReader("Tests/Data/Test_zScoreAnswer.csv").data
answer_column = [float(row['proportion']) for row in proportion_answer]
answer_column1 = [float(row['z_score']) for row in z_scoreAnswer]
sample_data = CsvReader('Tests/Data/Test_sample_data.csv').data
sample_column = [int(row['sampleData']) for row in sample_data]
def setUp(self) -> None:
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_statistics(self):
for row in self.test_answer:
pprint(row["average"])
self.assertEqual(self.statistics.population_mean(self.column),
float(row['average']))
self.assertEqual(self.statistics.result, float(row['average']))
def test_median_statistics(self):
for row in self.test_answer:
pprint(row["median"])
self.assertEqual(self.statistics.median(self.column),
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.column),
[float(row['mode'])])
self.assertEqual(self.statistics.result, [float(row['mode'])])
def test_deviation_statistics(self):
for row in self.test_answer:
pprint(row["deviation"])
self.assertEqual(
self.statistics.population_standard_deviation(self.column),
float(row['deviation']))
self.assertEqual(self.statistics.result, float(row['deviation']))
def test_variance_statistics(self):
for row in self.test_answer:
pprint(row["variance"])
self.assertEqual(self.statistics.population_variance(self.column),
float(row['variance']))
self.assertEqual(self.statistics.result, float(row['variance']))
def test_proportion_statistics(self):
self.assertEqual(self.statistics.proportion(self.column),
self.answer_column)
self.assertEqual(self.statistics.result, self.answer_column)
def test_variance_of_population_proportion_statistics(self):
for row in self.test_answer:
pprint(row["proportionVariance"])
self.assertEqual(
self.statistics.variance_of_population_proportion(self.column),
float(row['proportionVariance']))
self.assertEqual(self.statistics.result,
float(row['proportionVariance']))
def test_z_score_statistics(self):
self.assertEqual(self.statistics.z_score(self.column),
self.answer_column1)
self.assertEqual(self.statistics.result, self.answer_column1)
def test_population_correlation_coefficient_statistics(self):
pprint(
self.statistics.population_correlation_coefficient(
self.column, self.column1))
for row in self.test_answer:
pprint(row["proportionVariance"])
self.assertEqual(
self.statistics.population_correlation_coefficient(
self.column, self.column1),
float(row['population_correlation_coefficient_statistics']))
self.assertEqual(
self.statistics.result,
float(row['population_correlation_coefficient_statistics']))
def test_confidence_interval_statistics(self):
pprint(self.statistics.confidence_interval(self.column))
for row in self.test_answer:
interval_element = row["confidence_interval"].split(",", 1)
interval_result = []
for iE in interval_element:
fl = float(iE)
interval_result.append(fl)
self.assertEqual(self.statistics.confidence_interval(self.column),
interval_result)
self.assertEqual(self.statistics.result, interval_result)
def test_sample_mean_statistics(self):
for row in self.test_answer:
pprint(row["sample_mean"])
self.assertEqual(self.statistics.sample_mean(self.sample_column),
float(row['sample_mean']))
self.assertEqual(self.statistics.result, float(row['sample_mean']))
def test_sample_standard_deviation(self):
for row in self.test_answer:
pprint(row['sample_standard_deviation'])
self.assertEqual(
self.statistics.Sample_Standard_Deviation(self.sample_column),
float(row['sample_standard_deviation']))
self.assertEqual(self.statistics.result,
float(row['sample_standard_deviation']))
def test_sample_variance_proportion(self):
for row in self.test_answer:
pprint(row['sample_variance_proportion'])
self.assertEqual(
self.statistics.sample_variance_proportion(self.sample_column),
float(row['sample_variance_proportion']))
self.assertEqual(self.statistics.result,
float(row['sample_variance_proportion']))
def test_sample_method(self):
pprint(self.statistics.sample_method(self.column))
def test_p_value_statistics(self):
self.assertEqual(self.statistics.p_value(self.column),
self.answer_column1)
self.assertEqual(self.statistics.result, self.answer_column1)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics()
def test_instantiate_statistics(self):
self.assertIsInstance(self.statistics, Statistics)
def test_pop_mean(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.pop_mean(test_data),
float(row['Population Mean (Female)']))
# self.assertEqual(self.statistics.result, test_result['Population Mean (Female)'])
def test_median(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.med(test_data),
float(row['Median']))
# self.assertEqual(self.statistics.result, float(row['Median']))
def test_mode(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.mod(test_data),
float(row['Mode']))
# self.assertEqual(self.statistics.result, test_result(row['Mode']))
def test_population_stand_deviation(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.population_st_dev(test_data),
float(row['Population SD (Female)']))
# self.assertEqual(self.statistics.result, test_result(row['Population SD (Female)']))
def test_var_pop_proportion(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(
self.statistics.variance_pop_proportion(test_data),
float(row['Var Population Prop']))
# self.assertEqual(self.statistics.result, test_result(row['Var Population Prop']))
def test_proportion(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.proportion(test_data),
float(row['Proportion']))
# self.assertEqual(self.statistics.result, test_result(row['Proportion']))
def test_sample_mean(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.sample_mean(test_data),
float(row['Sample Mean']))
# self.assertEqual(self.statistics.result, test_result(row['Sample Mean']))
def test_sample_st_dev(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.sample_st_dev(test_data),
float(row['Sample SD']))
# self.assertEqual(self.statistics.result, test_result(row['Sample SD']))
def test_sample_var_prop(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.var_sam_prop(test_data),
float(row['Variance of Sample Proportion']))
# self.assertEqual(self.statistics.result, test_result(row['Variance of Sample Proportion']))
def test_p_value(self):
test_data = CsvNormalReader('Tests/Data/normal_dist.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
z_score_test_result = str(
self.statistics.z_score(
CsvReaderStats('Tests/Data/female_height.csv').data))
actual = test_result[0]['P Value']
for test_value in test_data:
expected = test_value.split(",")
if z_score_test_result == expected[0]:
self.assertAlmostEqual(actual, expected[1])
def test_z_score(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.z_score(test_data),
float(row['ZScore']))
# self.assertEqual(self.statistics.result, test_result(row['ZScore']))
def test_confidence_interval(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.confidence_interval(test_data),
(float(row['Confidence Interval (Lower)']),
float(row['Confidence Interval (Upper)'])))
# self.assertEqual(self.statistics.result, test_result(row['Confidence Interval (Lower)'],
# row['Confidence Interval ('Upper)']))
def test_population_variance(self):
test_data = CsvReaderStats('Tests/Data/female_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(self.statistics.population_variance(test_data),
float(row['Population Variance']))
# self.assertEqual(self.statistics.result, test_result(row['Population Variance']))
def test_pop_correlation_coefficient(self):
test_data_f = CsvReaderStats('Tests/Data/female_height.csv').data
test_data_m = CsvReaderStats('Tests/Data/male_height.csv').data
test_result = CsvReader('Tests/Data/Results_Statistics_Calc.csv').data
for row in test_result:
self.assertEqual(
self.statistics.pop_correlation_coefficient(
test_data_f, test_data_m),
float(row['Population '
'Correlation '
'Coefficient']))
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.Statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.Statistics, Statistics)
def test_mean(self):
test_data = CsvReader('Tests/Data/population_list.csv').data
result_data = CsvReader('Tests/Data/result_data.csv').data
for column in result_data:
mean_value = float(column['Mean'])
data = []
for row in test_data:
result = float(row['List1'])
data.append(result)
self.Statistics.mean(data)
self.assertEqual(round(self.Statistics.result), round(mean_value))
def test_median(self):
test_data = CsvReader('Tests/Data/population_list.csv').data
result_data = CsvReader('Tests/Data/result_data.csv').data
for column in result_data:
median_value = float(column['Median'])
data = []
for row in test_data:
result = float(row['List1'])
data.append(result)
self.Statistics.median(data)
self.assertEqual(round(self.Statistics.result), round(median_value))
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_variance(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['Variance'])
list1 = []
for row in test_data:
result = float(row['List1'])
list1.append(result)
self.Statistics.variance(list1)
self.assertEqual(round(self.Statistics.result), round(result_test))
def test_sample_mean(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['Sample Mean'])
list1 = []
for row in test_data:
result = float(row['List1'])
list1.append(result)
self.assertEqual(round(self.Statistics.sample_mean(list1)),
round(result_test))
def test_standardized_score(self):
test_data = CsvReader2('Tests/Data/population_list.csv').data
test_result = CsvReader2('Tests/Data/result_zscore.csv').data
'''
for column in test_result:
result_test = float(column['Z_score'])
list1 = list()
for row in test_data:
result = float(row[0])
list1.append(result)
'''
self.assertListEqual(self.Statistics.z_score(test_data), test_result)
def test_z_score(self):
test_data = CsvReader2('Tests/Data/population_list.csv').data
test_result = CsvReader2('Tests/Data/result_zscore.csv').data
'''
for column in test_result:
result_test = float(column['Z_score'])
list1 = list()
for row in test_data:
result = float(row[0])
list1.append(result)
'''
self.assertListEqual(self.Statistics.z_score(test_data), test_result)
def test_pop_correlation_coefficient(self):
test_data = CsvReader2('Tests/Data/population_list.csv').data
test_result = CsvReader('Tests/Data/result_data.csv').data
for column in test_result:
result_test = float(column['Pop_correlation_coefficient'])
'''
list1 = []
for row in test_data:
result = float(row['List1'])
list1.append(result)
'''
self.assertEqual(
round(self.Statistics.pop_correlation_coefficient(test_data)),
round(result_test))
def test_sample_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['Sample_Standard_Deviation'])
list1 = []
for row in test_data:
result = float(row['List1'])
list1.append(result)
self.assertEqual(
round(self.Statistics.sample_standard_deviation(list1)),
round(result_test))
def test_proportion_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['Proportion_result']))
for row in test_data:
result = float(row['List1'])
list1.append(result)
self.assertEqual(round(self.Statistics.proportion(list1)),
round(result_test))
def test_sample_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['Variance_Sample_result']))
for row in test_data:
result = int(row['List1'])
list1.append(result)
self.assertEqual(round(self.Statistics.sample_variance(list1)),
round(result_test))
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_confidence_interval(self):
test_data = CsvReader('Tests/Data/population_list.csv').data
result_cf_interval = CsvReader('Tests/Data/result_data.csv').data
for column in result_cf_interval:
result_test1 = float(column['Confidence_Interval1'])
result_test2 = float(column['Confidence_Interval2'])
data = []
for row in test_data:
result_data = float(row['List1'])
data.append(result_data)
x = self.Statistics.confidence_interval(data)
try:
self.assertAlmostEqual(x[0], result_test1)
self.assertAlmostEqual(x[1], result_test2)
except AssertionError as e:
print("Confidence Interval has Assertion Error:", e)
assert 0
def test_p_value(self):
test_data = CsvReader2('Tests/Data/population_list.csv').data
test_result = CsvReader('Tests/Data/result_data.csv').data
result_test = 0
for column in test_result:
result_test = float(column['P_Value'])
self.assertEqual(round(self.Statistics.p_value(test_data)),
round(result_test))