diff --git a/neo/rawio/neuralynxrawio/ncssections.py b/neo/rawio/neuralynxrawio/ncssections.py
index cf3da6113..8eb4b98c1 100644
--- a/neo/rawio/neuralynxrawio/ncssections.py
+++ b/neo/rawio/neuralynxrawio/ncssections.py
@@ -37,6 +37,19 @@
 import math
 import numpy as np
 
+from enum import IntEnum, auto
+
+
+class AcqType(IntEnum):
+    PRE4 = auto()
+    BML = auto()
+    DIGITALLYNX = auto()
+    DIGITALLYNXSX = auto()
+    CHEETAH64 = auto()
+    RAWDATAFILE = auto()
+    CHEETAH560 = auto()
+    ATLAS = auto()
+    UNKNOWN = auto()
 
 class NcsSections:
     """
@@ -250,7 +263,7 @@ def build_for_ncs_file(ncsMemMap, nlxHdr, gapTolerance=None, strict_gap_mode=Tru
         acqType = nlxHdr.type_of_recording()
         freq = nlxHdr["sampling_rate"]
 
-        if acqType == "PRE4":
+        if acqType == AcqType.PRE4:
             # Old Neuralynx style with truncated whole microseconds for actual sampling. This
             # restriction arose from the sampling being based on a master 1 MHz clock.
             microsPerSampUsed = math.floor(NcsSectionsFactory.get_micros_per_samp_for_freq(freq))
@@ -266,7 +279,8 @@ def build_for_ncs_file(ncsMemMap, nlxHdr, gapTolerance=None, strict_gap_mode=Tru
             ncsSects.sampFreqUsed = sampFreqUsed
             ncsSects.microsPerSampUsed = microsPerSampUsed
 
-        elif acqType in ["DIGITALLYNX", "DIGITALLYNXSX", "CHEETAH64", "CHEETAH560", "RAWDATAFILE"]:
+        elif acqType in [AcqType.DIGITALLYNX, AcqType.DIGITALLYNXSX, AcqType.CHEETAH64,
+                          AcqType.CHEETAH560, AcqType.RAWDATAFILE]:
             # digital lynx style with fractional frequency and micros per samp determined from block times
             if gapTolerance is None:
                 if strict_gap_mode:
@@ -293,7 +307,7 @@ def build_for_ncs_file(ncsMemMap, nlxHdr, gapTolerance=None, strict_gap_mode=Tru
             ncsSects.sampFreqUsed = sampFreqUsed
             ncsSects.microsPerSampUsed = NcsSectionsFactory.get_micros_per_samp_for_freq(sampFreqUsed)
 
-        elif acqType == "BML" or acqType == "ATLAS":
+        elif acqType == AcqType.BML or acqType == AcqType.ATLAS:
             # BML & ATLAS style with fractional frequency and micros per samp
             if strict_gap_mode:
                 # this is the old behavior, maybe we could put 0.9 sample interval no ?
diff --git a/neo/rawio/neuralynxrawio/nlxheader.py b/neo/rawio/neuralynxrawio/nlxheader.py
index ea3afd01a..e23d49acf 100644
--- a/neo/rawio/neuralynxrawio/nlxheader.py
+++ b/neo/rawio/neuralynxrawio/nlxheader.py
@@ -4,11 +4,19 @@
 import re
 from collections import OrderedDict
 
+from neo.rawio.neuralynxrawio.ncssections import AcqType
+
 
 class NlxHeader(OrderedDict):
     """
     Representation of basic information in all 16 kbytes Neuralynx file headers,
     including dates opened and closed if given.
