sebastienros.jint/Jint.Tests/Runtime/Debugger/BreakPointTests.cs

using Jint.Runtime.Debugger;

namespace Jint.Tests.Runtime.Debugger
{
    public class BreakPointTests
    {
        [Fact]
        public void BreakLocationsCompareEqualityByValue()
        {
            var loc1 = new BreakLocation(42, 23);
            var loc2 = new BreakLocation(42, 23);
            var loc3 = new BreakLocation(17, 7);

            Assert.Equal(loc1, loc2);
            Assert.True(loc1 == loc2);
            Assert.True(loc2 != loc3);
            Assert.False(loc1 != loc2);
            Assert.False(loc2 == loc3);
        }

        [Fact]
        public void BreakLocationsWithSourceCompareEqualityByValue()
        {
            var loc1 = new BreakLocation("script1", 42, 23);
            var loc2 = new BreakLocation("script1", 42, 23);
            var loc3 = new BreakLocation("script2", 42, 23);

            Assert.Equal(loc1, loc2);
            Assert.True(loc1 == loc2);
            Assert.True(loc2 != loc3);
            Assert.False(loc1 != loc2);
            Assert.False(loc2 == loc3);
        }

        [Fact]
        public void BreakLocationsOptionalSourceEqualityComparer()
        {
            var script1 = new BreakLocation("script1", 42, 23);
            var script2 = new BreakLocation("script2", 42, 23);
            var script2b = new BreakLocation("script2", 44, 23);
            var any = new BreakLocation(null, 42, 23);

            var comparer = new OptionalSourceBreakLocationEqualityComparer();
            Assert.True(comparer.Equals(script1, any));
            Assert.True(comparer.Equals(script2, any));
            Assert.False(comparer.Equals(script1, script2));
            Assert.False(comparer.Equals(script2, script2b));
            Assert.Equal(comparer.GetHashCode(script1), comparer.GetHashCode(any));
            Assert.Equal(comparer.GetHashCode(script1), comparer.GetHashCode(script2));
            Assert.NotEqual(comparer.GetHashCode(script2), comparer.GetHashCode(script2b));
        }

        [Fact]
        public void BreakPointReplacesPreviousBreakPoint()
        {
            var engine = new Engine(options => options.DebugMode());

            engine.Debugger.BreakPoints.Set(new BreakPoint(4, 5, "i === 1"));
            Assert.Collection(engine.Debugger.BreakPoints,
                breakPoint =>
                {
                    Assert.Equal(4, breakPoint.Location.Line);
                    Assert.Equal(5, breakPoint.Location.Column);
                    Assert.Equal("i === 1", breakPoint.Condition);
                });

            engine.Debugger.BreakPoints.Set(new BreakPoint(4, 5));
            Assert.Collection(engine.Debugger.BreakPoints,
                breakPoint =>
                {
                    Assert.Equal(4, breakPoint.Location.Line);
                    Assert.Equal(5, breakPoint.Location.Column);
                    Assert.Equal(null, breakPoint.Condition);
                });
        }

        [Fact]
        public void BreakPointRemovesBasedOnLocationEquality()
        {
            var engine = new Engine(options => options.DebugMode());

            engine.Debugger.BreakPoints.Set(new BreakPoint(4, 5, "i === 1"));
            engine.Debugger.BreakPoints.Set(new BreakPoint(5, 6, "j === 2"));
            engine.Debugger.BreakPoints.Set(new BreakPoint(10, 7, "x > 5"));
            Assert.Equal(3, engine.Debugger.BreakPoints.Count);

            engine.Debugger.BreakPoints.RemoveAt(new BreakLocation(null, 4, 5));
            engine.Debugger.BreakPoints.RemoveAt(new BreakLocation(null, 10, 7));

            Assert.Collection(engine.Debugger.BreakPoints,
                breakPoint =>
                {
                    Assert.Equal(5, breakPoint.Location.Line);
                    Assert.Equal(6, breakPoint.Location.Column);
                    Assert.Equal("j === 2", breakPoint.Condition);
                });
        }

        [Fact]
        public void BreakPointContainsBasedOnLocationEquality()
        {
            var engine = new Engine(options => options.DebugMode());

            engine.Debugger.BreakPoints.Set(new BreakPoint(4, 5, "i === 1"));
            engine.Debugger.BreakPoints.Set(new BreakPoint(5, 6, "j === 2"));
            engine.Debugger.BreakPoints.Set(new BreakPoint(10, 7, "x > 5"));
            Assert.True(engine.Debugger.BreakPoints.Contains(new BreakLocation(null, 5, 6)));
            Assert.False(engine.Debugger.BreakPoints.Contains(new BreakLocation(null, 8, 9)));
        }

