using System;
using System.ComponentModel;
using System.Linq;
using System.Xml.Serialization;
using NUnit.Framework;
using OpenTap.Engine.UnitTests;
using OpenTap.Plugins.BasicSteps;

namespace OpenTap.UnitTests
{
    [TestFixture]
    public class InputOutputRelationTest
    {
        [Test]
        public void TestBasicInputOutputRelation()
        {
            var seq = new SequenceStep();
            var delay1 = new DelayStep();
            var delay2 = new DelayStep();
            seq.ChildTestSteps.AddRange([delay1, delay2]);
            {
                var member = TypeData.GetTypeData(delay1).GetMember(nameof(DelayStep.DelaySecs));
                InputOutputRelation.Assign(delay2, member, delay1, member);
            }
            {
                double testValue = 10;
                delay1.DelaySecs = testValue;
                delay2.DelaySecs = 0;
                InputOutputRelation.UpdateInputs(delay2);
                Assert.AreEqual(delay1.DelaySecs, delay2.DelaySecs);
                Assert.AreEqual(testValue, delay1.DelaySecs);
            }
            {
                var member = TypeData.GetTypeData(delay1).GetMember(nameof(DelayStep.DelaySecs));
                InputOutputRelation.Unassign(delay2, member, delay1, member);
            }
            {
                double testValue = 10;
                delay1.DelaySecs = testValue;
                delay2.DelaySecs = 0;
                InputOutputRelation.UpdateInputs(delay2);
                Assert.AreNotEqual(delay1.DelaySecs, delay2.DelaySecs);
                Assert.AreEqual(testValue, delay1.DelaySecs);
            }
        }

        // The output is assigned to the input.
        public class OutputInput : TestStep
        {
            [Output(OutputAvailability.AfterDefer)]
            public double Output { get; set; }
            
            [Output(OutputAvailability.AfterRun)]
            public double Output2 { get; set; }
            
            public double Input { get; set; }
            
            public bool CheckExpectedInput { get; set; }
            public double ExpectedInput { get; set; }
            
            public bool Defer { get; set; }
            public double DelaySecs { get; set; } = 0.0;
            
            public override void Run()
            {
                if(CheckExpectedInput && ExpectedInput != Input)
                    throw new Exception("Input has unexpected value");
                
                if(DelaySecs > 0.0)
                    TapThread.Sleep(TimeSpan.FromSeconds(DelaySecs));
                UpgradeVerdict(Verdict.Pass);
                this.Results.Defer(() => Output = Input);
                Output2 = Input;
            }

            public override string ToString() => $"{Name}";
        }

