def test_single_block_multi_copy(self):
"""Test which forces one block to do multiple
copies at once, and then dumps to two files,
checking them both."""
logfiles = ['.log1.txt', '.log2.txt']
self.blocks.append((CopyBlock(), [0], [1, 2]))
self.blocks.append((WriteAsciiBlock(logfiles[0]), [1], []))
self.blocks.append((WriteAsciiBlock(logfiles[1]), [2], []))
Pipeline(self.blocks).main()
test_bytes = int(open(logfiles[0], 'r').read(1)) + int(
open(logfiles[1], 'r').read(1))
self.assertEqual(test_bytes, 4)
def test_simple_half_split(self):
"""Try to split up a single array in half, and dump to file"""
blocks = []
blocks.append([TestingBlock([1, 2]), [], [0]])
blocks.append([SplitterBlock([[0], [1]]), {'in': 0, 'out_1': 1, 'out_2': 2}])
blocks.append([WriteAsciiBlock('.log1.txt', gulp_size=4), [1], []])
blocks.append([WriteAsciiBlock('.log2.txt', gulp_size=4), [2], []])
Pipeline(blocks).main()
first_log = np.loadtxt('.log1.txt')
second_log = np.loadtxt('.log2.txt')
self.assertEqual(first_log.size, 1)
self.assertEqual(second_log.size, 1)
np.testing.assert_almost_equal(first_log + 1, second_log)
def setUp(self):
"""Set up a pipeline for a numpy operation in the middle"""
self.blocks = []
self.test_array = [1, 2, 3, 4]
self.blocks.append((TestingBlock(self.test_array), [], [0]))
self.blocks.append((WriteAsciiBlock('.log.txt'), [1], []))
self.expected_result = []
def setUp(self):
"""Assemble a basic pipeline with the FFT block"""
self.logfile = '.log.txt'
self.blocks = []
self.blocks.append(
(SigprocReadBlock('./data/1chan8bitNoDM.fil'), [], [0]))
self.blocks.append((FFTBlock(gulp_size=4096 * 8 * 8 * 8), [0], [1]))
self.blocks.append((WriteAsciiBlock(self.logfile), [1], []))
def dump_ring_and_read(self):
"""Dump block to ring, read in as histogram"""
logfile = ".log.txt"
self.blocks.append((WriteAsciiBlock(logfile), [1], []))
Pipeline(self.blocks).main()
test_bytes = open(logfile, 'r').read().split(' ')
histogram = np.array([np.float(x) for x in test_bytes])
return histogram
def test_throughput(self):
"""Read in data with a small throughput size. Expect all to go through."""
blocks = []
blocks.append((SigprocReadBlock('./data/1chan8bitNoDM.fil',
gulp_nframe=4096), [], [0]))
blocks.append((WriteAsciiBlock('.log.txt'), [0], []))
Pipeline(blocks).main()
log_data = np.loadtxt('.log.txt')
self.assertEqual(log_data.size, 12800)
def test_simple_copy(self):
"""Test which performs a read of a sigproc file,
copy to one ring, and then output as text."""
logfile = '.log.txt'
self.blocks.append((CopyBlock(), [0], [1]))
self.blocks.append((WriteAsciiBlock(logfile), [1], []))
Pipeline(self.blocks).main()
test_byte = open(logfile, 'r').read(1)
self.assertEqual(test_byte, '2')
def test_naming_rings(self):
"""Name the rings instead of numerating them"""
blocks = []
blocks.append((TestingBlock([1, 2, 3]), [], ['ring1']))
blocks.append((WriteAsciiBlock('.log.txt', gulp_size=3 * 4), ['ring1'], []))
open('.log.txt', 'w').close()
Pipeline(blocks).main()
result = np.loadtxt('.log.txt').astype(np.float32)
np.testing.assert_almost_equal(result, [1, 2, 3])
def test_multi_dimensional_input(self):
"""Input a 2 dimensional list, and have this printed"""
test_array = [[1, 2], [3, 4]]
self.blocks[0] = (WriteAsciiBlock('.log.txt', gulp_size=4*4), [0], [])
self.blocks.append((TestingBlock(test_array), [], [0]))
self.blocks.append((WriteHeaderBlock('.log2.txt'), [0], []))
Pipeline(self.blocks).main()
header = eval(open('.log2.txt').read()) #pylint:disable=eval-used
dumped_numbers = np.loadtxt('.log.txt').reshape(header['shape'])
np.testing.assert_almost_equal(dumped_numbers, test_array)
def test_multi_copy(self):
"""Test which performs a read of a sigproc file,
copy between many rings, and then output as
text."""
logfile = '.log.txt'
for i in range(10):
self.blocks.append((CopyBlock(), [i], [i + 1]))
self.blocks.append((WriteAsciiBlock(logfile), [10], []))
Pipeline(self.blocks).main()
test_byte = open(logfile, 'r').read(1)
self.assertEqual(test_byte, '2')
def test_data_throughput(self):
"""Check that data is being put through the block
(does this by checking consistency of shape/datatype)"""
blocks = []
blocks.append((SigprocReadBlock('./data/1chan8bitNoDM.fil'), [], [0]))
blocks.append((KurtosisBlock(), [0], [1]))
blocks.append((WriteAsciiBlock('.log.txt'), [1], []))
Pipeline(blocks).main()
test_byte = open('.log.txt', 'r').read().split(' ')
test_nums = np.array([float(x) for x in test_byte])
self.assertLess(np.max(test_nums), 256)
self.assertEqual(test_nums.size, 12800)
def test_pass_rings(self):
"""Pass rings entirely instead of naming/numerating them"""
block_set_one = []
block_set_two = []
ring1 = Ring()
block_set_one.append((TestingBlock([1, 2, 3]), [], [ring1]))
block_set_two.append((WriteAsciiBlock('.log.txt', gulp_size=3 * 4), [ring1], []))
open('.log.txt', 'w').close()
Pipeline(block_set_one).main() # The ring should communicate between the pipelines
Pipeline(block_set_two).main()
result = np.loadtxt('.log.txt').astype(np.float32)
np.testing.assert_almost_equal(result, [1, 2, 3])
def test_32bit_copy(self):
"""Perform a simple test to confirm that 32 bit
copying has no information loss"""
logfile = '.log.txt'
self.blocks = []
self.blocks.append(
(SigprocReadBlock('./data/256chan32bitNoDM.fil'), [], [0]))
self.blocks.append((CopyBlock(), [0], [1]))
self.blocks.append((WriteAsciiBlock(logfile), [1], []))
Pipeline(self.blocks).main()
test_bytes = open(logfile, 'r').read(500).split(' ')
self.assertAlmostEqual(np.float(test_bytes[0]), 0.72650784254)
def test_simple_ifft(self):
"""Put test data through a ring buffer and check correctness"""
self.logfile = '.log.txt'
self.blocks = []
test_array = [1, 2, 3]
self.blocks.append((TestingBlock(test_array), [], [0]))
self.blocks.append((IFFTBlock(gulp_size=3 * 4), [0], [1]))
self.blocks.append((WriteAsciiBlock(self.logfile), [1], []))
open(self.logfile, 'w').close()
Pipeline(self.blocks).main()
true_result = np.fft.ifft(test_array)
result = np.loadtxt(self.logfile).astype(np.float32).view(np.complex64)
np.testing.assert_almost_equal(result, true_result, 2)
def test_equivalent_data_to_copy(self):
"""Test that the data coming out of this pipeline is equivalent
the initial read data"""
self.logfile = '.log.txt'
self.blocks = []
self.blocks.append((
SigprocReadBlock(
'./data/1chan8bitNoDM.fil'),
[], [0]))
self.blocks.append((FFTBlock(gulp_size=4096 * 8 * 8 * 8 * 8), [0], [1]))
self.blocks.append((IFFTBlock(gulp_size=4096 * 8 * 8 * 8 * 8), [1], [2]))
self.blocks.append((WriteAsciiBlock(self.logfile), [2], []))
open(self.logfile, 'w').close()
Pipeline(self.blocks).main()
unfft_result = np.loadtxt(self.logfile).astype(np.float32).view(np.complex64)
self.blocks[1] = (CopyBlock(), [0], [1])
self.blocks[2] = (WriteAsciiBlock(self.logfile), [1], [])
del self.blocks[3]
open(self.logfile, 'w').close()
Pipeline(self.blocks).main()
untouched_result = np.loadtxt(self.logfile).astype(np.float32)
np.testing.assert_almost_equal(unfft_result, untouched_result, 2)
def test_for_bad_ring_definitions(self):
"""Try to pass bad input and outputs"""
blocks = []
blocks.append([TestingBlock([1, 2]), [], [0]])
blocks.append([
MultiAddBlock(),
{'in_2': 0, 'out_sum': 1}])
blocks.append([WriteAsciiBlock('.log.txt'), [1], []])
with self.assertRaises(AssertionError):
Pipeline(blocks).main()
blocks[1] = [
MultiAddBlock(),
{'bad_ring_name': 0, 'in_2': 0, 'out_sum': 1}]
with self.assertRaises(AssertionError):
Pipeline(blocks).main()
def test_non_linear_multi_copy(self):
"""Test which reads in a sigproc file, and
loads it between different rings in a
nonlinear fashion, then outputs to file."""
logfile = '.log.txt'
self.blocks.append((CopyBlock(), [0], [1]))
self.blocks.append((CopyBlock(), [0], [2]))
self.blocks.append((CopyBlock(), [2], [5]))
self.blocks.append((CopyBlock(), [0], [3]))
self.blocks.append((CopyBlock(), [3], [4]))
self.blocks.append((CopyBlock(), [5], [6]))
self.blocks.append((WriteAsciiBlock(logfile), [6], []))
Pipeline(self.blocks).main()
log_nums = open(logfile, 'r').read(500).split(' ')
test_num = np.float(log_nums[8])
self.assertEqual(test_num, 3)
def setUp(self):
"""Initiate blocks list with write asciiBlock"""
self.blocks = []
self.blocks.append((WriteAsciiBlock('.log.txt', gulp_size=3 * 4),
[0], []))
