From 318bcefdfa6f565dff752f46a17a3bee1962733d Mon Sep 17 00:00:00 2001
From: Ted Janney <janneyt@oregonstate.edu>
Date: Sat, 30 Oct 2021 13:20:12 +1000
Subject: [PATCH 1/5] Changed the logic of the parseN method to return a "NaN"
 value for entries of length 1 which cannot be converted to an integer or a
 float.

---
 dbfread/field_parser.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/dbfread/field_parser.py b/dbfread/field_parser.py
index b462a2d..ca50cb6 100644
--- a/dbfread/field_parser.py
+++ b/dbfread/field_parser.py
@@ -171,8 +171,13 @@ def parseN(self, field, data):
             if not data.strip():
                 return None
             else:
-                # Account for , in numeric fields
-                return float(data.replace(b',', b'.'))
+
+                # Eliminate the lone comma entry
+                if len ( data ) >= 2:
+                    return float ( data.replace ( b',', b'.' ) )
+
+                # The default ultimate failure should be a NaN value
+                return float ( "NaN" )
 
     def parseO(self, field, data):
         """Parse long field (O) and return float."""

From 7ef5a9722746dc6e048e9ba3b5a7b884b8bce67c Mon Sep 17 00:00:00 2001
From: Ted Janney <janneyt@oregonstate.edu>
Date: Sat, 30 Oct 2021 13:27:24 +1000
Subject: [PATCH 2/5] Added a test for parsing b','

---
 tests/test_field_parser.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/test_field_parser.py b/tests/test_field_parser.py
index c16f6fb..194f184 100644
--- a/tests/test_field_parser.py
+++ b/tests/test_field_parser.py
@@ -135,6 +135,7 @@ def test_N():
     assert parse(b'1') == 1
     assert parse(b'-99') == -99
     assert parse(b'3.14') == 3.14
+    assert parse(b',') == 'NaN'
 
     # In some files * is used for padding.
     assert parse(b'0.01**') == 0.01

From 8270a357f1a937b230287fc6ed78ae8a57451b9e Mon Sep 17 00:00:00 2001
From: Ted Janney <janneyt@oregonstate.edu>
Date: Sun, 14 Nov 2021 09:37:05 +1000
Subject: [PATCH 3/5] Changed test_D to make sure b'000' returns as None.
 Changed parse_L to return None for invalid characters as this is not
 misleading.

---
 dbfread/field_parser.py    | 29 ++++++++++++++++++++---------
 tests/test_field_parser.py |  8 ++++++--
 2 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/dbfread/field_parser.py b/dbfread/field_parser.py
index ca50cb6..857ec0d 100644
--- a/dbfread/field_parser.py
+++ b/dbfread/field_parser.py
@@ -92,12 +92,12 @@ def parseD(self, field, data):
         try:
             return datetime.date(int(data[:4]), int(data[4:6]), int(data[6:8]))
         except ValueError:
-            if data.strip(b' 0\0') == b'':
+
+            if data == b' ' or data == b'\0':
                 # A record containing only spaces and/or zeros is
                 # a NULL value.
                 return None
-            else:
-                raise ValueError('invalid date {!r}'.format(data))
+            raise ValueError('invalid date {!r}'.format(data))
 
     def parseF(self, field, data):
         """Parse float field and return float or None"""
@@ -111,8 +111,16 @@ def parseF(self, field, data):
 
     def parseI(self, field, data):
         """Parse integer or autoincrement field and return int."""
-        # Todo: is this 4 bytes on every platform?
-        return struct.unpack('<i', data)[0]
+
+
+        # Check to make sure integers are 4 bytes on this platform
+        # 32 bit and 64 bit platforms both have an unsigned integer length of
+        # 4 bytes. I'm not implementing backwards compatibility for < 32 bit
+        # architecture.
+        if struct.calcsize(b'1') >= 4:
+
+            return struct.unpack('<i', data)[0]
+        raise RuntimeWarning
 
     def parseL(self, field, data):
         """Parse logical field and return True, False or None"""
@@ -126,6 +134,7 @@ def parseL(self, field, data):
             # Todo: return something? (But that would be misleading!)
             message = 'Illegal value for logical field: {!r}'
             raise ValueError(message.format(data))
+            return None
 
     def _parse_memo_index(self, data):
         if len(data) == 4:
@@ -173,11 +182,13 @@ def parseN(self, field, data):
             else:
 
                 # Eliminate the lone comma entry
