Index: Ringtoets/HydraRing/src/Ringtoets.HydraRing.IO/HydraulicBoundaryDatabase/HydraulicBoundaryDatabaseReader.cs
===================================================================
diff -u -r99e4d6ea2e8c5c2e542357abb2577dd2cd942abf -rcb70bb1b407efb3bb39788178054a0bcc3933c7f
--- Ringtoets/HydraRing/src/Ringtoets.HydraRing.IO/HydraulicBoundaryDatabase/HydraulicBoundaryDatabaseReader.cs	(.../HydraulicBoundaryDatabaseReader.cs)	(revision 99e4d6ea2e8c5c2e542357abb2577dd2cd942abf)
+++ Ringtoets/HydraRing/src/Ringtoets.HydraRing.IO/HydraulicBoundaryDatabase/HydraulicBoundaryDatabaseReader.cs	(.../HydraulicBoundaryDatabaseReader.cs)	(revision cb70bb1b407efb3bb39788178054a0bcc3933c7f)
@@ -100,17 +100,15 @@
         }
 
         /// <summary>
-        /// Gets the database version from the metadata table.
+        /// Gets the version of the hydraulic boundary database.
         /// </summary>
-        /// <returns>The version found in the database, or <see cref="string.Empty"/> if the version
-        /// cannot be found.</returns>
+        /// <returns>The version found in the database, or <see cref="string.Empty"/> if the version cannot be found.</returns>
         /// <exception cref="CriticalFileReadException">Thrown when a query could not be executed on the database schema.</exception>
         public string GetVersion()
         {
-            string versionQuery = HydraulicBoundaryDatabaseQueryBuilder.GetVersionQuery();
             try
             {
-                using (IDataReader dataReader = CreateDataReader(versionQuery, null))
+                using (IDataReader dataReader = CreateDataReader(HydraulicBoundaryDatabaseQueryBuilder.GetVersionQuery(), null))
                 {
                     return !dataReader.Read() ? string.Empty : Convert.ToString(dataReader[GeneralTableDefinitions.GeneratedVersion]);
                 }
@@ -123,23 +121,20 @@
         }
 
         /// <summary>
-        /// Gets the track id from the metadata table.
+        /// Gets the track id from the hydraulic boundary database.
         /// </summary>
-        /// <returns>The track id found in the database, or 0 if the track id
-        /// cannot be found.</returns>
-        /// <exception cref="InvalidCastException">Thrown when the database returned incorrect 
-        /// values for required properties.</exception>
+        /// <returns>The track id found in the database, or 0 if the track id cannot be found.</returns>
+        /// <exception cref="InvalidCastException">Thrown when the database contains incorrect values for required properties.</exception>
         /// <exception cref="CriticalFileReadException">Thrown when a query could not be executed on the database schema.</exception>
         public long GetTrackId()
         {
-            string trackQuery = HydraulicBoundaryDatabaseQueryBuilder.GetTrackIdQuery();
-            var sqliteParameter = new SQLiteParameter
-            {
-                DbType = DbType.String
-            };
             try
             {
-                using (IDataReader dataReader = CreateDataReader(trackQuery, sqliteParameter))
+                using (IDataReader dataReader = CreateDataReader(HydraulicBoundaryDatabaseQueryBuilder.GetTrackIdQuery(),
+                                                                 new SQLiteParameter
+                                                                 {
+                                                                     DbType = DbType.String
+                                                                 }))
                 {
                     return !dataReader.Read() ? 0 : Convert.ToInt64(dataReader[GeneralTableDefinitions.TrackId]);
                 }
@@ -157,21 +152,19 @@
         }
 
         /// <summary>
-        /// Gets the amount of locations that can be read from the database.
+        /// Gets the amount of locations that can be read from the hydraulic boundary database.
         /// </summary>
-        /// <returns>The amount of locations that can be read.</returns>
+        /// <returns>The amount of locations that can be read, or 0 if no locations could be found.</returns>
         /// <exception cref="CriticalFileReadException">Thrown when a query could not be executed on the database schema.</exception>
         public int GetLocationCount()
         {
-            string locationCountQuery = HydraulicBoundaryDatabaseQueryBuilder.GetRelevantLocationsCountQuery();
-            var sqliteParameter = new SQLiteParameter
-            {
-                DbType = DbType.String
-            };
-
             try
             {
-                using (IDataReader dataReader = CreateDataReader(locationCountQuery, sqliteParameter))
+                using (IDataReader dataReader = CreateDataReader(HydraulicBoundaryDatabaseQueryBuilder.GetRelevantLocationsCountQuery(),
+                                                                 new SQLiteParameter
+                                                                 {
+                                                                     DbType = DbType.String
+                                                                 }))
                 {
                     return !dataReader.Read() ? 0 : Convert.ToInt32(dataReader[HrdLocationsTableDefinitions.Count]);
                 }
Index: Ringtoets/HydraRing/test/Ringtoets.HydraRing.IO.Test/HydraulicBoundaryDatabase/HydraulicBoundaryDatabaseReaderTest.cs
===================================================================
diff -u -r99e4d6ea2e8c5c2e542357abb2577dd2cd942abf -rcb70bb1b407efb3bb39788178054a0bcc3933c7f
--- Ringtoets/HydraRing/test/Ringtoets.HydraRing.IO.Test/HydraulicBoundaryDatabase/HydraulicBoundaryDatabaseReaderTest.cs	(.../HydraulicBoundaryDatabaseReaderTest.cs)	(revision 99e4d6ea2e8c5c2e542357abb2577dd2cd942abf)
+++ Ringtoets/HydraRing/test/Ringtoets.HydraRing.IO.Test/HydraulicBoundaryDatabase/HydraulicBoundaryDatabaseReaderTest.cs	(.../HydraulicBoundaryDatabaseReaderTest.cs)	(revision cb70bb1b407efb3bb39788178054a0bcc3933c7f)
@@ -42,227 +42,183 @@
         public void Constructor_NonExistingPath_ThrowsCriticalFileReadException()
         {
             // Setup
-            string testFile = Path.Combine(testDataPath, "none.sqlite");
-            string expectedMessage = new FileReaderErrorMessageBuilder(testFile).Build("Het bestand bestaat niet.");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "doesNotExist.sqlite");
 
             // Call
-            TestDelegate test = () => new HydraulicBoundaryDatabaseReader(testFile).Dispose();
+            TestDelegate test = () =>
+            {
+                using (new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile)) {}
+            };
 
             // Assert
             var exception = Assert.Throws<CriticalFileReadException>(test);
+            string expectedMessage = new FileReaderErrorMessageBuilder(hydraulicBoundaryDatabaseFile).Build("Het bestand bestaat niet.");
             Assert.AreEqual(expectedMessage, exception.Message);
         }
 
         [Test]
         [TestCase(null)]
         [TestCase("")]
-        public void Constructor_FileNullOrEmpty_ThrowsCriticalFileReadException(string fileName)
+        public void Constructor_FileNullOrEmpty_ThrowsCriticalFileReadException(string hydraulicBoundaryDatabaseFile)
         {
-            // Setup
-            string expectedMessage = $"Fout bij het lezen van bestand '{fileName}': bestandspad mag niet leeg of ongedefinieerd zijn.";
-
             // Call
-            TestDelegate test = () => new HydraulicBoundaryDatabaseReader(fileName).Dispose();
+            TestDelegate test = () =>
+            {
+                using (new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile)) {}
+            };
 
             // Assert
             var exception = Assert.Throws<CriticalFileReadException>(test);
+            string expectedMessage = $"Fout bij het lezen van bestand '{hydraulicBoundaryDatabaseFile}': bestandspad mag niet leeg of ongedefinieerd zijn.";
             Assert.AreEqual(expectedMessage, exception.Message);
         }
 
         [Test]
-        public void GetVersion_InvalidColumns_DoesNotThrowException()
+        public void Constructor_ValidFile_ExpectedValues()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "corruptschema.sqlite");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "complete.sqlite");
 