+
+    The OrderedDict contains entries for each property given in the header with '-' in front
+    of the key value as well as an 'ApplicationName', 'ApplicationVersion', 'recording_opened'
+    and 'recording_closed' entries. The 'InputRange', 'channel_ids', 'channel_names' and
+    'bit_to_microvolt' properties are set to lists of entries for each channel which may be
+    in the file.
     """
 
     HEADER_SIZE = 2**14  # Neuralynx files have a txt header of 16kB
@@ -22,7 +30,9 @@ def _to_bool(txt):
         else:
             raise Exception("Can not convert %s to bool" % txt)
 
-    # keys that may be present in header which we parse
+    # Keys that may be present in header which we parse. First entry of tuple is what is
+    # present in header, second entry is key which will be used in dictionary, third entry
+    # type the value will be converted to.
     txt_header_keys = [
         ("AcqEntName", "channel_names", None),  # used
         ("FileType", "", None),
@@ -68,69 +78,6 @@ def _to_bool(txt):
         ("NLX_Base_Class_Type", "", None),  # in version 4 and earlier versions of Cheetah
     ]
 
-    # Filename and datetime may appear in header lines starting with # at
-    # beginning of header or in later versions as a property. The exact format
-    # used depends on the application name and its version as well as the
-    # -FileVersion property.
-    #
-    # There are 4 styles understood by this code and the patterns used for parsing
-    # the items within each are stored in a dictionary. Each dictionary is then
-    # stored in main dictionary keyed by an abbreviation for the style.
-    header_pattern_dicts = {
-        # BML
-        "bml": dict(
-            datetime1_regex=r"## Time Opened: \(m/d/y\): (?P<date>\S+)" r"  At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%y %H:%M:%S.%f",
-        ),
-        # Cheetah after version 1 and before version 5
-        "bv5": dict(
-            datetime1_regex=r"## Time Opened: \(m/d/y\): (?P<date>\S+)" r"  At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S.%f",
-        ),
-        # Cheetah version 5.4.0
-        "v5.4.0": dict(
-            datetime1_regex=r"## Time Opened \(m/d/y\): (?P<date>\S+)" r"  At Time: (?P<time>\S+)",
-            datetime2_regex=r"## Time Closed \(m/d/y\): (?P<date>\S+)" r"  At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S.%f",
-        ),
-        # Cheetah version 5.6.0, some range of versions in between
-        "v5.6.0": dict(
-            datetime1_regex=r"## Time Opened: \(m/d/y\): (?P<date>\S+)" r" At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S.%f",
-        ),
-        # Cheetah version 5 before and including v 5.6.4 as well as version 1
-        "bv5.6.4": dict(
-            datetime1_regex=r"## Time Opened \(m/d/y\): (?P<date>\S+)" r"  \(h:m:s\.ms\) (?P<time>\S+)",
-            datetime2_regex=r"## Time Closed \(m/d/y\): (?P<date>\S+)" r"  \(h:m:s\.ms\) (?P<time>\S+)",
-            filename_regex=r"## File Name (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S.%f",
-        ),
-        "neuraview2": dict(
-            datetime1_regex=r"## Date Opened: \(mm/dd/yyy\): (?P<date>\S+)" r" At Time: (?P<time>\S+)",
-            datetime2_regex=r"## Date Closed: \(mm/dd/yyy\): (?P<date>\S+)" r" At Time: (?P<time>\S+)",
-            filename_regex=r"## File Name: (?P<filename>\S+)",
-            datetimeformat="%m/%d/%Y %H:%M:%S",
-        ),
-        "peg": dict(
-            datetime1_regex=r"-TimeCreated (?P<date>\S+) (?P<time>\S+)",
-            datetime2_regex=r"-TimeClosed (?P<date>\S+) (?P<time>\S+)",
-            filename_regex=r'-OriginalFileName "?(?P<filename>\S+)"?',
-            datetimeformat=r"%Y/%m/%d %H:%M:%S",
-            datetime2format=r"%Y/%m/%d %H:%M:%S.%f",
-        ),
-        # Cheetah after v 5.6.4 and default for others such as Pegasus
-        "def": dict(
-            datetime1_regex=r"-TimeCreated (?P<date>\S+) (?P<time>\S+)",
-            datetime2_regex=r"-TimeClosed (?P<date>\S+) (?P<time>\S+)",
-            filename_regex=r'-OriginalFileName "?(?P<filename>\S+)"?',
-            datetimeformat="%Y/%m/%d %H:%M:%S",
-        ),
-    }
-
     def __init__(self, filename, props_only=False):
         """
         Factory function to build NlxHeader for a given file.
@@ -148,22 +95,15 @@ def __init__(self, filename, props_only=False):
             ValueError("Neuralynx files must start with 8 # characters.")
 
         self.read_properties(filename, txt_header)
+        numChidEntries = self.convert_channel_ids_names(filename)
+        self.setApplicationAndVersion()
+        self.setBitToMicroVolt()
+        self.setInputRanges(numChidEntries)
+        # :TODO: needs to also handle filename property
 
         if not props_only:
             self.readTimeDate(txt_header)
 
