public void WriteScenarioWhenAvailable_WriterNull_ThrowsArgumentNullException()
        {
            // Call
            TestDelegate test = () => ExposedCalculationConfigurationWriter.PublicWriteScenarioWhenAvailable(
                null,
                new ScenarioConfiguration());

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(test);

            Assert.AreEqual("writer", exception.ParamName);
        }
        public void WriteDistributionWhenAvailable_MeanStandardDeviationStochastConfigurationWriterNull_ThrowsArgumentNullException()
        {
            // Call
            TestDelegate test = () => ExposedCalculationConfigurationWriter.PublicWriteDistributionWhenAvailable(
                null,
                "some name",
                new StochastConfiguration());

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(test);

            Assert.AreEqual("writer", exception.ParamName);
        }
        public void WriteElementWhenContentAvailable_BoolWriterNull_ThrowsArgumentNullException()
        {
            // Call
            TestDelegate test = () => ExposedCalculationConfigurationWriter.PublicWriteElementWhenContentAvailable(
                null,
                "some name",
                false);

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(test);

            Assert.AreEqual("writer", exception.ParamName);
        }
        public void WriteScenarioWhenAvailable_ScenarioConfigurationNull_WriterNotCalled()
        {
            // Setup
            var mocks     = new MockRepository();
            var xmlWriter = mocks.StrictMock <XmlWriter>();

            mocks.ReplayAll();

            // Call
            ExposedCalculationConfigurationWriter.PublicWriteScenarioWhenAvailable(
                xmlWriter,
                null);

            // Assert
            mocks.VerifyAll();
        }
        public void WriteElementWhenContentAvailable_BoolNull_WriterNotCalled()
        {
            // Setup
            var mocks     = new MockRepository();
            var xmlWriter = mocks.StrictMock <XmlWriter>();

            mocks.ReplayAll();

            // Call
            ExposedCalculationConfigurationWriter.PublicWriteElementWhenContentAvailable(
                xmlWriter,
                "some name",
                (bool?)null);

            // Assert
            mocks.VerifyAll();
        }
        public void WriteDistributionWhenAvailable_MeanStandardDeviationStochastConfigurationNull_WriterNotCalled()
        {
            // Setup
            var mocks     = new MockRepository();
            var xmlWriter = mocks.StrictMock <XmlWriter>();

            mocks.ReplayAll();

            // Call
            ExposedCalculationConfigurationWriter.PublicWriteDistributionWhenAvailable(
                xmlWriter,
                "some name",
                null);

            // Assert
            mocks.VerifyAll();
        }
        public void WriteDistributionWhenAvailable_MeanStandardDeviationStochastConfigurationDistributionNameNull_ThrowsArgumentNullException()
        {
            // Setup
            var mocks     = new MockRepository();
            var xmlWriter = mocks.StrictMock <XmlWriter>();

            mocks.ReplayAll();

            // Call
            TestDelegate test = () => ExposedCalculationConfigurationWriter.PublicWriteDistributionWhenAvailable(
                xmlWriter,
                null,
                new StochastConfiguration());

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(test);

            Assert.AreEqual("distributionName", exception.ParamName);
        }
        public void WriteScenarioWhenAvailable_ScenarioConfigurationSet_WriterCalledWithExpectedParameters()
        {
            // Setup
            var configuration = new ScenarioConfiguration();

            var mocks     = new MockRepository();
            var xmlWriter = mocks.StrictMock <XmlWriter>();

            xmlWriter.Expect(w => w.WriteScenario(configuration));
            mocks.ReplayAll();

            // Call
            ExposedCalculationConfigurationWriter.PublicWriteScenarioWhenAvailable(
                xmlWriter,
                configuration);

            // Assert
            mocks.VerifyAll();
        }
        public void WriteElementWhenContentAvailable_BoolElementNameNull_ThrowsArgumentNullException()
        {
            // Setup
            var mocks     = new MockRepository();
            var xmlWriter = mocks.StrictMock <XmlWriter>();

            mocks.ReplayAll();

            // Call
            TestDelegate test = () => ExposedCalculationConfigurationWriter.PublicWriteElementWhenContentAvailable(
                xmlWriter,
                null,
                false);

            // Assert
            var exception = Assert.Throws <ArgumentNullException>(test);

            Assert.AreEqual("elementName", exception.ParamName);
        }
        public void WriteElementWhenContentAvailable_BoolSet_WriterCalledWithExpectedParameters()
        {
            // Setup
            const string name  = "some name";
            const bool   value = true;

            var mocks     = new MockRepository();
            var xmlWriter = mocks.StrictMock <XmlWriter>();

            xmlWriter.Expect(w => w.WriteElementString(name, XmlConvert.ToString(value)));
            mocks.ReplayAll();

            // Call
            ExposedCalculationConfigurationWriter.PublicWriteElementWhenContentAvailable(
                xmlWriter,
                name,
                value);

            // Assert
            mocks.VerifyAll();
        }
        public void WriteDistributionWhenAvailable_StochastConfigurationSet_WriterCalledWithExpectedParameters()
        {
            // Setup
            const string name          = "some name";
            var          configuration = new StochastConfiguration();

            var mocks     = new MockRepository();
            var xmlWriter = mocks.StrictMock <XmlWriter>();

            xmlWriter.Expect(w => w.WriteDistribution(name, configuration));
            mocks.ReplayAll();

            // Call
            ExposedCalculationConfigurationWriter.PublicWriteDistributionWhenAvailable(
                xmlWriter,
                name,
                configuration);

            // Assert
            mocks.VerifyAll();
        }