#!/usr/bin/env python3
#------------------------------------------------------------------------------
#
# run_spice_tests_new.py --
#
#    Run all ngspice tests, assuming an input file "devices.txt" containing,
#    with one entry per line:
#
#    <device_name>  <device_type>  <expected_value>
#
#    where <device_type> is one of:  mosfet, bipolar, capacitor, resistor, or diode.
#
#------------------------------------------------------------------------------

import os
import pprint
import re
import subprocess
import json
import sys

__dir__ = os.path.dirname(os.path.abspath(__file__))
sys.path.append(os.path.abspath(os.path.join(__dir__, "..")))

from common import get_cell_directory

import find_all_devices
import find_all_devices_new

from plot_mosfet_iv import make_mosfet_iv_plot
from plot_mosfet_vth import make_mosfet_vth_plot
from plot_bipolar_iv import make_bipolar_iv_plot
from plot_bipolar_beta import make_bipolar_beta_plot
from plot_diode_iv import make_diode_iv_plot

#------------------------------------------------------------------------------
# Enumerate capacitors that have additional shield pin connection
#------------------------------------------------------------------------------

four_pin_caps = [
        'sky130_fd_pr__cap_vpp_03p9x03p9_m1m2_shieldl1_floatm3',
        'sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_shieldpo_floatm3',
        'sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4',
        'sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3_shieldpom4',
        'sky130_fd_pr__cap_vpp_06p8x06p1_m1m2m3_shieldl1m4',
        'sky130_fd_pr__cap_vpp_08p6x07p8_l1m1m2_shieldpo_floatm3',
        'sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4',
        'sky130_fd_pr__cap_vpp_11p3x11p8_l1m1m2m3m4_shieldm5_nhv',
        'sky130_fd_pr__cap_vpp_11p3x11p8_l1m1m2m3m4_shieldm5_nhv__base',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2_shieldpom3',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldm4',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldpom4',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldm5',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x',
        'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3_shieldl1m5_floatm4',
        'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldl1m5',
        'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldm5',
        'sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2_shieldm3_floatpo',
        'sky130_fd_pr__cap_vpp_04p4x04p6_l1m1m2m3m4_shieldpom5',
        'sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4_r',
        'sky130_fd_pr__cap_vpp_04p4x04p6_m1m2m3_shieldl1m5_floatm4_top',
        'sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3_shieldpom4_r',
        'sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3_shieldpom4_top',
        'sky130_fd_pr__cap_vpp_06p8x06p1_l1m1m2m3m4_shieldpo_floatm5',
        'sky130_fd_pr__cap_vpp_06p8x06p1_m1m2m3_shieldl1m4_r',
        'sky130_fd_pr__cap_vpp_06p8x06p1_m1m2m3_shieldl1m4_top',
        'sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4_r',
        'sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3_shieldl1m5_floatm4_top',
        'sky130_fd_pr__cap_vpp_08p6x07p8_m1m2m3m4_shieldpom5',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2_shieldpom3_r',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldm4_top',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3_shieldpom4_top',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldm5_r',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldm5_top',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_m5pullin',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_r',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_top',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x6',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x7',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x8',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_x9',
        'sky130_fd_pr__cap_vpp_11p5x11p7_l1m1m2m3m4_shieldpom5_xtop',
        'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3_shieldl1m5_floatm4_top',
        'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldl1m5_r',
        'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldl1m5_top',
        'sky130_fd_pr__cap_vpp_11p5x11p7_m1m2m3m4_shieldm5_r'
]

#------------------------------------------------------------------------------
# Enumerate nFETs that have additional p-well pin connection
#------------------------------------------------------------------------------

five_pin_fets = [
        'sky130_fd_pr__nfet_20v0_iso',
        'sky130_fd_pr__nfet_20v0_nvt_iso',
        'sky130_fd_pr__nfet_20v0_reverse_iso'
]

#------------------------------------------------------------------------------
# Specific handling of include files to work around limitations of the
# ad hoc methods used in find_all_devices.py.
#------------------------------------------------------------------------------