-    @staticmethod
-    def build_with_properties_only(filename):
-        """
-        Builds a version of the header without time and date or other validity checking.
-
-        Intended mostly for utilities but may also be useful for some recalcitrant header formats.
-
-        :param filename: name of Neuralynx file.
-        :return: NlxHeader with properties from header text
-        """
-        res = OrderedDict()
-
     def read_properties(self, filename, txt_header):
         """
         Read properties from header and place in OrderedDictionary which this object is.
@@ -183,25 +123,31 @@ def read_properties(self, filename, txt_header):
                 if type_ is not None:
                     value = type_(value)
                 self[name] = value
-        # if channel_ids or s not in self then the filename is used
-        name = os.path.splitext(os.path.basename(filename))[0]
-        # convert channel ids
-        if "channel_ids" in self:
-            chid_entries = re.findall(r"\S+", self["channel_ids"])
-            self["channel_ids"] = [int(c) for c in chid_entries]
-        else:
-            self["channel_ids"] = ["unknown"]
-        # convert channel names
-        if "channel_names" in self:
-            name_entries = re.findall(r"\S+", self["channel_names"])
-            if len(name_entries) == 1:
-                self["channel_names"] = name_entries * len(self["channel_ids"])
-            assert len(self["channel_names"]) == len(
-                self["channel_ids"]
-            ), "Number of channel ids does not match channel names."
-        else:
-            self["channel_names"] = ["unknown"] * len(self["channel_ids"])
-        # version and application name
+
+    def setInputRanges(self, numChidEntries):
+        if "InputRange" in self:
+            ir_entries = re.findall(r"\w+", self["InputRange"])
+            if len(ir_entries) == 1:
+                self["InputRange"] = [int(ir_entries[0])] * numChidEntries
+            else:
+                self["InputRange"] = [int(e) for e in ir_entries]
+            assert len(self["InputRange"]) == numChidEntries, \
+                "Number of channel ids does not match input range values."
+
+    def setBitToMicroVolt(self):
+        # convert bit_to_microvolt
+        if "bit_to_microVolt" in self:
+            btm_entries = re.findall(r"\S+", self["bit_to_microVolt"])
+            if len(btm_entries) == 1:
+                btm_entries = btm_entries * len(self["channel_ids"])
+            self["bit_to_microVolt"] = [float(e) * 1e6 for e in btm_entries]
+            assert len(self["bit_to_microVolt"]) == len( self["channel_ids"]), \
+                "Number of channel ids does not match bit_to_microVolt conversion factors."
+
+    def setApplicationAndVersion(self):
+        """
+        Set "ApplicationName" property and app_version attribute based on existing properties
+        """
         # older Cheetah versions with CheetahRev property
         if "CheetahRev" in self:
             assert "ApplicationName" not in self
@@ -214,36 +160,156 @@ def read_properties(self, filename, txt_header):
             assert len(match) == 1, "impossible to find application name and version"
             self["ApplicationName"], app_version = match[0]
         # BML Ncs file contain neither property, but 'NLX_Base_Class_Type'
-        elif "NLX_Base_Class_Type" in txt_header:
+        elif "NLX_Base_Class_Type" in self:
             self["ApplicationName"] = "BML"
             app_version = "2.0"
-        # Neuraview Ncs file contained neither property nor
-        # NLX_Base_Class_Type information
+        # Neuraview Ncs file contained neither property nor NLX_Base_Class_Type information
         else:
             self["ApplicationName"] = "Neuraview"
             app_version = "2"
+
         if " Development" in app_version:
             app_version = app_version.replace(" Development", ".dev0")
+
         self["ApplicationVersion"] = Version(app_version)
-        # convert bit_to_microvolt
-        if "bit_to_microVolt" in self:
-            btm_entries = re.findall(r"\S+", self["bit_to_microVolt"])
-            if len(btm_entries) == 1:
-                btm_entries = btm_entries * len(self["channel_ids"])
-            self["bit_to_microVolt"] = [float(e) * 1e6 for e in btm_entries]
-            assert len(self["bit_to_microVolt"]) == len(
+
+    def convert_channel_ids_names(self, filename):
+        """
+        Convert channel ids and channel name properties, if present.
+
+        :return number of channel id entries
+        """
+        # if channel_ids or names not in self then the filename is used for channel name
+        name = os.path.splitext(os.path.basename(filename))[0]
+
+        # convert channel ids
+        if "channel_ids" in self:
+            chid_entries = re.findall(r"\S+", self["channel_ids"])
+            self["channel_ids"] = [int(c) for c in chid_entries]
+        else:
+            self["channel_ids"] = ["unknown"]
+            chid_entries = []
+
+        # convert channel names
+        if "channel_names" in self:
+            name_entries = re.findall(r"\S+", self["channel_names"])
+            if len(name_entries) == 1:
+                self["channel_names"] = name_entries * len(self["channel_ids"])
+            assert len(self["channel_names"]) == len(
                 self["channel_ids"]
-            ), "Number of channel ids does not match bit_to_microVolt conversion factors."
-        if "InputRange" in self:
-            ir_entries = re.findall(r"\w+", self["InputRange"])
-            if len(ir_entries) == 1:
-                self["InputRange"] = [int(ir_entries[0])] * len(chid_entries)
-            else:
-                self["InputRange"] = [int(e) for e in ir_entries]
-            assert len(self["InputRange"]) == len(
-                chid_entries
-            ), "Number of channel ids does not match input range values."
+            ), "Number of channel ids does not match channel names."
+        else:
+            self["channel_names"] = ["unknown"] * len(self["channel_ids"])
 
+        return len(chid_entries)
+
+    # Filename and datetime may appear in header lines starting with # at
+    # beginning of header or in later versions as a property. The exact format
+    # used depends on the application name and its version as well as the
+    # -FileVersion property.
+    #
+    # There are 4 styles understood by this code and the patterns used for parsing
+    # the items within each are stored in a dictionary. Each dictionary is then
+    # stored in main dictionary keyed by an abbreviation for the style.
+    header_pattern_dicts = {
+        # BML - example
+        # ######## Neuralynx Data File Header
+        # ## File Name: null
+        # ## Time Opened: (m/d/y): 12/11/15  At Time: 11:37:39.000
+
+        # Cheetah after version 1 and before version 5 - example
+        # ######## Neuralynx Data File Header
+        # ## File Name F:\2000-01-01_18-28-39\RMH3.ncs
+        # ## Time Opened (m/d/y): 1/1/2000  (h:m:s.ms) 18:28:39.821
+        # ## Time Closed (m/d/y): 1/1/2000  (h:m:s.ms) 9:58:41.322
+
+        # Cheetah version 4.0.2 - example
+        # ######## Neuralynx Data File Header
+        # ## File Name: D:\Cheetah_Data\2003-10-4_10-2-58\CSC14.Ncs
+        # ## Time Opened: (m/d/y): 10/4/2003  At Time: 10:3:0.578
+
+        # Cheetah version 5.4.0 - example
+        # ######## Neuralynx Data File Header
+        # ## File Name C:\CheetahData\2000-01-01_00-00-00\CSC5.ncs
+        # ## Time Opened (m/d/y): 1/01/2001  At Time: 0:00:00.000
+        # ## Time Closed (m/d/y): 1/01/2001  At Time: 00:00:00.000
+
+        # Cheetah version 5.5.1 - example
+        # ######## Neuralynx Data File Header
+        # ## File Name C:\CheetahData\2013-11-29_17-05-05\Tet3a.ncs
+        # ## Time Opened (m/d/y): 11/29/2013  (h:m:s.ms) 17:5:16.793
+        # ## Time Closed (m/d/y): 11/29/2013  (h:m:s.ms) 18:3:13.603
+
+        # Cheetah version 5.6.0 - example
+        # ## File Name: F:\processing\sum-big-board\252-1375\recording-20180107\2018-01-07_15-14-54\04. tmaze1-no-light-start To tmaze1-light-stop\VT1_fixed.nvt
+        # ## Time Opened: (m/d/y): 2/5/2018 At Time: 18:5:12.654
+
+        # Cheetah version 5.6.3 - example
+        # ######## Neuralynx Data File Header
+        # ## File Name C:\CheetahData\2016-11-28_21-50-00\CSC1.ncs
+        # ## Time Opened (m/d/y): 11/28/2016  (h:m:s.ms) 21:50:33.322
+        # ## Time Closed (m/d/y): 11/28/2016  (h:m:s.ms) 22:44:41.145
+
+        # Cheetah version 5.7.4 - example
+        # ######## Neuralynx Data File Header
+        # and then properties
+        # -OriginalFileName "C:\CheetahData\2017-02-16_17-55-55\CSC1.ncs"
+        # -TimeCreated 2017/02/16 17:56:04
+        # -TimeClosed 2017/02/16 18:01:18
+
+        # Cheetah version 6.3.2 - example
+        # ######## Neuralynx Data File Header
+        # and then properties
+        # -OriginalFileName "G:\CheetahDataD\2019-07-12_13-21-32\CSC1.ncs"
+        # -TimeCreated 2019/07/12 13:21:32
+        # -TimeClosed 2019/07/12 15:07:55
+
+        # Cheetah version 6.4.1dev - example
+        # ######## Neuralynx Data File Header
+        # and then properties
+        # -OriginalFileName "D:\CheetahData\2021-02-26_15-46-33\CSC1.ncs"
+        # -TimeCreated 2021/02/26 15:46:52
+        # -TimeClosed 2021/10/12 09:07:58
+
+        # neuraview version 2 - example
+        # ######## Neuralynx Data File Header
+        # ## File Name: L:\McHugh Lab\Recording\2015-06-24_18-05-11\NeuraviewEventMarkers-20151214_SleepScore.nev
+        # ## Date Opened: (mm/dd/yyy): 12/14/2015 At Time: 15:58:32
+        # ## Date Closed: (mm/dd/yyy): 12/14/2015 At Time: 15:58:32
+        "neuraview2": dict(
+            datetime1_regex=r"## Date Opened: \(mm/dd/yyy\): (?P<date>\S+)" r" At Time: (?P<time>\S+)",
+            datetime2_regex=r"## Date Closed: \(mm/dd/yyy\): (?P<date>\S+)" r" At Time: (?P<time>\S+)",
+            datetimeformat="%m/%d/%Y %H:%M:%S",
+        ),
+        # pegasus version 2.1.1 and Cheetah beyond version 5.6.4 - example
+        # ######## Neuralynx Data File Header
+        # and then properties
+        # -OriginalFileName D:\Pegasus Data\Dr_NM\1902\2019-06-28_17-36-50\Events_0008.nev
+        # -TimeCreated 2019/06/28 17:36:50
+        # -TimeClosed 2019/06/28 17:45:48
+        "inProps": dict(
+            datetime1_regex=r"-TimeCreated (?P<date>\S+) (?P<time>\S+)",
+            datetime2_regex=r"-TimeClosed (?P<date>\S+) (?P<time>\S+)",
+            datetimeformat=r"%Y/%m/%d %H:%M:%S",
+            datetime2format=r"%Y/%m/%d %H:%M:%S.%f",
+        ),
+        # general version for date and time in ## header lines
+        "inHeader": dict(
+            datetime1_regex=r"## Time Opened: \(m/d/y\): (?P<date>\S+)" r"  At Time: (?P<time>\S+)",
+            datetimeformat="%m/%d/%y %H:%M:%S.%f",
+        ),
+        # version with time open and closed in ## header lines
+        "openClosedInHeader": dict(
+           datetime1_regex=r"## Time Opened \(m/d/y\): (?P<date>\S+)" r"  (\(h:m:s\.ms\)|At Time:) (?P<time>\S+)",
+           datetime2_regex=r"## Time Closed \(m/d/y\): (?P<date>\S+)" r"  (\(h:m:s\.ms\)|At Time:) (?P<time>\S+)",
+           datetimeformat="%m/%d/%Y %H:%M:%S.%f",
+        )
+    }
+
+    # regular expressions to match filename
+    filename_regex = [r"## File Name (?P<filename>\S+)",
+                       r'-OriginalFileName "?(?P<filename>\S+)"?']
+    
     def readTimeDate(self, txt_header):
         """
         Read time and date from text of header appropriate for app name and version