        [Fact]
        public void BreakPointBreaksAtPosition()
        {
            string script = @"let x = 1, y = 2;
if (x === 1)
{
x++; y *= 2;
}";

            var engine = new Engine(options => options.DebugMode());

            bool didBreak = false;
            engine.Debugger.Break += (sender, info) =>
            {
                Assert.Equal(4, info.Location.Start.Line);
                Assert.Equal(5, info.Location.Start.Column);
                didBreak = true;
                return StepMode.None;
            };

            engine.Debugger.BreakPoints.Set(new BreakPoint(4, 5));
            engine.Execute(script);
            Assert.True(didBreak);
        }

        [Fact]
        public void BreakPointBreaksInCorrectSource()
        {
            string script1 = @"let x = 1, y = 2;
if (x === 1)
{
x++; y *= 2;
}";

            string script2 = @"function test(x)
{
return x + 2;
}";

            string script3 = @"const z = 3;
test(z);";

            var engine = new Engine(options => { options.DebugMode(); });

            engine.Debugger.BreakPoints.Set(new BreakPoint("script2", 3, 0));

            bool didBreak = false;
            engine.Debugger.Break += (sender, info) =>
            {
                Assert.Equal("script2", info.Location.SourceFile);
                Assert.Equal(3, info.Location.Start.Line);
                Assert.Equal(0, info.Location.Start.Column);
                didBreak = true;
                return StepMode.None;
            };

            // We need to specify the source to the parser.
            // And we need locations too (Jint specifies that in its default options)
            engine.Execute(script1, "script1");
            Assert.False(didBreak);

            engine.Execute(script2, "script2");
            Assert.False(didBreak);

            // Note that it's actually script3 that executes the function in script2
            // and triggers the breakpoint
            engine.Execute(script3, "script3");
            Assert.True(didBreak);
        }

        [Fact]
        public void DebuggerStatementTriggersBreak()
        {
            string script = @"'dummy';
debugger;
'dummy';";

            var engine = new Engine(options => options
                .DebugMode()
                .DebuggerStatementHandling(DebuggerStatementHandling.Script));

            bool didBreak = false;
            engine.Debugger.Break += (sender, info) =>
            {
                Assert.Equal(PauseType.DebuggerStatement, info.PauseType);
                didBreak = true;
                return StepMode.None;
            };

            engine.Execute(script);

            Assert.True(didBreak);
        }

        [Fact]
        public void DebuggerStatementDoesNotTriggerBreakWhenStepping()
        {
            string script = @"'dummy';
debugger;
'dummy';";

            var engine = new Engine(options => options
                .DebugMode()
                .DebuggerStatementHandling(DebuggerStatementHandling.Script)
                .InitialStepMode(StepMode.Into));

            bool didBreak = false;
            int stepCount = 0;
            engine.Debugger.Break += (sender, info) =>
            {
                didBreak = true;
                return StepMode.None;
            };

            engine.Debugger.Step += (sender, info) =>
            {
                stepCount++;
                return StepMode.Into;
            };

            engine.Execute(script);
            Assert.Equal(3, stepCount);
            Assert.False(didBreak);
        }

        [Fact]
        public void DebuggerStatementDoesNotTriggerBreakWhenAtBreakPoint()
        {
            string script = @"'dummy';
debugger;
'dummy';";

            var engine = new Engine(options => options
                .DebugMode()
                .DebuggerStatementHandling(DebuggerStatementHandling.Script)
                .InitialStepMode(StepMode.None));

            int breakCount = 0;

            engine.Debugger.BreakPoints.Set(new BreakPoint(2, 0));

            engine.Debugger.Break += (sender, info) =>
            {
                Assert.Equal(PauseType.Break, info.PauseType);
                breakCount++;
                return StepMode.None;
            };

            engine.Execute(script);
            Assert.Equal(1, breakCount);
        }

        [Fact]
        public void BreakPointDoesNotTriggerBreakWhenStepping()
        {
            string script = @"
'first breakpoint';
'dummy';
'second breakpoint';";

            var engine = new Engine(options => options
                .DebugMode()
                .InitialStepMode(StepMode.Into));

            bool didStep = true;
            bool didBreak = true;

            engine.Debugger.BreakPoints.Set(new BreakPoint(2, 0));
            engine.Debugger.BreakPoints.Set(new BreakPoint(4, 0));

            engine.Debugger.Break += (sender, info) =>
            {
                didBreak = true;
                // first breakpoint shouldn't cause us to get here, because we're stepping,
                // but when we reach the second, we're running:
                Assert.True(TestHelpers.ReachedLiteral(info, "second breakpoint"));
                return StepMode.None;
            };

            engine.Debugger.Step += (sender, info) =>
            {
                didStep = true;
                if (TestHelpers.ReachedLiteral(info, "first breakpoint"))
                {
                    // Run from here
                    return StepMode.None;
                }
                return StepMode.Into;
            };

            engine.Execute(script);

            Assert.True(didStep);
            Assert.True(didBreak);
        }