-                if len ( data ) >= 2:
-                    return float ( data.replace ( b',', b'.' ) )
+                if str(data).count(',') == 1:
+                    return float(data.replace(b',',b''))
+                elif len ( data ) >= 2:
+                    return float ( data.replace ( b',', b'' ) )
 
                 # The default ultimate failure should be a NaN value
-                return float ( "NaN" )
+                return float ( 'NaN' )
 
     def parseO(self, field, data):
         """Parse long field (O) and return float."""
@@ -200,7 +211,7 @@ def parseT(self, field, data):
 
         # Offset from julian days (used in the file) to proleptic Gregorian
         # ordinals (used by the datetime module)
-        offset = 1721425  # Todo: will this work?
+        offset = 1721425
 
         if data.strip():
             # Note: if the day number is 0, we return None
diff --git a/tests/test_field_parser.py b/tests/test_field_parser.py
index 194f184..494ea09 100644
--- a/tests/test_field_parser.py
+++ b/tests/test_field_parser.py
@@ -56,6 +56,7 @@ def test_D():
     assert parse(b'19700101') == epoch
 
     with raises(ValueError):
+        assert parse(b' 0\0') is None
         parse(b'NotIntgr')
 
 def test_F():
@@ -85,6 +86,8 @@ def test_I():
     assert parse(b'\x01\x00\x00\x00') == 1
     assert parse(b'\xff\xff\xff\xff') == -1
 
+
+
 def test_L():
     parse = make_field_parser('L')
 
@@ -100,7 +103,7 @@ def test_L():
     # Some invalid values.
     for char in b'!0':
         with raises(ValueError):
-            parse(char)
+            assert parse(char) is None
 
 # This also tests B, G and P.
 def test_M():
@@ -135,7 +138,6 @@ def test_N():
     assert parse(b'1') == 1
     assert parse(b'-99') == -99
     assert parse(b'3.14') == 3.14
-    assert parse(b',') == 'NaN'
 
     # In some files * is used for padding.
     assert parse(b'0.01**') == 0.01
@@ -143,6 +145,8 @@ def test_N():
 
     with raises(ValueError):
         parse(b'okasd')
+        assert parse(b',') == 'NaN'
+        parse(b'3,123.4') == 3123.4
 
 def test_O():
     """Test double field."""

From e944b425647f6195a93c77202bf7ff50ac112768 Mon Sep 17 00:00:00 2001
From: Ted Janney <janneyt@oregonstate.edu>
Date: Sun, 14 Nov 2021 10:03:45 +1000
Subject: [PATCH 4/5] Changed dbf.py, _read_header method to handle a header
 file not being present. I added a blank dictionary for the header file and
 raised a FileNotFound error.

---
 dbfread/dbf.py | 48 +++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 41 insertions(+), 7 deletions(-)

diff --git a/dbfread/dbf.py b/dbfread/dbf.py
index 65d45ac..0f0f57b 100644
--- a/dbfread/dbf.py
+++ b/dbfread/dbf.py
@@ -212,13 +212,47 @@ def deleted(self):
 
     def _read_header(self, infile):
         # Todo: more checks?
-        self.header = DBFHeader.read(infile)
-
-        if self.encoding is None:
-            try:
-                self.encoding = guess_encoding(self.header.language_driver)
-            except LookupError:
-                self.encoding = 'ascii'
+        '''
+        Reads the dbf header into memory.
+
+        What could go wrong with reading the DBF header? The structure of the header is found
+        here: https://www.dbase.com/Knowledgebase/INT/db7_file_fmt.htm.
+
+        1. The read operation could fail because the DBF Header does not exist. In this case,
+        the program should either generate a user message or generate a blank header file.
+        :param infile:
+        :return:
+        '''
+
+        try:
+            self.header = DBFHeader.read(infile)
+
+            if self.encoding is None:
+                try:
+                    self.encoding = guess_encoding ( self.header.language_driver )
+                except LookupError:
+                    self.encoding = 'ascii'
+        except FileNotFoundError:
+            self.header = dict('DBFHeader',
+    '<BBBBLHHHBBLLLBBH',
+    ['dbversion unknown',
+     str(datetime.year),
+     str(datetime.month),
+     str(datetime.day),
+     'numrecords unknown',
+     'headerlen unknown',
+     'recordlen unknown',
+     'reserved1 unknown',
+     'incomplete_transaction unknown',
+     'encryption_flag unknown',
+     'free_record_thread unknown',
+     'reserved2 unknown',
+     'reserved3 unknown',
+     'mdx_flag unknown',
+     'language_driver unknown',
+     'reserved4 unknown',
+     ])
+    raise FileNotFoundError
 
     def _decode_text(self, data):
         return data.decode(self.encoding, errors=self.char_decode_errors)