-            // Precondition
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile), "Precondition: file can be opened for edits.");
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            // Call
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
-                var version = "some version";
-                // Call
-                TestDelegate test = () => version = hydraulicBoundaryDatabaseReader.GetVersion();
-
                 // Assert
-                Assert.DoesNotThrow(test);
-                const string expectedVersion = "Namedate7";
-                Assert.AreEqual(expectedVersion, version);
+                Assert.IsFalse(hydraulicBoundaryDatabaseReader.HasNext);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
         public void GetVersion_EmptyDatabase_ThrowsCriticalFileReadException()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "empty.sqlite");
-            string expectedException = new FileReaderErrorMessageBuilder(dbFile).Build("Kon geen locaties verkrijgen van de database.");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "empty.sqlite");
 
-            // Precondition
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile), "Precondition: file can be opened for edits.");
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Call
                 TestDelegate test = () => hydraulicBoundaryDatabaseReader.GetVersion();
 
                 // Assert
                 var exception = Assert.Throws<CriticalFileReadException>(test);
+                string expectedException = new FileReaderErrorMessageBuilder(hydraulicBoundaryDatabaseFile).Build("Kon geen locaties verkrijgen van de database.");
                 Assert.AreEqual(expectedException, exception.Message);
                 Assert.IsInstanceOf<SQLiteException>(exception.InnerException);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
