//-----------------------------------------------------------------------
// <copyright file="DamProject.cs" company="Deltares">     
//  Copyright (c) 2011 Deltares. All rights reserved.
// </copyright>
// <author>J. Bokma</author>
// <email>j.bokma@deltares.nl</email>
// <date>02-02-2011</date>
// <summary>n.a.</summary>
//-----------------------------------------------------------------------

namespace Deltares.Dam.Tests
{
    using Deltares.Dam.Data;
    using Deltares.Standard;
    using NUnit.Framework;

    /// <summary>
    ///This is a test class for DamCalculationTest and is intended
    ///to contain all DamCalculationTest Unit Tests
    ///</summary>
    [TestFixture]
    public class DamCalculationTest
    {

        private const string csvProjectPath = @"TestData\DeltaDijkSmall";
          //  "D:\\delftgeosystems\\Trunc (Mstab)\\data\\Dam\\DeltaDijk\\Small";

        

        #region Additional test attributes
        // 
        //You can use the following additional attributes as you write your tests:
        //
        //Use ClassInitialize to run code before running the first test in the class
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup to run code after all tests in a class have run
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize to run code before running each test
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup to run code after each test has run
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///A test for Version
        ///</summary>
        [Test]
        public void VersionTest()
        {
            DamCalculation target = new DamCalculation(); 
            string actual;
            actual = target.Version;
            string expected = "1.0.0.0";
            Assert.AreEqual(expected, actual);            
        }

        /// <summary>
        ///A test for Validate
        ///</summary>
        [Test]
        public void ValidateTestWithoutData()
        {
            DamCalculation target = new DamCalculation(); 
            CalculationResult expected = CalculationResult.InvalidInputData;
            CalculationResult actual;
            actual = target.Validate();
            Assert.AreEqual(expected, actual);            
        }

        /// <summary>
        ///A test for RegisterUserAbort
        ///</summary>
        [Test]
        public void RegisterUserAbortTest()
        {
            DamCalculation target = new DamCalculation(); 
            UserAbortDelegate userAbortDelegate = null; // TODO: Initialize to an appropriate value
            CalculationResult expected = CalculationResult.Succeeded;
            CalculationResult actual;
            actual = target.RegisterUserAbort(userAbortDelegate);
            Assert.AreEqual(expected, actual);
            
        }

        /// <summary>
        ///A test for RegisterSetValues
        ///</summary>
        [Test]
        public void RegisterSetValuesTest()
        {
            DamCalculation target = new DamCalculation();
            SetValuesDelegate setValuesDelegate = null; // TODO: Initialize to an appropriate value
            CalculationResult expected = CalculationResult.Succeeded;
            CalculationResult actual;
            actual = target.RegisterSetValues(setValuesDelegate);
            Assert.AreEqual(expected, actual);       
        }

        /// <summary>
        ///A test for RegisterSendMessage
        ///</summary>
        [Test]
        public void RegisterSendMessageTest()
        {
            DamCalculation target = new DamCalculation();
            SendMessageDelegate sendMessageDelegate = null; // TODO: Initialize to an appropriate value
            CalculationResult expected = CalculationResult.Succeeded;
            CalculationResult actual;
            actual = target.RegisterSendMessage(sendMessageDelegate);
            Assert.AreEqual(expected, actual);            
        }

        /// <summary>
        ///A test for RegisterSendDebugInfo
        ///</summary>
        [Test]
        public void RegisterSendDebugInfoTest()
        {
            DamCalculation target = new DamCalculation();
            SendDebugInfodelegate sendDebugInfoDelegate = null; // TODO: Initialize to an appropriate value
            CalculationResult expected = CalculationResult.Succeeded;
            CalculationResult actual;
            actual = target.RegisterSendDebugInfo(sendDebugInfoDelegate);
            Assert.AreEqual(expected, actual);            
        }

        /// <summary>
        ///A test for RegisterProgress
        ///</summary>
        [Test]
        public void RegisterProgressTest()
        {
            DamCalculation target = new DamCalculation();
            ProgressDelegate progressDelegate = null; // TODO: Initialize to an appropriate value
            CalculationResult expected = CalculationResult.Succeeded;
            CalculationResult actual;
            actual = target.RegisterProgress(progressDelegate);
            Assert.AreEqual(expected, actual);            
        }

        /// <summary>
        ///A test for RegisterGetValues
        ///</summary>
        [Test]
        public void RegisterGetValuesTest()
        {
            DamCalculation target = new DamCalculation();
            GetValuesDelegate getValuesDelegate = null; // TODO: Initialize to an appropriate value
            CalculationResult expected = CalculationResult.Succeeded;
            CalculationResult actual;
            actual = target.RegisterGetValues(getValuesDelegate);
            Assert.AreEqual(expected, actual);           
        }

        /// <summary>
        ///A test for GetResults
        ///</summary>
        [Test]
        public void GetResultsTest()
        {
            DamCalculation target = new DamCalculation();
            string results = string.Empty;
            string resultsExpected = "No results available.";
            CalculationResult expected = CalculationResult.Succeeded;
            CalculationResult actual;
            actual = target.GetResults(ref results);
            Assert.AreEqual(resultsExpected, results);
            Assert.AreEqual(expected, actual);            
        }

        [Test]
        [ExpectedException(typeof(DamCalculationException))]
        public void ThrowsExceptionWhenNoFailureMechanismSpecificationDefined()
        {
            var damCalculation = new DamCalculation();
            using (var damProject = new DamProject())
            {
                damCalculation.CalculateDamProject(damProject.DamProjectData);
            }
        }

        [Test]
        [ExpectedException(typeof(DamCalculationException))]
        public void ThrowsExceptionWhenNoLocationsDefined()
        {
            var damCalculation = new DamCalculation();
            using (var damProject = new DamProject())
            {
                var failureMechanismStabilityInsideMStabSpecification = new DamFailureMechanismeCalculationSpecification();
                failureMechanismStabilityInsideMStabSpecification.FailureMechanismSystemType = FailureMechanismSystemType.StabilityInside;
                damProject.DamProjectData.DamProjectCalculationSpecification.DamCalculationSpecifications.Add(failureMechanismStabilityInsideMStabSpecification);
                damCalculation.CalculateDamProject(damProject.DamProjectData);
            }
        }
    }
}