def includes_special_handling(devicename, corner, includes):
    newinclist = []
    for incfile in includes:
        # Pull the PDK path out of the include name
        if '/models/' in incfile:
            pdkbase_path = incfile.split('/models/')[0]
        elif '/cells/' in incfile:
            pdkbase_path = incfile.split('/cells/')[0]
        else:
            pdkbase_path = None

        if pdkbase_path:
            modpath = pdkbase_path + '/models'
            rcpath = modpath + '/r+c'
            parampath = modpath + '/parameters'
            cornerpath = modpath + '/corners/' + corner

            incbase = os.path.split(incfile)[1]
            if incbase == 'sky130_fd_pr__model__cap_vpp.model.spice':
                # Insert additional file.  NOTE:  Currently there is no way to pass
                # a BEOL corner to this routine.
                newinclist.append(rcpath + '/res_typical__cap_typical__lin.spice')
                newinclist.append(rcpath + '/res_typical__cap_typical.spice')
            elif incbase == 'sky130_fd_pr__model__cap_var.model.spice':
                newinclist.append(rcpath + '/res_typical__cap_typical__lin.spice')
                newinclist.append(rcpath + '/res_typical__cap_typical.spice')
                newinclist.append(cornerpath + '/nonfet.spice')
            elif incbase == corner + '.spice':
                newinclist.append(rcpath + '/res_typical__cap_typical__lin.spice')
                newinclist.append(rcpath + '/res_typical__cap_typical.spice')
            elif '__npn_11v0' in devicename:
                newinclist.append(modpath + '/sky130.lib.spice')
            elif 'model__diode_pd2nw_11v0' in incbase:
                newinclist.append(pdkbase_path + '/cells/pfet_g5v0d10v5/sky130_fd_pr__pfet_g5v0d10v5__' + corner + '.corner.spice')
            elif 'model__diode_pw2nd_11v0' in incbase:
                newinclist.append(modpath + '/sky130.lib.spice')
            elif 'model__parasitic__diodes_pw2dn' in incbase:
                newinclist.append(modpath + '/sky130.lib.spice')
            elif '__npn_05v5__' in incbase:
                newinclist.append(modpath + '/corners/' + corner + '/nonfet.spice')
            elif '__pnp_05v5_W0' in devicename:
                newinclist.append(modpath + '/corners/' + corner + '/nonfet.spice')
            elif '__pnp_05v5_W3' in devicename:
                newinclist.append(modpath + '/corners/' + corner + '.spice')
            elif '__nfet_20v0_nvt_iso' in devicename:
                newinclist.append(modpath + '/sky130.lib.spice')
                newinclist.append(pdkbase_path + '/cells/nfet_20v0/sky130_fd_pr__nfet_20v0__tt_discrete.corner.spice')

        newinclist.append(incfile)

    return newinclist

#------------------------------------------------------------------------------
# Run ngspice on the indicated input file in the "results" directory.
#------------------------------------------------------------------------------

TIMEOUT = 360