-        public void Constructor_ValidFile_ExpectedValues()
+        public void GetVersion_ValidFile_ExpectedValues()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "complete.sqlite");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "complete.sqlite");
 
-            // Call
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
-                // Assert
-                Assert.IsFalse(hydraulicBoundaryDatabaseReader.HasNext);
-            }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
-        }
-
-        [Test]
-        public void GetLocationCount_ValidFile_ExpectedValues()
-        {
-            // Setup
-            const int expectedNrOfLocations = 18;
-            string dbFile = Path.Combine(testDataPath, "complete.sqlite");
-
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
-            {
                 // Call
-                int nrOfLocations = hydraulicBoundaryDatabaseReader.GetLocationCount();
+                string version = hydraulicBoundaryDatabaseReader.GetVersion();
 
                 // Assert
-                Assert.AreEqual(expectedNrOfLocations, nrOfLocations);
-                Assert.IsFalse(hydraulicBoundaryDatabaseReader.HasNext);
+                Assert.AreEqual("Dutch coast South19-11-2015 12:0013", version);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
-        public void GetLocationCount_EmptyDatabase_ThrowsCriticalFileReadException()
+        public void GetTrackId_EmptyDatabase_ThrowsCriticalFileReadException()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "empty.sqlite");
-            string expectedException = new FileReaderErrorMessageBuilder(dbFile).Build("Kon geen locaties verkrijgen van de database.");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "empty.sqlite");
 
-            // Precondition
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile), "Precondition: file can be opened for edits.");
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Call
-                TestDelegate test = () => hydraulicBoundaryDatabaseReader.GetLocationCount();
+                TestDelegate test = () => hydraulicBoundaryDatabaseReader.GetTrackId();
 
                 // Assert
                 var exception = Assert.Throws<CriticalFileReadException>(test);
+                string expectedException = new FileReaderErrorMessageBuilder(hydraulicBoundaryDatabaseFile).Build("Kon geen locaties verkrijgen van de database.");
                 Assert.AreEqual(expectedException, exception.Message);
                 Assert.IsInstanceOf<SQLiteException>(exception.InnerException);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
-        public void GetVersion_ValidFile_ExpectedValues()
+        public void GetTrackId_InvalidColumns_ThrowsLineParseException()
         {
             // Setup
-            const string expectedVersion = "Dutch coast South19-11-2015 12:0013";
-            string dbFile = Path.Combine(testDataPath, "complete.sqlite");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "corruptschema.sqlite");
 
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Call
-                string version = hydraulicBoundaryDatabaseReader.GetVersion();
+                TestDelegate test = () => hydraulicBoundaryDatabaseReader.GetTrackId();
 
                 // Assert
