def __init__(self, system):
self.system = system
self.TOOL_NAME = self.__class__.__name__.lower()
build_root = os.path.join(Config().build_root,
self.system.sanitized_name)
self.src_root = os.path.join(build_root, 'src')
self.work_root = os.path.join(build_root,
self.TOOL_TYPE + '-' + self.TOOL_NAME)
self.cm = CoreManager()
self.cores = self.cm.get_depends(self.system.name)
self.env = os.environ.copy()
#FIXME: Remove BUILD_ROOT once cores have had some time
# to migrate to SRC_ROOT/WORK_ROOT
self.env['BUILD_ROOT'] = os.path.abspath(build_root)
self.env['SRC_ROOT'] = os.path.abspath(self.src_root)
self.env['WORK_ROOT'] = os.path.abspath(self.work_root)
self.plusarg = {}
self.vlogparam = {}
self.vlogdefine = {}
self.generic = {}
self.cmdlinearg = {}
def test_library_add():
from fusesoc.main import add_library, run
from fusesoc.coremanager import CoreManager
tcf = tempfile.NamedTemporaryFile(mode="w+")
conf = Config(file=tcf)
cm = CoreManager(conf)
args = Namespace()
args.name = 'fusesoc-cores'
args.location = None
args.config = tcf
args.no_auto_sync = False
vars(args)['sync-uri'] = sync_uri
add_library(cm, args)
expected = """[library.fusesoc-cores]
sync-uri = https://github.com/fusesoc/fusesoc-cores"""
tcf.seek(0)
result = tcf.read().strip()
assert expected == result
def get_sim(sim, core, export=False):
from fusesoc.coremanager import CoreManager
from fusesoc.main import _import
CoreManager().tool = sim
toplevel = core.get_toplevel({})
return _import('simulator', sim)(core, export=export, toplevel=toplevel)
def __init__(self, system, export, toplevel):
self.system = system
self.export = export
self.TOOL_NAME = self.__class__.__name__.lower()
self.flags = {'tool': self.TOOL_NAME, 'flow': self.TOOL_TYPE}
build_root = os.path.join(Config().build_root,
self.system.sanitized_name)
self.src_root = os.path.join(build_root, 'src')
self.work_root = os.path.join(build_root,
self.TOOL_TYPE + '-' + self.TOOL_NAME)
self.cm = CoreManager()
self.cores = self.cm.get_depends(self.system.name, self.flags)
self.env = os.environ.copy()
#FIXME: Remove BUILD_ROOT once cores have had some time
# to migrate to SRC_ROOT/WORK_ROOT
self.env['BUILD_ROOT'] = os.path.abspath(build_root)
self.env['SRC_ROOT'] = os.path.abspath(self.src_root)
self.env['WORK_ROOT'] = os.path.abspath(self.work_root)
self.plusarg = OrderedDict()
self.vlogparam = OrderedDict()
self.vlogdefine = OrderedDict()
self.generic = OrderedDict()
self.cmdlinearg = OrderedDict()
self.parsed_args = False
self.toplevel = toplevel
def test_copyto():
tests_dir = os.path.dirname(__file__)
core = get_core("copytocore")
flags = {'tool': 'icarus'}
export_root = None
work_root = os.path.join(tests_dir, 'build', core.name.sanitized_name,
core.get_work_root(flags))
if os.path.exists(work_root):
for f in os.listdir(work_root):
if os.path.isdir(os.path.join(work_root, f)):
shutil.rmtree(os.path.join(work_root, f))
else:
os.remove(os.path.join(work_root, f))
else:
os.makedirs(work_root)
eda_api = CoreManager().setup(core.name, flags, work_root, None)
assert eda_api['files'] == [{
'file_type': 'user',
'logical_name': '',
'name': 'copied.file',
'is_include_file': False
}, {
'file_type': 'tclSource',
'logical_name': '',
'name': 'subdir/another.file',
'is_include_file': False
}]
assert os.path.exists(os.path.join(work_root, 'copied.file'))
assert os.path.exists(os.path.join(work_root, 'subdir', 'another.file'))
def init_coremanager(config, args_cores_root):
logger.debug("Command line arguments: " + str(sys.argv))
if os.getenv("FUSESOC_CORES"):
logger.debug("FUSESOC_CORES: " +
str(os.getenv("FUSESOC_CORES").split(':')))
cm = CoreManager(config)
# Get the environment variable for further cores
env_cores_root = []
if os.getenv("FUSESOC_CORES"):
env_cores_root = os.getenv("FUSESOC_CORES").split(":")
env_cores_root.reverse()
core_libraries = [l['location'] for l in config.libraries.values()]
for cores_root in config.cores_root + \
[config.systems_root] + \
env_cores_root + \
core_libraries + \
args_cores_root:
try:
cm.add_cores_root(cores_root)
except (RuntimeError, IOError) as e:
logger.warning("Failed to register cores root '{}'".format(str(e)))
return cm
def list_cores(args):
cores = CoreManager().get_cores()
print("\nAvailable cores:\n")
if not cores:
cores_root = CoreManager().get_cores_root()
if cores_root:
logger.error("No cores found in " + ':'.join(cores_root))
else:
logger.error("cores_root is not defined")
exit(1)
maxlen = max(map(len, cores.keys()))
print('Core'.ljust(maxlen) + ' Cache status')
print("=" * 80)
for name in sorted(cores.keys()):
core = cores[name]
print(name.ljust(maxlen) + ' : ' + core.cache_status())
def test_sim(capsys):
class Args():
sim = None
testbench = None
target = None
keep = False
backendargs = None
setup = True
build_only = False
no_export = False
def __init__(self, system):
self.system = system
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
build_root = os.path.join(tests_dir, 'build')
config = Config()
config.build_root = build_root
config.cache_root = cache_root
common_cm = CoreManager(config)
common_cm.add_cores_root(cores_root)
args = Args(system="wb_common")
with pytest.raises(SystemExit):
sim(common_cm, args)
out, err = capsys.readouterr()
assert out == ""
#Workaround since this test fails with Travis on Python2.7. No idea why
import sys
if sys.version_info[0] > 2:
assert err == "No tool was supplied on command line or found in 'wb_common' core description\n"
def run(args):
cm = CoreManager()
config = Config()
for cores_root in [
config.cores_root, config.systems_root, args.cores_root
]:
try:
cm.add_cores_root(cores_root)
except (RuntimeError, IOError) as e:
pr_warn("Failed to register cores root '{}'".format(str(e)))
# Process global options
if vars(args)['32']:
config.archbits = 32
logger.debug("Forcing 32-bit mode")
elif vars(args)['64']:
config.archbits = 64
logger.debug("Forcing 64-bit mode")
else:
config.archbits = 64 if platform.architecture()[0] == '64bit' else 32
logger.debug("Autodetected " + str(config.archbits) + "-bit mode")
config.monochrome = vars(args)['monochrome']
if config.monochrome:
logger.debug("Monochrome output")
else:
logger.debug("Colorful output")
config.verbose = vars(args)['verbose']
if config.verbose:
logger.debug("Verbose output")
else:
logger.debug("Concise output")
# Run the function
args.func(args)
def run(args):
level = logging.DEBUG if args.verbose else logging.INFO
setup_logging(level=level, monchrome=args.monochrome)
logger.debug("Command line arguments: " + str(sys.argv))
if os.getenv("FUSESOC_CORES"):
logger.debug("FUSESOC_CORES: " +
str(os.getenv("FUSESOC_CORES").split(':')))
if args.verbose:
logger.debug("Verbose output")
else:
logger.debug("Concise output")
if args.monochrome:
logger.debug("Monochrome output")
else:
logger.debug("Colorful output")
if args.config:
config = Config(file=args.config)
else:
config = Config()
cm = CoreManager(config)
# Get the environment variable for further cores
env_cores_root = []
if os.getenv("FUSESOC_CORES"):
env_cores_root = os.getenv("FUSESOC_CORES").split(":")
env_cores_root.reverse()
for cores_root in [
config.cores_root, config.systems_root, env_cores_root,
args.cores_root
]:
try:
cm.add_cores_root(cores_root)
except (RuntimeError, IOError) as e:
logger.warning("Failed to register cores root '{}'".format(str(e)))
for library in config.libraries.values():
try:
cm.add_cores_root(library['location'])
except (RuntimeError, IOError) as e:
logger.warning("Failed to register cores root '{}'".format(str(e)))
# Process global options
if vars(args)['32']:
config.archbits = 32
logger.debug("Forcing 32-bit mode")
elif vars(args)['64']:
config.archbits = 64
logger.debug("Forcing 64-bit mode")
else:
config.archbits = 64 if platform.architecture()[0] == '64bit' else 32
logger.debug("Autodetected " + str(config.archbits) + "-bit mode")
# Run the function
args.func(cm, args)
def sim(args):
core = _get_core(args.system)
if args.sim:
sim_name = args.sim[0]
elif core.simulators:
sim_name = core.simulators[0]
else:
pr_err("No simulator was found in '" + args.system +
"' core description")
logger.error("No simulator was found in '" + args.system +
"' core description")
exit(1)
try:
CoreManager().tool = sim_name
sim = _import('simulator', sim_name)(core)
except DependencyError as e:
pr_err("'" + args.system + "' or any of its dependencies requires '" +
e.value + "', but this core was not found")
exit(1)
except ImportError:
pr_err("Unknown simulator '{}'".format(sim_name))
exit(1)
except OptionSectionMissing as e:
pr_err("'" + args.system + "' miss a mandatory parameter for " +
sim_name + " simulation (" + e.value + ")")
exit(1)
except RuntimeError as e:
pr_err(str(e))
exit(1)
if (args.testbench):
sim.toplevel = args.testbench[0]
if not args.keep or not os.path.exists(sim.work_root):
try:
sim.configure(args.plusargs)
print('')
except RuntimeError as e:
pr_err("Failed to configure the system")
pr_err(str(e))
exit(1)
if args.setup:
exit(0)
try:
sim.build()
except Source as e:
pr_err("'" + e.value +
"' source type is not valid. Choose 'C' or 'systemC'")
exit(1)
except RuntimeError as e:
pr_err("Failed to build simulation model")
pr_err(str(e))
exit(1)
if not args.build_only:
try:
sim.run(args.plusargs)
except RuntimeError as e:
pr_err("Failed to run the simulation")
pr_err(str(e))
def get_sim(sim, core, export=False):
import os.path
from fusesoc.coremanager import CoreManager
from fusesoc.config import Config
from fusesoc.main import _import
flags = {'flow': 'sim', 'tool': sim}
eda_api = CoreManager().get_eda_api(core.name, flags)
export_root = os.path.join(Config().build_root, core.name.sanitized_name,
'src')
work_root = os.path.join(Config().build_root, core.name.sanitized_name,
'sim-' + sim)
CoreManager().setup(core.name,
flags,
export=export,
export_root=export_root)
return _import(sim)(eda_api=eda_api, work_root=work_root)
def __init__(self, system):
config = Config()
self.system = system
self.build_root = os.path.join(config.build_root, self.system.name)
self.src_root = os.path.join(self.build_root, 'src')
self.cm = CoreManager()
self.cores = self.cm.get_depends(self.system.name)
self.env = os.environ.copy()
self.env['BUILD_ROOT'] = os.path.abspath(self.build_root)
def _get_core(name):
core = None
try:
core = CoreManager().get_core(Vlnv(name))
except RuntimeError as e:
logger.error(str(e))
exit(1)
except DependencyError as e:
logger.error("'" + name + "' or any of its dependencies requires '" + e.value + "', but this core was not found")
exit(1)
return core
def test_copyto():
import os
import tempfile
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.edalizer import Edalizer
from fusesoc.librarymanager import Library
from fusesoc.vlnv import Vlnv
flags = {"tool": "icarus"}
work_root = tempfile.mkdtemp(prefix="copyto_")
core_dir = os.path.join(os.path.dirname(__file__), "cores", "misc", "copytocore")
lib = Library("misc", core_dir)
cm = CoreManager(Config())
cm.add_library(lib)
core = cm.get_core(Vlnv("::copytocore"))
edalizer = Edalizer(
toplevel=core.name,
flags=flags,
core_manager=cm,
cache_root=None,
work_root=work_root,
export_root=None,
system_name=None,
)
edalizer.run()
eda_api = edalizer.edalize
assert eda_api["files"] == [
{
"file_type": "user",
"core": "::copytocore:0",
"logical_name": "",
"name": "copied.file",
"is_include_file": False,
},
{
"file_type": "tclSource",
"core": "::copytocore:0",
"logical_name": "",
"name": "subdir/another.file",
"is_include_file": False,
},
]
assert os.path.exists(os.path.join(work_root, "copied.file"))
assert os.path.exists(os.path.join(work_root, "subdir", "another.file"))
def sim(args):
core = _get_core(args.system)
if args.sim:
sim_name = args.sim[0]
elif core.simulators:
sim_name = core.simulators[0]
else:
logger.error("No simulator was found in '" + args.system +
"' core description")
logger.error("No simulator was found in '" + args.system +
"' core description")
exit(1)
try:
CoreManager().tool = sim_name
sim = _import('simulator', sim_name)(core, export=True)
except DependencyError as e:
logger.error("'" + args.system +
"' or any of its dependencies requires '" + e.value +
"', but this core was not found")
exit(1)
except ImportError:
logger.error("Unknown simulator '{}'".format(sim_name))
exit(1)
except RuntimeError as e:
logger.error(str(e))
exit(1)
if (args.testbench):
sim.toplevel = args.testbench[0]
else:
sim.toplevel = sim.system.simulator['toplevel']
if not args.keep or not os.path.exists(sim.work_root):
try:
sim.configure(args.plusargs)
print('')
except RuntimeError as e:
logger.error("Failed to configure the system")
logger.error(str(e))
exit(1)
if args.setup:
exit(0)
try:
sim.build()
except RuntimeError as e:
logger.error("Failed to build simulation model")
logger.error(str(e))
exit(1)
if not args.build_only:
try:
sim.run(args.plusargs)
except RuntimeError as e:
logger.error("Failed to run the simulation")
logger.error(str(e))
exit(1)
def get_core(core):
from fusesoc.coremanager import CoreManager
from fusesoc.config import Config
from fusesoc.main import _get_core
config = Config()
config.build_root = build_root
config.cache_root = cache_root
cm = CoreManager(config)
cm.add_cores_root(cores_root)
return _get_core(cm, core)
def get_synth(tool, core, export=False):
import os.path
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.main import _import
flags = {'flow': 'synth', 'tool': tool}
eda_api = CoreManager().get_eda_api(core.name, flags)
work_root = os.path.join(Config().build_root, core.name.sanitized_name,
'bld-' + tool)
return _import(core.main.backend)(eda_api=eda_api, work_root=work_root)
def configure(self):
if os.path.exists(self.work_root):
shutil.rmtree(self.work_root)
os.makedirs(self.work_root)
cm = CoreManager()
for name in self.cores:
pr_info("Preparing " + name)
core = cm.get_core(name)
dst_dir = os.path.join(Config().build_root, self.system.name,
'src', name)
core.setup()
core.export(dst_dir)
def main():
# VUnit steals the command line args so we use an environment variable
# to determine which core we're picking up
toplevel = os.getenv("CORE", "")
if not toplevel:
sys.stderr.write("Need to provide CORE environment variable")
sys.exit(1)
# Create VUnit instance by parsing command line arguments
vu = VUnit.from_argv()
#Create singleton instances for core manager and configuration handler
#Configuration manager is not needed in this example
cm = CoreManager()
# Assume we're running in the same directory containing the cores
cm.add_cores_root(".")
#Get the sorted list of dependencies starting from the top-level core
try:
cores = cm.get_depends(toplevel)
except DependencyError as e:
print("'{}' or any of its dependencies requires '{}', but this core was not found".format(top_core, e.value))
sys.exit(2)
#Iterate over cores, filesets and files and add all relevant sources files to vunit
incdirs = set()
src_files = []
#'usage' is a list of tags to look for in the filesets.
# Only look at filesets where any of these tags are present
usage = ['sim']
for core_name in cores:
core = cm.get_core(core_name)
core.setup()
basepath = core.files_root
for fs in core.file_sets:
if (set(fs.usage) & set(usage)) and ((core_name == toplevel) or not fs.private):
for file in fs.file:
if file.is_include_file:
#TODO: incdirs not used right now
incdirs.add(os.path.join(basepath, os.path.dirname(file.name)))
else:
try:
vu.library(file.logical_name)
except KeyError:
vu.add_library(file.logical_name)
vu.add_source_file(os.path.join(basepath, file.name), file.logical_name)
# Run vunit function
vu.main()
def update(args):
for root in CoreManager().get_cores_root():
if os.path.exists(root):
args = ['-C', root, 'config', '--get', 'remote.origin.url']
repo_root = ""
try:
repo_root = subprocess.check_output(['git'] +
args).decode("utf-8")
if repo_root.strip() in [repo[1] for repo in REPOS]:
pr_info("Updating '{}'".format(root))
args = ['-C', root, 'pull']
Launcher('git', args).run()
except subprocess.CalledProcessError:
pass
def test_verilator():
tests_dir = os.path.dirname(__file__)
params = '--vlogparam_bool --vlogparam_int=42 --vlogparam_str=hello'
params += ' --vlogdefine_bool --vlogdefine_int=42 --vlogdefine_str=hello'
Config().build_root = os.path.join(tests_dir, 'build')
Config().cache_root = os.path.join(tests_dir, 'cache')
cores_root = os.path.join(tests_dir, 'cores')
CoreManager().add_cores_root(cores_root)
core = _get_core("mor1kx-generic")
sim_name = 'verilator'
CoreManager().tool = sim_name
backend = _import('simulator', sim_name)(core, export=False)
backend.configure(params.split())
ref_dir = os.path.join(tests_dir, __name__)
work_root = backend.work_root
assert '' == compare_file(ref_dir, work_root, 'config.mk')
assert '' == compare_file(ref_dir, work_root, 'Makefile')
assert '' == compare_file(ref_dir, work_root, core.sanitized_name + '.vc')
def configure(self):
logger.debug('configure() *Entered*')
if os.path.exists(self.work_root):
shutil.rmtree(self.work_root)
os.makedirs(self.work_root)
cm = CoreManager()
for name in self.cores:
print("Preparing " + name)
core = cm.get_core(name)
dst_dir = os.path.join(Config().build_root, self.system.name,
'src', name)
core.setup()
core.export(dst_dir)
logger.debug('configure() -Done-')
def cmd_files(args):
cfg_file = _ConfigFile("")
cfg = Config(file=cfg_file)
# logging.basicConfig(level=logging.DEBUG)
cm = CoreManager(cfg)
packages_dir = get_packages_dir()
project_dir = os.path.dirname(packages_dir)
cm.add_library(Library("project", project_dir))
if args.library_path is not None:
for lib in args.library_path:
colon_i = lib.find(':')
if colon_i > 1:
path = lib[colon_i + 1:]
lib_name = lib[:colon_i]
else:
path = lib
lib_name = "cmdline"
cm.add_library(Library(lib_name, path))
top_flags = {"is_toplevel": True}
if hasattr(args, "target") and args.target is not None:
top_flags["target"] = args.target
# Use detailed arguments
core_deps = cm.get_depends(Vlnv(args.vlnv), flags=top_flags)
flags = {}
if hasattr(args, "flags") and args.flags is not None:
for f in args.flags:
subflags = f.split(',')
for sf in subflags:
flags[sf] = True
file_type = None
if args.file_type is not None:
file_type = set()
for t in args.file_type:
subtypes = t.split(',')
for st in subtypes:
file_type.add(st)
_extract_files(sys.stdout, core_deps, file_type, flags, args.include)
def _get_core(name, has_system=False):
core = None
try:
core = CoreManager().get_core(Vlnv(name))
except RuntimeError as e:
pr_err(str(e))
exit(1)
except DependencyError as e:
pr_err("'" + name + "' or any of its dependencies requires '" + e.value + "', but this core was not found")
exit(1)
if has_system and not core.backend:
pr_err("Unable to find .system file for '{}'".format(name))
exit(1)
return core
def get_core(core):
import os
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.main import _get_core
tests_dir = os.path.dirname(__file__)
Config().build_root = os.path.join(tests_dir, 'build')
Config().cache_root = os.path.join(tests_dir, 'cache')
cores_root = os.path.join(tests_dir, 'cores')
CoreManager().add_cores_root(cores_root)
return _get_core(core)
def init_coremanager(config, args_cores_root):
logger.debug("Initializing core manager")
cm = CoreManager(config)
args_libs = [Library(acr, acr) for acr in args_cores_root]
# Add libraries from config file, env var and command-line
for library in config.libraries + args_libs:
try:
cm.add_library(library)
except (RuntimeError, IOError) as e:
_s = "Failed to register library '{}'"
logger.warning(_s.format(str(e)))
return cm
def _get_core(name, has_system=False):
core = None
try:
core = CoreManager().get_core(Vlnv(name))
except RuntimeError as e:
logger.error(str(e))
exit(1)
except DependencyError as e:
logger.error("'" + name + "' or any of its dependencies requires '" +
e.value + "', but this core was not found")
exit(1)
if has_system and not core.get_tool({'flow': 'synth', 'tool': None}):
logger.error("Unable to find synthesis info for '{}'".format(name))
exit(1)
return core
def __init__(self, system):
config = Config()
self.system = system
self.build_root = os.path.join(config.build_root, self.system.name)
self.src_root = os.path.join(self.build_root, 'src')
if 'toplevel' in self.system.simulator:
self.toplevel = self.system.simulator['toplevel']
else:
self.toplevel = 'orpsoc_tb'
self.vpi_modules = []
self.cm = CoreManager()
self.cores = self.cm.get_depends(self.system.name)
logger.debug( "depend --> " +str (self.cores))
self.env = os.environ.copy()
self.env['CORE_ROOT'] = os.path.abspath(self.system.core_root)
self.env['BUILD_ROOT'] = os.path.abspath(self.build_root)
self.env['SIMULATOR'] = self.TOOL_NAME
self.verilog = _Verilog()
for core_name in self.cores:
logger.debug('core_name=' + core_name)
core = self.cm.get_core(core_name)
if core.verilog:
if core.verilog.include_dirs:
logger.debug('core.include_dirs=' + str(core.verilog.include_dirs))
else:
logger.debug('core.include_dirs=None')
self.verilog.include_dirs += [os.path.join(self.src_root, core_name, d) for d in core.verilog.include_dirs]
self.verilog.tb_include_dirs += [os.path.join(self.src_root, core_name, d) for d in core.verilog.tb_include_dirs]
self.verilog.src_files += [os.path.join(self.src_root, core_name, f) for f in core.verilog.src_files]
self.verilog.tb_src_files += [os.path.join(self.src_root, core_name, f) for f in core.verilog.tb_src_files]
if core_name == self.system.name:
self.verilog.tb_src_files += [os.path.join(self.src_root, core_name, f) for f in core.verilog.tb_private_src_files]
if core.vpi:
vpi_module = {}
core_root = os.path.join(self.src_root, core_name)
vpi_module['include_dirs'] = [os.path.abspath(os.path.join(core_root, d)) for d in core.vpi.include_dirs]
vpi_module['src_files'] = [os.path.abspath(os.path.join(core_root, f)) for f in core.vpi.src_files]
vpi_module['name'] = core.name
vpi_module['libs'] = [l for l in core.vpi.libs]
self.vpi_modules += [vpi_module]
def test_eda_api_vpi():
import os.path
import tempfile
from fusesoc.config import Config
from fusesoc.coremanager import CoreManager
from fusesoc.vlnv import Vlnv
tests_dir = os.path.dirname(__file__)
build_root = tempfile.mkdtemp()
cache_root = os.path.join(tests_dir, 'cache')
cores_root = os.path.join(tests_dir, 'capi2_cores')
work_root = os.path.join(build_root, 'work')
export_root = os.path.join(build_root, 'src')
config = Config()
config.build_root = build_root
config.cache_root = cache_root
cm = CoreManager(config)
cm.add_cores_root(cores_root)
eda_api = cm.setup(Vlnv("vpi"), {'tool': 'icarus'}, work_root, export_root)
expected = {
'files': [],
'hooks': {},
'name':
'vpi_0',
'parameters': [],
'tool_options': {
'icarus': {}
},
'toplevel':
'not_used',
'version':
'0.1.2',
'vpi': [{
'src_files': ['../src/vpi_0/f1', '../src/vpi_0/f3'],
'include_dirs': ['../src/vpi_0/'],
'libs': ['some_lib'],
'name': 'vpi1'
}, {
'src_files': ['../src/vpi_0/f4'],
'include_dirs': [],
'libs': [],
'name': 'vpi2'
}]
}
assert eda_api == expected
