public void CannotSelectInputGreaterThanSix()
        {
            const int greaterThanInput = 7;
            var pre = new Preamplifier();

            pre.SelectInput(greaterThanInput);
        }
        public void CanMuteOnSystem()
        {
            var pre = new Preamplifier();

            pre.Mute(PreamplifierMuteState.On);

            Assert.AreEqual(true, pre.IsMuted);
        }
        public void CanNameCurrentInput()
        {
            const string inputName = "SACD";
            var pre = new Preamplifier();

            pre.CurrentInput.Name = inputName;

            Assert.AreEqual(inputName, pre.CurrentInput.Name);
            Debug.WriteLine(String.Format("Current Input Name = \"{0}\"", pre.CurrentInput.Name));
        }
        public void AutomaticMuteOffWhenVolumeChanged()
        {
            var pre = new Preamplifier();

            pre.Volume = 65;
            pre.Mute(PreamplifierMuteState.On);
            pre.Volume = 70;

            Assert.AreEqual(false, pre.IsMuted);
        }
        public void CannotSelectInputNumberZero()
        {
            const int inputZero = 0;
            var pre = new Preamplifier();

            pre.SelectInput(inputZero);
        }
        public void CanCreateNewPreamplifier()
        {
            var pre = new Preamplifier();

            Assert.NotNull(pre);
        }
        public void PreamplifierHasSixInputs()
        {
            const int numberOfInputs = 6;
            var pre = new Preamplifier();

            Assert.AreEqual(numberOfInputs, pre.Inputs.Count);

            foreach (var i in pre.Inputs)
            {
                Debug.WriteLine(String.Format("Input {0}", i.Number));
            }
        }
        public void DefaultVolumeForEachInputShouldBeZero()
        {
            const int expectedVolume = 0;
            var pre = new Preamplifier();

            foreach (var i in pre.Inputs)
            {
                Assert.AreEqual(expectedVolume, i.Volume);
                Debug.WriteLine(String.Format("Input {0} Volume = {1}", i.Number, i.Volume));
            }
        }
        public void DefaultSelectedInputIsNumberOne()
        {
            const int inputNumber = 1;
            var pre = new Preamplifier();

            Assert.AreEqual(inputNumber, pre.CurrentInput.Number);

            Debug.WriteLine(String.Format("Input {0}", pre.CurrentInput.Number));
        }
        public void ChangeVolumeOnCurrentInput()
        {
            const int expectedVolume = 100;
            var pre = new Preamplifier();

            pre.Volume = expectedVolume;

            Assert.AreEqual(expectedVolume, pre.Volume);
            Assert.AreEqual(expectedVolume, pre.CurrentInput.Volume);
        }
        public void CanSoftMuteSystem()
        {
            var pre = new Preamplifier { Volume = 100 };

            pre.Mute(PreamplifierMuteState.Soft);

            Assert.AreEqual(true, pre.IsSoftMuted);
        }
        public void CanSelectDifferentInput()
        {
            const int expectedInput = 2;
            var pre = new Preamplifier();

            Debug.WriteLine(String.Format("Default Input = #{0}", pre.CurrentInput.Number));

            pre.SelectInput(expectedInput);

            Assert.AreEqual(expectedInput, pre.CurrentInput.Number);
            Debug.WriteLine(String.Format("New Input = #{0}", pre.CurrentInput.Number));
        }
        public void CannotSelectNegativeInput()
        {
            const int negativeInput = -1;
            var pre = new Preamplifier();

            pre.SelectInput(negativeInput);
        }