11931128344

Committed 20 Nov 2024 10:07AM UTC coverage: 74.094% (+0.03%) from 74.066%

Build # 11931128344

Build Type

push

github

Committed by

web-flow

Commit Message

WriteInTryAnalzyer (#1248)

* WriteInTryAnalzyer

* simple test for WriteInTryAnalzyer

Run Details

4979 of 7326 branches covered (67.96%)

Branch coverage included in aggregate %.

193 of 243 new or added lines in 5 files covered. (79.42%)

1 existing line in 1 file now uncovered.

13254 of 17282 relevant lines covered (76.69%)

18313.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.05

/src/Neo.Compiler.CSharp/Optimizer/Analysers/TryCatchFinallyCoverage.cs

using Neo.Json;
using Neo.SmartContract;
using Neo.SmartContract.Manifest;
using Neo.VM;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Threading.Tasks.Dataflow;
using static Neo.Optimizer.JumpTarget;
using static Neo.Optimizer.OpCodeTypes;

namespace Neo.Optimizer
{
    public class TryCatchFinallySingleCoverage
    {
        public readonly ContractInBasicBlocks contractInBasicBlocks;
        public readonly int tryAddr;
        public readonly int catchAddr;
        public readonly int finallyAddr;
        public readonly BasicBlock tryBlock;
        public readonly BasicBlock? catchBlock;
        public readonly BasicBlock? finallyBlock;
        public HashSet<BasicBlock> tryBlocks { get; protected set; }
        public HashSet<BasicBlock> catchBlocks { get; protected set; }
        public HashSet<BasicBlock> finallyBlocks { get; protected set; }
        // where to go after the try-catch-finally is finished
        public HashSet<BasicBlock> endingBlocks { get; protected set; }
        public TryCatchFinallySingleCoverage(ContractInBasicBlocks contractInBasicBlocks,
            int tryAddr, int catchAddr, int finallyAddr,
            BasicBlock tryBlock, BasicBlock? catchBlock, BasicBlock? finallyBlock,
            HashSet<BasicBlock> tryBlocks, HashSet<BasicBlock> catchBlocks, HashSet<BasicBlock> finallyBlocks,
            HashSet<BasicBlock> endingBlocks)
        {
            this.contractInBasicBlocks = contractInBasicBlocks;
            this.tryAddr = tryAddr;
            this.catchAddr = catchAddr;
            this.finallyAddr = finallyAddr;
            this.tryBlock = tryBlock;
            this.catchBlock = catchBlock;
            this.finallyBlock = finallyBlock;
            this.tryBlocks = tryBlocks;
            this.catchBlocks = catchBlocks;
            this.finallyBlocks = finallyBlocks;
            this.endingBlocks = endingBlocks;
        }

        public TryCatchFinallySingleCoverage(ContractInBasicBlocks contractInBasicBlocks,
            int tryAddr, int catchAddr, int finallyAddr,
            BasicBlock tryBlock, BasicBlock? catchBlock, BasicBlock? finallyBlock) :
            this(contractInBasicBlocks, tryAddr, catchAddr, finallyAddr, tryBlock, catchBlock, finallyBlock,
                [], [], [], [])
        { }
    }

    public class TryCatchFinallyCoverage
    {
        public ContractInBasicBlocks contractInBasicBlocks { get; protected set; }
        // key: start of try block. prevBlock.instructions.Last() is TRY
        public Dictionary<BasicBlock, TryCatchFinallySingleCoverage> allTry { get; protected set; }

        public TryCatchFinallyCoverage(NefFile nef, ContractManifest manifest, JToken? debugInfo = null)
            : this(new ContractInBasicBlocks(nef, manifest, debugInfo)) { }

        public TryCatchFinallyCoverage(ContractInBasicBlocks contractInBasicBlocks)
        {
            this.contractInBasicBlocks = contractInBasicBlocks;
            allTry = new();
            foreach (BasicBlock b in contractInBasicBlocks.sortedBasicBlocks)
            {
                Instruction lastI = b.instructions.Last();
                if (lastI.OpCode == OpCode.TRY || lastI.OpCode == OpCode.TRY_L)
                {
                    (int catchAddr, int finallyAddr) = JumpTarget.ComputeTryTarget(b.lastAddr, lastI);
                    BasicBlock? catchBlock = catchAddr < 0 ? null : contractInBasicBlocks.basicBlocksByStartAddr[catchAddr];
                    BasicBlock? finallyBlock = finallyAddr < 0 ? null : contractInBasicBlocks.basicBlocksByStartAddr[finallyAddr];
                    allTry.Add(b.nextBlock!, new TryCatchFinallySingleCoverage(contractInBasicBlocks, b.lastAddr, catchAddr, finallyAddr, b, catchBlock, finallyBlock));
                }
            }
            foreach (BasicBlock b in allTry.Keys)
            {
                Stack<(BasicBlock tryBlock, BasicBlock? endFinallyBlock, TryType tryType, bool continueAfterFinally)> tryStack = new();
                tryStack.Push((b, null, TryType.TRY, true));
                CoverSingleTry(b, tryStack);
            }
        }

        public BranchType CoverSingleTry(BasicBlock currentBlock,
            Stack<(BasicBlock tryBlock, BasicBlock? endFinallyBlock, TryType tryType, bool continueAfterFinally)> tryStack)
        {
            if (tryStack.Count <= 0)
                return BranchType.OK;
            tryStack = InstructionCoverage.CopyStack(tryStack);
            (BasicBlock tryBlock, BasicBlock? endFinallyBlock, TryType tryType, bool continueAfterFinally) = tryStack.Peek();
            HashSet<BasicBlock> handledBlocks = tryType switch
            {
                TryType.TRY => allTry[tryBlock].tryBlocks,
                TryType.CATCH => allTry[tryBlock].catchBlocks,
                TryType.FINALLY => allTry[tryBlock].finallyBlocks,
                _ => throw new ArgumentException($"Invalid {nameof(tryType)} {tryType}"),
            };
            while (true)
            {
                if (handledBlocks.Contains(currentBlock))
                    return currentBlock.branchType;
                handledBlocks.Add(currentBlock);
                Instruction instruction = currentBlock.instructions.Last();
                if (instruction.OpCode == OpCode.ABORT || instruction.OpCode == OpCode.ABORTMSG)
                    return BranchType.ABORT;
                if (callWithJump.Contains(instruction.OpCode))
                {
                    if (instruction.OpCode == OpCode.CALLA)
                        foreach (int callaTarget in contractInBasicBlocks.coverage.pushaTargets.Keys)
                        {
                            BasicBlock callABlock = contractInBasicBlocks.basicBlocksByStartAddr[callaTarget];
                            CoverSingleTry(callABlock, tryStack);
                            // TODO: if a PUSHA cannot be covered, do not add it as a CALLA target
                        }
                    else
                    {
                        int callTarget = ComputeJumpTarget(currentBlock.lastAddr, instruction);
                        BasicBlock calledBlock = contractInBasicBlocks.basicBlocksByStartAddr[callTarget];
                        CoverSingleTry(calledBlock, tryStack);
                    }
                    if (currentBlock.branchType == BranchType.OK)
                        if (currentBlock.nextBlock != null)
                            // nextBlock can still be null, when we call a method in try that ABORTs
                            return CoverSingleTry(currentBlock.nextBlock!, tryStack);
                    return currentBlock.branchType;
                }
                if (instruction.OpCode == OpCode.RET)
                    return currentBlock.branchType;
                if (tryThrowFinally.Contains(instruction.OpCode))
                {
                    if (instruction.OpCode == OpCode.TRY || instruction.OpCode == OpCode.TRY_L)
                    {
                        tryStack.Push((currentBlock.nextBlock!, null, TryType.TRY, true));
                        CoverSingleTry(currentBlock.nextBlock!, tryStack);
                    }
                    if (instruction.OpCode == OpCode.THROW)
                    {
                        BasicBlock prevTryBlock;
                        TryType tryStateType;
                        do
                            (prevTryBlock, _, tryStateType, _) = tryStack.Pop();
                        while (tryStateType != TryType.TRY && tryStateType != TryType.CATCH && tryStack.Count > 0);
                        if (tryStateType == TryType.TRY)
                        {
                            if (allTry[prevTryBlock].catchBlock != null)
                            {
                                tryStack.Push((prevTryBlock, null, TryType.CATCH, true));
                                return CoverSingleTry(allTry[prevTryBlock].catchBlock!, tryStack);
                            }
                            else if (allTry[prevTryBlock].finallyBlock != null)
                            {
                                tryStack.Push((prevTryBlock, null, TryType.FINALLY, false));
                                if (CoverSingleTry(allTry[prevTryBlock].finallyBlock!, tryStack) == BranchType.ABORT)
                                    return BranchType.ABORT;
                                return BranchType.THROW;
                            }
                        }
                        if (tryType == TryType.CATCH && allTry[tryBlock].finallyBlock != null)
                        {
                            tryStack.Push((prevTryBlock, null, TryType.FINALLY, false));
                            if (CoverSingleTry(allTry[prevTryBlock].finallyBlock!, tryStack) == BranchType.ABORT)
                                return BranchType.ABORT;
                        }
                        return BranchType.THROW;
                    }
                    if (instruction.OpCode == OpCode.ENDTRY || instruction.OpCode == OpCode.ENDTRY_L)
                    {
                        if (tryType != TryType.TRY && tryType != TryType.CATCH)
                            throw new BadScriptException("No try stack on ENDTRY");
                        tryStack.Pop();  // pop the ending TRY or CATCH
                        if (tryType == TryType.TRY && allTry[tryBlock].catchBlock != null)
                        {
                            tryStack.Push((tryBlock, null, TryType.CATCH, true));
                            CoverSingleTry(allTry[tryBlock].catchBlock!, tryStack);
                        }
                        int endPointer = ComputeJumpTarget(currentBlock.lastAddr, instruction);
                        endFinallyBlock = contractInBasicBlocks.basicBlocksByStartAddr[endPointer];
                        if (allTry[tryBlock].finallyBlock != null)
                        {
                            tryStack.Push(new(tryBlock, endFinallyBlock, TryType.FINALLY, true));
                            currentBlock = allTry[tryBlock].finallyBlock!;
                        }
                        else
                        {
                            allTry[tryBlock].endingBlocks.Add(endFinallyBlock);
                            currentBlock = endFinallyBlock;
                        }
                        return CoverSingleTry(currentBlock, tryStack);
                    }
                    if (instruction.OpCode == OpCode.ENDFINALLY)
                    {
                        if (tryType != TryType.FINALLY)
                            throw new BadScriptException("No finally stack on ENDFINALLY");
                        tryStack.Pop();  // pop the ending FINALLY
                        if (continueAfterFinally)
                        {
                            allTry[tryBlock].endingBlocks.Add(endFinallyBlock!);
                            return CoverSingleTry(endFinallyBlock!, tryStack);
                        }
                        // For this basic block in finally, the branch type is OK
                        // The throw is caused by previous codes
                        return BranchType.OK;
                    }
                }
                if (unconditionalJump.Contains(instruction.OpCode))
                {
                    int target = ComputeJumpTarget(currentBlock.lastAddr, instruction);
                    BasicBlock targetBlock = contractInBasicBlocks.basicBlocksByStartAddr[target];
                    return CoverSingleTry(targetBlock, tryStack);
                }
                if (conditionalJump.Contains(instruction.OpCode) || conditionalJump_L.Contains(instruction.OpCode))
                {
                    BranchType noJump = CoverSingleTry(currentBlock.nextBlock!, tryStack);
                    int target = ComputeJumpTarget(currentBlock.lastAddr, instruction);
                    BasicBlock targetBlock = contractInBasicBlocks.basicBlocksByStartAddr[target];
                    BranchType jump = CoverSingleTry(targetBlock, tryStack);
                    if (noJump == BranchType.OK || jump == BranchType.OK)
                        return BranchType.OK;
                    if (noJump == BranchType.ABORT && jump == BranchType.ABORT)
                        return BranchType.ABORT;
                    if (noJump == BranchType.THROW || jump == BranchType.THROW)  // THROW, ABORT => THROW
                        return BranchType.THROW;
                }
                currentBlock = currentBlock.nextBlock!;
            }
        }
    }
}

1	using Neo.Json;
2	using Neo.SmartContract;
3	using Neo.SmartContract.Manifest;
4	using Neo.VM;
5	using System;
6	using System.Collections;
7	using System.Collections.Generic;
8	using System.Linq;
9	using System.Linq.Expressions;
10	using System.Net;
11	using System.Threading.Tasks.Dataflow;
12	using static Neo.Optimizer.JumpTarget;
13	using static Neo.Optimizer.OpCodeTypes;
14
15	namespace Neo.Optimizer
16	{
17	public class TryCatchFinallySingleCoverage
18	{
19	public readonly ContractInBasicBlocks contractInBasicBlocks;
20	public readonly int tryAddr;
21	public readonly int catchAddr;
22	public readonly int finallyAddr;
23	public readonly BasicBlock tryBlock;
24	public readonly BasicBlock? catchBlock;
25	public readonly BasicBlock? finallyBlock;
26	public HashSet<BasicBlock> tryBlocks { get; protected set; }	261✔
27	public HashSet<BasicBlock> catchBlocks { get; protected set; }	242✔
28	public HashSet<BasicBlock> finallyBlocks { get; protected set; }	524✔
29	// where to go after the try-catch-finally is finished
30	public HashSet<BasicBlock> endingBlocks { get; protected set; }	78✔
31	public TryCatchFinallySingleCoverage(ContractInBasicBlocks contractInBasicBlocks,	42✔
32	int tryAddr, int catchAddr, int finallyAddr,	42✔
33	BasicBlock tryBlock, BasicBlock? catchBlock, BasicBlock? finallyBlock,	42✔
34	HashSet<BasicBlock> tryBlocks, HashSet<BasicBlock> catchBlocks, HashSet<BasicBlock> finallyBlocks,	42✔
35	HashSet<BasicBlock> endingBlocks)	42✔
36	{	42✔
37	this.contractInBasicBlocks = contractInBasicBlocks;	42✔
38	this.tryAddr = tryAddr;	42✔
39	this.catchAddr = catchAddr;	42✔
40	this.finallyAddr = finallyAddr;	42✔
41	this.tryBlock = tryBlock;	42✔
42	this.catchBlock = catchBlock;	42✔
43	this.finallyBlock = finallyBlock;	42✔
44	this.tryBlocks = tryBlocks;	42✔
45	this.catchBlocks = catchBlocks;	42✔
46	this.finallyBlocks = finallyBlocks;	42✔
47	this.endingBlocks = endingBlocks;	42✔
48	}	42✔
49
50	public TryCatchFinallySingleCoverage(ContractInBasicBlocks contractInBasicBlocks,
51	int tryAddr, int catchAddr, int finallyAddr,
52	BasicBlock tryBlock, BasicBlock? catchBlock, BasicBlock? finallyBlock) :
53	this(contractInBasicBlocks, tryAddr, catchAddr, finallyAddr, tryBlock, catchBlock, finallyBlock,	42✔
54	[], [], [], [])	42✔
55	{ }	84✔
56	}
57
58	public class TryCatchFinallyCoverage
59	{
60	public ContractInBasicBlocks contractInBasicBlocks { get; protected set; }	454✔
61	// key: start of try block. prevBlock.instructions.Last() is TRY
62	public Dictionary<BasicBlock, TryCatchFinallySingleCoverage> allTry { get; protected set; }	1,262✔
63
64	public TryCatchFinallyCoverage(NefFile nef, ContractManifest manifest, JToken? debugInfo = null)
NEW 65	: this(new ContractInBasicBlocks(nef, manifest, debugInfo)) { }	×
66
67	public TryCatchFinallyCoverage(ContractInBasicBlocks contractInBasicBlocks)	2✔
68	{	2✔
69	this.contractInBasicBlocks = contractInBasicBlocks;	2✔
70	allTry = new();	2✔
71	foreach (BasicBlock b in contractInBasicBlocks.sortedBasicBlocks)	1,566✔
72	{	780✔
73	Instruction lastI = b.instructions.Last();	780✔
74	if (lastI.OpCode == OpCode.TRY \|\| lastI.OpCode == OpCode.TRY_L)	780✔
75	{	42✔
76	(int catchAddr, int finallyAddr) = JumpTarget.ComputeTryTarget(b.lastAddr, lastI);	42✔
77	BasicBlock? catchBlock = catchAddr < 0 ? null : contractInBasicBlocks.basicBlocksByStartAddr[catchAddr];	42✔
78	BasicBlock? finallyBlock = finallyAddr < 0 ? null : contractInBasicBlocks.basicBlocksByStartAddr[finallyAddr];	42✔
79	allTry.Add(b.nextBlock!, new TryCatchFinallySingleCoverage(contractInBasicBlocks, b.lastAddr, catchAddr, finallyAddr, b, catchBlock, finallyBlock));	42✔
80	}	42✔
81	}	780✔
82	foreach (BasicBlock b in allTry.Keys)	90✔
83	{	42✔
84	Stack<(BasicBlock tryBlock, BasicBlock? endFinallyBlock, TryType tryType, bool continueAfterFinally)> tryStack = new();	42✔
85	tryStack.Push((b, null, TryType.TRY, true));	42✔
86	CoverSingleTry(b, tryStack);	42✔
87	}	42✔
88	}	2✔
89
90	public BranchType CoverSingleTry(BasicBlock currentBlock,
91	Stack<(BasicBlock tryBlock, BasicBlock? endFinallyBlock, TryType tryType, bool continueAfterFinally)> tryStack)
92	{	912✔
93	if (tryStack.Count <= 0)	912✔
94	return BranchType.OK;	32✔
95	tryStack = InstructionCoverage.CopyStack(tryStack);	880✔
96	(BasicBlock tryBlock, BasicBlock? endFinallyBlock, TryType tryType, bool continueAfterFinally) = tryStack.Peek();	880✔
97	HashSet<BasicBlock> handledBlocks = tryType switch	880!
98	{	880✔
99	TryType.TRY => allTry[tryBlock].tryBlocks,	198✔
100	TryType.CATCH => allTry[tryBlock].catchBlocks,	200✔
101	TryType.FINALLY => allTry[tryBlock].finallyBlocks,	482✔
NEW 102	_ => throw new ArgumentException($"Invalid {nameof(tryType)} {tryType}"),	×
103	};	880✔
104	while (true)	1,040✔
105	{	1,040✔
106	if (handledBlocks.Contains(currentBlock))	1,040✔
107	return currentBlock.branchType;	352✔
108	handledBlocks.Add(currentBlock);	688✔
109	Instruction instruction = currentBlock.instructions.Last();	688✔
110	if (instruction.OpCode == OpCode.ABORT \|\| instruction.OpCode == OpCode.ABORTMSG)	688✔
111	return BranchType.ABORT;	2✔
112	if (callWithJump.Contains(instruction.OpCode))	686✔
113	{	12✔
114	if (instruction.OpCode == OpCode.CALLA)	12!
NEW 115	foreach (int callaTarget in contractInBasicBlocks.coverage.pushaTargets.Keys)	×
NEW 116	{	×
NEW 117	BasicBlock callABlock = contractInBasicBlocks.basicBlocksByStartAddr[callaTarget];	×
NEW 118	CoverSingleTry(callABlock, tryStack);	×
119	// TODO: if a PUSHA cannot be covered, do not add it as a CALLA target
NEW 120	}	×
121	else
122	{	12✔
123	int callTarget = ComputeJumpTarget(currentBlock.lastAddr, instruction);	12✔
124	BasicBlock calledBlock = contractInBasicBlocks.basicBlocksByStartAddr[callTarget];	12✔
125	CoverSingleTry(calledBlock, tryStack);	12✔
126	}	12✔
127	if (currentBlock.branchType == BranchType.OK)	12✔
128	if (currentBlock.nextBlock != null)	12✔
129	// nextBlock can still be null, when we call a method in try that ABORTs
130	return CoverSingleTry(currentBlock.nextBlock!, tryStack);	10✔
131	return currentBlock.branchType;	2✔
132	}
133	if (instruction.OpCode == OpCode.RET)	674✔
134	return currentBlock.branchType;	2✔
135	if (tryThrowFinally.Contains(instruction.OpCode))	672✔
136	{	154✔
137	if (instruction.OpCode == OpCode.TRY \|\| instruction.OpCode == OpCode.TRY_L)	154✔
138	{	4✔
139	tryStack.Push((currentBlock.nextBlock!, null, TryType.TRY, true));	4✔
140	CoverSingleTry(currentBlock.nextBlock!, tryStack);	4✔
141	}	4✔
142	if (instruction.OpCode == OpCode.THROW)	154✔
143	{	34✔
144	BasicBlock prevTryBlock;
145	TryType tryStateType;
146	do
147	(prevTryBlock, _, tryStateType, _) = tryStack.Pop();	36✔
148	while (tryStateType != TryType.TRY && tryStateType != TryType.CATCH && tryStack.Count > 0);	36✔
149	if (tryStateType == TryType.TRY)	34✔
150	{	30✔
151	if (allTry[prevTryBlock].catchBlock != null)	30✔
152	{	26✔
153	tryStack.Push((prevTryBlock, null, TryType.CATCH, true));	26✔
154	return CoverSingleTry(allTry[prevTryBlock].catchBlock!, tryStack);	26✔
155	}
156	else if (allTry[prevTryBlock].finallyBlock != null)	4!
157	{	4✔
158	tryStack.Push((prevTryBlock, null, TryType.FINALLY, false));	4✔
159	if (CoverSingleTry(allTry[prevTryBlock].finallyBlock!, tryStack) == BranchType.ABORT)	4!
NEW 160	return BranchType.ABORT;	×
161	return BranchType.THROW;	4✔
162	}
NEW 163	}	×
164	if (tryType == TryType.CATCH && allTry[tryBlock].finallyBlock != null)	4!
165	{	4✔
166	tryStack.Push((prevTryBlock, null, TryType.FINALLY, false));	4✔
167	if (CoverSingleTry(allTry[prevTryBlock].finallyBlock!, tryStack) == BranchType.ABORT)	4!
NEW 168	return BranchType.ABORT;	×
169	}	4✔
170	return BranchType.THROW;	4✔
171	}
172	if (instruction.OpCode == OpCode.ENDTRY \|\| instruction.OpCode == OpCode.ENDTRY_L)	120✔
173	{	78✔
174	if (tryType != TryType.TRY && tryType != TryType.CATCH)	78!
NEW 175	throw new BadScriptException("No try stack on ENDTRY");	×
176	tryStack.Pop(); // pop the ending TRY or CATCH	78✔
177	if (tryType == TryType.TRY && allTry[tryBlock].catchBlock != null)	78✔
178	{	36✔
179	tryStack.Push((tryBlock, null, TryType.CATCH, true));	36✔
180	CoverSingleTry(allTry[tryBlock].catchBlock!, tryStack);	36✔
181	}	36✔
182	int endPointer = ComputeJumpTarget(currentBlock.lastAddr, instruction);	78✔
183	endFinallyBlock = contractInBasicBlocks.basicBlocksByStartAddr[endPointer];	78✔
184	if (allTry[tryBlock].finallyBlock != null)	78✔
185	{	72✔
186	tryStack.Push(new(tryBlock, endFinallyBlock, TryType.FINALLY, true));	72✔
187	currentBlock = allTry[tryBlock].finallyBlock!;	72✔
188	}	72✔
189	else
190	{	6✔
191	allTry[tryBlock].endingBlocks.Add(endFinallyBlock);	6✔
192	currentBlock = endFinallyBlock;	6✔
193	}	6✔
194	return CoverSingleTry(currentBlock, tryStack);	78✔
195	}
196	if (instruction.OpCode == OpCode.ENDFINALLY)	42✔
197	{	38✔
198	if (tryType != TryType.FINALLY)	38!
NEW 199	throw new BadScriptException("No finally stack on ENDFINALLY");	×
200	tryStack.Pop(); // pop the ending FINALLY	38✔
201	if (continueAfterFinally)	38✔
202	{	30✔
203	allTry[tryBlock].endingBlocks.Add(endFinallyBlock!);	30✔
204	return CoverSingleTry(endFinallyBlock!, tryStack);	30✔
205	}
206	// For this basic block in finally, the branch type is OK
207	// The throw is caused by previous codes
208	return BranchType.OK;	8✔
209	}
210	}	4✔
211	if (unconditionalJump.Contains(instruction.OpCode))	522✔
212	{	58✔
213	int target = ComputeJumpTarget(currentBlock.lastAddr, instruction);	58✔
214	BasicBlock targetBlock = contractInBasicBlocks.basicBlocksByStartAddr[target];	58✔
215	return CoverSingleTry(targetBlock, tryStack);	58✔
216	}
217	if (conditionalJump.Contains(instruction.OpCode) \|\| conditionalJump_L.Contains(instruction.OpCode))	464✔
218	{	304✔
219	BranchType noJump = CoverSingleTry(currentBlock.nextBlock!, tryStack);	304✔
220	int target = ComputeJumpTarget(currentBlock.lastAddr, instruction);	304✔
221	BasicBlock targetBlock = contractInBasicBlocks.basicBlocksByStartAddr[target];	304✔
222	BranchType jump = CoverSingleTry(targetBlock, tryStack);	304✔
223	if (noJump == BranchType.OK \|\| jump == BranchType.OK)	304!
224	return BranchType.OK;	304✔
NEW 225	if (noJump == BranchType.ABORT && jump == BranchType.ABORT)	×
NEW 226	return BranchType.ABORT;	×
NEW 227	if (noJump == BranchType.THROW \|\| jump == BranchType.THROW) // THROW, ABORT => THROW	×
NEW 228	return BranchType.THROW;	×
NEW 229	}	×
230	currentBlock = currentBlock.nextBlock!;	160✔
231	}	160✔
232	}	912✔
233	}
234	}

neo-project / neo-devpack-dotnet / 11931128344

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous