def _build_parser(self, parser_state, file_handle, data_key=None):
"""
Build and return the parser
"""
# Default the parser to None
parser = None
config = self._parser_config.get(data_key)
#
# If the key is CTDPF_CKL_WFP_RECOVERED, build the ctdpf_ckl_wfp parser and
# provide a config that includes the specific recovered particle types.
#
if data_key == DataTypeKey.CTDPF_CKL_WFP_RECOVERED:
config.update({
DataSetDriverConfigKeys.PARTICLE_MODULE:
'mi.dataset.parser.ctdpf_ckl_wfp_particles',
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
'instrument_data_particle_class':
CtdpfCklWfpRecoveredDataParticle,
'metadata_particle_class':
CtdpfCklWfpRecoveredMetadataParticle
}
})
log.debug("My Config: %s", config)
parser = CtdpfCklWfpParser(
config, parser_state, file_handle,
lambda state, ingested: self._save_parser_state(
state, data_key, ingested), self._data_callback,
self._sample_exception_callback,
os.path.getsize(file_handle.name))
#
# If the key is CTDPF_CKL_WFP_TELEMETERED, build the ctdpf_ckl_wfp parser and
# provide a config that includes the specific telemetered particle types.
#
elif data_key == DataTypeKey.CTDPF_CKL_WFP_TELEMETERED:
config.update({
DataSetDriverConfigKeys.PARTICLE_MODULE:
'mi.dataset.parser.ctdpf_ckl_wfp_particles',
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
'instrument_data_particle_class':
CtdpfCklWfpTelemeteredDataParticle,
'metadata_particle_class':
CtdpfCklWfpTelemeteredMetadataParticle
}
})
log.debug("My Config: %s", config)
parser = CtdpfCklWfpParser(
config, parser_state, file_handle,
lambda state, ingested: self._save_parser_state(
state, data_key, ingested), self._data_callback,
self._sample_exception_callback,
os.path.getsize(file_handle.name))
else:
raise ConfigurationException\
('Bad Configuration: %s - Failed to build ctdpf_ckl_wfp parser',config)
return parser
def test_bad_time_data(self):
"""
If the timestamps are missing, raise a sample exception and do not parse the file
"""
stream_handle = StringIO(
CtdpfCklWfpParserUnitTestCase.TEST_DATA_BAD_TIME)
#********************************************
# Test the "recovered" version of the parser
#********************************************
with self.assertRaises(SampleException):
recovered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_RECOVERED),
self.recovered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA_BAD_TIME))
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
with self.assertRaises(SampleException):
telemetered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_TELEMETERED),
self.telemetered_start_state, stream_handle,
self.state_callback, self.pub_callback,
self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA_BAD_TIME))
def test_bad_eop_data(self):
"""
If the last "data" record in the file is not 11 byes of 0xFF, raise a sample exception
and do not parse the file.
"""
stream_handle = StringIO(
CtdpfCklWfpParserUnitTestCase.TEST_DATA_BAD_EOP)
#********************************************
# Test the "recovered" version of the parser
#********************************************
with self.assertRaises(SampleException):
recovered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_RECOVERED),
self.recovered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA_BAD_EOP))
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
with self.assertRaises(SampleException):
telemetered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_RECOVERED),
self.telemetered_start_state, stream_handle,
self.state_callback, self.pub_callback,
self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA_BAD_EOP))
def test_simple_pad(self):
"""
Read test data and pull out data particles one at a time.
Assert that the results are those we expected.
"""
filepath = os.path.join(RESOURCE_PATH, 'simple_pad.dat')
filesize = os.path.getsize(filepath)
#********************************************
# Test the "recovered" version of the parser
#********************************************
with open(filepath, 'rb') as stream_handle:
recovered_parser = CtdpfCklWfpParser(
self._recov_config, stream_handle,
self.exception_callback,
filesize)
particles = recovered_parser.get_records(5)
self.assert_particles(particles, 'test_simple_pad_recov.yml', RESOURCE_PATH)
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
with open(filepath, 'rb') as stream_handle:
telemetered_parser = CtdpfCklWfpParser(
self._telem_config, stream_handle,
self.exception_callback,
filesize)
particles = telemetered_parser.get_records(1)
self.assert_particles(particles, 'test_simple_pad_telem.yml', RESOURCE_PATH)
def test_bad_eop_data(self):
"""
If the last "data" record in the file is not 11 byes of 0xFF, raise a sample exception
and do not parse the file.
"""
filepath = os.path.join(RESOURCE_PATH, 'bad_eop_data.dat')
filesize = os.path.getsize(filepath)
#********************************************
# Test the "recovered" version of the parser
#********************************************
with self.assertRaises(SampleException):
with open(filepath, 'rb') as stream_handle:
CtdpfCklWfpParser(
self._recov_config, stream_handle,
self.exception_callback,
filesize)
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
with self.assertRaises(SampleException):
with open(filepath, 'rb') as stream_handle:
CtdpfCklWfpParser(
self._recov_config, stream_handle,
self.exception_callback,
filesize)
def test_bad_time_data(self):
"""
If the timestamps are missing, raise a sample exception and do not parse the file
"""
filepath = os.path.join(RESOURCE_PATH, 'bad_time_data.dat')
filesize = os.path.getsize(filepath)
#********************************************
# Test the "recovered" version of the parser
#********************************************
with self.assertRaises(SampleException):
with open(filepath, 'rb') as stream_handle:
CtdpfCklWfpParser(
self._recov_config, stream_handle,
self.exception_callback,
filesize)
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
with self.assertRaises(SampleException):
with open(filepath, 'rb') as stream_handle:
CtdpfCklWfpParser(
self._telem_config, stream_handle,
self.exception_callback,
filesize)
def test_long_stream(self):
"""
Test a long stream
"""
filepath = os.path.join(RESOURCE_PATH, 'C0000038.dat')
filesize = os.path.getsize(filepath)
#********************************************
# Test the "recovered" version of the parser
#********************************************
with open(filepath) as stream_handle:
recovered_parser = CtdpfCklWfpParser(
self._recov_config, stream_handle,
self.exception_callback, filesize)
self.parser = recovered_parser
recovered_result = self.parser.get_records(271)
self.assert_particles(recovered_result, 'C0000038_recov.yml', RESOURCE_PATH)
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
with open(filepath) as stream_handle:
telemetered_parser = CtdpfCklWfpParser(
self._telem_config, stream_handle,
self.exception_callback, filesize)
self.parser = telemetered_parser
telemetered_result = self.parser.get_records(271)
self.assert_particles(telemetered_result, 'C0000038_telem.yml', RESOURCE_PATH)
def test_mid_state_start(self):
"""
Test starting the parser in a state in the middle of processing
"""
stream_handle = StringIO(CtdpfCklWfpParserUnitTestCase.TEST_DATA)
#********************************************
# Test the "recovered" version of the parser
#********************************************
# set the state after the metadata and first record
recovered_new_state = {
StateKey.POSITION: 11,
StateKey.RECORDS_READ: 1,
StateKey.METADATA_SENT: True
}
recovered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_RECOVERED),
recovered_new_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA))
self.parser = recovered_parser
recovered_result = recovered_parser.get_records(1)
self.assert_result(recovered_result, 22, self.particle_b, False, 2,
True)
recovered_result = self.parser.get_records(1)
self.assert_result(recovered_result, 33, self.particle_c, True, 3,
True)
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
# set the state after the metadata and first record
telemetered_new_state = {
StateKey.POSITION: 11,
StateKey.RECORDS_READ: 1,
StateKey.METADATA_SENT: True
}
telemetered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_RECOVERED),
telemetered_new_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA))
self.parser = telemetered_parser
telemetered_result = telemetered_parser.get_records(1)
self.assert_result(telemetered_result, 22, self.particle_b, False, 2,
True)
telemetered_result = self.parser.get_records(1)
self.assert_result(telemetered_result, 33, self.particle_c, True, 3,
True)
def process(self):
log = get_logger()
try:
file_handle = open(self._sourceFilePath, 'rb')
filesize = os.path.getsize(file_handle.name)
state = None
parser_state = None
def state_callback(state, ingested):
pass
def pub_callback(data):
log.trace("Found data: %s", data)
def sample_exception_callback(exception):
self._particleDataHdlrObj.setParticleDataCaptureFailure()
parser = CtdpfCklWfpParser(
self._config, parser_state, file_handle,
lambda state, ingested: state_callback(state, ingested),
pub_callback, sample_exception_callback, filesize)
driver = DataSetDriver(parser, self._particleDataHdlrObj)
driver.processFileStream()
finally:
file_handle.close()
return self._particleDataHdlrObj
def test_long_stream(self):
"""
Test a long stream
"""
filepath = os.path.join(RESOURCE_PATH, 'C0000038.DAT')
filesize = os.path.getsize(filepath)
stream_handle = open(filepath)
#********************************************
# Test the "recovered" version of the parser
#********************************************
recovered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_RECOVERED),
self.recovered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback, filesize)
self.parser = recovered_parser
# next get records
recovered_result = self.parser.get_records(271)
self.assertEqual(recovered_result[0], self.particle_meta_long)
self.assertEqual(recovered_result[1], self.particle_a_long)
self.assertEqual(recovered_result[2], self.particle_b_long)
self.assertEqual(recovered_result[-1], self.particle_last)
self.assertEqual(recovered_parser._state[StateKey.POSITION], 2970)
self.assertEqual(recovered_parser._state[StateKey.RECORDS_READ], 270)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 2970)
self.assertEqual(self.state_callback_value[StateKey.RECORDS_READ], 270)
self.assertEqual(self.publish_callback_value[-1], self.particle_last)
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
telemetered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_TELEMETERED),
self.telemetered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback, filesize)
self.parser = telemetered_parser
# next get records
telemetered_result = self.parser.get_records(271)
self.assertEqual(telemetered_result[0], self.particle_meta_long)
self.assertEqual(telemetered_result[1], self.particle_a_long)
self.assertEqual(telemetered_result[2], self.particle_b_long)
self.assertEqual(telemetered_result[-1], self.particle_last)
self.assertEqual(telemetered_parser._state[StateKey.POSITION], 2970)
self.assertEqual(telemetered_parser._state[StateKey.RECORDS_READ], 270)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 2970)
self.assertEqual(self.state_callback_value[StateKey.RECORDS_READ], 270)
self.assertEqual(self.publish_callback_value[-1], self.particle_last)
def _build_parser(self, stream_handle):
parser_config = {
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
METADATA_PARTICLE_CLASS_KEY:
CtdpfCklWfpRecoveredMetadataParticle,
DATA_PARTICLE_CLASS_KEY: CtdpfCklWfpRecoveredDataParticle
}
}
file_size = os.path.getsize(stream_handle.name)
parser = CtdpfCklWfpParser(parser_config, stream_handle,
self._exception_callback, file_size)
return parser
def _build_parser(self, stream_handle):
parser_config = {
WfpCFileCommonConfigKeys.PRESSURE_FIELD_C_FILE: CtdpfCklWfpDataParticleKey.PRESSURE,
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
METADATA_PARTICLE_CLASS_KEY: CtdpfCklWfpTelemeteredMetadataParticle,
DATA_PARTICLE_CLASS_KEY: CtdpfCklWfpTelemeteredDataParticle
}
}
file_size = os.path.getsize(stream_handle.name)
parser = CtdpfCklWfpParser(parser_config,
stream_handle,
self._exception_callback,
file_size,
self._e_file_time_pressure_tuples)
return parser
def _build_parser(self, parser_state, infile, data_key=None):
"""
Build and return the parser
"""
# Default the parser to None
parser = None
config = self._parser_config.get(data_key)
#
# If the key is CTDPF_CKL_WFP, build the ctdpf_ckl_wfp parser and
# provide a config that includes the specific recovered particle types.
#
if data_key == DataTypeKey.CTDPF_CKL_WFP:
log.debug('CAG DRIVER - build parser for %s. State is %s',
data_key, parser_state)
config.update({
DataSetDriverConfigKeys.PARTICLE_MODULE:
'mi.dataset.parser.ctdpf_ckl_wfp_particles',
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
INSTRUMENT_DATA_PARTICLE_CLASS:
CtdpfCklWfpRecoveredDataParticle,
METADATA_PARTICLE_CLASS:
CtdpfCklWfpRecoveredMetadataParticle
}
})
parser = CtdpfCklWfpParser(
config, parser_state, infile,
lambda state, ingested: self._save_parser_state(
state, data_key, ingested), self._data_callback,
self._sample_exception_callback, os.path.getsize(infile.name))
#
# If the key is CTDPF_CKL_WFP_SIO_MULE, build the ctdpf_ckl_wfp_sio_mule parser and
# provide a config that includes the specific telemetered particle types.
#
elif data_key == DataTypeKey.CTDPF_CKL_WFP_SIO_MULE:
log.debug('CAG DRIVER - build parser for %s. State is %s',
data_key, parser_state)
config.update({
DataSetDriverConfigKeys.PARTICLE_MODULE:
'mi.dataset.parser.ctdpf_ckl_wfp_sio_mule',
DataSetDriverConfigKeys.PARTICLE_CLASS: None,
DataSetDriverConfigKeys.PARTICLE_CLASSES_DICT: {
INSTRUMENT_DATA_PARTICLE_CLASS:
CtdpfCklWfpSioMuleDataParticle,
METADATA_PARTICLE_CLASS: CtdpfCklWfpSioMuleMetadataParticle
}
})
parser = CtdpfCklWfpSioMuleParser(
config, parser_state, infile,
lambda state: self._save_parser_state(
state, DataTypeKey.CTDPF_CKL_WFP_SIO_MULE),
self._data_callback, self._sample_exception_callback)
else:
raise ConfigurationException(
'Bad Configuration: %s - Failed to build ctdpf_ckl_wfp parser',
config)
return parser
def test_set_state(self):
"""
Test changing to a new state after initializing the parser and
reading data, as if new data has been found and the state has
changed
"""
stream_handle = StringIO(CtdpfCklWfpParserUnitTestCase.TEST_DATA)
#********************************************
# Test the "recovered" version of the parser
#********************************************
recovered_new_state = {
StateKey.POSITION: 11,
StateKey.RECORDS_READ: 1,
StateKey.METADATA_SENT: True
}
recovered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_RECOVERED),
self.recovered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA))
self.parser = recovered_parser
recovered_result = recovered_parser.get_records(1)
self.assert_result(recovered_result, 0, self.particle_meta, False, 0,
True)
# essentially skips particle a
recovered_parser.set_state(recovered_new_state)
recovered_result = recovered_parser.get_records(1)
self.assert_result(recovered_result, 22, self.particle_b, False, 2,
True)
recovered_result = recovered_parser.get_records(1)
self.assert_result(recovered_result, 33, self.particle_c, True, 3,
True)
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
telemetered_new_state = {
StateKey.POSITION: 11,
StateKey.RECORDS_READ: 1,
StateKey.METADATA_SENT: True
}
telemetered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_TELEMETERED),
self.telemetered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA))
self.parser = telemetered_parser
telemetered_result = telemetered_parser.get_records(1)
self.assert_result(telemetered_result, 0, self.particle_meta, False, 0,
True)
# essentially skips particle a
telemetered_parser.set_state(telemetered_new_state)
telemetered_result = telemetered_parser.get_records(1)
self.assert_result(telemetered_result, 22, self.particle_b, False, 2,
True)
telemetered_result = telemetered_parser.get_records(1)
self.assert_result(telemetered_result, 33, self.particle_c, True, 3,
True)
def test_get_many(self):
"""
Read test data and pull out multiple data particles at one time.
Assert that the results are those we expected.
"""
stream_handle = StringIO(CtdpfCklWfpParserUnitTestCase.TEST_DATA)
#********************************************
# Test the "recovered" version of the parser
#********************************************
recovered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_RECOVERED),
self.recovered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA))
self.parser = recovered_parser
# next get records
# NOTE - while we ask for 4 records, the metadata is a special case
# the number of records read is actually 3. See the IDD for details.
recovered_result = recovered_parser.get_records(4)
self.assertEqual(recovered_result, [
self.particle_meta, self.particle_a, self.particle_b,
self.particle_c
])
self.assertEqual(recovered_parser._state[StateKey.POSITION], 33)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 33)
self.assertEqual(self.publish_callback_value[0], self.particle_meta)
self.assertEqual(self.publish_callback_value[1], self.particle_a)
self.assertEqual(self.publish_callback_value[2], self.particle_b)
self.assertEqual(self.publish_callback_value[3], self.particle_c)
self.assertEqual(self.file_ingested_value, True)
self.assertEqual(recovered_parser._state[StateKey.RECORDS_READ], 3)
self.assertEqual(self.state_callback_value[StateKey.RECORDS_READ], 3)
self.assertEqual(recovered_parser._state[StateKey.METADATA_SENT], True)
self.assertEqual(self.state_callback_value[StateKey.METADATA_SENT],
True)
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
telemetered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_TELEMETERED),
self.telemetered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA))
self.parser = telemetered_parser
# next get records
telemetered_result = telemetered_parser.get_records(4)
self.assertEqual(telemetered_result, [
self.particle_meta, self.particle_a, self.particle_b,
self.particle_c
])
self.assertEqual(telemetered_parser._state[StateKey.POSITION], 33)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 33)
self.assertEqual(self.publish_callback_value[0], self.particle_meta)
self.assertEqual(self.publish_callback_value[1], self.particle_a)
self.assertEqual(self.publish_callback_value[2], self.particle_b)
self.assertEqual(self.publish_callback_value[3], self.particle_c)
self.assertEqual(self.file_ingested_value, True)
self.assertEqual(telemetered_parser._state[StateKey.RECORDS_READ], 3)
self.assertEqual(self.state_callback_value[StateKey.RECORDS_READ], 3)
self.assertEqual(telemetered_parser._state[StateKey.METADATA_SENT],
True)
self.assertEqual(self.state_callback_value[StateKey.METADATA_SENT],
True)
def test_simple_pad(self):
"""
Read test data and pull out data particles one at a time.
Assert that the results are those we expected.
"""
stream_handle = StringIO(CtdpfCklWfpParserUnitTestCase.TEST_DATA_PAD)
#********************************************
# Test the "recovered" version of the parser
#********************************************
recovered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_RECOVERED),
self.recovered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA_PAD))
self.parser = recovered_parser
# next get records
recovered_result = recovered_parser.get_records(1)
self.assert_result(recovered_result, 0, self.particle_meta, False, 0,
True)
recovered_result = self.parser.get_records(1)
self.assert_result(recovered_result, 11, self.particle_a, False, 1,
True)
recovered_result = self.parser.get_records(1)
self.assert_result(recovered_result, 22, self.particle_b, False, 2,
True)
recovered_result = self.parser.get_records(1)
self.assert_result(recovered_result, 33, self.particle_c, True, 3,
True)
# no data left, dont move the position
recovered_result = recovered_parser.get_records(1)
self.assertEqual(recovered_result, [])
self.assertEqual(recovered_parser._state[StateKey.POSITION], 33)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 33)
self.assert_(isinstance(self.publish_callback_value, list))
self.assertEqual(self.publish_callback_value[0], self.particle_c)
#**********************************************
# Test the "telemetered" version of the parser
#**********************************************
telemetered_parser = CtdpfCklWfpParser(
self.config.get(DataTypeKey.CTDPF_CKL_WFP_TELEMETERED),
self.telemetered_start_state, stream_handle, self.state_callback,
self.pub_callback, self.exception_callback,
len(CtdpfCklWfpParserUnitTestCase.TEST_DATA_PAD))
self.parser = telemetered_parser
# next get records
telemetered_result = telemetered_parser.get_records(1)
self.assert_result(telemetered_result, 0, self.particle_meta, False, 0,
True)
telemetered_result = self.parser.get_records(1)
self.assert_result(telemetered_result, 11, self.particle_a, False, 1,
True)
telemetered_result = self.parser.get_records(1)
self.assert_result(telemetered_result, 22, self.particle_b, False, 2,
True)
telemetered_result = self.parser.get_records(1)
self.assert_result(telemetered_result, 33, self.particle_c, True, 3,
True)
# no data left, dont move the position
telemetered_result = telemetered_parser.get_records(1)
self.assertEqual(telemetered_result, [])
self.assertEqual(telemetered_parser._state[StateKey.POSITION], 33)
self.assertEqual(self.state_callback_value[StateKey.POSITION], 33)
self.assert_(isinstance(self.publish_callback_value, list))
self.assertEqual(self.publish_callback_value[0], self.particle_c)