@@ -255,30 +321,31 @@ def readTimeDate(self, txt_header):
         if an == "Cheetah":
             av = self["ApplicationVersion"]
             if av <= Version("2"):  # version 1 uses same as older versions
-                hpd = NlxHeader.header_pattern_dicts["bv5.6.4"]
+                hpd = NlxHeader.header_pattern_dicts["openClosedInHeader"]
             elif av < Version("5"):
-                hpd = NlxHeader.header_pattern_dicts["bv5"]
+                hpd = NlxHeader.header_pattern_dicts["inHeader"]
             elif av <= Version("5.4.0"):
-                hpd = NlxHeader.header_pattern_dicts["v5.4.0"]
+                hpd = NlxHeader.header_pattern_dicts["openClosedInHeader"]
             elif av == Version("5.6.0"):
-                hpd = NlxHeader.header_pattern_dicts["v5.6.0"]
+                hpd = NlxHeader.header_pattern_dicts["inHeader"]
             elif av <= Version("5.6.4"):
-                hpd = NlxHeader.header_pattern_dicts["bv5.6.4"]
+                hpd = NlxHeader.header_pattern_dicts["openClosedInHeader"]
             else:
-                hpd = NlxHeader.header_pattern_dicts["def"]
+                hpd = NlxHeader.header_pattern_dicts["inProps"]
         elif an == "BML":