        [Fact(Skip = "Non-source breakpoint is triggered before Statement, while debugger statement is now triggered by ExecuteInternal")]
        public void DebuggerStatementAndBreakpointTriggerSingleBreak()
        {
            string script = @"'dummy';
debugger;
'dummy';";

            var engine = new Engine(options => options
                .DebugMode()
                .DebuggerStatementHandling(DebuggerStatementHandling.Script));

            engine.Debugger.BreakPoints.Set(new BreakPoint(2, 0));

            int breakTriggered = 0;
            engine.Debugger.Break += (sender, info) =>
            {
                breakTriggered++;
                return StepMode.None;
            };

            engine.Execute(script);

            Assert.Equal(1, breakTriggered);
        }

        [Fact]
        public void BreakpointOverridesStepOut()
        {
            string script = @"function test()
{
'dummy';
'source';
'dummy';
'target';
}
test();";

            var engine = new Engine(options => options.DebugMode());

            engine.Debugger.BreakPoints.Set(new BreakPoint(4, 0));
            engine.Debugger.BreakPoints.Set(new BreakPoint(6, 0));

            int step = 0;
            engine.Debugger.Break += (sender, info) =>
            {
                step++;
                switch (step)
                {
                    case 1:
                        return StepMode.Out;
                    case 2:
                        Assert.True(info.ReachedLiteral("target"));
                        break;
                }
                return StepMode.None;
            };

            engine.Execute(script);

            Assert.Equal(2, step);
        }

        [Fact]
        public void ErrorInConditionalBreakpointLeavesCallStackAlone()
        {
            string script = @"
function foo()
{
let x = 0;
'before breakpoint';
'breakpoint 1 here';
'breakpoint 2 here';
'after breakpoint';
}

foo();
";
            var engine = new Engine(options => options.DebugMode().InitialStepMode(StepMode.Into));

            int stepsReached = 0;
            int breakpointsReached = 0;

            // This breakpoint will be hit:
            engine.Debugger.BreakPoints.Set(new BreakPoint(6, 0, "x == 0"));
            // This condition is an error (y is not defined). DebugHandler will
            // treat it as an unmatched breakpoint:
            engine.Debugger.BreakPoints.Set(new BreakPoint(7, 0, "y == 0"));

            engine.Debugger.Step += (sender, info) =>
            {
                if (info.ReachedLiteral("before breakpoint"))
                {
                    Assert.Equal(1, engine.CallStack.Count);
                    stepsReached++;
                    return StepMode.None;
                }
                else if (info.ReachedLiteral("after breakpoint"))
                {
                    Assert.Equal(1, engine.CallStack.Count);
                    stepsReached++;
                    return StepMode.None;
                }
                return StepMode.Into;
            };

            engine.Debugger.Break += (sender, info) =>
            {
                breakpointsReached++;
                return StepMode.Into;
            };

            engine.Execute(script);

            Assert.Equal(1, breakpointsReached);
            Assert.Equal(2, stepsReached);
        }

        private class SimpleHitConditionBreakPoint : BreakPoint
        {
            public SimpleHitConditionBreakPoint(int line, int column, string condition = null,
                int? hitCondition = null) : base(line, column, condition)
            {
                HitCondition = hitCondition;
            }

            public int HitCount { get; set; }
            public int? HitCondition { get; set; }
        }

        [Fact]
        public void BreakPointCanBeExtended()
        {
            // More of a documentation than a required test, this shows the usefulness of BreakPoint being
            // extensible - as a test, at least it ensures that it is.
            var script = @"
for (let i = 0; i < 10; i++)
{
    'breakpoint';
}
";
            var engine = new Engine(options => options.DebugMode().InitialStepMode(StepMode.None));

            engine.Debugger.BreakPoints.Set(
                new SimpleHitConditionBreakPoint(4, 4, condition: null, hitCondition: 5));

            int numberOfBreaks = 0;
            engine.Debugger.Break += (sender, info) =>
            {
                Assert.True(info.ReachedLiteral("breakpoint"));
                var extendedBreakPoint = Assert.IsType<SimpleHitConditionBreakPoint>(info.BreakPoint);
                extendedBreakPoint.HitCount++;
                if (extendedBreakPoint.HitCount == extendedBreakPoint.HitCondition)
                {
                    // Here is where we would normally pause the execution.
                    // the breakpoint is hit for the fifth time, when i is 4 (off by one)
                    Assert.Equal(4, info.CurrentScopeChain[0].GetBindingValue("i").AsInteger());
                    numberOfBreaks++;
                }
                return StepMode.None;
            };

            engine.Execute(script);

            Assert.Equal(1, numberOfBreaks);
        }
    }
}