-                Assert.AreEqual(expectedVersion, version);
-                Assert.IsFalse(hydraulicBoundaryDatabaseReader.HasNext);
+                var exception = Assert.Throws<LineParseException>(test);
+                string expectedMessage = new FileReaderErrorMessageBuilder(hydraulicBoundaryDatabaseFile).Build("Kritieke fout opgetreden bij het uitlezen van waardes uit kolommen in de database.");
+                Assert.AreEqual(expectedMessage, exception.Message);
+                Assert.IsInstanceOf<InvalidCastException>(exception.InnerException);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
         public void GetTrackId_ValidFile_ExpectedValues()
         {
             // Setup
-            const long expectedTrackId = 13;
-            string dbFile = Path.Combine(testDataPath, "complete.sqlite");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "complete.sqlite");
 
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Call
                 long trackId = hydraulicBoundaryDatabaseReader.GetTrackId();
 
                 // Assert
-                Assert.AreEqual(expectedTrackId, trackId);
-                Assert.IsFalse(hydraulicBoundaryDatabaseReader.HasNext);
+                Assert.AreEqual((long) 13, trackId);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
-        public void GetTrackId_EmptyDatabase_ThrowsCriticalFileReadException()
+        public void GetLocationCount_EmptyDatabase_ThrowsCriticalFileReadException()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "empty.sqlite");
-            string expectedException = new FileReaderErrorMessageBuilder(dbFile).Build("Kon geen locaties verkrijgen van de database.");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "empty.sqlite");
 
-            // Precondition
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile), "Precondition: file can be opened for edits.");
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Call
-                TestDelegate test = () => hydraulicBoundaryDatabaseReader.GetTrackId();
+                TestDelegate test = () => hydraulicBoundaryDatabaseReader.GetLocationCount();
 
                 // Assert
                 var exception = Assert.Throws<CriticalFileReadException>(test);
+                string expectedException = new FileReaderErrorMessageBuilder(hydraulicBoundaryDatabaseFile).Build("Kon geen locaties verkrijgen van de database.");
                 Assert.AreEqual(expectedException, exception.Message);
                 Assert.IsInstanceOf<SQLiteException>(exception.InnerException);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
-        public void GetTrackId_InvalidColumns_ThrowsLineParseException()
+        public void GetLocationCount_ValidFile_ExpectedValues()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "corruptschema.sqlite");
-            string expectedMessage = new FileReaderErrorMessageBuilder(dbFile).Build("Kritieke fout opgetreden bij het uitlezen van waardes uit kolommen in de database.");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "complete.sqlite");
 
-            // Precondition
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile), "Precondition: file can be opened for edits.");
-
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Call
-                TestDelegate test = () => hydraulicBoundaryDatabaseReader.GetTrackId();
+                int nrOfLocations = hydraulicBoundaryDatabaseReader.GetLocationCount();
 
                 // Assert
-                var exception = Assert.Throws<LineParseException>(test);
-                Assert.AreEqual(expectedMessage, exception.Message);
-                Assert.IsInstanceOf<InvalidCastException>(exception.InnerException);
+                Assert.AreEqual(18, nrOfLocations);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
         public void ReadLocation_InvalidColumns_ThrowsLineParseException()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "corruptschema.sqlite");
-            string expectedMessage = new FileReaderErrorMessageBuilder(dbFile).Build("Kritieke fout opgetreden bij het uitlezen van waardes uit kolommen in de database.");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "corruptschema.sqlite");
+            string expectedMessage = new FileReaderErrorMessageBuilder(hydraulicBoundaryDatabaseFile).Build("Kritieke fout opgetreden bij het uitlezen van waardes uit kolommen in de database.");
 
-            // Precondition
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile), "Precondition: file can be opened for edits.");
-
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Call
                 hydraulicBoundaryDatabaseReader.PrepareReadLocation();