-            hpd = NlxHeader.header_pattern_dicts["bml"]
+            hpd = NlxHeader.header_pattern_dicts["inHeader"]
             av = Version("2")
         elif an == "Neuraview":
             hpd = NlxHeader.header_pattern_dicts["neuraview2"]
             av = Version("2")
         elif an == "Pegasus":
-            hpd = NlxHeader.header_pattern_dicts["peg"]
+            hpd = NlxHeader.header_pattern_dicts["inProps"]
             av = Version("2")
         else:
             an = "Unknown"
             av = "NA"
-            hpd = NlxHeader.header_pattern_dicts["def"]
+            hpd = NlxHeader.header_pattern_dicts["inProps"]
+
         # opening time
         sr = re.search(hpd["datetime1_regex"], txt_header)
         if not sr:
@@ -320,51 +387,50 @@ def type_of_recording(self):
         """
         Determines type of recording in Ncs file with this header.
 
-        RETURN:
-            one of 'PRE4','BML','DIGITALLYNX','DIGITALLYNXSX','UNKNOWN'
+        RETURN: NcsSections.AcqType
         """
 
         if "NLX_Base_Class_Type" in self:
 
             # older style standard neuralynx acquisition with rounded sampling frequency
             if self["NLX_Base_Class_Type"] == "CscAcqEnt":
