// Copyright (C) Stichting Deltares 2019. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System.Collections.Generic;
using System.Data;
using Deltares.DamEngine.Calculators.KernelWrappers.Common;
using Deltares.DamEngine.Calculators.KernelWrappers.DamPipingSellmeijer4Forces;
using Deltares.DamEngine.Calculators.KernelWrappers.Interfaces;
using Deltares.DamEngine.Calculators.KernelWrappers.WtiPipingSellmeijerRevised;
using Deltares.DamEngine.Data.Design;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.Results;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamEngine.TestHelpers.Factories;
using Deltares.WTIPiping;
using NUnit.Framework;

namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.WtiPipingSellmeijerRevised
{
    [TestFixture]
    public class WtiPipingSellmeijerRevisedKernelWrapperTests
    {
        [TestCase(0, 49.5, 1860.9050036726026, 1302.9335025708217, 1302.6335025708217, 0.037999943884683543)]
        [TestCase(10, 59.5, 2196.3999536424808, 1537.7799675497363, 1537.4799675497363, 0.038699691219277771)]
        [TestCase(-10, 39.5, 1519.6869237263827, 1064.0808466084677, 1063.7808466084678, 0.037131708214086942)]
        public void TestFullCalculation(double distanceToEntryPoint, double expectedSeepageLength, double expectedFoSbe, double expectedHcbe, 
            double expectedDeltaPhiCbe, double expectedCcreep)
        {
            // expected results are based on test in Sellmeijer2011CalculatorTests, CalculateTestValues
            // as performed in the Wti kernel itself.
            
            const double diff = 0.0001;

            var location = new Location("Location 1")
            {
                DistanceToEntryPoint = distanceToEntryPoint,
                SurfaceLine = FactoryForSurfaceLines.CreateSurfaceLineForWtiPiping(),
                ModelFactors =
                {
                    UpliftCriterionPiping = 1.0
                },
                ModelParametersForPlLines =
                {
                    DampingFactorPl3 = 0.25,
                    DampingFactorPl4 = 0.10
                }
            };
            location.Scenarios.Add(new DesignScenario());
            var designScenario = new DesignScenario
            {
                LocationScenarioID = "1",
                Location = location,
            };

            var subSoilScenario = new SoilGeometryProbability
            {
                SoilProfile1D = FactoryForSoilProfiles.CreatePipingSellmeijerProfileWithOneSandlayer(),
                SegmentFailureMechanismType = SegmentFailureMechanismType.Piping
            };
            var damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification()
            {
                FailureMechanismSystemType = FailureMechanismSystemType.Piping,
                PipingModelType = PipingModelType.Wti2017
            };
            var damKernelInput = new DamKernelInput
            {
                Location = location,
                SubSoilScenario = subSoilScenario,
                RiverLevelHigh = 1.0,
                DamFailureMechanismeCalculationSpecification = damFailureMechanismeCalculationSpecification
            };

            var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();

            // Prepare the wrapper. Result is input for the calculation dll
            IKernelDataInput damPipingInput;
            IKernelDataOutput kernelDataOutput;
            kernelWrapper.Prepare(damKernelInput, 0, out damPipingInput, out kernelDataOutput);

            // The factory used here in the Engine to create the soilprofile uses Physics.FactorMicroMeterToMeter in setting the D70.
            // The original test in WTI piping kernel uses the D70 without this factor so in order to get the same results here, 
            // correct the D70 for this here.
            (damPipingInput as WtiPipingSellmeijerRevisedInput).D70 = (damPipingInput as WtiPipingSellmeijerRevisedInput).D70 * (1/Physics.FactorMicroMeterToMeter);

            // Validate the input
            List<LogMessage> messages;
            kernelWrapper.Validate(damPipingInput, kernelDataOutput, out messages);
            Assert.AreEqual(0, messages.Count);

            // Run the dll. All expected results are from calculation by hand.
            kernelWrapper.Execute(damPipingInput, kernelDataOutput, out messages);
            var damPipingOutput = (WtiPipingSellmeijerRevisedOutput)kernelDataOutput;
            Assert.AreEqual(0, messages.Count);
            Assert.AreEqual(expectedFoSbe, damPipingOutput.FoSbe, diff);
            Assert.AreEqual(expectedHcbe, damPipingOutput.Hcbe, diff);
            Assert.AreEqual(expectedDeltaPhiCbe, damPipingOutput.DeltaPhiCbe, diff);
            Assert.AreEqual(0.56948691811077123, damPipingOutput.FoSu, diff);
            Assert.AreEqual(0.56948691811077123, damPipingOutput.Hcu, diff);
            Assert.AreEqual(0.4271151885830784, damPipingOutput.DeltaPhiCu, diff);
            Assert.AreEqual(4.19, damPipingOutput.EffectiveStress, diff);
            Assert.AreEqual(expectedSeepageLength, damPipingOutput.SeepageLength, diff);

            // Fill the design results
            List<DesignResult> results;
            kernelWrapper.PostProcess(damKernelInput, damPipingOutput, designScenario, "", out results);
            foreach (var result in results)
            {
                Assert.AreEqual(FailureMechanismSystemType.Piping, result.DamFailureMechanismeCalculation.FailureMechanismSystemType);
                Assert.AreEqual(PipingModelType.Wti2017, result.DamFailureMechanismeCalculation.PipingModelType);
                Assert.IsNotNullOrEmpty(result.LocationName);
                Assert.IsNotNullOrEmpty(result.ScenarioName);
                Assert.IsNotNullOrEmpty(result.ProfileName);
                Assert.AreEqual(90, result.PipingDesignResults.Wti2017BackwardErosionSafetyFactor, diff);
                Assert.AreEqual(expectedHcbe, result.PipingDesignResults.Wti2017BackwardErosionHcritical, diff);
                Assert.AreEqual(expectedDeltaPhiCbe, result.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC, diff);
                Assert.AreEqual(0.70, result.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced, diff);
                Assert.AreEqual(0.56948691811077123, result.PipingDesignResults.Wti2017UpliftSafetyFactor, diff);
                Assert.AreEqual(0.56948691811077123, result.PipingDesignResults.Wti2017UpliftHcritical, diff);
                Assert.AreEqual(0.4271151885830784, result.PipingDesignResults.Wti2017UpliftDeltaPhiC, diff);
                Assert.AreEqual(0.40, result.PipingDesignResults.Wti2017HeaveSafetyFactor, diff);
                Assert.AreEqual(0.40, result.PipingDesignResults.Wti2017HeaveHcritical, diff);
                Assert.AreEqual(0.75, result.PipingDesignResults.Wti2017Gradient, diff);
                Assert.AreEqual(4.19, result.PipingDesignResults.EffectiveStress, diff);
                Assert.AreEqual(expectedCcreep, result.PipingDesignResults.CCreep, diff);

                Assert.AreEqual(90, result.PipingDesignResults.Wti2017SafetyFactorOverall, diff);
                Assert.AreEqual(expectedHcbe, result.PipingDesignResults.Wti2017HcriticalOverall, diff);

                Assert.AreEqual(59.5, result.PipingDesignResults.LocalExitPointX);
                Assert.AreEqual(0.88258734130293759, result.PipingDesignResults.UpliftFactor);
                Assert.AreEqual(true, result.PipingDesignResults.UpliftSituation != null && ((UpliftSituation)result.PipingDesignResults.UpliftSituation).IsUplift);
                Assert.AreEqual(CalculationResult.Succeeded, result.CalculationResult);

                Assert.AreEqual(location.SurfaceLine, result.PipingDesignResults.RedesignedSurfaceLine);
            }
        }

        [TestCase(0, 49.5)]
        [TestCase(10, 59.5)]
        [TestCase(-10, 39.5)]
        public void TestPrepareWithInfluenceOfDistanceToEntryPoint(double distanceToEnrtyPoint, double expectedSeepageLength)
        {
            const double diff = 0.0001;

            var location = new Location
            {
                DistanceToEntryPoint = distanceToEnrtyPoint,
                SurfaceLine = FactoryForSurfaceLines.CreateSurfaceLineForWtiPiping(),
                ModelFactors =
                {
                    UpliftCriterionPiping = 1.0
                },
                ModelParametersForPlLines =
                {
                    DampingFactorPl3 = 0.25,
                    DampingFactorPl4 = 0.10
                }
            };
            location.Scenarios.Add(new DesignScenario());
            var subSoilScenario = new SoilGeometryProbability
            {
                SoilProfile1D = FactoryForSoilProfiles.CreatePipingSellmeijerProfileWithOneSandlayer(),
                SegmentFailureMechanismType = SegmentFailureMechanismType.Piping
            };
            var damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification()
            {
                FailureMechanismSystemType = FailureMechanismSystemType.Piping,
                PipingModelType = PipingModelType.Wti2017
            };
            
            var damKernelInput = new DamKernelInput
            {
                Location = location,
                SubSoilScenario = subSoilScenario,
                RiverLevelHigh = 1.0,
                DamFailureMechanismeCalculationSpecification = damFailureMechanismeCalculationSpecification
            };
            var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
            IKernelDataInput kernelDataInput;
            IKernelDataOutput kernelDataOutput;
            kernelWrapper.Prepare(damKernelInput, 0, out kernelDataInput, out kernelDataOutput);
            var damPipingInput = (WtiPipingSellmeijerRevisedInput)kernelDataInput;
            var damPipingOutput = (WtiPipingSellmeijerRevisedOutput)kernelDataOutput;
            Assert.AreEqual(1.0, damPipingInput.HRiver, diff);
            Assert.AreEqual(0.0, damPipingInput.HExit, diff);
            Assert.AreEqual(0.3, damPipingInput.Rc, diff);
            Assert.AreEqual(1.0, damPipingInput.DTotal, diff);
            Assert.AreEqual(8.0, damPipingInput.DAquifer, diff);
            Assert.AreEqual(expectedSeepageLength, damPipingInput.SeepageLength, diff);
            Assert.AreEqual(0.000200, damPipingInput.D70, diff);
            Assert.AreEqual(0.25, damPipingInput.WhitesDragCoefficient, diff);
            Assert.AreEqual(37.0, damPipingInput.BeddingAngle, diff);
            Assert.AreEqual(1.33E-06, damPipingInput.KinematicViscosityWater, diff);
            Assert.AreEqual(0.0001, damPipingInput.DarcyPermeability, diff);
            Assert.AreEqual(1.000, damPipingInput.ModelFactorUplift, diff);
            Assert.AreEqual(4.19, damPipingInput.EffectiveStress, diff);
            Assert.AreEqual(0.75, damPipingInput.PhiExit, diff);
            Assert.AreEqual(0.75, damPipingInput.RExit, diff);
            Assert.AreEqual(0.00, damPipingInput.PhiPolder, diff);
            // All expected results are from calculation by hand.
            Assert.AreEqual(4.19, damPipingOutput.EffectiveStress, diff);
            Assert.AreEqual(59.50, damPipingOutput.ExitPointX, diff);
            Assert.AreEqual(0.88258734130293759, damPipingOutput.UpliftFactor, diff);
            Assert.AreEqual(true, damPipingOutput.UpliftSituation.IsUplift);            
        }

        [Test]
        public void TestValidate()
        {
            var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();

            // Validate without setting values. Expected error messages.
            var damPipingInput = new WtiPipingSellmeijerRevisedInput();
            var damPipingOutput = new WtiPipingSellmeijerRevisedOutput();
            List<LogMessage> messages;
            kernelWrapper.Validate(damPipingInput, damPipingOutput, out messages);
            Assert.IsTrue(messages.Count > 0);

            // Validate the input when valid input is provided. Expected no messages.
            damPipingInput = new WtiPipingSellmeijerRevisedInput()
            {
                HRiver = 1.0,
                HExit = 0.0,
                Rc = 0.3,
                DTotal = 2.0,
                DAquifer = 8.0,
                SeepageLength = 40.5,
                D70 = 200.0,
                WhitesDragCoefficient = 0.25,
                BeddingAngle = 37.0,
                KinematicViscosityWater = 1.33E-06,
                DarcyPermeability = 0.0001,
                RExit = 0.25
            };
            messages.Clear();
            kernelWrapper.Validate(damPipingInput, damPipingOutput, out messages);
            Assert.AreEqual(0, messages.Count);
        }

        [Test]
        public void TestPostProcess()
        {
            var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();

            var subSoilScenario = new SoilGeometryProbability
            {
                SoilProfile1D = FactoryForSoilProfiles.CreatePipingSellmeijerProfileWithOneSandlayer(),
                SegmentFailureMechanismType = SegmentFailureMechanismType.Piping
            };
            var damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification()
            {
                FailureMechanismSystemType = FailureMechanismSystemType.Piping,
                PipingModelType = PipingModelType.Wti2017
            };
            var input = new DamKernelInput
            {
                Location = new Location(),
                SubSoilScenario = subSoilScenario,
                DamFailureMechanismeCalculationSpecification = damFailureMechanismeCalculationSpecification
            };
            input.Location = new Location();
            input.Location.Scenarios.Add(new DesignScenario());
            var upliftSituation = new UpliftSituation
            {
                IsUplift = true
            };
            var calculationResult = CalculationResult.Succeeded;
            var output = new WtiPipingSellmeijerRevisedOutput()
            {
                SeepageLength = 30,
                FoSbe = 1.1,
                Hcbe = 2.2,
                DeltaPhiCbe = 1.3,
                DeltaPhibe = 11.3,
                ExitPointX = 3.3,
                UpliftFactor = 4.4,
                UpliftSituation = upliftSituation,
                CalculationResult = calculationResult,
                FoSu = 5.5,
                Hcu = 6.6,
                DeltaPhiCu = 7.7,
                FoSh = 3.4,
                Hch = 11.1,
                Gradient = 1.11,
                EffectiveStress = 321.21
            };

            var designScenario = new DesignScenario
            {
                Location = input.Location
            };
            List<DesignResult> results;
            kernelWrapper.PostProcess(input, output, designScenario, "", out results);
            foreach (var result in results)
            {
                Assert.AreEqual(output.FoSbe, result.PipingDesignResults.Wti2017BackwardErosionSafetyFactor);
                Assert.AreEqual(output.Hcbe, result.PipingDesignResults.Wti2017BackwardErosionHcritical);
                Assert.AreEqual(output.DeltaPhiCbe, result.PipingDesignResults.Wti2017BackwardErosionDeltaPhiC);
                Assert.AreEqual(output.DeltaPhibe, result.PipingDesignResults.Wti2017BackwardErosionDeltaPhiReduced);
                Assert.AreEqual(output.FoSu, result.PipingDesignResults.Wti2017UpliftSafetyFactor);
                Assert.AreEqual(output.Hcu, result.PipingDesignResults.Wti2017UpliftHcritical);
                Assert.AreEqual(output.DeltaPhiCu, result.PipingDesignResults.Wti2017UpliftDeltaPhiC);
                Assert.AreEqual(output.FoSh, result.PipingDesignResults.Wti2017HeaveSafetyFactor);
                Assert.AreEqual(output.Hch, result.PipingDesignResults.Wti2017HeaveHcritical);
                Assert.AreEqual(output.Gradient, result.PipingDesignResults.Wti2017Gradient);
                Assert.AreEqual(output.EffectiveStress, result.PipingDesignResults.EffectiveStress);
                // CCreep is calculated by hand.
                Assert.AreEqual(23.076923076923077, result.PipingDesignResults.CCreep);

                // Overall results (FoS and Hc) are taken from the case with maximum FoS from Uplift (u), Heave (h) and Backward Erorsion  (be)
                // Here this is uplift, so the results must be equal to those of Uplift.
                Assert.AreEqual(output.FoSu, result.PipingDesignResults.Wti2017SafetyFactorOverall);
                Assert.AreEqual(output.Hcu, result.PipingDesignResults.Wti2017HcriticalOverall);

                Assert.AreEqual(output.ExitPointX, result.PipingDesignResults.LocalExitPointX);
                Assert.AreEqual(output.UpliftFactor, result.PipingDesignResults.UpliftFactor);
                Assert.AreEqual(output.UpliftSituation, result.PipingDesignResults.UpliftSituation);
                Assert.AreEqual(output.CalculationResult, result.CalculationResult);

                Assert.AreEqual(input.Location.SurfaceLine, result.PipingDesignResults.RedesignedSurfaceLine);
            }
        }

        [Test]
        [ExpectedException(typeof(NoNullAllowedException), ExpectedMessage = "Geen invoer object gedefinieerd voor WTI Sellmeijer Revised")]
        [SetUICulture("nl-NL")]
        public void TestLanguageNLThrowsExceptionInExecuteWhenInputIsNull()
        {
            var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
            List<LogMessage> messages;
            kernelWrapper.Execute(null, null, out messages);
        }

        [Test]
        [ExpectedException(typeof(NoNullAllowedException), ExpectedMessage = "No input object defined for WTI Sellmeijer Revised")]
        [SetUICulture("en-US")]
        public void TestLanguageENThrowsExceptionInExecuteWhenInputIsNull()
        {
            var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
            List<LogMessage> messages;
            kernelWrapper.Execute(null, null, out messages);
        }

        [Test]
        [ExpectedException(typeof(NoNullAllowedException), ExpectedMessage = "Geen uitvoer object gedefinieerd voor WTI Sellmeijer Revised")]
        [SetUICulture("nl-NL")]
        public void TestThrowsExceptionInPostProcessWhenOutputIsNull()
        {
            var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
            List<DesignResult> results;
            kernelWrapper.PostProcess(new DamKernelInput(), null, null, "", out results);
        }

        [Test]
        [ExpectedException(typeof(NoNullAllowedException), ExpectedMessage = "Geen invoer object gedefinieerd voor WTI Sellmeijer Revised")]
        [SetUICulture("nl-NL")]
        public void TestThrowsExceptionInPostProcessWhenInputIsNull()
        {
            var kernelWrapper = new WtiPipingSellmeijerRevisedKernelWrapper();
            List<DesignResult> results;
            kernelWrapper.PostProcess(null, new DamPipingSellmeijer4ForcesOutput(), null, "", out results);
        }

        [TestCase(CharacteristicPointType.BottomDitchPolderSide, PipingCharacteristicPointType.BottomDitchPolderSide)]
        [TestCase(CharacteristicPointType.BottomDitchDikeSide, PipingCharacteristicPointType.BottomDitchDikeSide)]
        [TestCase(CharacteristicPointType.DikeLine, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.DikeToeAtPolder, PipingCharacteristicPointType.DikeToeAtPolder)]
        [TestCase(CharacteristicPointType.DikeToeAtRiver, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.DikeTopAtPolder, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.DikeTopAtRiver, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.DitchDikeSide, PipingCharacteristicPointType.DitchDikeSide)]
        [TestCase(CharacteristicPointType.DitchPolderSide, PipingCharacteristicPointType.DitchPolderSide)]
        [TestCase(CharacteristicPointType.None, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.ShoulderBaseInside, PipingCharacteristicPointType.ShoulderBaseInside)]
        [TestCase(CharacteristicPointType.ShoulderBaseOutside, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.ShoulderTopInside, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.ShoulderTopOutside, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.SurfaceLevelInside, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.SurfaceLevelOutside, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.TrafficLoadInside, PipingCharacteristicPointType.None)]
        [TestCase(CharacteristicPointType.TrafficLoadOutside, PipingCharacteristicPointType.None)]        
        public void TestConvertToPipingPointType(CharacteristicPointType charPointType, PipingCharacteristicPointType pipingCharacteristicPointType)
        {
            Assert.AreEqual(pipingCharacteristicPointType, WtiPipingSellmeijerRevisedKernelWrapper.ConvertToPipingPointType(charPointType));            
        }

        [Test]
        public void TestConvertToPipingSurfaceLine()
        {
            const double diff = 0.0001;
            var surfaceLine = FactoryForSurfaceLines.CreateSurfaceLineForWtiPiping(true);
            var surfaceLinePiping = WtiPipingSellmeijerRevisedKernelWrapper.ConvertToPipingSurfaceLine(surfaceLine);
            Assert.AreEqual(12, surfaceLinePiping.Points.Count);
            // Check some coodinates and types
            Assert.AreEqual(34.5, surfaceLinePiping.Points[2].X, diff);
            Assert.AreEqual(0, surfaceLinePiping.Points[2].Y, diff);
            Assert.AreEqual(5, surfaceLinePiping.Points[2].Z, diff);
            Assert.AreEqual(PipingCharacteristicPointType.None, surfaceLinePiping.Points[2].Type);

            Assert.AreEqual(38.5, surfaceLinePiping.Points[4].X, diff);
            Assert.AreEqual(0, surfaceLinePiping.Points[4].Y, diff);
            Assert.AreEqual(5, surfaceLinePiping.Points[4].Z, diff);
            Assert.AreEqual(PipingCharacteristicPointType.None, surfaceLinePiping.Points[4].Type);

            Assert.AreEqual(58.5, surfaceLinePiping.Points[7].X, diff);
            Assert.AreEqual(0, surfaceLinePiping.Points[7].Y, diff);
            Assert.AreEqual(0, surfaceLinePiping.Points[7].Z, diff);
            Assert.AreEqual(PipingCharacteristicPointType.DitchDikeSide, surfaceLinePiping.Points[7].Type);

            Assert.AreEqual(61.5, surfaceLinePiping.Points[9].X, diff);
            Assert.AreEqual(0, surfaceLinePiping.Points[9].Y, diff);
            Assert.AreEqual(-1, surfaceLinePiping.Points[9].Z, diff);
            Assert.AreEqual(PipingCharacteristicPointType.BottomDitchPolderSide, surfaceLinePiping.Points[9].Type);
        }

        [Test]
        public void TestConvertToPipingProfile()
        {
            const double diff = 0.0001;
            var profile = FactoryForSoilProfiles.CreatePipingSellmeijerProfileWithOneSandlayer();
            var profilePiping = WtiPipingSellmeijerRevisedKernelWrapper.ConvertToPipingProfile(profile);
            Assert.AreEqual(2, profilePiping.Layers.Count);

            Assert.AreEqual(10, profilePiping.Layers[0].TopLevel, diff);
            Assert.AreEqual(11, profilePiping.Layers[0].AbovePhreaticLevel, diff);
            Assert.AreEqual(14, profilePiping.Layers[0].BelowPhreaticLevel, diff);
            Assert.AreEqual(false, profilePiping.Layers[0].IsAquifer);
            Assert.AreEqual(double.NaN, profilePiping.Layers[0].DryUnitWeight, diff);

            Assert.AreEqual(-2, profilePiping.Layers[1].TopLevel, diff);
            Assert.AreEqual(20, profilePiping.Layers[1].AbovePhreaticLevel, diff);
            Assert.AreEqual(22, profilePiping.Layers[1].BelowPhreaticLevel, diff);
            Assert.AreEqual(true, profilePiping.Layers[1].IsAquifer);
            Assert.AreEqual(double.NaN, profilePiping.Layers[1].DryUnitWeight, diff);

            Assert.AreEqual(-10, profilePiping.BottomLevel, diff);
        }

        [Test]
        public void TestAssignFailedValuesWtiUplift()
        {
            var output = new WtiPipingSellmeijerRevisedOutput();
            //  Uplift 
            output.FoSu = 1;
            output.Hcu = 1;
            output.DeltaPhiCu = 1;
            // Heave
            output.FoSh = 1;
            output.Hch = 1;
            output.Gradient = 1;
            // Sellmeijer revised
            output.FoSbe = 1;
            output.Hcbe = 1;
            output.DeltaPhiCbe = 1;
            WtiPipingSellmeijerRevisedKernelWrapper.AssignFailedValuesWtiUplift(output);
            //  Uplift 
            Assert.AreEqual(0, output.FoSu);
            Assert.AreEqual(0, output.Hcu);
            Assert.AreEqual(0, output.DeltaPhiCu);
            // Heave
            Assert.AreEqual(1, output.FoSh);
            Assert.AreEqual(1, output.Hch);
            Assert.AreEqual(1, output.Gradient);
            // Sellmeijer revised
            Assert.AreEqual(1, output.FoSbe);
            Assert.AreEqual(1, output.Hcbe);
            Assert.AreEqual(1, output.DeltaPhiCbe);
        }

        [Test]
        public void TestAssignFailedValuesWtiHeave()
        {
            var output = new WtiPipingSellmeijerRevisedOutput();
            //  Uplift 
            output.FoSu = 1;
            output.Hcu = 1;
            output.DeltaPhiCu = 1;
            // Heave
            output.FoSh = 1;
            output.Hch = 1;
            output.Gradient = 1;
            // Sellmeijer revised
            output.FoSbe = 1;
            output.Hcbe = 1;
            output.DeltaPhiCbe = 1;
            WtiPipingSellmeijerRevisedKernelWrapper.AssignFailedValuesWtiHeave(output);
            //  Uplift 
            Assert.AreEqual(1, output.FoSu);
            Assert.AreEqual(1, output.Hcu);
            Assert.AreEqual(1, output.DeltaPhiCu);
            // Heave
            Assert.AreEqual(0, output.FoSh);
            Assert.AreEqual(0, output.Hch);
            Assert.AreEqual(0, output.Gradient);
            // Sellmeijer revised
            Assert.AreEqual(1, output.FoSbe);
            Assert.AreEqual(1, output.Hcbe);
            Assert.AreEqual(1, output.DeltaPhiCbe);
        }

        [Test]
        public void TestAssignFailedValuesWtiSellmeijerRevised()
        {
            var output = new WtiPipingSellmeijerRevisedOutput();
            //  Uplift 
            output.FoSu = 1;
            output.Hcu = 1;
            output.DeltaPhiCu = 1;
            // Heave
            output.FoSh = 1;
            output.Hch = 1;
            output.Gradient = 1;
            // Sellmeijer revised
            output.FoSbe = 1;
            output.Hcbe = 1;
            output.DeltaPhiCbe = 1;
            WtiPipingSellmeijerRevisedKernelWrapper.AssignFailedValuesWtiSellmeijerRevised(output);
            //  Uplift 
            Assert.AreEqual(1, output.FoSu);
            Assert.AreEqual(1, output.Hcu);
            Assert.AreEqual(1, output.DeltaPhiCu);
            // Heave
            Assert.AreEqual(1, output.FoSh);
            Assert.AreEqual(1, output.Hch);
            Assert.AreEqual(1, output.Gradient);
            // Sellmeijer revised
            Assert.AreEqual(0, output.FoSbe);
            Assert.AreEqual(0, output.Hcbe);
            Assert.AreEqual(0, output.DeltaPhiCbe);
        }

    }
}