@@ -273,16 +229,15 @@
                 Assert.AreEqual(expectedMessage, exception.Message);
                 Assert.IsInstanceOf<ConversionException>(exception.InnerException);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
         public void ReadLocation_ValidFileReadOneLocation_ExpectedValues()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "complete.sqlite");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "complete.sqlite");
 
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Call
                 hydraulicBoundaryDatabaseReader.PrepareReadLocation();
@@ -291,19 +246,18 @@
                 // Assert
                 Assert.IsNotNull(location);
             }
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
         public void ReadLocation_ValidFilereadAllLocations_ExpectedValues()
         {
             // Setup
             const int nrOfLocations = 18;
-            string dbFile = Path.Combine(testDataPath, "complete.sqlite");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "complete.sqlite");
             var boundaryLocations = new List<ReadHydraulicBoundaryLocation>();
             CollectionAssert.IsEmpty(boundaryLocations);
 
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Call
                 hydraulicBoundaryDatabaseReader.PrepareReadLocation();
@@ -318,20 +272,19 @@
             }
 
             CollectionAssert.AllItemsAreInstancesOfType(boundaryLocations, typeof(ReadHydraulicBoundaryLocation));
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
         }
 
         [Test]
         public void ParameteredConstructor_PathToExistingFile_ExpectedValues()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "emptyschema.sqlite");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "emptyschema.sqlite");
 
             // Call
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Assert
-                Assert.AreEqual(dbFile, hydraulicBoundaryDatabaseReader.Path);
+                Assert.AreEqual(hydraulicBoundaryDatabaseFile, hydraulicBoundaryDatabaseReader.Path);
                 Assert.IsInstanceOf<SqLiteDatabaseReaderBase>(hydraulicBoundaryDatabaseReader);
             }
         }
@@ -340,10 +293,10 @@
         public void Constructor_EmptyDatabase_HasNextFalse()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "emptyschema.sqlite");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "emptyschema.sqlite");
 
             // Call
-            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile))
+            using (var hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile))
             {
                 // Assert
                 Assert.IsFalse(hydraulicBoundaryDatabaseReader.HasNext);
@@ -354,28 +307,28 @@
         public void Dispose_AfterConstruction_CorrectlyReleasesFile()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "complete.sqlite");
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile), "Precondition failed: The file should be writable to begin with.");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "complete.sqlite");
+            Assert.IsTrue(TestHelper.CanOpenFileForWrite(hydraulicBoundaryDatabaseFile), "Precondition failed: The file should be writable to begin with.");
 
             // Call
-            new HydraulicBoundaryDatabaseReader(dbFile).Dispose();
+            new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile).Dispose();
 
             // Assert
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
+            Assert.IsTrue(TestHelper.CanOpenFileForWrite(hydraulicBoundaryDatabaseFile));
         }
 
         [Test]
         public void Dispose_WhenReadLocation_CorrectlyReleasesFile()
         {
             // Setup
-            string dbFile = Path.Combine(testDataPath, "complete.sqlite");
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile), "Precondition failed: The file should be writable to begin with.");
+            string hydraulicBoundaryDatabaseFile = Path.Combine(testDataPath, "complete.sqlite");
+            Assert.IsTrue(TestHelper.CanOpenFileForWrite(hydraulicBoundaryDatabaseFile), "Precondition failed: The file should be writable to begin with.");
 
             HydraulicBoundaryDatabaseReader hydraulicBoundaryDatabaseReader = null;
             ReadHydraulicBoundaryLocation boundaryLocation;
             try
             {
-                hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(dbFile);
+                hydraulicBoundaryDatabaseReader = new HydraulicBoundaryDatabaseReader(hydraulicBoundaryDatabaseFile);
                 hydraulicBoundaryDatabaseReader.PrepareReadLocation();
                 boundaryLocation = hydraulicBoundaryDatabaseReader.ReadLocation();
             }
@@ -387,7 +340,7 @@
 
             // Assert
             Assert.NotNull(boundaryLocation);
-            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
+            Assert.IsTrue(TestHelper.CanOpenFileForWrite(hydraulicBoundaryDatabaseFile));
         }
     }
 }
\ No newline at end of file