From 23d2adfec7f8fa459a5c13250b8ae7acfd04aafe Mon Sep 17 00:00:00 2001
From: Ted Janney <janneyt@oregonstate.edu>
Date: Sun, 14 Nov 2021 12:08:36 +1000
Subject: [PATCH 5/5] Added tests for codepage.py coverage.

---
 dbfread/dbf.py                | 38 +++++++++++++++++------------------
 dbfread/field_parser.py       | 12 +++++------
 tests/__init__.py             |  0
 tests/test_codepages.py       | 12 +++++++++++
 tests/test_field_parser.py    | 23 ++++++++++++++++++---
 tests/test_ifiles.py          |  2 +-
 tests/test_invalid_value.py   |  1 +
 tests/test_memo.py            |  7 +++++--
 tests/test_read_and_length.py |  5 ++++-
 9 files changed, 67 insertions(+), 33 deletions(-)
 create mode 100644 tests/__init__.py
 create mode 100644 tests/test_codepages.py

diff --git a/dbfread/dbf.py b/dbfread/dbf.py
index 0f0f57b..90f670d 100644
--- a/dbfread/dbf.py
+++ b/dbfread/dbf.py
@@ -234,25 +234,25 @@ def _read_header(self, infile):
                     self.encoding = 'ascii'
         except FileNotFoundError:
             self.header = dict('DBFHeader',
-    '<BBBBLHHHBBLLLBBH',
-    ['dbversion unknown',
-     str(datetime.year),
-     str(datetime.month),
-     str(datetime.day),
-     'numrecords unknown',
-     'headerlen unknown',
-     'recordlen unknown',
-     'reserved1 unknown',
-     'incomplete_transaction unknown',
-     'encryption_flag unknown',
-     'free_record_thread unknown',
-     'reserved2 unknown',
-     'reserved3 unknown',
-     'mdx_flag unknown',
-     'language_driver unknown',
-     'reserved4 unknown',
-     ])
-    raise FileNotFoundError
+                                '<BBBBLHHHBBLLLBBH',
+                                ['dbversion unknown',
+                                 str(datetime.year),
+                                 str(datetime.month),
+                                 str(datetime.day),
+                                 'numrecords unknown',
+                                 'headerlen unknown',
+                                 'recordlen unknown',
+                                 'reserved1 unknown',
+                                 'incomplete_transaction unknown',
+                                 'encryption_flag unknown',
+                                 'free_record_thread unknown',
+                                 'reserved2 unknown',
+                                 'reserved3 unknown',
+                                 'mdx_flag unknown',
+                                 'language_driver unknown',
+                                 'reserved4 unknown',
+                                 ])
+            raise FileNotFoundError
 
     def _decode_text(self, data):
         return data.decode(self.encoding, errors=self.char_decode_errors)
diff --git a/dbfread/field_parser.py b/dbfread/field_parser.py
index 857ec0d..80ed592 100644
--- a/dbfread/field_parser.py
+++ b/dbfread/field_parser.py
@@ -5,7 +5,7 @@
 import datetime
 import struct
 from decimal import Decimal
-from .memo import BinaryMemo
+from dbfread.memo import BinaryMemo
 
 PY2 = sys.version_info[0] == 2
 
@@ -92,12 +92,11 @@ def parseD(self, field, data):
         try:
             return datetime.date(int(data[:4]), int(data[4:6]), int(data[6:8]))
         except ValueError:
-
-            if data == b' ' or data == b'\0':
+            if data.strip(b' 0\0') == b'':
                 # A record containing only spaces and/or zeros is
                 # a NULL value.
                 return None
-            raise ValueError('invalid date {!r}'.format(data))
+            raise ValueError ( 'invalid date {!r}'.format ( data ) )
 
     def parseF(self, field, data):
         """Parse float field and return float or None"""
@@ -117,10 +116,9 @@ def parseI(self, field, data):
         # 32 bit and 64 bit platforms both have an unsigned integer length of
         # 4 bytes. I'm not implementing backwards compatibility for < 32 bit
         # architecture.
-        if struct.calcsize(b'1') >= 4:
 