        [Test]
        public void TestInputOutputRelationsInTestPlan()
        {

            var step1 = new OutputInput {Output = 5, Input = 5, Name = "Step 1"};
            var step2 = new OutputInput {ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 2"};
            var step3 = new OutputInput {ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 3"};
            var plan = new TestPlan();
            plan.ChildTestSteps.AddRange(new []{step1, step2, step3});
            {
                var outputMember = TypeData.GetTypeData(step1).GetMember(nameof(OutputInput.Output));
                var inputMember = TypeData.GetTypeData(step1).GetMember(nameof(OutputInput.Input));
                InputOutputRelation.Assign(step2, inputMember, step1, outputMember );
                InputOutputRelation.Assign(step3, inputMember, step2, outputMember);
                
                Assert.IsTrue(InputOutputRelation.IsOutput(step1, outputMember));
                Assert.IsFalse(InputOutputRelation.IsInput(step1, outputMember));
                Assert.IsFalse(InputOutputRelation.IsOutput(step1, inputMember));
                Assert.IsFalse(InputOutputRelation.IsInput(step1, inputMember));

                Assert.IsTrue(InputOutputRelation.IsInput(step2, inputMember));
                Assert.IsTrue(InputOutputRelation.IsOutput(step2, outputMember));
                Assert.IsTrue(InputOutputRelation.IsInput(step3, inputMember));
                Assert.IsFalse(InputOutputRelation.IsOutput(step3, outputMember));
            }

            {
                var run = plan.Execute();
                Assert.AreEqual(Verdict.Pass, run.Verdict);
            }
        }
        
        [TestCase(1)]
        [TestCase(2)]
        [TestCase(4)]
        [TestCase(8)] // connect 8 inputs/outputs and update across 8 threads.
        [TestCase(64)]
        public void TestInputOutputRelationsInTestPlanParallelN(int n)
        {
            var plan = new TestPlan();
            var parallel = new ParallelStep();
            
            plan.ChildTestSteps.Add(parallel);
            var step1 = new OutputInput {Output = 5, Input = 5, Name = "Step 1"};
            parallel.ChildTestSteps.Add(step1);
            for (int i = 0; i < n; i++)
            {
                var prevStep = parallel.ChildTestSteps.Last() as OutputInput;
                var newStep = new OutputInput {Output = 5, Input = 5, Name = "Step " + (i + 1)};
                parallel.ChildTestSteps.Add(newStep);
                // setup the connections.
                var outputMember = TypeData.GetTypeData(prevStep).GetMember(nameof(OutputInput.Output));
                var inputMember = TypeData.GetTypeData(newStep).GetMember(nameof(OutputInput.Input));
                InputOutputRelation.Assign(newStep, inputMember, prevStep, outputMember );
            }
            var r = plan.Execute();
            Assert.AreEqual(Verdict.Pass, r.Verdict);
        }
        [Test]
        public void TestInputOutputLoop()
        {
            var plan = new TestPlan();
            var parallel = new ParallelStep();
            
            plan.ChildTestSteps.Add(parallel);
            var step1 = new OutputInput {Output = 5, Input = 5, Name = "Step 1"};
            var step2 = new OutputInput {Output = 5, Input = 5, Name = "Step 1"};
            var step3 = new OutputInput {Output = 5, Input = 5, Name = "Step 1"};
            parallel.ChildTestSteps.AddRange(new [] {step1, step2, step3});
            var a = TypeData.GetTypeData(step1).GetMember(nameof(step1.Input));
            var b = TypeData.GetTypeData(step1).GetMember(nameof(step1.Output));
            InputOutputRelation.Assign(step2, a, step1, b);
            InputOutputRelation.Assign(step3, a, step2, b);
            InputOutputRelation.Assign(step1, a, step3, b);

           
            var r = plan.Execute();
            Assert.AreEqual(Verdict.Error, r.Verdict);
        }

        [Test]
        public void TestSerializingConnectionsBetweenSteps()
        {
            var step1 = new OutputInput {Output = 5, Input = 5, Name = "Step 1"};
            var step2 = new OutputInput {ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 2"};
            var step3 = new OutputInput {ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 3"};
            var plan = new TestPlan();
            plan.ChildTestSteps.AddRange(new []{step1, step2, step3});
            var outputMember = TypeData.GetTypeData(step1).GetMember(nameof(OutputInput.Output));
            var inputMember = TypeData.GetTypeData(step1).GetMember(nameof(OutputInput.Input));
            InputOutputRelation.Assign(step2, inputMember, step1, outputMember);
            InputOutputRelation.Assign(step3, inputMember, step2, outputMember);

            var xml = plan.SerializeToString();

            var plan2 = Utils.DeserializeFromString<TestPlan>(xml);

            step1 = (OutputInput)plan2.Steps[0];
            step2 = (OutputInput)plan2.Steps[1];
            step3 = (OutputInput)plan2.Steps[2];
            Assert.IsTrue(InputOutputRelation.IsOutput(step1, outputMember));
            Assert.IsFalse(InputOutputRelation.IsInput(step1, outputMember));
            Assert.IsFalse(InputOutputRelation.IsOutput(step1, inputMember));
            Assert.IsFalse(InputOutputRelation.IsInput(step1, inputMember));

            Assert.IsTrue(InputOutputRelation.IsInput(step2, inputMember));
            Assert.IsTrue(InputOutputRelation.IsOutput(step2, outputMember));
            Assert.IsTrue(InputOutputRelation.IsInput(step3, inputMember));
            Assert.IsFalse(InputOutputRelation.IsOutput(step3, outputMember));
        }

        class SelectAssignmentFromAnnotationMenu : IUserInputInterface, IUserInterface
        {
            public bool WasInvoked;
            public string SelectName { get; set; }
            public void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal)
            {
                var datas = AnnotationCollection.Annotate(dataObject);
                var selectedName = datas.GetMember("Output");
                var avail = selectedName.Get<IAvailableValuesAnnotationProxy>();
                avail.SelectedValue = avail.AvailableValues.First(x => (x.Source.ToString().Contains(SelectName)));
                
                var response = datas.GetMember("Response");
                var availRespons = response.Get<IAvailableValuesAnnotationProxy>();
                availRespons.SelectedValue =
                    availRespons.AvailableValues.FirstOrDefault(x => x.Source.ToString().Contains("Cancel") == false);
                
                datas.Write();
                
                WasInvoked = true;
            }

            public void NotifyChanged(object obj, string property) { }
        }

        
        [Test]
        public void TestMenuAnnotationForInputOutputRelations()
        {
            var userInput = UserInput.GetInterface();
            var request = new SelectAssignmentFromAnnotationMenu();
            UserInput.SetInterface(request);
            try
            {
                var step1 = new OutputInput {Output = 5, Input = 5, Name = "Step 1"};
                var step2 = new OutputInput {ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 2"};
                var step3 = new OutputInput {ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 3"};
                var plan = new TestPlan();
                plan.ChildTestSteps.AddRange(new[] {step1, step2, step3});

                var menu = AnnotationCollection.Annotate(step2).GetMember(nameof(OutputInput.Input))
                    .Get<MenuAnnotation>();
                request.SelectName = "Step 1";
                menu.MenuItems.First(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.AssignOutput).Get<IMethodAnnotation>().Invoke();
                request.SelectName = "Step 2";
                menu = AnnotationCollection.Annotate(step3).GetMember(nameof(OutputInput.Input))
                    .Get<MenuAnnotation>();
                menu.MenuItems.First(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.AssignOutput).Get<IMethodAnnotation>().Invoke();

                var input1 = AnnotationCollection.Annotate(step3).GetMember(nameof(OutputInput.Input)).GetAll<IIconAnnotation>()
                    .FirstOrDefault(x => x.IconName == IconNames.Input);
                
                var input2 = AnnotationCollection.Annotate(step2).GetMember(nameof(OutputInput.Input)).GetAll<IIconAnnotation>()
                    .FirstOrDefault(x => x.IconName == IconNames.Input);

                Assert.IsNotNull(input1);
                Assert.IsNotNull(input2);
                
                var run = plan.Execute();
                Assert.AreEqual(Verdict.Pass, run.Verdict);
                Assert.IsTrue(request.WasInvoked);
            }
            finally
            {
                UserInput.SetInterface(userInput);
            }
        }

        [Test]
        public void IconAnnotationForInputOutputRelations()
        {
            var step1 = new OutputInput { Output = 5, Input = 5, Name = "Step 1" };
            var step2 = new OutputInput { ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 2" };
            var step3 = new OutputInput { ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 3" };
            var plan = new TestPlan();
            plan.ChildTestSteps.AddRange(new[] { step1, step2, step3 });
            var outputMember = TypeData.GetTypeData(step1).GetMember(nameof(OutputInput.Output));
            var inputMember = TypeData.GetTypeData(step1).GetMember(nameof(OutputInput.Input));
            InputOutputRelation.Assign(step2, inputMember, step1, outputMember);
            InputOutputRelation.Assign(step3, inputMember, step2, outputMember);


            var a = AnnotationCollection.Annotate(step2);
            var im = a.GetMember(inputMember.Name);
            var iicon = im.Get<ISettingReferenceIconAnnotation>();
            Assert.NotNull(iicon);
            Assert.AreEqual(IconNames.Input, iicon.IconName);
            Assert.AreEqual(step1.Id, iicon.TestStepReference);
            Assert.AreEqual(outputMember.Name, iicon.MemberName);

            var om = a.GetMember(outputMember.Name);
            var oicon = om.Get<ISettingReferenceIconAnnotation>();
            Assert.NotNull(oicon);
            Assert.AreEqual(IconNames.OutputAssigned, oicon.IconName);
            Assert.AreEqual(step3.Id, oicon.TestStepReference);
            Assert.AreEqual(inputMember.Name, oicon.MemberName);
        }

        [Test]
        public void TestMenuAnnotationForInputOutputRelationsMultiSelect()
        {
            var userInput = UserInput.GetInterface();
            var request = new SelectAssignmentFromAnnotationMenu();
            UserInput.SetInterface(request);
            try
            {
                var seq1 = new SequenceStep();
                var seq2 = new SequenceStep();
                var step1 = new OutputInput {Output = 5, Input = 5, Name = "Step 1"};
                var step2 = new OutputInput {ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 2"};
                seq1.ChildTestSteps.Add(step2);
                var step3 = new OutputInput {ExpectedInput = 5, CheckExpectedInput = true, Name = "Step 3"};
                seq2.ChildTestSteps.Add(step3);
                var plan = new TestPlan();
                plan.ChildTestSteps.AddRange(new ITestStep[] {step1, seq1, seq2});

                var menu = AnnotationCollection.Annotate(new []{step2, step3}).GetMember(nameof(OutputInput.Input))
                    .Get<MenuAnnotation>();
                request.SelectName = "Step 1";
                menu.MenuItems.First(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.AssignOutput).Get<IMethodAnnotation>().Invoke();

                var input1 = AnnotationCollection.Annotate(step3).GetMember(nameof(OutputInput.Input)).GetAll<IIconAnnotation>()
                    .FirstOrDefault(x => x.IconName == IconNames.Input);
                Assert.IsNotNull(input1);

                step2.Input = 0;
                step3.Input = 0;
                var run = plan.Execute();
                Assert.AreEqual(Verdict.Pass, run.Verdict);
                Assert.IsTrue(request.WasInvoked);
                
                menu = AnnotationCollection.Annotate(new []{step2, step3}).GetMember(nameof(OutputInput.Input))
                    .Get<MenuAnnotation>();
                menu.MenuItems.First(x => x.Get<IconAnnotationAttribute>().IconName == IconNames.UnassignOutput).Get<IMethodAnnotation>().Invoke();
                var input2 = AnnotationCollection.Annotate(step3).GetMember(nameof(OutputInput.Input)).GetAll<IIconAnnotation>()
                    .FirstOrDefault(x => x.IconName == IconNames.Input);
                Assert.IsNull(input2);
                step2.Input = 0;
                step3.Input = 0;
                run = plan.Execute();
                Assert.AreEqual(Verdict.Error, run.Verdict);
                
                
            }
            finally
            {
                UserInput.SetInterface(userInput);
            }
        }
        

        [Test]
        public void InputSweepTest()
        {
            var plan = new TestPlan();
            var sweep = new SweepLoop();
            plan.ChildTestSteps.Add(sweep);
            var menu = AnnotationCollection.Annotate(sweep).GetMember(nameof(SweepLoop.SweepParameters)).Get<MenuAnnotation>();
            var member = menu.MenuItems.FirstOrDefault(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.AssignOutput);
            member.Get<IMethodAnnotation>().Invoke(); // this previously failed with an null reference exception.
        }

        [Test]
        public void TestAutoRemoveInputOutputRelation()
        {
            var plan = new TestPlan();
            var repeat = new RepeatStep();
            plan.ChildTestSteps.Add(repeat);
            var log = new LogStep();
            repeat.ChildTestSteps.Add(log);
            {
                var member = TypeData.GetTypeData(log).GetMember(nameof(LogStep.LogMessage));
                var outputMember = TypeData.GetTypeData(repeat).GetMember(nameof(RepeatStep.IterationInfo));
                InputOutputRelation.Assign(log, member, repeat, outputMember);
                Assert.IsTrue(InputOutputRelation.IsInput(log, member));
                Assert.IsTrue(InputOutputRelation.IsOutput(repeat, outputMember));
            }
            plan.ChildTestSteps.Remove(repeat);
            {
                var member = TypeData.GetTypeData(log).GetMember(nameof(LogStep.LogMessage));
                var outputMember = TypeData.GetTypeData(repeat).GetMember(nameof(RepeatStep.IterationInfo));
                Assert.IsTrue(InputOutputRelation.IsInput(log, member));
                Assert.IsTrue(InputOutputRelation.IsOutput(repeat, outputMember));
            }

            repeat.ChildTestSteps.Remove(log);
            {
                var member = TypeData.GetTypeData(log).GetMember(nameof(LogStep.LogMessage));
                var outputMember = TypeData.GetTypeData(repeat).GetMember(nameof(RepeatStep.IterationInfo));
                Assert.IsFalse(InputOutputRelation.IsInput(log, member));
                Assert.IsFalse(InputOutputRelation.IsOutput(repeat, outputMember));
            }
        }

        public class ReadOnlyMemberOutput : TestStep
        {
            [Output]
            public double X { get; private set; }
            
            [XmlIgnore]
            [Browsable(true)]
            public double Y { get; set; }
            public override void Run()
            {
                
            }
        }
        
        [Test]
        public void TestSerializeReadOnlyMemberInputOutput()
        {
            var plan = new TestPlan();
            var a = new ReadOnlyMemberOutput();
            var b = new ReadOnlyMemberOutput();
            plan.ChildTestSteps.Add(a);
            plan.ChildTestSteps.Add(b);
            var readonlyMember = TypeData.GetTypeData(a).GetMember(nameof(a.X));
            var writableMember = TypeData.GetTypeData(a).GetMember(nameof(a.Y));
            InputOutputRelation.Assign(b, writableMember, a, readonlyMember);
            Assert.IsTrue(InputOutputRelation.IsOutput(a, readonlyMember));
            Assert.IsTrue(InputOutputRelation.IsInput(b, writableMember));

            var xml = plan.SerializeToString();
            plan = Utils.DeserializeFromString<TestPlan>(xml);
            a = (ReadOnlyMemberOutput)plan.ChildTestSteps[0];
            b = (ReadOnlyMemberOutput)plan.ChildTestSteps[1];
            Assert.IsTrue(InputOutputRelation.IsOutput(a, readonlyMember));
            Assert.IsTrue(InputOutputRelation.IsInput(b, writableMember));
        }

        [Test]
        public void TestMultipleOutputFromTheSameProperty()
        {
            var a = new OutputInput();
            var b = new OutputInput();
            var seq = new SequenceStep();
            seq.ChildTestSteps.AddRange([a,b]);
            var inputMember = TypeData.GetTypeData(a).GetMember(nameof(a.Input));
            var outputMember= TypeData.GetTypeData(b).GetMember(nameof(b.Output));
            var inputMember2= TypeData.GetTypeData(a).GetMember(nameof(a.ExpectedInput)); 
            InputOutputRelation.Assign(a, inputMember, b, outputMember);
            InputOutputRelation.Assign(a, inputMember2, b, outputMember);

            Assert.IsTrue(InputOutputRelation.IsInput(a, inputMember));
            Assert.IsTrue(InputOutputRelation.IsInput(a, inputMember2));
            Assert.Throws<ArgumentException>(() => InputOutputRelation.Assign(a, inputMember, b, outputMember));
            Assert.Throws<ArgumentException>(() => InputOutputRelation.Assign(a, inputMember2, b, outputMember));
        }

        [Test]
        public void LogPrintOutputOrderTest()
        {
            // previously, the value of the {Log Message} in GetFormattedName
            // would be based on the previous value of the input, not the current.
            // It should be based on the current value. E.g the order of the messages should be correct.
            var plan = new TestPlan();
            var repeat = new RepeatStep {Count = 3, Action =  RepeatStep.RepeatStepAction.Fixed_Count};
            var logOutput = new LogStep{Name = "Log Step {Log Message}"};
            var x = logOutput.GetFormattedName();
            plan.ChildTestSteps.Add(repeat);
            repeat.ChildTestSteps.Add(logOutput);
            InputOutputRelation.Assign(logOutput, TypeData.GetTypeData(logOutput).GetMember(nameof(logOutput.LogMessage)),
                repeat, TypeData.GetTypeData(repeat).GetMember(nameof(repeat.IterationInfo))
            );

            var rl = new PlanRunCollectorListener();
            plan.Execute(new IResultListener[] {}); // create the initial condition that repeat.IterationInfo is "3 of 3".
            plan.Execute(new IResultListener[] {rl});
            int i1 = rl.LogString.IndexOf("Log Step 1 of 3\" started");
            int i2 = rl.LogString.IndexOf("Log Step 2 of 3\" started");
            int i3 = rl.LogString.IndexOf("Log Step 3 of 3\" started");
            Assert.IsTrue(i1 < i2);
            Assert.IsTrue(i2 < i3);
        }

        public class InputOutputTypesStep : TestStep
        {
            [Output]
            public int IntInput { get; set; }
            [Output]
            public double DoubleInput { get; set; }
            [Output]
            public string StringInput { get; set; }
            [Output]
            public float FloatInput { get; set; }

            public override void Run()
            {
                
            }
        }

        [Test]
        [TestCase("Iteration", "3 of 3")]
        [TestCase("Outputs \\ Iteration", "3")]
        public void TestInputOutputNameClash(string output, string expected)
        {
            var plan = new TestPlan();
            var repeat = new RepeatStep();
            var step = new InputOutputTypesStep();
            plan.ChildTestSteps.Add(repeat);
            plan.ChildTestSteps.Add(step);

            var a = AnnotationCollection.Annotate(step);
            var im = a.GetMember(nameof(step.StringInput));
            var menu = im.Get<MenuAnnotation>();

            var request = new SelectAssignmentFromAnnotationMenu();
            UserInput.SetInterface(request);
            request.SelectName = output;
            menu.MenuItems.First(x => x.Get<IconAnnotationAttribute>()?.IconName == IconNames.AssignOutput)
                .Get<IMethodAnnotation>().Invoke();

            plan.Execute();
            Assert.AreEqual(step.StringInput, expected);
        }

        [Test]
        public void TestInputOutputTypes()
        {
            var step1 = new InputOutputTypesStep();
            var step2 = new InputOutputTypesStep();
            var plan = new TestPlan();
            plan.ChildTestSteps.AddRange(new[]
            {
                step1, step2
            });
            {
                var intMember = TypeData.GetTypeData(step1).GetMember(nameof(InputOutputTypesStep.IntInput));
                var doubleMember = TypeData.GetTypeData(step1).GetMember(nameof(InputOutputTypesStep.DoubleInput));
                var stringMember = TypeData.GetTypeData(step1).GetMember(nameof(InputOutputTypesStep.StringInput));
                var floatMember = TypeData.GetTypeData(step1).GetMember(nameof(InputOutputTypesStep.FloatInput));
                InputOutputRelation.Assign(step2, doubleMember, step1, stringMember);
                InputOutputRelation.Assign(step2, stringMember, step1, doubleMember);
                InputOutputRelation.Assign(step2, intMember, step1, doubleMember);
                InputOutputRelation.Assign(step2, floatMember, step1, floatMember);
            }
            {
                step1.IntInput = 1;
                step1.DoubleInput = 2;
                step1.StringInput = "3";
                step1.FloatInput = 4;
                InputOutputRelation.UpdateInputs(step2);
                Assert.AreEqual(2, step2.IntInput);
                Assert.AreEqual(3.0, step2.DoubleInput);
                Assert.AreEqual("2", step2.StringInput);
                Assert.AreEqual(4, step2.FloatInput);
                
                // When one of the inputs is assigned an invalid value, an exception should be thrown on UpdateInputs.
                step1.StringInput = "abc";
                Assert.Throws<Exception>(() => InputOutputRelation.UpdateInputs(step2));
            }
        }

        enum SpecialValue
        {
            UnspecifiedResult
        }

        [TestCase("A", typeof(double), null, false)]
        [TestCase("A", typeof(float), null, false)]
        [TestCase("A", typeof(int), null, false)]
        [TestCase("1", typeof(int), null, false)]
        [TestCase("True", typeof(int), null, false)]
        [TestCase("True", typeof(bool), null, false)]
        [TestCase("A", typeof(string), "A", true)]
        [TestCase(true, typeof(int), 1, true)]
        [TestCase(true, typeof(double), 1.0, true)]
        [TestCase(false, typeof(double), 0.0, true)]
        [TestCase(false, typeof(int), 0, true)]
        [TestCase(false, typeof(string), "False", true)]
        [TestCase(long.MaxValue, typeof(float), SpecialValue.UnspecifiedResult, true)]
        [TestCase(long.MaxValue, typeof(double), SpecialValue.UnspecifiedResult, true)]
        [TestCase(long.MaxValue, typeof(long), long.MaxValue, true)]
        [TestCase(long.MaxValue, typeof(int), typeof(OverflowException), true)]
        [TestCase(ulong.MaxValue, typeof(long), typeof(OverflowException), true)]
        [TestCase(100000, typeof(byte), typeof(OverflowException), true)]
        [TestCase(255, typeof(byte), 255, true)]
        [TestCase(256, typeof(byte), typeof(OverflowException), true)]
        [TestCase(1e20, typeof(int), typeof(OverflowException), true)]
        [TestCase(1e20, typeof(byte), typeof(OverflowException), true)]
        [TestCase(1.0, typeof(byte), 1, true)]
        [TestCase(1.0, typeof(int), 1, true)]
        [TestCase(1.0, typeof(float), 1.0, true)]
        [TestCase(1.0, typeof(double), 1.0, true)]
        [TestCase(1.0, typeof(string), "1", true)]
        public void TestConvertOutputToInput(object from, Type intoType, object exceptionOrResult, bool canConvert)
        {
            var toTypeData = TypeData.FromType(intoType);
            var fromTypeData = TypeData.GetTypeData(from);
            Assert.IsTrue(canConvert == InputOutputRelation.CanConvert(toTypeData, fromTypeData));
            if (canConvert)
            {
                try
                {
                    var to = InputOutputRelation.ConvertValue(from, toTypeData);
                    Assert.IsFalse(exceptionOrResult is Exception);
                    if (Equals(exceptionOrResult, SpecialValue.UnspecifiedResult))
                    {
                        var to2 = (double)InputOutputRelation.ConvertValue(to, TypeData.FromType(typeof(double)));
                        Assert.IsTrue(to2 != 0.0);
                    }
                    else
                    {
                        Assert.AreEqual(exceptionOrResult, to);
                    }
                }
                catch (Exception e)
                {
                    Assert.AreEqual(exceptionOrResult, e.GetType());
                }
            }
        }

        
        [TestCase(typeof(Verdict), typeof(string), true)]
        [TestCase(typeof(Verdict), typeof(double), false)]
        [TestCase(typeof(double), typeof(Verdict), false)]
        [TestCase(typeof(string), typeof(Verdict), false)]
        public void TestCanConvertBehavior(Type from, Type to, bool canConvert)
        {
            var from2 = TypeData.FromType(from);
            var to2 = TypeData.FromType(to);
            var canConvertValue = InputOutputRelation.CanConvert(to2, from2);
            Assert.AreEqual(canConvert, canConvertValue);
        }

        [TestCase(true)]
        [TestCase(false)]
        public void TestInputAndOutputWithRemovedMixins(bool way)
        {
            var seq1 = new SequenceStep();
            var b1 = new TestNumberMixinBuilder()
            {
                Name = "Test",
                IsOutput = true
            };
            var seq2 = new SequenceStep();
            var b2 = new TestNumberMixinBuilder
            {
                Name = "Test"
            };
            var plan = new TestPlan();
            plan.ChildTestSteps.Add(seq1);
            plan.ChildTestSteps.Add(seq2);

            MixinFactory.LoadMixin(seq1, b1);
            MixinFactory.LoadMixin(seq2, b2);
            
            var member1 = (MixinMemberData) TypeData.GetTypeData(seq1).GetMember("Number.Test");
            var member2 = (MixinMemberData) TypeData.GetTypeData(seq2).GetMember("Number.Test");
            InputOutputRelation. Assign(seq2, member2, seq1, member1);
            
            var x1 = InputOutputRelation.GetRelations(seq1).Count();
            var x12 = InputOutputRelation.GetRelations(seq2).Count();
            Assert.AreEqual(1, x1);
            Assert.AreEqual(1, x12);
            
            // Now the input/output relation has been set up.
            // Two things can happen:
            // 1. The mixin is removed from seq1 -> the input member is lost.
            // 2. The mixin is removed from seq2 -> the output member is lost.
            // in either case the relation should be removed.
            
            if(way)
                MixinFactory.UnloadMixin(seq1, member1);
            else
                MixinFactory.UnloadMixin(seq2, member2);
            var x2 = InputOutputRelation.GetRelations(seq1).Count();
            var x22 = InputOutputRelation.GetRelations(seq2).Count();
            Assert.AreEqual(0, x2);
            Assert.AreEqual(0, x22);
        }
    }
}