-                return "PRE4"
+                return AcqType.PRE4
 
             # BML style with fractional frequency and microsPerSamp
             elif self["NLX_Base_Class_Type"] == "BmlAcq":
-                return "BML"
+                return AcqType.BML
 
             else:
-                return "UNKNOWN"
+                return AcqType.UNKNOWN
 
         elif "HardwareSubSystemType" in self:
 
             # DigitalLynx
             if self["HardwareSubSystemType"] == "DigitalLynx":
-                return "DIGITALLYNX"
+                return AcqType.DIGITALLYNX
 
             # DigitalLynxSX
             elif self["HardwareSubSystemType"] == "DigitalLynxSX":
-                return "DIGITALLYNXSX"
+                return AcqType.DIGITALLYNXSX
 
             # Cheetah64
             elif self["HardwareSubSystemType"] == "Cheetah64":
-                return "CHEETAH64"
+                return AcqType.CHEETAH64
 
             # RawDataFile
             elif self["HardwareSubSystemType"] == "RawDataFile":
-                return "RAWDATAFILE"
+                return AcqType.RAWDATAFILE
 
             else:
-                return "UNKNOWN"
+                return AcqType.UNKNOWN
 
         elif "FileType" in self:
 
             if "FileVersion" in self and self["FileVersion"] in ["3.2", "3.3", "3.4"]:
-                return self["AcquisitionSystem"].split()[1].upper()
+                return AcqType[self["AcquisitionSystem"].split()[1].upper()]
 
             else:
-                return "CHEETAH560"  # only known case of FileType without FileVersion
+                return AcqType.CHEETAH560  # only known case of FileType without FileVersion
 
         else:
-            return "UNKNOWN"
+            return AcqType.UNKNOWN
diff --git a/neo/test/rawiotest/test_neuralynxrawio.py b/neo/test/rawiotest/test_neuralynxrawio.py
index 297a27858..52f3b77f4 100644
--- a/neo/test/rawiotest/test_neuralynxrawio.py
+++ b/neo/test/rawiotest/test_neuralynxrawio.py
@@ -5,7 +5,7 @@
 
 from neo.rawio.neuralynxrawio.neuralynxrawio import NeuralynxRawIO
 from neo.rawio.neuralynxrawio.nlxheader import NlxHeader
-from neo.rawio.neuralynxrawio.ncssections import NcsSection, NcsSections, NcsSectionsFactory
+from neo.rawio.neuralynxrawio.ncssections import AcqType, NcsSection, NcsSections, NcsSectionsFactory
 from neo.test.rawiotest.common_rawio_test import BaseTestRawIO
 
 import logging
