def test_applier_form (self):
a = BaseCharacter(self.bfm, 'a')
cluster1 = BaseCluster(self.bfm, base_character=a)
cluster1_form = '{0}{1}{2}{3}{3}'.format(AFM, BNFM, HAS_FEATURE,
NOT_HAS_FEATURE)
self.optional.append(cluster1)
expected = '({})?'.format(cluster1_form)
self.assertEqual(self.optional.applier_form, expected)
self.optional.match_multiple = True
expected = '({})*'.format(cluster1_form)
self.assertEqual(self.optional.applier_form, expected)
voiced = BaseFeature(self.bfm, 'voiced')
feature_set = BaseFeatureSet(self.bfm)
feature_set.set(voiced, HAS_FEATURE)
feature_set_form = '{0}{1}{2}{2}{3}'.format(
AFM, BNFM, INAPPLICABLE_FEATURE, HAS_FEATURE)
self.optional.append(feature_set)
expected = '({}{})*'.format(cluster1_form, feature_set_form)
self.assertEqual(self.optional.applier_form, expected)
def test_illegal_append (self):
feature_set = BaseFeatureSet(self.bfm)
self.optional.append(feature_set)
optional = Optional(self.bfm)
self.assertRaises(IllegalArgumentError, optional.append, self.optional)
group = Group(self.bfm, 1)
self.assertRaises(IllegalArgumentError, optional.append, group)
bfm2_configuration = '''
[Base Features] anterior consonantal voiced
[Base Characters] a: anterior'''
bfm2 = BinaryFeaturesModelParser().parse(bfm2_configuration)
a = BaseCharacter(bfm2, 'a')
cluster = BaseCluster(bfm2, base_character=a)
self.assertRaises(MismatchedModelsError, self.optional.append, cluster)
def test_normalised_form (self):
bfs = BaseFeatureSet(self.bfm)
nf1 = NormalisedForm('{0}{1}{1}{1}{1}{1}'.format(
BNFM, INAPPLICABLE_FEATURE))
self.assertEqual(bfs.normalised_form, nf1)
bfs.set(self.anterior, HAS_FEATURE)
nf2 = NormalisedForm('{0}{1}{2}{2}{2}{2}'.format(
BNFM, HAS_FEATURE, INAPPLICABLE_FEATURE))
self.assertEqual(bfs.normalised_form, nf2)
bfs.set(self.long, NOT_HAS_FEATURE)
nf3 = NormalisedForm('{0}{1}{2}{2}{3}{2}'.format(
BNFM, HAS_FEATURE, INAPPLICABLE_FEATURE, NOT_HAS_FEATURE))
self.assertEqual(bfs.normalised_form, nf3)
bfs.set(self.anterior, None)
nf4 = NormalisedForm('{0}{2}{2}{2}{3}{2}'.format(
BNFM, HAS_FEATURE, INAPPLICABLE_FEATURE, NOT_HAS_FEATURE))
self.assertEqual(bfs.normalised_form, nf4)
def test_applier_form (self):
bfs = BaseFeatureSet(self.bfm)
af1 = '{0}{1}{2}{2}{2}{2}{2}'.format(AFM, BNFM, INAPPLICABLE_FEATURE)
self.assertEqual(bfs.applier_form, af1)
bfs.set(self.anterior, HAS_FEATURE)
af2 = '{0}{1}{2}{3}{3}{3}{3}'.format(AFM, BNFM, HAS_FEATURE,
INAPPLICABLE_FEATURE)
self.assertEqual(bfs.applier_form, af2)
bfs.set(self.long, NOT_HAS_FEATURE)
af3 = '{0}{1}{2}{3}{3}{4}{3}'.format(AFM, BNFM, HAS_FEATURE,
INAPPLICABLE_FEATURE,
NOT_HAS_FEATURE)
self.assertEqual(bfs.applier_form, af3)
bfs.set(self.anterior, None)
af4 = '{0}{1}{3}{3}{3}{4}{3}'.format(AFM, BNFM, HAS_FEATURE,
INAPPLICABLE_FEATURE,
NOT_HAS_FEATURE)
self.assertEqual(bfs.applier_form, af4)
def test_applier_form(self):
group = Group(self.bfm, 1)
feature_set = BaseFeatureSet(self.bfm)
feature_set_form = '{0}{1}{2}{2}{2}'.format(AFM, BNFM,
INAPPLICABLE_FEATURE)
self.assertEqual(feature_set.applier_form, feature_set_form)
group.append(feature_set)
expected = '(?P<group1>{})'.format(feature_set_form)
self.assertEqual(group.applier_form, expected)
c = BaseCharacter(self.bfm, 'c')
cluster = BaseCluster(self.bfm, base_character=c)
optional = Optional(self.bfm)
optional.append(cluster)
optional_form = '({0}{1}{2}{3}{2})?'.format(AFM, BNFM, HAS_FEATURE,
NOT_HAS_FEATURE)
self.assertEqual(optional.applier_form, optional_form)
group.append(optional)
expected = '(?P<group1>{}{})'.format(feature_set_form, optional_form)
self.assertEqual(group.applier_form, expected)
def test_set_illegal (self):
stressed = SuprasegmentalFeature(self.bfm, 'stressed')
bfs = BaseFeatureSet(self.bfm)
self.assertRaises(MismatchedTypesError, bfs.set, stressed, HAS_FEATURE)
