class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_statistics(self):
test_data = CsvReader('Tests/Data/unit_test_mean.csv').data
for row in test_data:
result = int(row['Result'])
self.assertEqual(self.statistics.mean(row['Value 1'], row['Value 2'], row['Value 3']), result)
self.assertEqual(self.statistics.result, result)
def test_median_statistics(self):
test_data = CsvReader('Tests/Data/unit_test_median.csv').data
for row in test_data:
result = float(row['Result'])
self.assertEqual(self.statistics.median(row['Value 1'], row['Value 2'], row['Value 3'], row['Value 4'], row['Value 5'], row['Value 6'], row['Value 7'], row['Value 8'], row['Value 9']), result)
self.assertEqual(self.statistics.result, result)
def test_mode_statistics(self):
test_data = CsvReader('Tests/Data/unit_test_mode.csv').data
for row in test_data:
result = int(row['Result'])
self.assertEqual(self.statistics.mode(row['Value 1'], row['Value 2'], row['Value 3'], row['Value 4'], row['Value 5'], row['Value 6'], row['Value 7'], row['Value 8']), result)
self.assertEqual(self.statistics.result, result)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_decorator_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_statistics_calculator_return_variance(self):
data = [1, 2, 3, 4, 5, 6]
result = self.statistics.variance(data)
self.assertEqual(2.9166666666666665, result)
def test_statistics_calculator_return_quartiles(self):
data = [2, 6, 7]
result = self.statistics.quartile(data, 0.25, 0, None)
self.assertEqual(4, result)
def test_statistics_calculator_return_skew(self):
data = [3, 5, 6, 5, 3, 2, 1, 40]
result = self.statistics.skew(data, None, None)
self.assertEqual(2.734386516915545, result)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.testData = getRandomNums(1, 1, 100, 20)
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_calculator(self):
mean = self.statistics.mean(self.testData)
self.assertEqual(mean, 38.95)
def test_median_calculator(self):
med = self.statistics.median(self.testData)
self.assertEqual(med, 27.5)
def test_mode_calculator(self):
theMode = self.statistics.mode(self.testData)
self.assertEqual(theMode, 2)
def test_meanDev_calculator(self):
meandev = self.statistics.meanDev(self.testData)
self.assertEqual(meandev, 26.740000000000002)
def test_stdDev_calculator(self):
std = self.statistics.stdDev(self.testData)
self.assertEqual(std, 29.052495589880053)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_decorator_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
# Test Mean
def test_statistics_calculator_return_mean(self):
data = [1, 2, 3, 4, 5]
result = self.statistics.mean(data)
self.assertEqual(3, result)
# Test Mode
def test_statistics_calculator_return_mode(self):
data = [1, 2, 3, 3, 4, 5]
result = self.statistics.mode(data)
self.assertEqual(3, result)
def test_statistics_calculator_return_NoMode(self):
data = [1, 2, 3, 4, 5]
result = self.statistics.mode(data)
self.assertEqual('no mode', result)
# Test Median
def test_statistics_calculator_return_median(self):
data = [2, 4, 6, 8, 10]
result = self.statistics.median(data)
self.assertEqual(6, result)
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/Mean.csv").data
for row in test_data:
#result = float(row['Result'])
self.assertEqual(
self.statistics.mean(row['Value 1'], row['Value 2']),
float(row['Result']))
self.assertEqual(self.statistics.result, float(row['Result']))
def test_median(self):
test_data = CsvReader("/Tests/Data/Median.csv").data
for row in test_data:
#result = float(row['Result'])
self.assertEqual(
self.statistics.median(row['Value 1'], row['Value 2'],
row['Value 3'], row['Value 4']),
float(row['Result']))
self.assertEqual(self.statistics.result, float(row['Result']))
def setUp(self) -> None:
#seed(5)
self.statistics = Statistics()
self.testData0 = random_code()
self.testData1 = random_code_no_seed()
self.testData2 = random_select()
self.testData3 = random_select_no_seed()
self.testZ = zValues(self.testData0)
self.testZscore = zValues(self.testData0)
def setUp(self) -> None:
self.testData = random_code()
self.testData2 = random_code2()
self.statistics = Statistics()
# self.testData1 = random_code_withoutSeed()
self.testZ = z_values(self.testData)
self.testSystematic = Systematic(self.testData)
self.testZscore = z_values(self.testData)
def setUp(self) -> None:
random.seed(5)
self.randomData = []
i = 0
while i < 6:
self.randomData.append(random.randint(1, 100))
i += 1
#pprint.pprint(self.randomData)
#[80, 33, 95, 46, 89, 95]
self.statistics = Statistics()
def setUp(self) -> None:
'''seed(5)
self.testData = randint(0, 10, 20)'''
random.seed(5)
self.randomData = []
i = 0
while i < 6:
self.randomData.append(random.randint(1, 100))
i += 1
#pprint.pprint(self.randomData)
self.statistics = Statistics()
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
random.seed(5)
self.randomData = []
i = 0
while i < 6:
self.randomData.append(random.randint(1, 100))
i += 1
#pprint.pprint(self.randomData)
#[80, 33, 95, 46, 89, 95]
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_calculator(self):
mean = self.statistics.mean([2, 4, 6, 8, 10])
self.assertEqual(mean, 6)
def test_median_calculator(self):
median = self.statistics.median([2, 4, 6, 8, 10])
self.assertEqual(median, 6)
def test_mode_calculator(self):
mode = self.statistics.mode([22, 33, 44, 44, 53])
self.assertEqual(mode, [44])
def test_variance_calculator(self):
variance = self.statistics.variance(self.randomData)
self.assertEqual(variance, 2235.5)
def test_standard_deviation_calculator(self):
standard_deviation = self.statistics.standard_deviation(self.randomData)
self.assertEqual(standard_deviation, 47.281074437876306)
def test_quartliles_statistics(self):
quartiles = self.statistics.quartile(self.randomData)
self.assertEqual(quartiles, (54.5, 84.5, 93.5))
def test_skewness_statisitcs(self):
skewness = self.statistics.skewness(self.randomData)
self.assertEqual(skewness, -0.4653024547677381)
def test_samplecorrelation_statistics(self):
correlation = self.statistics.sampleCorrelation(self.randomData, self.randomData) #should just be 1?
self.assertEqual(correlation, 1.6112726459405051)
def test_zscore_statisitcs(self):
zscore = self.statistics.zScore(self.randomData)
self.assertEqual(zscore, 0.4653024547677381)
def test_meandeviation_statisitcs(self):
meanDeviation = self.statistics.mean_deviation(self.randomData)
self.assertEqual(meanDeviation, 2235.5)
def setUp(self) -> None:
seed(5)
self.testData = []
for i in range(0, 10):
num = random.randint(0, 15)
self.testData.append(num)
self.mean_value = statistics.mean(self.testData)
self.median_value = statistics.median(self.testData)
self.mode_value = statistics.mode(self.testData)
self.variance_value = statistics.variance(self.testData)
self.standard_deviation_value = statistics.stdev(self.testData)
self.statistics = Statistics()
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics('Data/unit_test_variance_pop_prop.csv')
def test_sample_mean(self):
mean_data = CsvReader('Data/unit_test_variance_pop_prop.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)
four_val = int(d['Value 4'])
data_list.append(four_val)
five_val = int(d['Value 5'])
self.assertAlmostEqual(
self.statistics.variance_pop_proportion(data_list),
float(d['Result']),
places=2)
self.assertAlmostEqual(self.statistics.result,
float(d['Result']),
places=3)
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) -> None:
self.statistics = Statistics('Data/unit_test_median.csv')
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")
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics('Data/unit_test_standardized_score.csv')
def test_sample_mean(self):
mean_data = CsvReader('Data/unit_test_standardized_score.csv').data
for d in mean_data:
data_list = []
first_val = int(d['Value 1'])
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'])
self.assertAlmostEqual(self.statistics.standardized_score(
first_val, data_list, fourth_val),
float(d['Result']),
places=3)
self.assertAlmostEqual(self.statistics.result,
float(d['Result']),
places=3)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics('Data/unit_test_population_correlation_coefficient.csv')
def test_sample_mean(self):
mean_data = CsvReader('Data/unit_test_population_correlation_coefficient.csv').data
for d in mean_data:
x_vals = []
y_vals = []
X1 = int(d['X1'])
x_vals.append(X1)
Y1 = int(d['Y1'])
y_vals.append(Y1)
X2 = int(d['X2'])
x_vals.append(X2)
Y2 = int(d['Y2'])
y_vals.append(Y2)
X3 = int(d['X3'])
x_vals.append(X3)
Y3 = int(d['Y3'])
y_vals.append(Y3)
X4 = int(d['X4'])
x_vals.append(X4)
Y4 = int(d['Y4'])
y_vals.append(Y4)
X5 = int(d['X5'])
x_vals.append(X5)
Y5 = int(d['Y5'])
y_vals.append(Y5)
self.assertAlmostEqual(self.statistics.population_corre_coefficient(x_vals, y_vals), float(d['Result']), places=3)
self.assertAlmostEqual(self.statistics.result, float(d['Result']), places=3)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics('Data/unit_test_variance_sample_prop.csv')
def test_sample_mean(self):
try:
mean_data = CsvReader(
'Data/unit_test_variance_sample_prop.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)
self.assertEqual(
self.statistics.variance_sample_proportion(data_list),
int(d['Result']),
places=2)
self.assertEqual(self.statistics.result,
int(d['Result']),
places=2)
except:
FileNotFoundError("Error. File was not found")
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics('Tests/Data/UnitTestStats.csv')
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_decorator_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_statistics(self):
test_data = CsvReader('Tests/Data/UnitTestStats.csv').data
first_row = ([i for i in test_data if i['Mean'] != ''])[0]
mean_value = float(first_row['Mean'])
self.assertEqual(self.statistics.mean(), mean_value)
def test_sample_mean_statistics(self):
test_data = CsvReader('Tests/Data/UnitTestStats.csv').data
first_row = ([i for i in test_data if i['Sample_Mean'] != ''])[0]
sample_mean_value = float(first_row['Sample_Mean'])
self.assertEqual(self.statistics.sample_mean(), sample_mean_value)
def test_median_statistics(self):
test_data = CsvReader('Tests/Data/UnitTestStats.csv').data
first_row = ([i for i in test_data if i['Median'] != ''])[0]
median_value = float(first_row['Median'])
self.assertEqual(self.statistics.median(), median_value)
def test_mode_statistics(self):
test_data = CsvReader('Tests/Data/UnitTestStats.csv').data
first_row = ([i for i in test_data if i['Mode'] != ''])[0]
mode_value = float(first_row['Mode'])
self.assertEqual(self.statistics.mode(), str(mode_value))
def test_pv_statistics(self):
test_data = CsvReader('Tests/Data/UnitTestStats.csv').data
first_row = ([i for i in test_data if i['Pop_Var'] != ''])[0]
pop_var = float(first_row['Pop_Var'])
self.assertEqual(self.statistics.pv(), pop_var)
def test_psd_statistics(self):
test_data = CsvReader('Tests/Data/UnitTestStats.csv').data
first_row = ([i for i in test_data if i['Pop_Std_Dev'] != ''])[0]
pop_std_dev = float(first_row['Pop_Std_Dev'])
self.assertEqual(self.statistics.psd(), pop_std_dev)
def test_pcc_statistics(self):
test_data = CsvReader('Tests/Data/UnitTestStats.csv').data
first_row = ([i for i in test_data if i['Pop_Cor_Coef'] != ''])[0]
pop_cor_coef = float(first_row['Pop_Cor_Coef'])
self.assertEqual(self.statistics.pcc(), pop_cor_coef)
def test_zscore_statistics(self):
test_data = CsvReader('Tests/Data/UnitTestStats.csv').data
first_row = ([i for i in test_data if i['Z_Score'] != ''])[0]
z_score = float(first_row['Z_Score'])
self.assertEqual(self.statistics.z(), z_score)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
seed(5)
self.testData = randint(0, 10, 20)
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_calculator(self):
mean = self.statistics.mean(self.testData)
self.assertEqual(mean, 4.25)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_statistics(self):
test_data = CsvReader('Tests/Data/UnitTestStats.csv').data
for row in test_data:
result = 'mean'
self.assertEqual(self.statistics.mean(self.data, result))
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.testData = getRandomNums(9, 1, 10, 10)
self.statistics = Statistics()
def test_instantiate_statistics_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_statistics_mean(self):
mean = self.statistics.mean(self.testData)
self.assertEqual(mean, 5.9)
print(self.testData)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.testData = [
813, 731, 560, 32, 361, 41, 461, 450, 317, 976, 6, 99, 99, 601, 45,
209, 994, 100, 49, 916
]
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_calculator(self):
mean = self.statistics.mean(self.testData)
self.assertEqual(mean, statistics.mean(self.testData))
def test_median_calculator(self):
median = self.statistics.median(self.testData)
self.assertEqual(median, statistics.median(self.testData))
def test_mode_calculator(self):
mode = self.statistics.mode(self.testData)
self.assertEqual(mode, statistics.mode(self.testData))
def test_variance_calculator(self):
variance = self.statistics.variance(self.testData)
self.assertEqual(variance, statistics.variance(self.testData))
def test_stdev_calculator(self):
stdev = self.statistics.stdev(self.testData)
self.assertEqual(stdev, statistics.stdev(self.testData))
def test_zscore_calculator(self):
zscore = self.statistics.zscore(self.testData)
self.assertEqual(zscore, stats_zscore(self.testData))
def setUp(self) -> None:
random.seed(5)
#self.testData = [0,1,2,3,4,5,6,6] #randint(0, 10, 20)
self.statistics = Statistics()
self.testData = []
self.zscoredata = []
dataset_reader = CsvReader('Tests/Dataset.csv').data
for row in dataset_reader:
self.testData.append(int(row['DataSet']))
stat_answers = CsvReader('Tests/UnitTestStatAnswers.csv').data
for row in stat_answers:
self.mean = float(row['mean'])
self.median = float(row['median'])
self.mode = float(row['mode'])
self.variance = float(row['variance'])
self.stddev = float(row['stddev'])
zscore_reader = CsvReader('Tests/UnitTestZScoreAnswers.csv').data
for row in zscore_reader:
self.zscoredata.append(float(row['zscore']))
class MyTestCase(unittest.TestCase):
def setUp(self):
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_decorator_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
# Test Mean -------------------------------------------------------------
def test_statistics_calculator_return_mean(self):
data = [1, 2, 3, 4, 5]
result = self.statistics.mean(data)
self.assertEqual(3, result)
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
random.seed(5)
#self.testData = [0,1,2,3,4,5,6,6] #randint(0, 10, 20)
self.statistics = Statistics()
self.testData = []
self.zscoredata = []
dataset_reader = CsvReader('Tests/Dataset.csv').data
for row in dataset_reader:
self.testData.append(int(row['DataSet']))
stat_answers = CsvReader('Tests/UnitTestStatAnswers.csv').data
for row in stat_answers:
self.mean = float(row['mean'])
self.median = float(row['median'])
self.mode = float(row['mode'])
self.variance = float(row['variance'])
self.stddev = float(row['stddev'])
zscore_reader = CsvReader('Tests/UnitTestZScoreAnswers.csv').data
for row in zscore_reader:
self.zscoredata.append(float(row['zscore']))
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_calculator(self):
mean = self.statistics.mean(self.testData)
self.assertEqual(mean, self.mean)
def test_median_calculator(self):
median = self.statistics.median(self.testData)
self.assertEqual(median, self.median)
def test_mode_calculator(self):
mode = self.statistics.mode(self.testData)
self.assertEqual(mode, self.mode)
def test_stddev_calculator(self):
stddev = self.statistics.stddev(self.testData)
self.assertEqual(stddev, self.stddev)
def test_variance_calculator(self):
variance = self.statistics.variance(self.testData)
self.assertEqual(variance, self.variance)
def test_zscore_calculator(self):
ZScore = self.statistics.zscore(self.testData)
for i in range(0, len(ZScore) - 1):
self.assertEqual(round(ZScore[i], 4), round(self.zscoredata[i], 4))
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
seed(5)
self.testData = []
for i in range(0, 10):
num = random.randint(0, 15)
self.testData.append(num)
self.mean_value = statistics.mean(self.testData)
self.median_value = statistics.median(self.testData)
self.mode_value = statistics.mode(self.testData)
self.variance_value = statistics.variance(self.testData)
self.standard_deviation_value = statistics.stdev(self.testData)
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.statistics, Statistics)
def test_mean_calculator(self):
mean = self.statistics.stats_mean(self.testData)
self.assertEqual(mean, self.mean_value)
def test_median_calculator(self):
median = self.statistics.stats_median(self.testData)
self.assertEqual(median, self.median_value)
def test_mode_calculator(self):
mode = self.statistics.stats_mode(self.testData)
self.assertEqual(mode, self.mode_value)
def test_median_calculator(self):
median = self.statistics.stats_median(self.testData)
self.assertEqual(median, self.median_value)
def test_mode_calculator(self):
mode = self.statistics.stats_mode(self.testData)
self.assertEqual(mode, self.mode_value)
def test_variance_calculator(self):
variance = self.statistics.stats_variance(self.testData)
self.assertEqual(variance, round((self.variance_value), 1))
def test_standard_deviation_calculator(self):
standard_deviation = self.statistics.stats_standard_deviation(
self.testData)
self.assertEqual(standard_deviation,
round((self.standard_deviation_value), 1))
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']))
class MyTestCase(unittest.TestCase):
def setUp(self) -> None:
self.statistics = Statistics('Data/unit_test_mean.csv')
def test_sample_mean(self):
mean_data = CsvReader('Data/unit_test_mean.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)
self.assertAlmostEqual(self.statistics.population_mean(data_list), int(d['Result']))
self.assertAlmostEqual(self.statistics.result, int(d['Result']))
class MyTestCase(unittest.TestCase):
def setUp(self):
self.random = Random()
self.statistics = Statistics()
def test_instantiate_calculator(self):
self.assertIsInstance(self.random, Random)
def test_decorator_calculator(self):
self.assertIsInstance(self.random, Random)
# Test Random -------------------------------------------------------------
def test_random_int_seed(self):
testdata = self.random.Random_int_nums(1, 100, 5, 5)
mean = self.statistics.mean(testdata)
self.assertEqual(mean, 48.2)
def test_random_int(self):
testdata = self.random.Random_int_nums(1, 100, 5, None)
testdata2 = self.random.Random_int_nums(1, 100, 5, None)
mean = self.statistics.mean(testdata)
mean2 = self.statistics.mean(testdata2)
self.assertNotEqual(mean, mean2)
def test_random_float_seed(self):
testdata = self.random.Random_float_nums(1.0, 100.0, 5, 3)
testdata2 = self.random.Random_float_nums(1.0, 100.0, 5, 3)
mean = self.statistics.mean(testdata)
mean2 = self.statistics.mean(testdata2)
self.assertAlmostEqual(mean, mean2)
def test_random_float(self):
testdata = self.random.Random_float_nums(1.0, 100.0, 5, None)
testdata2 = self.random.Random_float_nums(1.0, 100.0, 5, None)
mean = self.statistics.mean(testdata)
mean2 = self.statistics.mean(testdata2)
self.assertNotEqual(mean, mean2)
def setUp(self):
self.statistics = Statistics()
