def test_gaussian(self): test_frame = pd.DataFrame({'col1': range(5), 'col2': range(5)}) noise = GaussianNoise(1) noisy_frame = noise.impact(test_frame) with self.assertRaises(AssertionError): pd_testing.assert_frame_equal(test_frame, noisy_frame) pass
def test_addition(self): prototype1 = Reporter(attributes=[DictValue('noisy', faults=GaussianNoise(sigma=0.1)), DictValue('noisier', faults=GaussianNoise(sigma=0.2))]) prototype2 = Reporter(attributes=[DictValue('noised', faults=GaussianNoise(sigma=0.1)), DictValue('noisier', faults=InterruptionFault(likelihood=0.1))]) new_prototype = prototype1 + prototype2 self.assertIs(len(new_prototype.attributes), 3) self.assertIs(len(new_prototype.get_attribute_by_id('noisier').faults), 2) pass
def test_fault_collection(self): faults = evaluate_faults( [GaussianNoise(sigma=0.1), GaussianNoise(sigma=0.2)]) self.assertEqual(len(faults), 2) for f in faults: self.assertIsInstance(f, GaussianNoise) self.assertEqual(literal_eval(faults[0].init_statement), {'sigma': 0.1}) self.assertEqual(literal_eval(faults[1].init_statement), {'sigma': 0.2}) pass
def test_gaussian(self): noise = GaussianNoise(30) input_image = Image.open( str(pkg_resources.resource_filename(__name__, 'test_image.jpeg'))) initial_hash = hashlib.sha512() initial_hash.update(np.array(input_image)) messy_image = noise.impact(input_image) messy_hash = hashlib.sha512() messy_hash.update(np.array(messy_image)) self.assertNotEqual(initial_hash.digest(), messy_hash.digest()) self.assertEqual(input_image.size, messy_image.size) self.assertEqual(input_image.mode, messy_image.mode) pass
def test_single_fault(self): faults = evaluate_faults(GaussianNoise(sigma=0.1)) self.assertEqual(len(faults), 1) self.assertIsInstance(faults[0], GaussianNoise) self.assertEqual(literal_eval(faults[0].init_statement), {'sigma': 0.1}) pass
def test_introspected_attribute_fault_mapping(self): new_reporter = Reporter(faults=GaussianNoise(sigma=1)) data = {'att1': 1, 'att2': 2} output_data = new_reporter(data).observed self.assertNotEqual(data, output_data) self.assertEqual(data.keys(), output_data.keys()) pass
def test_fault_application(self): constitutively_fallible_object = Fallible(GaussianNoise(sigma=0.1)) faults, result = constitutively_fallible_object.apply_all_faults(100) self.assertEqual(len(faults), 1) self.assertIsInstance(faults[0], GaussianNoise) self.assertEqual(literal_eval(faults[0].init_statement), {'sigma': 0.1}) self.assertIsNot(100, result) pass
def test_attribute_fault_mapping(self): new_reporter = Reporter( attributes=[DictValue('att1'), DictValue('att2')], faults=GaussianNoise(sigma=1)) data = {'att1': 1, 'att2': 2} output_data = new_reporter(data).observed self.assertNotEqual(data, output_data) pass
def machine_error(scale): """ Simple example Noisifier recipe, applies gaussian noise and occasional interruptions to the input depending on the scale given, recommended scale range from 1-10 """ return Noisifier(reporter=Reporter(faults=[ GaussianNoise(sigma=0.1 * scale), InterruptionFault(likelihood=min(1, 0.01 * scale)) ]), faults=None)
def test_addition(self): test_attribute1 = AttributeReader('test', faults=GaussianNoise(sigma=1)) test_attribute2 = AttributeReader( 'test', faults=InterruptionFault(likelihood=1)) new_attribute = test_attribute1 + test_attribute2 self.assertIs(len(new_attribute.faults), 2) self.assertIsInstance(new_attribute.faults[0], GaussianNoise) self.assertIsInstance(new_attribute.faults[1], InterruptionFault) pass
def test_attribute_faults(self): new_prototype = Reporter(attributes=[DictValue('noisy', faults=GaussianNoise(sigma=0.1)), DictValue('noiseless')]) report0 = new_prototype({'noisy': 100, 'noiseless': 100}) self.assertEqual(report0.truth, {'noisy': 100, 'noiseless': 100}) self.assertEqual(report0.observed['noiseless'], 100) self.assertNotEqual(report0.observed['noisy'], 100) self.assertEqual(len(report0.triggered_faults['reporter']), 0) self.assertEqual(len(report0.triggered_faults['noiseless']), 0) self.assertEqual(len(report0.triggered_faults['noisy']), 1) self.assertIsInstance(report0.triggered_faults['noisy'][0], GaussianNoise) pass
def test_object_series_call(self): class Foo: def __init__(self, noisy, noiseless): self.noisy = noisy self.noiseless = noiseless new_prototype = Reporter(attributes=[ ObjectAttribute('noisy', faults=GaussianNoise(sigma=0.1)), ObjectAttribute('noiseless') ]) series_builder = Noisifier(reporter=new_prototype) data = [Foo(100, 100), Foo(10, 100), Foo(100, 10)] result = series_builder(data) self.assertEqual(len([i for i in result]), 3) for truth, new in zip(data, result): self.assertEqual(truth.noiseless, new.noiseless) self.assertNotEqual(truth.noisy, new.noisy) pass
def test_looping(self): new_prototype = Reporter(attributes=[ DictValue('noisy', faults=GaussianNoise(sigma=0.1)), DictValue('noiseless') ]) series_builder = Noisifier(reporter=new_prototype) data = [{ 'noisy': 100, 'noiseless': 100 }, { 'noisy': 10, 'noiseless': 50 }, { 'noisy': 100, 'noiseless': 10 }] result = series_builder(data, loop=True) for index, value in enumerate(result): if index == 4: break self.assertEqual(value['noiseless'], 50) pass
def test_dict_series_call(self): new_prototype = Reporter(attributes=[ DictValue('noisy', faults=GaussianNoise(sigma=0.1)), DictValue('noiseless') ]) series_builder = Noisifier(reporter=new_prototype) data = [{ 'noisy': 100, 'noiseless': 100 }, { 'noisy': 10, 'noiseless': 100 }, { 'noisy': 100, 'noiseless': 10 }] result = series_builder(data) self.assertEqual(len([i for i in result]), 3) for truth, new in zip(data, result): self.assertEqual(truth['noiseless'], new['noiseless']) self.assertNotEqual(truth['noisy'], new['noisy']) pass
def fault_strategy(): return [GaussianNoise(sigma=0.1)]
def test_method_delegation(self): new_prototype = Reporter(attributes=[DictValue('noisy', faults=GaussianNoise(sigma=0.1)), DictValue('noiseless')]) report = new_prototype({'noisy': 100, 'noiseless': 100}) self.assertEqual(set(report.keys()), {'noisy', 'noiseless'}) pass
def test_slicing(self): new_prototype = Reporter(attributes=[DictValue('noisy', faults=GaussianNoise(sigma=0.1)), DictValue('noiseless')]) report = new_prototype({'noisy': 100, 'noiseless': 100}) self.assertEqual(report['noiseless'], 100) pass