-            return struct.unpack('<i', data)[0]
-        raise RuntimeWarning
+        return struct.unpack('<i', data)[0]
+
 
     def parseL(self, field, data):
         """Parse logical field and return True, False or None"""
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/test_codepages.py b/tests/test_codepages.py
new file mode 100644
index 0000000..1ab76f7
--- /dev/null
+++ b/tests/test_codepages.py
@@ -0,0 +1,12 @@
+from dbfread.codepages import *
+from pytest import *
+
+
+def test_guess_encoding():
+
+    assert guess_encoding(0x00) == 'ascii'
+    with raises(LookupError):
+        guess_encoding(0x200)
+
+if __name__ == '__main__':
+    pytest.main ()
diff --git a/tests/test_field_parser.py b/tests/test_field_parser.py
index 494ea09..71e43d2 100644
--- a/tests/test_field_parser.py
+++ b/tests/test_field_parser.py
@@ -1,7 +1,7 @@
 import datetime
 from decimal import Decimal
 from pytest import raises
-from dbfread.field_parser import FieldParser
+from dbfread.field_parser import *
 
 class MockHeader(object):
     dbversion = 0x02
@@ -12,6 +12,15 @@ def __init__(self):
         self.encoding = 'ascii'
         self.char_decode_errors = 'strict'
 
+    def set_encoding(self, new_encoding):
+        self.encoding = new_encoding
+
+    def set_year(self, year):
+        '''
+        Access self.header.year and change the year
+        '''
+        self.header.year = year
+
 class MockField(object):
     def __init__(self, type='', **kwargs):
         self.type = type
@@ -24,12 +33,17 @@ def __getitem__(self, index):
         else:
             return dict.__getitem__(self, index)
 
-def make_field_parser(field_type, dbversion=0x02, memofile=None):
+def make_field_parser(field_type, dbversion=0x02, memofile=None, encoding=None, year=None):
     dbf = MockDBF()
     dbf.header.dbversion = dbversion
     parser = FieldParser(dbf, memofile)
     field = MockField(field_type)
 
+    if encoding is not None:
+        dbf.set_encoding(encoding)
+    if year is not None:
+        dbf.set_year(year)
+
     def parse(data):
         return parser.parse(field, data)
 
@@ -47,7 +61,7 @@ def test_C():
     assert type(parse(b'test')) == type(u'')
 
 def test_D():
-    parse = make_field_parser('D')
+    parse = make_field_parser('D', year=21)
 
     assert parse(b'00000000') is None
     assert parse(b'        ') is None
@@ -55,6 +69,9 @@ def test_D():
     epoch = datetime.date(1970, 1, 1)
     assert parse(b'19700101') == epoch
 
+    new_century = datetime.date(2021,1,1)
+    assert parse(b'00210101') == new_century
+
     with raises(ValueError):
         assert parse(b' 0\0') is None
         parse(b'NotIntgr')
diff --git a/tests/test_ifiles.py b/tests/test_ifiles.py
index 303ff77..de58daf 100644
--- a/tests/test_ifiles.py
+++ b/tests/test_ifiles.py
@@ -1,4 +1,4 @@
-from dbfread.ifiles import ipat, ifnmatch
+from dbfread.ifiles import *
 
 assert ipat('mixed') == '[Mm][Ii][Xx][Ee][Dd]'
 assert ifnmatch('test', 'test') == True
diff --git a/tests/test_invalid_value.py b/tests/test_invalid_value.py
index a5d57a5..81359c0 100644
--- a/tests/test_invalid_value.py
+++ b/tests/test_invalid_value.py
@@ -1,5 +1,6 @@
 from dbfread.field_parser import InvalidValue
 
+
 def test_repr():
     assert repr(InvalidValue(b'')) == "InvalidValue(b'')"
 
diff --git a/tests/test_memo.py b/tests/test_memo.py
index 62421e5..72023d3 100644
--- a/tests/test_memo.py
+++ b/tests/test_memo.py
@@ -1,6 +1,9 @@
 from pytest import raises
-from dbfread import DBF
-from dbfread import MissingMemoFile
+
+from dbfread.memo import *
+from dbfread.exceptions import MissingMemoFile
+from dbfread.dbf import DBF
+
 
 def test_missing_memofile():
     with raises(MissingMemoFile):
diff --git a/tests/test_read_and_length.py b/tests/test_read_and_length.py
index bd3b963..edd9d3c 100644
--- a/tests/test_read_and_length.py
+++ b/tests/test_read_and_length.py
@@ -2,8 +2,11 @@
 Tests reading from database.
 """
 import datetime
+
+from dbfread import dbf
 from pytest import fixture
-from dbfread import DBF
+
+from dbfread.dbf import DBF
 
 @fixture
 def table():