@Test
	public void testFallthoughOverrideBranchToInstNext2() throws AddressFormatException {
		//verify the instructions needed for the test
		Address skip2Addr = defaultSpace.getAddress(SK_EQ_100008);
		Instruction skip2 = program.getListing().getInstructionAt(skip2Addr);
		assertNotNull(skip2);
		assertEquals("skeq", skip2.toString());
		Address addAddr = defaultSpace.getAddress(ADD_R0_R0_10000a);
		Instruction add = program.getListing().getInstructionAt(addAddr);
		assertNotNull(add);
		assertEquals("add r0,r0", add.toString());
		Address subAddr2 = defaultSpace.getAddress(SUB_R0_R0_10000c);
		Instruction sub2 = program.getListing().getInstructionAt(subAddr2);
		assertNotNull(sub2);
		assertEquals("sub r0,r0", sub2.toString());
		Address subAddr3 = defaultSpace.getAddress(SUB_R0_R0_10000e);
		Instruction sub3 = program.getListing().getInstructionAt(subAddr3);
		assertNotNull(sub3);
		assertEquals("sub r0,r0", sub3.toString());

		//get the pcode before the fallthrough override
		PcodeOp[] beforeFallthroughOverride = skip2.getPcode(false);
		assertTrue(beforeFallthroughOverride.length == 1);
		assertTrue(beforeFallthroughOverride[0].getOpcode() == PcodeOp.CBRANCH); //CBRANCH to inst_next2

		//verify that requesting overrides when there are none is the same as not requesting overrides
		assertTrue(equalPcodeOpArrays(skip2.getPcode(true), skip2.getPcode(false)));

		//apply the fallthrough override
		int tid = program.startTransaction("test");
		skip2.setFallThrough(subAddr3);
		program.endTransaction(tid, true);

		//verify that nothing changes if no overrides are requested
		assertTrue(equalPcodeOpArrays(beforeFallthroughOverride, skip2.getPcode(false)));
		assertTrue(equalPcodeOpArrays(beforeFallthroughOverride, skip2.getPcode()));

		//get the overridden pcode
		PcodeOp[] afterFallthroughOverride = skip2.getPcode(true);
		assertTrue(afterFallthroughOverride.length == beforeFallthroughOverride.length + 1);

		//verify that the CBRANCH to inst_next2 is *not* modified
		assertTrue(beforeFallthroughOverride[0].getOpcode() == PcodeOp.CBRANCH);
		assertTrue(equalPcodeOps(beforeFallthroughOverride[0], afterFallthroughOverride[0]));

		//verify the appended branch
		PcodeOp appendedBranch = afterFallthroughOverride[1];
		assertNull(appendedBranch.getOutput());
		assertTrue(appendedBranch.getOpcode() == PcodeOp.BRANCH);
		assertTrue(appendedBranch.getNumInputs() == 1);
		assertTrue(appendedBranch.getInput(0).isAddress());
		assertTrue(appendedBranch.getInput(0).getOffset() == subAddr3.getOffset());

		//create primary overriding reference and fallthrough override on add
		int id = program.startTransaction("test");
		Reference overrideRef = refManager.addMemoryReference(addAddr, func2Addr,
			RefType.JUMP_OVERRIDE_UNCONDITIONAL, SourceType.USER_DEFINED, -1);
		refManager.setPrimary(overrideRef, true);
		add.setFallThrough(subAddr3);
		program.endTransaction(id, true);

		//verify that overrideRef changes the target of the appended branch
		//and makes no other changes
		PcodeOp[] unmodifiedAdd = add.getPcode(false);
		PcodeOp[] overriddenAdd = add.getPcode(true);
		assertTrue(overriddenAdd.length == unmodifiedAdd.length + 1);
		for (int i = 0; i < unmodifiedAdd.length; ++i) {
			assertTrue(equalPcodeOps(unmodifiedAdd[i], overriddenAdd[i]));
		}
		PcodeOp overriddenBranch = overriddenAdd[overriddenAdd.length - 1];
		assertTrue(overriddenBranch.getOpcode() == PcodeOp.BRANCH);
		assertTrue(overriddenBranch.getInput(0).getOffset() == func2Addr.getOffset());
	}
Test that a fallthrough override does *not* modify branches to inst_next2
Test that the BRANCH op appended by a fallthrough override *is* subject to 
further modification by a JUMP_OVERRIDE_UNCONDITIONAL reference
@throws AddressFormatException if {@code AddressSpace.getAddress} throws it
Ghidra/Test/IntegrationTest/src/test.slow/java/ghidra/program/model/pcode/PcodeEmitContextTest.java