def runspice(scriptpath, resultname, devicename, expectedval):

    scriptdir = os.path.dirname(scriptpath)
    scriptfile = os.path.basename(scriptpath)
    scriptbase, scriptext = scriptfile.split('.', 1)

    stdout_file = os.path.join(scriptdir, scriptbase+'.stdout')
    stderr_file = os.path.join(scriptdir, scriptbase+'.stderr')

    stdout_fobj = open(stdout_file, 'w')
    stderr_fobj = open(stderr_file, 'w')

    print('Running ngspice on', scriptfile, "(in %s)" % scriptdir)
    with subprocess.Popen(
                ['ngspice', scriptpath],
                stdin= subprocess.DEVNULL,
                stdout = stdout_fobj,
                stderr = stderr_fobj,
                cwd = scriptdir,
                universal_newlines = True,
                close_fds=True,
            ) as sproc:

        stdout_fobj.close()
        stderr_fobj.close()

        try:
            sproc_retcode = sproc.wait(timeout=TIMEOUT)
        except subprocess.TimeoutExpired as e:
            print("WARNING: ngspice on %s timed out!" % scriptpath)
            # Give ngspice 5 seconds to die on SIGTERM before sending SIGKILL
            sproc.terminate()
            try:
                sproc_retcode = sproc.wait(timeout=5)
            except subprocess.TimeoutExpired as e:
                sproc.kill()
            sproc_retcode = sproc.poll()
            assert sproc_retcode is not None, str(sproc)+" won't terminate!?"

    stdout = open(stdout_file).read().splitlines(True)
    stderr = open(stderr_file).read().splitlines(True)

    if True:
        found = True if resultname == 'none' else False
        valueline = False
        returncode = 0
        reason = 'Success'

        for line in stdout:
            if line.strip('\n').strip() == '':
                continue
            print('Diagnostic:  ngspice output line is "' + line.strip('\n').strip() + '"')
            if valueline:
                try:
                    rvaluestring = line.split('=')[1].strip()
                except:
                    rvaluestring = line.strip('\n').strip()
                if rvaluestring != expectedval:
                    if expectedval == 'none':
                        returncode = rvaluestring
                    else:
                        print('Result error:  Expected "' + resultname + '" with value "' + expectedval + '" but got ' + rvaluestring)
                        reason = 'Expected "' + resultname + '" with value "' + expectedval + '" but got ' + rvaluestring
                        returncode = -1
                valueline = False

            elif resultname != 'none' and resultname in line:
                found = True
                valueline = True

        if stderr:
            errors = False
            messages = []
            for line in stderr:
                if len(line.strip()) > 0:
                    messages.append(line)
                    if 'error' in line.lower():
                        errors = True
            if errors:
                print('Execution error:  Ngspice returned error messages:')
                # Print errors.  Also try to pull the most relevant error message.
                for message in messages:
                    print(message)
                    if 'find model' in message.lower() or 'undefined' in message.lower() or 'unknown' in message.lower() or 'valid model' in message.lower() or 'many parameters' in message.lower() or 'few parameters' in message.lower():
                        reason = message
                if reason == 'Success':
                    for message in messages:
                        if 'error' in message.lower():
                            reason = message
                if reason == 'Success':
                    reason = message[0]
                returncode = -1
            else:
                print('Ngspice warnings:')
                for message in messages:
                    print(message)
        return_code = sproc_retcode
        if return_code != 0:
            print('Execution error:  Ngspice exited with error code ' + str(return_code))
            if reason == 'Success':
                reason = 'Ngspice exited with error code ' + str(return_code)
            return (-2, reason)

    if found:
        return (returncode, reason)
    else:
        print('Result error:  Expected result name ' + resultname + ' but did not receive it.')
        reason = 'Expected result name ' + resultname + ' but did not receive it.'
        return (-1, reason)

#------------------------------------------------------------------------------
# Read ".spice.in" file, replace DEVICENAME string with the device name,
# PDKVERSION with the version (v0.20.1), and CORNER with the simulation
# corner (tt), and write out as ".spice" file in "results" directory.
#------------------------------------------------------------------------------

def relpath(a, b):
    """
    >>> relpath("a/c/1", "b/c")
    "1"

    >>> relpath("a/c/2", "a/b")
    "../c/2"

    >>> relpath(
    ...  "/ssd/gob/foss-eda-tools/skywater-pdk-scratch-new/libraries/sky130_fd_pr/v0.20.1/cells/rf_pfet_01v8/tests/sky130_fd_pr__rf_pfet_01v8_aF02W0p84L0p15__pfet_vth.spice",
    ...  "/ssd/gob/foss-eda-tools/skywater-pdk-scratch-new/skywater-pdk/libraries/sky130_fd_pr/v0.20.1/cells/rf_pfet_01v8/tests",
    ... )

    """
    a = os.path.abspath(a).split('/')
    b = os.path.abspath(b).split('/')

    c = []
    while a[0] == b[0]:
        c = a.pop(0)
        b.pop(0)

    ac = a[len(c):]
    bc = a[len(c):]

    return os.path.join(['..']*len(bc)+ac)


