Exemplo n.º 1
0
        public void GivenReadSoilProfileThrowsException_WhenReadingNextProfile_ReturnsNextProfile()
        {
            // Given
            string dbFile = Path.Combine(testDataPath, "1dprofileWithInvalidLayerProperty.soil");

            SoilProfileReadException exception = null;
            var readSoilProfiles = new List <SoilProfile1D>();

            using (var reader = new SoilProfile1DReader(dbFile))
            {
                reader.Initialize();

                // When
                try
                {
                    reader.ReadSoilProfile();
                }
                catch (SoilProfileReadException e)
                {
                    exception = e;
                }

                // Then
                readSoilProfiles.Add(reader.ReadSoilProfile());
            }

            Assert.IsInstanceOf <SoilProfileReadException>(exception);
            Assert.AreEqual("Profile", exception.ProfileName);
            Assert.AreEqual(1, readSoilProfiles.Count);
            Assert.AreEqual("Profile2", readSoilProfiles[0].Name);

            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
        }
Exemplo n.º 2
0
        public void GivenDatabaseWithSoilProfilesAndPreconsolidationStresses_WhenReadingPreconsolidationStressesFails_ThenThrowsSoilProfileReadExceptionAndCanContinueReading()
        {
            // Given
            string dbFile = Path.Combine(testDataPath, "2dProfilesWithAndWithoutPreconsolidationStressesUnparsableValues.soil");

            var readProfiles = new List <SoilProfile2D>();
            SoilProfileReadException expectedException = null;

            using (var reader = new SoilProfile2DReader(dbFile))
            {
                reader.Initialize();

                while (reader.HasNext)
                {
                    // When
                    try
                    {
                        readProfiles.Add(reader.ReadSoilProfile());
                    }
                    catch (SoilProfileReadException e)
                    {
                        expectedException = e;
                    }
                }

                // Then
                Assert.IsFalse(reader.HasNext);
                Assert.AreEqual(2, readProfiles.Count);
            }

            Assert.IsNotNull(expectedException);
            Assert.AreEqual("InvalidPreconsolidationStress1", expectedException.ProfileName);

            CollectionAssert.AreEqual(new[]
            {
                "Profile_1",
                "Profile_2"
            }, readProfiles.Select(profile => profile.Name));
            CollectionAssert.AreEqual(new[]
            {
                3,
                3
            }, readProfiles.Select(profile => profile.Layers.Count()));
            CollectionAssert.AreEqual(new[]
            {
                1,
                1
            }, readProfiles.Select(profile => profile.PreconsolidationStresses.Count()));

            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
        }
Exemplo n.º 3
0
        public void GivenDatabaseWithThreeProfilesWithPreconsolidationStresses_WhenReadingPreconsolidationStressesFails_ThenThrowsSoilProfileReadExceptionAndCanContinueReading()
        {
            // Given
            string dbFile = Path.Combine(testDataPath, "2dprofileWithPreconsolidationStressesAndUnparsableValues.soil");

            SoilProfileReadException actualException = null;
            var readStresses = new List <PreconsolidationStress>();

            using (var reader = new PreconsolidationStressReader(dbFile))
            {
                reader.Initialize();

                while (reader.HasNext)
                {
                    try
                    {
                        // When
                        readStresses.AddRange(reader.ReadPreconsolidationStresses());
                    }
                    catch (SoilProfileReadException e)
                    {
                        actualException = e;
                    }
                }

                // Then
                Assert.IsFalse(reader.HasNext);
            }

            Assert.IsNotNull(actualException);
            Assert.AreEqual("Profile_1", actualException.ProfileName);

            CollectionAssert.AreEqual(new[]
            {
                2,
                3
            }, readStresses.Select(stress => stress.XCoordinate));
            CollectionAssert.AreEqual(new[]
            {
                2,
                3
            }, readStresses.Select(stress => stress.ZCoordinate));

            CollectionAssert.AreEqual(new[]
            {
                3,
                3
            }, readStresses.Select(stress => stress.StressDistributionType));
            CollectionAssert.AreEqual(new[]
            {
                2,
                3
            }, readStresses.Select(stress => stress.StressMean));
            CollectionAssert.AreEqual(new[]
            {
                1,
                1
            }, readStresses.Select(stress => stress.StressCoefficientOfVariation));
            CollectionAssert.AreEqual(new[]
            {
                0,
                0
            }, readStresses.Select(stress => stress.StressShift));

            Assert.IsTrue(TestHelper.CanOpenFileForWrite(dbFile));
        }