def test_plain_past_negative(self):
        ichidan_expected = {
            u"寝る": (u"寝なかった", "nenakatta"),
            u"出来る": (u"出来なかった", "dekinakatta"),
            u"見つける": (u"見つけなかった", "mitsukenakatta")
        }

        for k in ichidan_expected.keys():
            set_global_ichidan(k[:-1], kanji_to_romaji(k)[:-2])
            ck, cr = conjugate_ichidan_plain_past_negative()
            self.assertEqual(ichidan_expected[k], (ck, cr))
    def test_polite_past_negative(self):
        ichidan_expected = {
            u"寝る": (u"寝ませんでした", "nemasen deshita"),
            u"出来る": (u"出来ませんでした", "dekimasen deshita"),
            u"見つける": (u"見つけませんでした", "mitsukemasen deshita")
        }

        for k in ichidan_expected.keys():
            set_global_ichidan(k[:-1], kanji_to_romaji(k)[:-2])
            ck, cr = conjugate_ichidan_polite_past_negative()
            self.assertEqual(ichidan_expected[k], (ck, cr))
    def test_plain_imperative(self):
        ichidan_expected = {
            u"寝る": (u"寝ろ", "nero"),
            u"出来る": (u"出来ろ", "dekiro"),
            u"見つける": (u"見つけろ", "mitsukero")
        }

        for k in ichidan_expected.keys():
            set_global_ichidan(k[:-1], kanji_to_romaji(k)[:-2])
            ck, cr = conjugate_ichidan_plain_imperative()
            self.assertEqual(ichidan_expected[k], (ck, cr))
    def test_polite_imperative_negative(self):
        ichidan_expected = {
            u"寝る": (u"寝なさるな", "nenasaruna"),
            u"出来る": (u"出来なさるな", "dekinasaruna"),
            u"見つける": (u"見つけなさるな", "mitsukenasaruna")
        }

        for k in ichidan_expected.keys():
            set_global_ichidan(k[:-1], kanji_to_romaji(k)[:-2])
            ck, cr = conjugate_ichidan_polite_imperative_negative()
            self.assertEqual(ichidan_expected[k], (ck, cr))
    def test_polite_volitional(self):
        ichidan_expected = {
            u"寝る": (u"寝ましょう", "nemashou"),
            u"出来る": (u"出来ましょう", "dekimashou"),
            u"見つける": (u"見つけましょう", "mitsukemashou")
        }

        for k in ichidan_expected.keys():
            set_global_ichidan(k[:-1], kanji_to_romaji(k)[:-2])
            ck, cr = conjugate_ichidan_polite_volitional()
            self.assertEqual(ichidan_expected[k], (ck, cr))
    def test_plain_te_form(self):
        ichidan_expected = {
            u"寝る": (u"寝て", "nete"),
            u"出来る": (u"出来て", "dekite"),
            u"見つける": (u"見つけて", "mitsukete")
        }

        for k in ichidan_expected.keys():
            set_global_ichidan(k[:-1], kanji_to_romaji(k)[:-2])
            ck, cr = conjugate_ichidan_plain_te_form()
            self.assertEqual(ichidan_expected[k], (ck, cr))
Example #7
0
    def test_polite_past(self):
        ichidan_expected = {
            "寝る": ("寝ました", "nemashita"),
            "出来る": ("出来ました", "dekimashita"),
            "見つける": ("見つけました", "mitsukemashita")
        }

        for k in list(ichidan_expected.keys()):
            set_global_ichidan(k[:-1], kanji_to_romaji(k)[:-2])
            ck, cr = conjugate_ichidan_polite_past()
            self.assertEqual(ichidan_expected[k], (ck, cr))
Example #8
0
    def test_plain_negative(self):
        ichidan_expected = {
            "寝る": ("寝ない", "nenai"),
            "出来る": ("出来ない", "dekinai"),
            "見つける": ("見つけない", "mitsukenai")
        }

        for k in list(ichidan_expected.keys()):
            set_global_ichidan(k[:-1], kanji_to_romaji(k)[:-2])
            ck, cr = conjugate_ichidan_plain_negative()
            self.assertEqual(ichidan_expected[k], (ck, cr))
Example #9
0
    def test_plain_volitional(self):
        ichidan_expected = {
            "寝る": ("寝よう", "neyou"),
            "出来る": ("出来よう", "dekiyou"),
            "見つける": ("見つけよう", "mitsukeyou")
        }

        for k in list(ichidan_expected.keys()):
            set_global_ichidan(k[:-1], kanji_to_romaji(k)[:-2])
            ck, cr = conjugate_ichidan_plain_volitional()
            self.assertEqual(ichidan_expected[k], (ck, cr))