From 8b2da469cff976132af93de3429881278b00cbfb Mon Sep 17 00:00:00 2001 From: Brian Matherly Date: Fri, 25 Dec 2009 20:39:02 +0000 Subject: [PATCH] Remove GEDCOM tests - they are broken and not used. svn: r13914 --- src/GrampsDbUtils/test/GR_test.py | 146 ---------- src/GrampsDbUtils/test/_GedcomChar_test.py | 164 ----------- src/GrampsDbUtils/test/ged_skip_notes_test.py | 84 ------ src/test/ansel_utf8_test.py | 257 ------------------ src/test/gedread_util.py | 130 --------- src/test/test/gedread_util_test.py | 2 + src/test/test/test_util_test.py | 1 + 7 files changed, 3 insertions(+), 781 deletions(-) delete mode 100644 src/GrampsDbUtils/test/GR_test.py delete mode 100644 src/GrampsDbUtils/test/_GedcomChar_test.py delete mode 100644 src/GrampsDbUtils/test/ged_skip_notes_test.py delete mode 100644 src/test/ansel_utf8_test.py delete mode 100644 src/test/gedread_util.py diff --git a/src/GrampsDbUtils/test/GR_test.py b/src/GrampsDbUtils/test/GR_test.py deleted file mode 100644 index 86d65e9c0..000000000 --- a/src/GrampsDbUtils/test/GR_test.py +++ /dev/null @@ -1,146 +0,0 @@ -""" GR_test.py - -This is a first try at some gedcom read testing that does not -require running a gramps CLI - -The biggest difficulty is that every test fragment needs custom -test code. Maybe that's unavoidable, and the best that can be -done is to group similar tests together, so that setUp can be -shared. - -Maybe more can be shared: one commonly used test recipe is -to develop a data structure that can be looped over to test -similar fragments with the same piece of test code, putting -fragments and possible control or other validation information -in the data structure. - -A controlling principle for such structures is that they should be -designed for maximum ease (and intuitiveness) of data declaration -""" - -import os.path as op - -import unittest as U -import re - -from test import test_util as tu -from test import gedread_util as gr - - -# NoteSource_frag -# tests structure: NOTE > SOUR -# using the 2 formats of the SOUR element -# bug #(?) does not properly ignore the SOUR -# test by looking for warning messages resulting -# from parse_record seeing the non-skipped SOUR -# -# SB: the NOTE data should contain the SOUR or xref -# but this is NYI (SOUR is ignored within NOTE) -# ----------------------------------------------- - - -# -# numcheck based testing -# verifies the number of db items via a get_number_of_X() call -# returns an error string or None -# -# ? candidate for inclusion in gedread_util.py -# -class nc(): - """nc object -- creates a numcheck function - - instantiate a nc object as follows - c = nc("people", 4) - and call, passing the database, as follows - err = c(db) - which will check for exactly 4 people in the db - and return a displayable message on error, else None - - NB: name _must_ match the X names in db get_number_of_X - """ - def dbncheck(self, dbcall): - err = None - got = dbcall() - if not got == self.num: - err = "%s: got %d, expected %d" % (self.name, got, self.num) - return err - def __init__(self, name, num): - self.name = name - self.num = num - self.getname = "get_number_of_" + name - def __call__(self, db): - dbcall = getattr(db,self.getname) - self.dbncheck(dbcall) - -class fnci(): - """fnci (frag-numcheckset item) is a data container for: - a fragment of gedcom - a sequence of nc items to check - """ - def __init__(self, frag, ncset): - self.frag = frag - self.ncset = ncset - -# test data table for Test1.test1a_numchecks -fnumchecks = ( - fnci("""0 @N1@ NOTE Note containing embedded source -1 SOUR embedded source""", - (nc("notes", 1),) - ), - fnci("""0 @N2@ NOTE Note containing referenced source -1 SOUR @SOUR1@ -0 @SOUR1@ SOUR -1 TITL Phoney source title""", - (nc("notes", 1), nc("sources",1),) - ), - )#end fnumchecks - - -# -# ? candidate for inclusion in test_util.py -# -def _checklog(tlogger, pat=None): - # look for absence of specific messages in log - matches = 0 - ltext = tlogger.logfile_getlines() - if ltext: - if pat is None: - matches = len(ltext) - else: - pat = re.compile(pat) - for l in ltext: - match = re.match(pat, l) - if match: - matches += 1 - # debugging - print "(%d) %r" % (matches, match) - return matches - - - -class Test1(U.TestCase): - def setUp(self): - # make a test subdir and compose some pathnames - self.tdir = tu.make_subdir("RG_test") - self.tdb = op.join(self.tdir,"test_db") - self.ifil = op.join(self.tdir,"test_in.ged") - self.lfil = op.join(self.tdir,"test.log") - - def test1a_numchecks(self): - tl = tu.TestLogger() - for i,f in enumerate(fnumchecks): - gr.make_gedcom_input(self.ifil, f.frag) - db = gr.create_empty_db(self.tdb) - tl.logfile_init(self.lfil) - gr.gread(db,self.ifil) - errs = _checklog(tl, r"Line \d+") - self.assertEquals(errs, 0, - "ncset(%d): got %d unexpected log messages" % - (i,errs)) - # ok, no log error message, check db counts - for call in f.ncset: - err = call(db) - self.assertFalse(err, err) - -if __name__ == "__main__": - U.main() diff --git a/src/GrampsDbUtils/test/_GedcomChar_test.py b/src/GrampsDbUtils/test/_GedcomChar_test.py deleted file mode 100644 index 8910345ab..000000000 --- a/src/GrampsDbUtils/test/_GedcomChar_test.py +++ /dev/null @@ -1,164 +0,0 @@ -#!/usr/bin/env python -import unittest -import os.path -import codecs -import struct - -from test import test_util as tu -m = tu.msg - -par = tu.path_append_parent() -here = tu.absdir() - -import _GedcomChar as G - -cdir = tu.make_subdir("test_data") - -# unicode block "latin1 supplement" chars -utest_chars = "".join(map(unichr, range(0xA0,0x100))) + "\n" - -# 12 ansel test chars (raw 8-bit bytes, here) -atest_list = range(0xa1,0xa7) + range(0xb1,0xb7) + [0x0a,] -atest_bytes = struct.pack("B"*13, *atest_list) - -# unicode mappings of above (http://www.gymel.com/charsets/ANSEL.html) -a2u = u"".join(map(unichr, ( - 0x141, 0xd8, 0x110, 0xde, 0xc6, 0x152, - 0x142, 0xf8, 0x111, 0xfe, 0xe6, 0x153, - 0x0a, ))) - -def gen_chars(filename, encoding): - """write generic test chars as given file and encoding""" - if not os.path.exists(filename): - codecs.open(filename, "wb", encoding).write(utest_chars) - -### -class Test1_ansi(unittest.TestCase): - """Test original "ANSI" reader and codecs: latin, cp1252""" - enc = "latin-1" - cp = "cp1252" - fil = os.path.join(cdir,enc) - exp = utest_chars - - def setUp(self): - gen_chars(self.fil, self.enc) - - def test1a_read_ansi(self): - f = open(self.fil) - ra= G.AnsiReader(f) - got = ra.readline() - self.assertEquals(got,self.exp, m(got,self.exp, "AnsiReader")) - - def test1b_read_codec_latin1(self): - got=codecs.open(self.fil, encoding=self.enc).read() - self.assertEquals(got,self.exp, m(got,self.exp, "using codec %s" % self.enc)) - - def test1c_read_codec_cp1252(self): - got=codecs.open(self.fil, encoding=self.cp).read() - self.assertEquals(got,self.exp, m(got,self.exp, "using codec %s" % self.cp)) - -### -class Test2_ansel(unittest.TestCase): - """Test original AnselReader (later: ansel codec)""" - enc = "ansel" - afil = os.path.join(cdir,enc) - exp = a2u - - def setUp(self): - open(self.afil, "wb").write(atest_bytes) - - def test2a_read_ansel(self): - f = open(self.afil) - ra = G.AnselReader(f) - got = ra.readline() - self.assertEquals(got,self.exp, m(got,self.exp, "AnselReader")) - -### -class Test3(unittest.TestCase): - """Test otriginal UTF8Reader and codecs: utf_8, utf_8_sig - with no 'BOM' (sig) in input (the common case) - - out of curiosity, verify behavior reading a 1-byte file - """ - enc = "utf_8" - enc_sig = enc + "_sig" - ufil = os.path.join(cdir, "chars.utf8") - f1byte = os.path.join(cdir, "1byte") - exp = utest_chars - - def setUp(self): - gen_chars(self.ufil, self.enc) - if not os.path.exists(self.f1byte): - open(self.f1byte, "wb").write("1") - - def test3a_u8_UTF8Reader_NO_BOM_sig(self): - f=open(self.ufil) - ra=G.UTF8Reader(f) - g = ra.readline() - self.assertEquals(g,self.exp, m(g,self.exp, "orig UTF8Reader")) - r2 = G.UTF8Reader(open(self.f1byte)) - g = r2.readline() - self.assertEquals(g,"1", - m(g,"1", "read 1-byte file")) - - # NB: utf_8 reads data and never expects a BOM-sig - def test3b_utf8_codec_NO_BOM_sig_as_expected(self): - g=codecs.open(self.ufil, encoding=self.enc).read() - self.assertEquals(g,self.exp, m(g,self.exp, "codec utf8")) - g=codecs.open(self.f1byte, encoding=self.enc).read() - self.assertEquals(g,"1", m(g,"1", "codec utf8")) - - # NB: utf_8_sig reads data even absent a BOM-sig (GOOD!) - def test3c_utf8_sig_codec_NO_BOM_sig_tolerated_GOOD(self): - g=codecs.open(self.ufil, encoding=self.enc_sig).read() - self.assertEquals(g,self.exp, - m(g,self.exp, "codec utf_8_sig NO sig input")) - g=codecs.open(self.f1byte, encoding=self.enc_sig).read() - self.assertEquals(g,"1", - m(g,"1", "codec utf_8_sig NO sig input")) - -### -class Test4(unittest.TestCase): - """Test otriginal UTF8Reader and codecs: utf_8, utf_8_sig - with 'BOM' (sig) in input (uncommon, [some?] MS Windows only?) - """ - enc = "utf_8" - enc_sig = enc + "_sig" - ufil = os.path.join(cdir, "chars.utf8_sig") - exp = utest_chars - - def setUp(self): - gen_chars(self.ufil, self.enc_sig) - - def test4a_u8_UTF8Reader_WITH_BOM_sig(self): - f=open(self.ufil) - ra=G.UTF8Reader(f) - g = ra.readline() - self.assertEquals(g,self.exp, m(g,self.exp, "orig UTF8Reader")) - - # utf_8 reads an initial BOM-sig as data -- oops, pity - # write the test to verify this known codec behavior - # ==> Recommend: do not use utf8 as input codec (use utf_8_sig) - def test4b_utf8_codec_WITH_BOM_sig_reads_as_data_PITY(self): - g=codecs.open(self.ufil, encoding=self.enc).read() - e0=u'\ufeff' - self.assertEquals(g[0], e0, - m(g[0],e0, "codec utf8 reads 'BOM'-sig as data" )) - g = g[1:] - self.assertEquals(g,self.exp, - m(g,self.exp, "codec utf8 reads rest of data ok")) - - # utf_8_sig reads and ignores the BOM-sig - def test4c_utf8_sig_codec_WITH_BOM_sig_as_expected(self): - g=codecs.open(self.ufil, encoding=self.enc_sig).read() - self.assertEquals(g,self.exp, - m(g,self.exp, "codec utf_8_sig NO sig input")) - -### - - - -if __name__ == "__main__": - unittest.main() - -#===eof=== diff --git a/src/GrampsDbUtils/test/ged_skip_notes_test.py b/src/GrampsDbUtils/test/ged_skip_notes_test.py deleted file mode 100644 index cd54976b4..000000000 --- a/src/GrampsDbUtils/test/ged_skip_notes_test.py +++ /dev/null @@ -1,84 +0,0 @@ -"""test for GedcomParse empty notes and skipped subordinates - -Empty notes are discarded -- with a warning -Skipped subordinate data also produce warnings -""" - -import os -import unittest as U -import logging - -from test import test_util as tu -from test import gedread_util as gr - - -class Test(U.TestCase): - """ this test verifies fix for bug 1851 """ - def setUp(self): - # make a dir to hold an input gedcom file - self.tdir = tu.make_subdir("gsn_test") - - def test1(self): - test_fragment=""" -0 @I1@ INDI -1 NAME Adam /TheFirst/ -1 DEAT -2 DATE EST 2 FEB 2000 -2 PLAC Bdorf -2 ADDR Haus Nr. 44 -2 NOTE this one should stay -2 NOTE -3 CONT this should stay too, but -3 CONT next one SB skipped (empty) -2 NOTE -0 @N101@ NOTE a real note -0 @N102@ NOTE -1 CONT a real continuation-only note -1 CONT should skip next (N103 empty) -2 JUNK2 -3 JUNK3 -0 @N103@ NOTE -0 @N199@ NOTE -1 SOUR @S987@ -""" - # expect warnings for discarded empty notes above - wNotes=3 # lines 32,39,40 [here] - # expect warnings for skipped subordinates (blocks) above - # remember consececutive lines skipped give 1 message - wSubs=2 # lines (37+38), 41 - - # create a gedcom input file - # from canned head/tail -- see gedread_util - infil = os.path.join(self.tdir,"test_in.ged") - gr.make_gedcom_input(infil, test_fragment) - self.assertTrue(os.path.isfile(infil), - "create input file %s" % infil) - - # create an empty database - dbpath = os.path.join(self.tdir,"test_db") - db = gr.create_empty_db(dbpath) - self.assertTrue(os.path.isdir(dbpath), - "create database (dir) %s" % dbpath) - - # create logfile to test for read log-messages - # (note: uses recently added test_util - log = os.path.join(self.tdir, "test_log") - tl = tu.TestLogger() - tl.logfile_init(log) - # now read the gedcom - gr.gread(db, infil) - loglines = tl.logfile_getlines() - #NB incorrect SUBM handling causes one extraneous warning - xWarns = 1 - ll = len(loglines) - tot = xWarns+wNotes+wSubs - self.assertEquals(ll,tot, tu.msg(ll,tot, - "log has expected warning content")) - # verify notes that survive - numNotes = 4 - nn = db.get_number_of_notes() - self.assertEquals(nn,numNotes, - tu.msg(nn,numNotes, "db has right number of notes")) - -if __name__ == "__main__": - U.main() diff --git a/src/test/ansel_utf8_test.py b/src/test/ansel_utf8_test.py deleted file mode 100644 index 61b9db47d..000000000 --- a/src/test/ansel_utf8_test.py +++ /dev/null @@ -1,257 +0,0 @@ -#!/usr/bin/python -tt - -# Instructions for use -# -------------------- -# Eventually, this code might use a testing infrastructure (conventions TBD) -# but, at present this is intended for use as a manual operation by placing -# this file (temporarily) in the same dir as the module it tests. -# -# Running -# ./test-ansel_utf8.py [-v] -# should report 'OK' -# the -v option shows individual results for each test function -# --------------------------------------------------------------------------- - -# TODO -# --------------------------------------------------------- -# make table of test cases for readability -# ansel U+xxxx UTF8 char-name string (char where appl) -# --------------------------------------------------------- - -import ansel_utf8 as A -import unittest - -# debugging provision to capture some strings for exernal examination -# note that this debug output is ASCII, by virture of using `` (repr) -OUT=0 -if OUT > 0: - import sys -# set output levels 1,2,4 (or-ing ok) for string (repr) in tests 1a,1b,2a -# then manipulate that data with separate tools for additional validation -# tools refs: -# http://search.cpan.org/~esummers/MARC-Charset-0.98/lib/MARC/Charset.pm -# http://pypi.python.org/pypi/pymarc -# --- -# (perl) MARC::Charset -# (python) pymarc omits eszett,euro (patchable); only does ansel-to-utf8 -# shell: echo -e 'utf-8 encoded chars' works well -# ==> NB: when examining unicode characters (rather than hexdump) externally, -# it is absolutely essential to use a good unicode terminal for correct -# display of combining forms (other than precomposed) -# (eg: use xterm rather than konsole or gnome-terminal) -# ==> and of course, use a locale with the UTF-8 charset - - -# test convwenience utility extends python by showing got & expected (like perl) -# useful at least for the commonly used assertEquals() -# conventions: -# dup the expected and got parms from the assertEquals and add a message -# (and an optional prefix to distinguish sub-tests) -# ==> code the assert as assertEquals(got, exp, msg(got,exp,mess,pfx)) -def msg(got, expect, msgbase, prefix=""): - if prefix: - prefix += ": " - return "%s%s\n .....got %s\n expected %s" % (prefix, msgbase, `got`, `expect`) - - -class Test1(unittest.TestCase): - """ test basic ansel_to_unicode and inversion """ - - def test_1a(self): - """ 1a: map ansel onebyte to unicode and inverse """ - # no combining chars here .. see later test for those - count = 0 - sans = "" - suni = u"" - for acode in sorted(A._onebyte.keys()): - count += 1 - sans += acode - suni += A._onebyte[acode] - if OUT & 1: - print "test1a: %d codes" % count - print " ansel:%s" % `sans` - print " utf-8:%s" % `suni.encode("utf-8")` # U8 for debugging - sys.stdout.flush() - a2u = A.ansel_to_utf8(sans) - self.assertEquals(a2u,suni, msg(a2u,suni, "map onebyte ansel to unicode")) - u2a = A.utf8_to_ansel(suni) - self.assertEquals(u2a,sans, msg(u2a, sans, "invert onebyte to unicode mapping")) - - def test_1b(self): - """ 1b: map ansel twobyte to unicode and inverse """ - # these are the precomposed combining forms - count = 0 - sans = "" - suni = u"" - for acode in sorted(A._twobyte.keys()): - count += 1 - sans += acode - suni += A._twobyte[acode] - if OUT & 2: - print "test1b: %d codes" % count - print " ansel:%s" % `sans` - print " utf-8:%s" % `suni.encode("utf-8")` # U8 - sys.stdout.flush() - a2u = A.ansel_to_utf8(sans) - self.assertEquals(a2u,suni, msg(a2u,suni,"map twobyte ansel to unicode")) - u2a = A.utf8_to_ansel(suni) - self.assertEquals(u2a,sans, msg(u2a,sans, "invert twobyte to unicode mapping")) - -class Test2(unittest.TestCase): - """ test unicode_to_ansel (basic precomposed forms) and inversion """ - - def test_2a(self): - """ 2a: unicode to ansel and inverse """ - count = 0 - sans = "" - suni = u"" - for ucode in sorted(A._utoa.keys()): - count += 1 - suni += ucode - sans += A._utoa[ucode] - if OUT & 4: - print "test2a: %d codes" % count - print " utf-8:%s" % `suni.encode("utf-8")` # U8 - print " ansel:%s" % `sans` - sys.stdout.flush() - u2a = A.utf8_to_ansel(suni) - self.assertEquals(u2a,sans, msg(u2a,sans, "map unicode to ansel")) - a2u = A.ansel_to_utf8(sans) - self.assertEquals(a2u,suni, msg(a2u,suni, "invert unicode to ansel mapping")) - -class Test3(unittest.TestCase): - """ test pass-through for matches with ansel ascii-subset """ - - def test3a(self): - """ 3a: ansel to unicode for matches with ascii and inverse """ - ascii_ok = "".join(A._use_ASCII) - ascii_uni = unicode(ascii_ok) - a2u = A.ansel_to_utf8(ascii_ok) - # could match with lengths wrong? can't hurt to test - la = len(ascii_ok) - la2u = len(a2u) - self.assertEquals(la2u, la, msg(la2u, la, "ascii subset ansel to unicode lengths match")) - self.assertEquals(a2u, ascii_uni, - msg(a2u, ascii_uni, "ascii subset ansel to unicode strings match")) - a2u2a = A.utf8_to_ansel(a2u) - self.assertEquals(a2u2a, ascii_ok, - msg(a2u2a, ascii_ok, "invert ascii subset ansel to unicode")) - - def test3b(self): - """ 3b: (sample) non-matching ascii control chars map to space """ - for x in [0,1,8,9,11,26,28,127]: - a2u = A.ansel_to_utf8(chr(x)) - self.assertEquals(a2u, unicode(' '), - msg(a2u, unicode(' '), "map disallowed ASCII to unicode space")) - u2a = A.utf8_to_ansel(unichr(x)) - self.assertEquals(u2a, ' ', - msg(u2a, ' ', "map unicode to space for disallowed ASCII")) - - def test3c(self): - """ 3c: (sample) no-match ansel to unicode cases """ - for x in [0x80,0x87,0x9F,0xFF]: - a2u = A.ansel_to_utf8(chr(x)) - self.assertEquals(a2u, u'\ufffd', - msg(a2u, u'\ufffd', "ansel no-match should return unicode Replacement Char")) - - def test3d(self): - """ 3d: (sample) no-match unicode to ansel cases """ - for x in [1024,4096, 65535]: - u2a = A.utf8_to_ansel(unichr(x)) - self.assertEquals(u2a, '?', - msg(u2a, '?', "unicode no-match should return question mark")) - -class Test4(unittest.TestCase): - """ test some special cases """ - - def test4a(self): - """ 4a: empty strings should return empty strings """ - self.assertEquals(A.ansel_to_utf8(""), u"", "empty a2u") - self.assertEquals(A.utf8_to_ansel(u""), "", "empty u2a") - - def test4b_unmapped_combos(self): - """ 4b: (sample) unmapped (non-precomposed) combinations """ - samples = ( - # ansel, unicode, failure-report-message .. see function msg() - ("b\xE5Ze", u"bZ\u0304e", "b Z+macron e"), - ( "\xE5Z", u"Z\u0304", "Z+macron"), - ("b\xE5Z\xE9Xe", u"bZ\u0304X\u030ce", "b Z+macron X+caron e"), - ( "\xE5Z\xE9X", u"Z\u0304X\u030c", "Z+macron X+caron"), - ) - for a,u,m in samples: - # ansel to unicode and inverse - a2u=A.ansel_to_utf8(a) - self.assertEquals(a2u, u, msg(a2u, u, m, "a2u")) - a2u2a = A.utf8_to_ansel(a2u) - self.assertEquals(a2u2a, a, msg(a2u2a, a, m, "a2u2a")) - - # unicode to ansel and inverse - u2a = A.utf8_to_ansel(u) - self.assertEquals(u2a, a, msg(u2a, a, m, "u2a")) - u2a2u = A.ansel_to_utf8(u2a) - self.assertEquals(u2a2u, u, msg(u2a2u, u, m, "u2a2u")) - - def test4c_multiple_combos(self): - """ 4c: (a2u) ignore multiple combinations (include precomposed) """ - samples = ( - ("b\xF0\xE5Ze", u"bZ\u0304e", "b Z+macron e"), - ( "\xF0\xE5Z", u"Z\u0304", " Z+macron"), - ("\xF0\xE5Z\xE9X", u"Z\u0304X\u030c", " Z+macron X+caron"), - ("\xE5Z\xF0\xE9X", u"Z\u0304X\u030c", "Z+macron X+caron"), - ('\xF0\xE5A', u'\u0100', " A+macron"), - ("\xE5Z\xE5\xF0\xE9X", u"Z\u0304X\u030c", "Z+macron X+caron"), - ) - for a,u,m in samples: - a2u=A.ansel_to_utf8(a) - self.assertEquals(a2u, u, msg(a2u,u,m, "a2u drop extra ")) - - def test4d_multiple_combos(self): - """ 4c: (u2a) ignore multiple combinations (include precomposed) """ - samples = ( - ("b\xE5Ze", u"bZ\u0304\u0327e", "b Z+macron e"), - ("\xE5Z\xE5A", u"Z\u0304\u0327\u0100", "Z+macron A+macron"), - ("\xE5A\xE5Z", u"\u0100\u0327\u030cZ\u0304", "A+macron Z+macron"), - ) - for a,u,m in samples: - u2a=A.utf8_to_ansel(u) - self.assertEquals(u2a, a, msg(u2a,a,m, "u2a drop extra ")) - -class Test99(unittest.TestCase): - """ test regression cases """ - - def test_99a(self): - """ 99a: sanity check on counts """ - n1B= len(A._onebyte) - n2B= len(A._twobyte) - na = n1B+n2B - nu = len(A._utoa) - self.assertEquals(na, nu, msg(na, nu, "basic counts: a2u=u2a")) - nac = len(A._acombiners) - nuc = len(A._ucombiners) - self.assertEquals(nac, nuc, msg(nac, nuc, "combiner counts: a2u=u2a")) - - def test_99b(self): - """ 99b: fix incorrect mapping for ansel 0xAE - - It used-to-be U+02be but was changed March 2005 to U+02bc - Note : the other revs per notes make double-wide combining - char halves into an ambiguous mess -- let's ignore that! - http://lcweb2.loc.gov/diglib/codetables/45.html - might as well add validation of other additions, though - """ - - # (ansel, uni, msg) - revs = ( - ('\xAE', u'\u02bc', "modifier right-half ring is now modifier Apostrophe"), - ('\xC7', u'\xdf', "added code for eszet"), - ('\xC8', u'\u20ac', "added code for euro"), - ) - for a, u, m in revs: - g = A.ansel_to_utf8(a) - self.assertEquals(g,u, - msg(g, u, m, "spec change")) - -if __name__ == '__main__': - unittest.main() - -#===eof=== diff --git a/src/test/gedread_util.py b/src/test/gedread_util.py deleted file mode 100644 index 156c6cab9..000000000 --- a/src/test/gedread_util.py +++ /dev/null @@ -1,130 +0,0 @@ -"""unittest support utilities for reading gedcom - -see gedread_test.py for sample usage - -""" - -import os.path -import shutil - -from test import test_util as tu -from GrampsDbUtils import _ReadGedcom as RG -import DbState -import gen.db -import config - -# extraneous leading newlines do not seem to cause problems -# (and actually make it convenient reading the test files!) -# future: may need to remove such lines here if problems develop - -# These ged-chunks provide/observe the following requirements -# - minimum required header elements -# - a trailer -# - and one record (spec minimum), using a SUBM -# Note: not all specified requirements seem strongly enforcced -# eg: at least one record, also nonexistent references seem -# ok by design, so the SUBM could have been missing -# Also note that the 'tail' containing the SUBM record referenced -# in the header causes a line of console output because we -# presently do not process SUBM records at all -# (seems like a bug to me -- to be dealt with later) -# --------------------------------------------------------------- - -# _head is presently simply a header with minimum content -_head =""" -0 HEAD -1 SOUR test_gedread_System_ID -1 SUBM @SUBM1@ -1 GEDC -2 VERS 5.5 -2 FORM LINEAGE-LINKED -1 CHAR ASCII -""" - -# _tail is presently a single (SUBM) record plus the trailer -# to satisfy the "one or more records" in the spec -# it also provides a target for the xref in the header -# it also gives a "skipping 1 subordinate.." message error -# which presumeably will be fixed someday -_tail = """ -0 @SUBM1@ SUBM -1 NAME test /gedread/ -0 TRLR -""" - -def make_gedcom_input(gfile, fragment): - """create gedcom file with 'fragment' between our head & tail - - fragment would normally be 1 or more complete records - fragment could be an empty string ("") - - """ - fh = open(gfile,"w") - for txt in (_head, fragment, _tail): - fh.write(txt) - fh.close() - - -# code patterned after contents of ReadGedcom.import2, -# but avoiding the occurrence of a popup DialogError. -# NOTE: may need rewrite to track mods in ReadGedcom -# test this code via src/test/test/gedread_util_test.py -# ------------------------------------------------------- -def gread(db, fname): - """read gedcom file into a test db - - NB: test modules may want to consider also, the simplified - test logging (from test_util) which is especially helpful - for testing gedcom support - - """ - cback = None - DEF_SRC = False - ifile = open(fname,"rU") - try: - try: - s1 = RG.StageOne(ifile) - s1.parse() - except Exception,e: - raise tu.TestError("stage1 error %r" % e) - - useTrans = False - ifile.seek(0) - try: - gp = RG.GedcomParser(db, ifile, fname, cback, s1, DEF_SRC) - except Exception, e: - raise tu.TestError("parser init error %r" % e) - - ##ro = db.readonly - ##db.readonly = False # why? - try: - gp.parse_gedcom_file(useTrans) - err = "" - except Exception, e: - raise tu.TestError("parse error %r" %e) - ##db.readonly = ro - finally: - ifile.close() - - -# test db creation -# -# This may deserve it's own module, but for now it is only used here -# -# state doesn't seem to be necessary for testing -# let's try just returning the db -#---------------------------------------------------- -def create_empty_db(dbpath): - """create an empty db for the test caller""" - state = DbState.DbState() - dbclass = gen.db.dbdir.GrampsDBDir - state.change_database(dbclass()) - # create empty db (files) via load() - cback = None - mode = "rw" - if os.path.isdir(dbpath): - shutil.rmtree(dbpath) - state.db.load(dbpath, cback, mode) - return state.db - -#===eof=== diff --git a/src/test/test/gedread_util_test.py b/src/test/test/gedread_util_test.py index bfafd68c0..90c59991c 100644 --- a/src/test/test/gedread_util_test.py +++ b/src/test/test/gedread_util_test.py @@ -52,6 +52,8 @@ class Test(U.TestCase): np = db.get_number_of_people() self.assertEquals(np,1, tu.msg(np,1, "db has exactly one person")) + db.close() + del tl if __name__ == "__main__": U.main() diff --git a/src/test/test/test_util_test.py b/src/test/test/test_util_test.py index e4b3b6985..aedf4bdd3 100644 --- a/src/test/test/test_util_test.py +++ b/src/test/test/test_util_test.py @@ -181,6 +181,7 @@ class Test4(U.TestCase): nl = len(ll) self.assertEquals(nl,2, tu.msg(nl,2, "pass %d: expected line count" % i)) + del tl if __name__ == "__main__":