class TestQualityCodesFiltering():
"""Tests for the function do_claims_have_quality_codes."""
def setup(self):
"""Setup base measure object for these tests."""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [
{'code': 'pn_code'}
]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'pn_x_code'}
]
})
]
self.measure_definition = MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
def test_get_measure_quality_codes(self):
"""Test _get_measure_quality_codes."""
assert self.measure_definition.get_measure_quality_codes() == set(['pn_code', 'pn_x_code'])
def test_claims_have_quality_codes_true(self):
"""Test do_claims_have_quality_codes if there are matching codes."""
test_claims_with_quality_codes = [
claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'G9607'}]}),
claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'pn_code'}]}),
claim.Claim({'claim_lines': [
{'clm_line_hcpcs_cd': 'pn_x_code'},
{'clm_line_hcpcs_cd': 'pn_code'}
]}),
]
quality_codes = self.measure_definition.get_measure_quality_codes()
assert claim_filtering.do_any_claims_have_quality_codes(
test_claims_with_quality_codes, quality_codes=quality_codes)
def test_claims_have_quality_codes_false(self):
"""Test do_claims_have_quality_codes return False if there are none."""
test_claims_with_no_quality_codes = [
claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'G9607'}]}),
claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'G9607'}]}),
claim.Claim({'claim_lines': [
{'clm_line_hcpcs_cd': 'G9607'},
{'clm_line_hcpcs_cd': 'G9607'}
]}),
]
quality_codes = self.measure_definition.get_measure_quality_codes()
assert not claim_filtering.do_any_claims_have_quality_codes(
test_claims_with_no_quality_codes, quality_codes=quality_codes)
def __init__(self, *args, **kwargs):
"""Instantiate a Measure226 calculator."""
super(Measure226MultipleStrata, self).__init__(*args, **kwargs)
# Raise an error if the measure definition doesn't indicate the presence of multiple strata.
assert self.has_multiple_strata
# Split eligibility options into separate submeasures.
self.submeasures = {
stratum.name: PatientProcessMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [option],
'performance_options': self.PERFORMANCE_OPTION_BY_STRATUM_NAME[stratum.name]
})
)
for stratum, option in zip(self.measure_definition.strata, self.eligibility_options)
}
# Check that the three strata names appear as expected.
for name in ['screenedForUse', 'intervention', 'overall']:
assert name in self.submeasures
# Check that the 'intervention' stratum has additional procedure codes (but not the others).
assert self.submeasures['intervention'].eligibility_options[0].additional_procedure_codes
assert not (
self.submeasures['overall'].eligibility_options[0].additional_procedure_codes or
self.submeasures['screenedForUse'].eligibility_options[0].additional_procedure_codes
)
def test_measure_definition():
"""Make sure all of the measure definition code can be run without error."""
sample_measure_code = {
'code': 'code',
'modifiers': ['a', 'b'],
'placesOfService': ['a', 'b'],
'modifierExclusions': ['a', 'b'],
'placesOfServiceExclusions': ['a', 'b']
}
test_measure_definition = {
'isInverse': True,
'eligibilityOptions': [{
'minAge': 0,
'maxAge': 100,
'sexCode': 'F',
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
'procedureCodes': [sample_measure_code]
}],
'performanceOptions': [{
'optionType': 'performanceMet',
'qualityCodes': [sample_measure_code]
}]
}
MeasureDefinition(test_measure_definition)
def test_filter_by_valid_dates_with_restrictions():
"""Test that filter by valid dates behaves correctly for measures with date restrictions."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': []
})
)
measure.date_ranges = [
(datetime.date(2017, 1, 1), datetime.date(2017, 3, 31)),
(datetime.date(2017, 10, 1), datetime.date(2017, 12, 31))
]
claims = [
claim.Claim({
'clm_from_dt': datetime.date(2017, month, 1),
'clm_thru_dt': datetime.date(2017, month, 1),
}) for month in range(1, 13)
]
output = measure.filter_by_valid_dates(claims)
expected = claims[:3] + claims[-3:]
assert output == expected
def test_get_eligible_instances():
"""Test that get eligible instances only returns instances with enough encounters."""
bene_1_claim_1 = claim.Claim({
'bene_sk': 'bene_1',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_2_claim_1 = claim.Claim({
'bene_sk': 'bene_2',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_2_claim_2 = claim.Claim({
'bene_sk': 'bene_2',
'clm_from_dt': datetime.date(2017, 6, 1),
})
bene_3_claim_1 = claim.Claim({
'bene_sk': 'bene_3',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_3_claim_2 = claim.Claim({
'bene_sk': 'bene_3',
'clm_from_dt': datetime.date(2017, 3, 1),
})
bene_3_claim_3 = claim.Claim({
'bene_sk': 'bene_3',
'clm_from_dt': datetime.date(2017, 12, 1),
})
bene_4_claim_1 = claim.Claim({
'bene_sk': 'bene_4',
'clm_from_dt': datetime.date(2017, 1, 1),
})
bene_4_claim_2 = claim.Claim({
'bene_sk': 'bene_4',
'clm_from_dt': datetime.date(2017, 1, 1),
})
claims = [
bene_1_claim_1,
bene_2_claim_1,
bene_2_claim_2,
bene_3_claim_1,
bene_3_claim_2,
bene_3_claim_3,
bene_4_claim_1,
bene_4_claim_2,
]
measure = MultipleEncounterMeasure(measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': []
}))
output = measure.get_eligible_instances(claims)
expected = [[bene_2_claim_2], [bene_3_claim_2, bene_3_claim_3]]
assert output == expected
def setup(self):
"""Instantiate a measure for each of the tests."""
eligibility_options = [
EligibilityOption({'diagnosisCodes': ['dx_code_a', 'dx_code_b']})
]
self.measure = IntersectingDiagnosisMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': eligibility_options,
'performance_options': []
}))
def test_str():
"""Test that QPPMeasure objects can be represented as strings."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'measure_number': '314159265',
'eligibility_options': [],
'performance_options': []
})
)
assert measure.__str__() == '(Measure 314159265)'
def test_procedure_code_not_match(self):
"""Check that claims that do not have the desired encounter code are not returned."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.plain_eligibility_option],
'performance_options': []
})
)
test_claims = [claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'other_code'}]})]
output = measure.filter_by_eligibility_criteria(test_claims)
assert output == []
def test_group_claims_by_date_returns_empty_list():
"""Test that group_claims_by_date returns an empty list of episodes when given no claims."""
measure = DateWindowEOCMeasure(measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': []
}))
claims = []
output = measure.group_claims_by_date(claims)
expected = []
assert output == expected
def test_pos_not_match(self):
"""Check that claim lines that do not have the require place of service are not returned."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.eligibility_option_with_place_of_service],
'performance_options': []
})
)
test_claims = [claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})]
output = measure.filter_by_eligibility_criteria(test_claims)
assert output == []
def setup(self):
"""Setup base measure object for these tests."""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [
{'code': 'pn_code'}
]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'pn_x_code'}
]
})
]
self.measure_definition = MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
def setup(self):
"""Create sample models for use in the tests."""
self.measure_code = MeasureCode({
'code': 'code',
'modifiers': ['a', 'b'],
'placesOfService': ['a', 'b'],
'modifierExclusions': ['a', 'b'],
'placesOfServiceExclusions': ['a', 'b']
})
self.eligibility_option = EligibilityOption({
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
})
self.performance_option = PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'code_a'}
]
})
self.measure = MeasureDefinition({
'isInverse': True,
'eligibilityOptions': [{
'minAge': 0,
'maxAge': 100,
'sexCode': 'F',
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
'procedureCodes': [self.measure_code]
}],
'performanceOptions': [{
'optionType': 'performanceMet',
'qualityCodes': [self.measure_code]
}]
})
self.stratum = Stratum({'name': 'primary_stratum'})
def test_dx_code_x_match(self):
"""Check the case where the measure has a dx_code_x and the claim doesn't have it."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.eligibility_option_with_dx_codes],
'performance_options': []
})
)
test_claim = claim.Claim({
'dx_codes': ['dx_code'], 'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})
output = measure.filter_by_eligibility_criteria([test_claim])
assert output == [test_claim]
def test_additional_dx_code_no_prerequisites(self):
"""Check the case where a claim lacks a required dx_code, but has additional ones."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.eligibility_option_with_additional_dx_codes],
'performance_options': []
})
)
test_claim = claim.Claim({
'dx_codes': ['dx_code_2'], 'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})
output = measure.filter_by_eligibility_criteria([test_claim])
assert output == []
def test_additional_dx_code_no_match(self):
"""Check the case where a measure has an additional diag code and the claim lacks it."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.eligibility_option_with_additional_dx_codes],
'performance_options': []
})
)
test_claim = claim.Claim({
'dx_codes': ['dx_code_1'], 'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})
output = measure.filter_by_eligibility_criteria([test_claim])
assert output == []
def setup(self):
"""Setup base measure object for these tests."""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [
{'code': 'pn_code'}
]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'pn_x_code'}
]
}),
PerformanceOption({
'optionType': 'eligiblePopulationExclusion',
'qualityCodes': [
{'code': 'pd_x_code'}
]
})
]
self.measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
)
self.inverse_measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options,
'is_inverse': True
})
)
def load_measure_definition(measure_number,
single_source_json=load_single_source()):
"""
Load a MeasureDefinition model describing a single measure.
Arguments:
measure_number: A string, e.g. '046'
single_source_json: a mapping measure_number-->measure_definition
"""
measure_definition = single_source_json.get(measure_number, None)
if measure_definition:
return MeasureDefinition(measure_definition, strict=False)
else:
raise KeyError(
'Measure number {} does not exist.'.format(measure_number))
def test_compute_eligible_instance_weight(self):
"""Make sure the _count_eligible_instances calculation is accurate."""
procedure_codes = [
MeasureCode({'code': 'code_a'}),
MeasureCode({'code': 'code_b'}),
MeasureCode({'code': 'code_c'})
]
eligibility_options = [
EligibilityOption({
'procedureCodes': procedure_codes[:2]
}),
EligibilityOption({
'procedureCodes': procedure_codes[2:]
})
]
measure = visit_measure.VisitMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': eligibility_options,
'performance_options': []
})
)
claim_lines = [
{
'clm_line_hcpcs_cd': 'code_a',
'mdfr_cds': [],
'clm_pos_code': '23'
},
{
'clm_line_hcpcs_cd': 'code_a',
'mdfr_cds': ['GQ'],
'clm_pos_code': '43'
},
{
'clm_line_hcpcs_cd': 'code_c',
'mdfr_cds': ['AX'],
'clm_pos_code': ''
}
]
test_claims = [claim.Claim({'claim_lines': claim_lines})]
output = measure._compute_eligible_instance_weight(test_claims)
assert output == 3
def test_get_eligible_instances():
"""Test that get_eligible_instances groups by diagnosis code and beneficiary."""
eligibility_options = [
EligibilityOption({
'diagnosisCodes': ['dx_code_a', 'dx_code_b'],
}),
EligibilityOption({
'diagnosisCodes': ['dx_code_c'],
})
]
measure = IntersectingDiagnosisMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': eligibility_options,
'performance_options': []
}))
claim_one = claim.Claim({
'dx_codes': ['dx_code_a'],
'bene_sk': 1001,
})
claim_two = claim.Claim({
'dx_codes': ['dx_code_a', 'dx_code_b'],
'bene_sk': 1001,
})
claim_three = claim.Claim({
'dx_codes': ['dx_code_c'],
'bene_sk': 1001,
})
claim_four = claim.Claim({
'dx_codes': ['dx_code_a'],
'bene_sk': 2001,
})
claims = [claim_one, claim_two, claim_three, claim_four]
output = measure.get_eligible_instances(claims)
expected = [[claim_one, claim_two], [claim_three], [claim_four]]
for instance in output:
assert instance in expected
for instance in expected:
assert instance in output
assert len(output) == len(expected)
def test_get_eligible_instances_raises_attribute_error():
"""
Test that get_eligible_instances raises AttributeError.
This method can only be called from subclasses of QPPMeasure that have
the fields_to_group_by attribute.
"""
claims = []
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': []
})
)
with pytest.raises(AttributeError):
measure.get_eligible_instances(claims)
def test_init_submeasure_classes(self):
"""Test that the initialized measure has the correct submeasure definitions."""
submeasure_definitions = {
submeasure_name: submeasure.measure_definition
for submeasure_name, submeasure in
self.measure.submeasures.items()
}
expected = {
stratum.name: MeasureDefinition({
'eligibility_options': [eligibility_option],
'performance_options':
self.measure.PERFORMANCE_OPTION_BY_STRATUM_NAME[stratum.name]
})
for stratum, eligibility_option in zip(
self.measure.measure_definition.strata,
self.measure.eligibility_options)
}
assert submeasure_definitions == expected
def test_group_claims_by_date():
"""Test that group_claims_by_date groups claims into episodes correctly."""
measure = DateWindowEOCMeasure(measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': []
}))
a1 = claim.Claim({'clm_from_dt': datetime.date(2016, 1, 1)})
a2 = claim.Claim({'clm_from_dt': datetime.date(2016, 1, 10)})
b1 = claim.Claim({'clm_from_dt': datetime.date(2016, 6, 1)})
b2 = claim.Claim({'clm_from_dt': datetime.date(2016, 6, 10)})
c1 = claim.Claim({'clm_from_dt': datetime.date(2016, 12, 1)})
claims = [a1, b1, a2, b2, c1]
output = measure.group_claims_by_date(claims)
expected = [[a1, a2], [b1, b2], [c1]]
assert output == expected
def test_pos_match(self):
"""Check that only claims that have the desired encounter code and pos are returned."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.eligibility_option_with_place_of_service],
'performance_options': []
})
)
test_claims = [claim.Claim({
'claim_lines': [
{
'clm_line_hcpcs_cd': 'good_code',
'clm_pos_code': 23
}
]
})]
output = measure.filter_by_eligibility_criteria(test_claims)
assert output == test_claims
def test_assign_performance_markers_multiple_code_sets_fails(self):
"""
Test assign_performance_markers in the case of >1 quality code per performance option.
Verify that marker is not assigned if not all required quality codes are present.
"""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [
{'code': 'code_a'},
{'code': 'code_b'}
]
})
]
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
)
claim_lines = [
{
'clm_line_hcpcs_cd': 'code_a',
'mdfr_cds': [],
'clm_pos_code': ''
},
{
'clm_line_hcpcs_cd': 'code_c',
'mdfr_cds': [],
'clm_pos_code': ''
}
]
test_claim = claim.Claim({'claim_lines': claim_lines})
output = measure._assign_performance_markers(test_claim)
expected = set()
assert output == expected
def test_filter_by_presence_of_quality_codes():
"""Test filter_by_presence_of_quality_codes returns all claims with quality codes."""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [
{'code': 'pn_code'}
]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'pn_x_code'}
]
}),
PerformanceOption({
'optionType': 'eligiblePopulationExclusion',
'qualityCodes': [
{'code': 'pd_x_code'}
]
})
]
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
)
claim_with_quality_code = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'pn_code'}]})
claim_without_quality_code = claim.Claim(
{'claim_lines': [{'clm_line_hcpcs_cd': 'irrelevant_code'}]}
)
claims = [claim_with_quality_code, claim_without_quality_code]
output = measure.filter_by_presence_of_quality_codes(claims)
expected = [claim_with_quality_code]
assert output == expected
def get_test_measure():
"""Build the Measure used in the CT Scan Measure tests."""
eligibility_options = [
EligibilityOption({
'procedureCodes': [MeasureCode({'code': '99281'})],
'diagnosis_codes': ['dx_code_1']
})
]
performance_options = [
PerformanceOption({
'optionType':
'performanceNotMet',
'quality_codes': [MeasureCode({
'code': 'quality_code',
})]
})
]
return CTScanMeasure(measure_definition=MeasureDefinition(
{
'eligibility_options': eligibility_options,
'performance_options': performance_options
}))
def test_assign_performance_markers(self):
"""Test that assigning performance markers to a single claim works as intended."""
performance_options = [
PerformanceOption({
'optionType': 'performanceMet',
'qualityCodes': [
{
'code': 'code_a',
'placesOfService': ['AA'],
'placesOfServiceExclusions': ['GQ']
}
]
}),
PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'code_a'}
]
})
]
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [],
'performance_options': performance_options
})
)
claim_lines = [{
'clm_line_hcpcs_cd': 'code_a',
'mdfr_cds': [],
'clm_pos_code': ''
}]
test_claim = claim.Claim({'claim_lines': claim_lines})
output = measure._assign_performance_markers(test_claim)
expected = set(['performanceNotMet'])
assert output == expected
def test_procedure_code_match(self):
"""Check that only claims that have the desired encounter code are returned."""
measure = qpp_measure.QPPMeasure(
measure_definition=MeasureDefinition({
'eligibility_options': [self.plain_eligibility_option],
'performance_options': []
})
)
claim_with_good_code = claim.Claim({'claim_lines': [{'clm_line_hcpcs_cd': 'good_code'}]})
claim_with_bad_code = claim.Claim(
{'claim_lines': [{'clm_line_hcpcs_cd': 'bad_code'}]}
)
other_claim_with_good_code = claim.Claim(
{'claim_lines': [
{'clm_line_hcpcs_cd': 'good_code'},
{'clm_line_hcpcs_cd': 'bad_code'}
]}
)
test_claims = [claim_with_good_code, claim_with_bad_code, other_claim_with_good_code]
output = measure.filter_by_eligibility_criteria(test_claims)
assert output == [claim_with_good_code, other_claim_with_good_code]
def setup(self):
"""Initialize useful values."""
self.performance_year = 2017
self.line_with_quality_code = ClaimLine({'clm_line_hcpcs_cd': 'G9607'})
self.line_without_quality_code = ClaimLine(
{'clm_line_hcpcs_cd': 'not_a_real_code'})
self.claim_with_quality_code_january = Claim({
'clm_from_dt':
datetime.date(self.performance_year, 1, 1),
'claim_lines': [self.line_with_quality_code]
})
self.claim_without_quality_code_january = Claim({
'clm_from_dt':
datetime.date(self.performance_year, 1, 1),
'claim_lines': [self.line_without_quality_code]
})
self.all_claims = [
self.__getattribute__(attr) for attr in dir(self)
if type(self.__getattribute__(attr)) == Claim
]
self.all_claims_in_performance_year = [
claim for claim in self.all_claims
if claim['clm_from_dt'].year == self.performance_year
]
self.claim_with_relevant_procedure_code = self.claim_with_quality_code_january
self.measure_definition = MeasureDefinition({
'eligibility_options':
[EligibilityOption({'procedureCodes': [{
'code': 'G9607'
}]})],
'performance_options': []
})
class TestReprFunctionality():
"""Test to ensure that all models' representations can recreate the original object."""
def setup(self):
"""Create sample models for use in the tests."""
self.measure_code = MeasureCode({
'code': 'code',
'modifiers': ['a', 'b'],
'placesOfService': ['a', 'b'],
'modifierExclusions': ['a', 'b'],
'placesOfServiceExclusions': ['a', 'b']
})
self.eligibility_option = EligibilityOption({
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
})
self.performance_option = PerformanceOption({
'optionType': 'performanceNotMet',
'qualityCodes': [
{'code': 'code_a'}
]
})
self.measure = MeasureDefinition({
'isInverse': True,
'eligibilityOptions': [{
'minAge': 0,
'maxAge': 100,
'sexCode': 'F',
'diagnosisCodes': ['a.b.c'],
'diagnosisExclusionCodes': ['d.e.f'],
'additionalDiagnosisCodes': ['g.h.i'],
'procedureCodes': [self.measure_code]
}],
'performanceOptions': [{
'optionType': 'performanceMet',
'qualityCodes': [self.measure_code]
}]
})
self.stratum = Stratum({'name': 'primary_stratum'})
def test_repr_for_measure_codes(self):
"""Test that measure codes are represented correctly."""
assert(self.measure_code == eval(self.measure_code.__repr__()))
def test_repr_for_eligibility_option(self):
"""Test that eligibility options are represented correctly."""
assert(self.eligibility_option == eval(self.eligibility_option.__repr__()))
def test_repr_for_performance_option(self):
"""Test that performance options are represented correctly."""
assert(self.performance_option == eval(self.performance_option.__repr__()))
def test_repr_for_measure_definitions(self):
"""Test that measure definitions are represented correctly."""
assert(self.measure == eval(self.measure.__repr__()))
def test_repr_for_strata(self):
"""Test that strata are represented correctly."""
assert(self.stratum == eval(self.stratum.__repr__()))