@@ -174,23 +174,23 @@ def test_exclude_filenames(self):
         self.assertEqual(len(rawio.header["event_channels"]), 0)
 
 
-class TestNcsRecordingType(TestNeuralynxRawIO, unittest.TestCase):
+class TestNcsRecordingType(BaseTestRawIO, unittest.TestCase):
     """
     Test of decoding of NlxHeader for type of recording.
     """
-
+    rawioclass = NeuralynxRawIO
     entities_to_test = []
 
     ncsTypeTestFiles = [
-        ("neuralynx/Cheetah_v4.0.2/original_data/CSC14_trunc.Ncs", "PRE4"),
-        ("neuralynx/Cheetah_v5.4.0/original_data/CSC5_trunc.Ncs", "DIGITALLYNX"),
-        ("neuralynx/Cheetah_v5.5.1/original_data/STet3a.nse", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v5.5.1/original_data/Tet3a.ncs", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v5.6.3/original_data/CSC1.ncs", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v5.6.3/original_data/TT1.ntt", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v5.7.4/original_data/CSC1.ncs", "DIGITALLYNXSX"),
-        ("neuralynx/Cheetah_v6.3.2/incomplete_blocks/CSC1_reduced.ncs", "DIGITALLYNXSX"),
-        ("neuralynx/Pegasus_v2.1.1/Events_0008.nev", "ATLAS"),
+        ("neuralynx/Cheetah_v4.0.2/original_data/CSC14_trunc.Ncs", AcqType.PRE4),
+        ("neuralynx/Cheetah_v5.4.0/original_data/CSC5_trunc.Ncs", AcqType.DIGITALLYNX),
+        ("neuralynx/Cheetah_v5.5.1/original_data/STet3a.nse", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v5.5.1/original_data/Tet3a.ncs", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v5.6.3/original_data/CSC1.ncs", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v5.6.3/original_data/TT1.ntt", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v5.7.4/original_data/CSC1.ncs", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Cheetah_v6.3.2/incomplete_blocks/CSC1_reduced.ncs", AcqType.DIGITALLYNXSX),
+        ("neuralynx/Pegasus_v2.1.1/Events_0008.nev", AcqType.ATLAS),
     ]
 
     def test_recording_types(self):
@@ -202,11 +202,11 @@ def test_recording_types(self):
             self.assertEqual(hdr.type_of_recording(), typeTest[1])
 
 
-class TestNcsSectionsFactory(TestNeuralynxRawIO, unittest.TestCase):
+class TestNcsSectionsFactory(BaseTestRawIO, unittest.TestCase):
     """
     Test building NcsBlocks for files of different revisions.
     """
-
+    rawioclass = NeuralynxRawIO
     entities_to_test = []
 
     def test_ncsblocks_partial(self):
@@ -323,11 +323,11 @@ def test_block_verify(self):
         self.assertTrue(NcsSectionsFactory._verifySectionsStructure(data1, nb1))
 
 
-class TestNcsSections(TestNeuralynxRawIO, unittest.TestCase):
+class TestNcsSections(BaseTestRawIO, unittest.TestCase):
     """
     Test building NcsBlocks for files of different revisions.
     """
-
+    rawioclass = NeuralynxRawIO
     entities_to_test = []
 
     def test_equality(self):
@@ -360,7 +360,9 @@ def test_equality(self):
         ns0.sampFreqUsed = 400
         self.assertNotEqual(ns0, ns1)
 
-class TestNlxHeader(TestNeuralynxRawIO, unittest.TestCase):
+class TestNlxHeader(BaseTestRawIO, unittest.TestCase):
+    rawioclass = NeuralynxRawIO
+
     def test_no_date_time(self):
         filename = self.get_local_path("neuralynx/NoDateHeader/NoDateHeader.nev")
 
@@ -375,12 +377,3 @@ def test_no_date_time(self):
 
 if __name__ == "__main__":
     unittest.main()
-
-    # test = TestNeuralynxRawIO()
-    # test.test_scan_ncs_files()
-    # test.test_exclude_filenames()
-    # test.test_include_filenames()
-
-    # test = TestNcsSectionsFactory()
-    # test.test_ncsblocks_partial()
-    # test.test_build_given_actual_frequency()