def genspice(outdir, scripttemplate, devicename, includes, corner):
    print('Generating simulation netlist for device ' + devicename)

    templatefile = os.path.join(__dir__, scripttemplate+'.in')
    assert os.path.exists(templatefile), templatefile
    with open(templatefile) as ifile:
        spicelines = ifile.read().splitlines()

    # Some parameters to pass to the output
    # Default works for low-voltage FET devices
    # (More are needed---some are being shadowed by other errors)

    if devicename == 'sky130_fd_pr__esd_nfet_01v8':
        params = 'W=20.35 L=0.165 M=1'
    elif devicename == 'sky130_fd_pr__esd_nfet_05v0_nvt':
        params = 'W=10 L=2 M=1'
    elif devicename == 'sky130_fd_pr__nfet_05v0_nvt':
        params = 'W=10 L=2 M=1'
    elif devicename == 'sky130_fd_pr__nfet_03v3_nvt':
        params = 'W=10 L=0.5 M=1'
    elif devicename == 'sky130_fd_pr__esd_nfet_03v3_nvt':
        params = 'W=10 L=0.5 M=1'
    elif devicename == 'sky130_fd_pr__esd_pfet_g5v0d10v5':
        params = 'W=14.5 L=0.55 M=1'
    elif devicename == 'sky130_fd_pr__esd_nfet_g5v0d10v5':
        params = 'W=17.5 L=0.55 M=1'
    elif devicename == 'sky130_fd_pr__pfet_01v8_mvt':
        params = 'W=1.68 L=0.15 M=1'
    elif devicename == 'sky130_fd_pr__pfet_01v8_lvt':
        params = 'W=1.0 L=1.0 M=1'
    elif devicename.startswith('sky130_fd_pr__nfet_g5v0d16v0'):
        params = 'W=20 L=0.7 M=1'
    elif devicename.startswith('sky130_fd_pr__pfet_g5v0d16v0'):
        params = 'W=5 L=0.66 M=1'
    elif devicename == 'sky130_fd_pr__pfet_g5v0d16v0':
        params = 'W=20 L=0.8 M=1'
    elif devicename == 'sky130_fd_pr__nfet_g5v0d16v0':
        params = 'W=10 L=0.5 M=1'
    elif devicename == 'sky130_fd_pr__special_nfet_pass_lvt':
        params = 'W=0.3 L=0.15 M=1'
    elif devicename == 'sky130_fd_pr__special_nfet_pass':
        params = 'W=0.14 L=0.15 M=1'
    elif devicename == 'sky130_fd_pr__special_pfet_pass':
        params = 'W=0.14 L=0.15 M=1'
    elif devicename == 'sky130_fd_pr__special_nfet_pass_flash':
        params = 'W=0.45 L=0.15 M=1'
    elif devicename == 'sky130_fd_pr__special_nfet_latch':
        params = 'W=0.21 L=0.15 M=1'
    elif devicename.startswith('sky130_fd_pr__nfet_20v0_nvt'):
        params = 'W=20 L=1 M=1'

    # sky130_fd_pr__pfet_01v8
    elif devicename[-1] == 'v':
        params = 'W=3.0 L=0.15 M=1'

    # sky130_fd_pr__rf_pfet_01v8_aF02W0p84L0p15 -- no params
    else:
        params = ''

    # More handling of subcircuits with partial parameter definitions
    # and invalid defaults:

    if 'bM' in devicename and not 'W' in devicename and not 'L' in devicename:
        if '01v8' in devicename:
            params = 'W=1.65 L=0.15'
        elif '10v5' in devicename:
            if 'nfet_g5v0d10v5_b' in devicename:
                # The 5V nFET for some reason is characterized at 3.01um
                params = 'W=3.01 L=0.5'
            else:
                params = 'W=3.0 L=0.5'
    elif 'bM' in devicename and 'W' in devicename and not 'L' in devicename:
        if '01v8' in devicename:
            params = 'L=0.15'
        elif '10v5' in devicename:
            params = 'L=0.5'

    foutpath = os.path.abspath(os.path.join(outdir, 'tests', devicename + '__' + scripttemplate))
    foutdir = os.path.dirname(foutpath)
    os.makedirs(foutdir, exist_ok=True)

    includelines = []
    for incfile in includes:
        relincfile = os.path.relpath(incfile, foutdir)
        if '.lib.spice' in incfile:
            includelines.append('.lib "{}" {}'.format(relincfile, corner))
        else:
            includelines.append('.include "{}"'.format(relincfile))

    outlines = []
    for line in spicelines:
        newline = line.replace('INCLUDELINES', '\n'.join(includelines))
        newline = newline.replace('DEVICENAME', devicename)
        newline = newline.replace('CORNER', corner)
        newline = newline.replace('PARAMS', params)
        outlines.append(newline)

    with open(foutpath, 'w') as ofile:
        for line in outlines:
            print(line, file=ofile)

    return foutpath

#------------------------------------------------------------------------------
# Run a spice simulation (or two) for the device specified in 'line' (obtained
# from the list of devices and expected values).
#------------------------------------------------------------------------------

