new_contents: from unittest import TestCase, main
  import os
  
  import angr
  import archinfo
  
  
  test_location = os.path.join(
      os.path.dirname(os.path.realpath(__file__)), "..", "..", "..", "..", "binaries", "tests"
  )
  
  
  # pylint: disable=missing-class-docstring
  # pylint: disable=no-self-use
  class TestPcodeEngine(TestCase):
  
      def test_shellcode(self):
          """
          Test basic CFG recovery and symbolic/concrete execution paths.
          """
          base_address = 0
          prototype = "int node_d(long)"
          code = archinfo.arch_from_id('AMD64').asm('''
          node_a:
              test rdi, rdi
              jz node_c
          node_b:
              mov rax, 0x1234
              jmp node_d
          node_c:
              mov rax, 0x5678
          node_d:
              ret
          ''', base_address)
  
          arch = angr.engines.pcode.ArchPcode.arch_from_lang_id('x86:LE:64:default')
          angr.calling_conventions.register_default_cc(arch.name, angr.calling_conventions.SimCCSystemVAMD64)
          p = angr.load_shellcode(code, arch=arch, load_address=base_address, engine=angr.engines.UberEnginePcode)
  
          # Recover the CFG
          c = p.analyses.CFGFast(normalize=True)
          assert len(c.model.nodes()) == 4
  
          # Execute symbolically
          s = p.factory.call_state(base_address, prototype=prototype)
          simgr = p.factory.simulation_manager(s)
          simgr.run()
          assert sum(map(len, simgr.stashes.values())) == 2
          assert {s.solver.eval(s.regs.rax) for s in simgr.deadended} == {0x1234, 0x5678}
  
          # Execute concretely
          callable_func = p.factory.callable(base_address, prototype=prototype, concrete_only=True)
          for input_, expected_output in [(0, 0x5678), (1, 0x1234), (0xffffffffffffffff, 0x1234)]:
              assert (callable_func(input_) == expected_output).is_true()
  
      def test_fauxware(self):
          """
          Test basic fauxware execution.
          """
          p = angr.Project(os.path.join(test_location, 'x86_64', "fauxware"), auto_load_libs=False,
                           engine=angr.engines.UberEnginePcode)
          simgr = p.factory.simgr()
          simgr.run()
  
          assert sum(map(len, simgr.stashes.values())) == len(simgr.deadended) == 3
  
          grant_paths = [s for s in simgr.deadended if b'trusted' in s.posix.dumps(1)]
          assert len(grant_paths) == 2
          assert sum(b"\x00\x00\x00\x00\x00\x00\x00\x00\x00SOSNEAKY\x00" == s.posix.dumps(0) for s in grant_paths) == 1
  
          deny_paths = [s for s in simgr.deadended if b'Go away!' in s.posix.dumps(1)]
          assert len(deny_paths) == 1
  
  
  if __name__ == '__main__':
      main()
  
subject: Add a couple sanity check test cases