def do_for_device(pdk_path, version, devicedir, devicename, corner):

    passes = []
    fails = []
    ignores = []
    baseline_run = False
    baseline_entries = []
    reasons = {}

    # NOTE:  When a line in the device list does not have an entry
    # for expected value, then this is a baseline run, and will
    # dump the device name and output measured to a file
    # 'devices_baseline.txt'

    baseline_run = True

    # Determine the device type from the name
    # (to do:  Pull additional information about the device from the name)
    # (also to do:  separate nmos/pmos testbenches and pnp/npn testbenches)

    # Inductors
    # sky130_fd_pr__ind.*
    if "__ind" in devicename:
        devicetype = 'inductor'

    # Capacitors
    # sky130_fd_pr__cap_mim.*
    # sky130_fd_pr__cap.*
    elif "__cap_mim" in devicename:
        devicetype = 'mimcap'
    elif "__cap" in devicename:
        devicetype = 'capacitor'

    # Diodes (as subcircuits)
    # sky130_fd_pr__esd_rf_diode.*
    # Diodes (as SPICE primitive devices)
    # sky130_fd_pr__diode.*
    elif "_diode" in devicename:
        devicetype = 'diode'

    # MOSFETs (n-type)
    # sky130_fd_pr__esd_nfet.*
    # sky130_fd_pr__nfet.*
    # sky130_fd_pr__rf_nfet.*
    # sky130_fd_pr__special_nfet.*
    elif "_nfet" in devicename:
        devicetype = 'nfet'

    # MOSFETs (p-type)
    # sky130_fd_pr__esd_pfet.*
    # sky130_fd_pr__pfet.*
    # sky130_fd_pr__rf_pfet.*
    # sky130_fd_pr__special_pfet.*
    elif "_pfet" in devicename:
        devicetype = 'pfet'

    # Bipolars (NPN)
    # sky130_fd_pr__rf_npn.*
    # sky130_fd_pr__npn.*
    elif "_npn" in devicename:
        devicetype = 'npn'
    # Bipolars (PNP)
    # sky130_fd_pr__pnp.*
    # sky130_fd_pr__rf_pnp.*
    elif "_pnp" in devicename:
        devicetype = 'pnp'

    # Resistors
    # sky130_fd_pr__res.*
    elif "_res" in devicename:
        devicetype = 'resistor'

    else:
        raise SystemError('Unknown device:'+devicename)

    # Check list of devices for additional sub-types
    if devicetype == 'nfet':
        if devicename in five_pin_fets:
            devicetype = 'nfet5term'

    elif devicetype == 'capacitor':
        if devicename in four_pin_caps:
            devicetype = 'capacitor4pin'

    #deps = {}
    #provided_by = {}
    #find_all_devices_new.get_deps_for_device(pdk_path, version, devicename, corner, deps, provided_by)
    #assert devicename in provided_by, (devicename+'\n'+pprint.pformat(provided_by))
    #includes = find_all_devices_new.flatten_deps_to_files(devicename, deps, provided_by)
    top_dir = os.path.join(pdk_path, "skywater-pdk", "libraries", "sky130_fd_pr", version)
    assert os.path.exists(top_dir), top_dir
    includes = find_all_devices.do_find_all_devices(top_dir, None, devicename, feol=corner)
    includes = [os.path.abspath(i) for i in includes]

    # Special handling to include files that need to be included but are not
    # handled properly by the various ad-hoc methods used in find_all_devices.py
    includes = includes_special_handling(devicename, corner, includes)

    print()
    print("Includes needed:")
    pprint.pprint(includes)
    print()

    try:
        print('Diagnostic:  Determined device ' + devicename + ' to be type ' + devicetype)
    except:
        print('Unknown device type for device name ' + devicename + '.  Cannot simulate.')
        reasons[devicename] = 'Unknown device type for device name ' + devicename + '.  Cannot simulate.'
        fails.append(devicename)
        return (passes, fails, ignores, baseline_entries, reasons)

    # Devices for which no include was found count as "ignores"
    if includes == []:
        ignores.append(devicename)
        devicetype = 'ignored'

    if baseline_run:
        expectedval = 'none'

    if devicetype == 'nfet' or devicetype == 'nfet5term' or devicetype == 'pfet':
        spicefile = genspice(devicedir, devicetype + '_vth.spice', devicename, includes, corner)
        (result, reason) = runspice(spicefile, 'threshold voltage', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)
        if result != -2:
            make_mosfet_iv_plot(devicedir + '/tests', devicename, version, corner)

    elif devicetype == 'npn' or devicetype == 'pnp':
        spicefile = genspice(devicedir, devicetype + '.spice', devicename, includes, corner)
        (result, reason) = runspice(spicefile, 'maximum beta', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)
        if result != -2:
            make_bipolar_iv_plot(devicedir + '/tests', devicename, version, corner)
            make_bipolar_beta_plot(devicedir + '/tests', devicename, version, corner)

    elif devicetype == 'mimcap':
        spicefile = genspice(devicedir, 'mimcap_test.spice', devicename, includes, corner)
        (result, reason) = runspice(spicefile, 'capacitance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'capacitor':
        spicefile = genspice(devicedir, 'capval_test.spice', devicename, includes, corner)
        (result, reason) = runspice(spicefile, 'capacitance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'capacitor4pin':
        spicefile = genspice(devicedir, 'cap4termval_test.spice', devicename, includes, corner)
        (result, reason) = runspice(spicefile, 'capacitance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'inductor':
        spicefile = genspice(devicedir, 'inductor_test.spice', devicename, includes, corner)
        (result, reason) = runspice(spicefile, 'inductance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'resistor':
        spicefile = genspice(devicedir, 'resval_test.spice', devicename, includes, corner)
        (result, reason) = runspice(spicefile, 'resistance', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)

    elif devicetype == 'diode' or devicetype == 'diode_dev':
        spicefile = genspice(devicedir, devicetype + '_vth.spice', devicename, includes, corner)
        (result, reason) = runspice(spicefile, 'threshold voltage', devicename, expectedval)
        reasons[devicename] = reason
        if baseline_run and isinstance(result, str):
            baseline_entries.append(devicename + '    ' + result)
            passes.append(devicename)
        elif result != 0:
            fails.append(devicename)
        else:
            passes.append(devicename)
        if result != -2:
            make_diode_iv_plot(devicedir + '/tests', devicename, version, corner)

    output = (passes, fails, ignores, baseline_entries, reasons)

    bsim4v5_out = os.path.abspath(os.path.join(devicedir, 'tests', 'bsim4v5.out'))
    if os.path.exists(bsim4v5_out):
        os.unlink(bsim4v5_out)

    foutpath = os.path.abspath(os.path.join(devicedir, 'tests', '%s_results.json' % devicename))
    with open(foutpath, 'w') as f:
        json.dump(dict(zip(('passes', 'fails', 'ignores', 'baseline_entries', 'reasons'), output)), f, sort_keys=True, indent="  ")
    return output

#------------------------------------------------------------------------------
# Main script starts here (no arguments, at least for now)
#------------------------------------------------------------------------------

def main(pdk_path, version, device):
    assert os.path.exists(pdk_path), pdk_path
    prlib_path = os.path.join(pdk_path, "libraries", "sky130_fd_pr", version)
    assert os.path.exists(prlib_path), prlib_path

    devicedir = get_cell_directory(pdk_path, 'sky130_fd_pr', version, device)

    bits = device.split('__')
    assert len(bits) > 1, (bits, device)
    assert bits.pop(0) == 'sky130_fd_pr', (bits, device)
    ddir = os.path.join(prlib_path, "cells", bits.pop(0))

    if bits:
        corner = bits.pop(0)
    else:
        corner = 'tt'

    # One-off problem:  Some things pop up in the "corner" field that are not
    # corners. . .  Not sure that this is the best handling, but at least it
    # produces a valid result.
    if corner == 'subcell' or corner == 'base' or corner == 'parasitic':
        corner = 'tt'

    if device.endswith('__'+corner):
        device = device[:-len('__'+corner)]

    passes, fails, ignores, baseline_entries, reasons = do_for_device(
            pdk_path, version, devicedir, device, corner)
    if passes:
        print("Pass:", passes)
    if fails:
        print("Fails:", fails)
    if ignores:
        print("Ignores:", fails)
    if baseline_entries:
        print("Baseline Entries:", baseline_entries)
    if reasons:
        print("Reasons:", reasons)

    return len(fails)


if __name__ == "__main__":
    args = list(sys.argv)
    args.pop(0)

    pdk_path = args.pop(0)
    if args and args[0] and args[0][0] == 'v':
        version = args.pop(0)
    else:
        version = 'v0.20.1'

    assert len(args) == 1, args

    sys.exit(main(pdk_path, version, args[0]))