klayout/src/db/unit_tests/dbNetlistDeviceClassesTests.cc

/*

  KLayout Layout Viewer
  Copyright (C) 2006-2018 Matthias Koefferlein

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/


#include "dbNetlistDeviceClasses.h"
#include "dbNetlist.h"
#include "tlUnitTest.h"

#include <memory>
#include <limits>

TEST(1_SerialResistors)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 1.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (r1);
  circuit->add_device (r2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n3);
  circuit->connect_pin (pin_b.id (), n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D r1 (A=n1,B=n2) [R=1]\n"
    "  D r2 (A=n2,B=n3) [R=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D r1 (A=n1,B=n3) [R=4]\n"
  );
};

TEST(2_SerialResistors1Swapped)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 1.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (r1);
  circuit->add_device (r2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n3);
  circuit->connect_pin (pin_b.id (), n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D r1 (A=n1,B=n2) [R=1]\n"
    "  D r2 (A=n3,B=n2) [R=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D r1 (A=n1,B=n3) [R=4]\n"
  );
};

TEST(3_SerialResistors1OtherSwapped)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 1.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (r1);
  circuit->add_device (r2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n3);
  circuit->connect_pin (pin_b.id (), n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D r1 (A=n2,B=n1) [R=1]\n"
    "  D r2 (A=n2,B=n3) [R=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D r1 (A=n3,B=n1) [R=4]\n"
  );
};

TEST(4_SerialResistors2Swapped)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 1.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (r1);
  circuit->add_device (r2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n3);
  circuit->connect_pin (pin_b.id (), n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D r1 (A=n2,B=n1) [R=1]\n"
    "  D r2 (A=n3,B=n2) [R=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D r1 (A=n3,B=n1) [R=4]\n"
  );
};

TEST(5_SerialResistorsNoCombination)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 1.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c = circuit->add_pin ("C");

  circuit->add_device (r1);
  circuit->add_device (r2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_c.id (), n2);  // prevents combination
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n3);
  circuit->connect_pin (pin_b.id (), n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3,C=n2):\n"
    "  D r1 (A=n1,B=n2) [R=1]\n"
    "  D r2 (A=n2,B=n3) [R=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3,C=n2):\n"
    "  D r1 (A=n1,B=n2) [R=1]\n"
    "  D r2 (A=n2,B=n3) [R=3]\n"
  );
};

TEST(6_ParallelResistors)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 2.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (r1);
  circuit->add_device (r2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D r1 (A=n1,B=n2) [R=2]\n"
    "  D r2 (A=n1,B=n2) [R=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D r1 (A=n1,B=n2) [R=1.2]\n"
  );
};

TEST(7_ParallelResistors1Swapped)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 2.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (r1);
  circuit->add_device (r2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n1);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D r1 (A=n2,B=n1) [R=2]\n"
    "  D r2 (A=n1,B=n2) [R=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D r1 (A=n2,B=n1) [R=1.2]\n"
  );
};

TEST(8_ParallelResistors1OtherSwapped)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 2.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (r1);
  circuit->add_device (r2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D r1 (A=n1,B=n2) [R=2]\n"
    "  D r2 (A=n2,B=n1) [R=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D r1 (A=n1,B=n2) [R=1.2]\n"
  );
};

TEST(9_ParallelResistors2Swapped)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 2.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (r1);
  circuit->add_device (r2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n1);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D r1 (A=n2,B=n1) [R=2]\n"
    "  D r2 (A=n2,B=n1) [R=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D r1 (A=n2,B=n1) [R=1.2]\n"
  );
};

TEST(10_ComplexRegistorCombination)
{
  db::DeviceClassResistor *res = new db::DeviceClassResistor ();

  db::Netlist nl;
  nl.add_device_class (res);

  /**
   *                    (n2)
   *       +--[ r1=1.0 ]--+--[ r2=1.0 ]--+
   *       |                             |
   * <a> --x (n1)                   (n3) x--[ r4=0.8 ]--+-- <b>
   *       |                             |             (n4)
   *       +----------[ r3=3.0 ]---------+
   */

  db::Device *r1 = new db::Device (res, "r1");
  r1->set_parameter_value (db::DeviceClassResistor::param_id_R, 1.0);
  db::Device *r2 = new db::Device (res, "r2");
  r2->set_parameter_value (db::DeviceClassResistor::param_id_R, 1.0);
  db::Device *r3 = new db::Device (res, "r3");
  r3->set_parameter_value (db::DeviceClassResistor::param_id_R, 3.0);
  db::Device *r4 = new db::Device (res, "r4");
  r4->set_parameter_value (db::DeviceClassResistor::param_id_R, 0.8);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (r1);
  circuit->add_device (r2);
  circuit->add_device (r3);
  circuit->add_device (r4);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);
  r3->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  r1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  r2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n3);
  r3->connect_terminal (db::DeviceClassResistor::terminal_id_B, n3);
  r4->connect_terminal (db::DeviceClassResistor::terminal_id_A, n3);

  db::Net *n4 = new db::Net ("n4");
  circuit->add_net (n4);
  circuit->connect_pin (pin_b.id (), n4);
  r4->connect_terminal (db::DeviceClassResistor::terminal_id_B, n4);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n4):\n"
    "  D r1 (A=n1,B=n2) [R=1]\n"
    "  D r2 (A=n2,B=n3) [R=1]\n"
    "  D r3 (A=n1,B=n3) [R=3]\n"
    "  D r4 (A=n3,B=n4) [R=0.8]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n4):\n"
    "  D r4 (A=n1,B=n4) [R=2]\n"
  );
};

TEST(11_SerialInductors)
{
  db::DeviceClassInductor *ind = new db::DeviceClassInductor ();

  db::Netlist nl;
  nl.add_device_class (ind);

  db::Device *l1 = new db::Device (ind, "l1");
  l1->set_parameter_value (db::DeviceClassInductor::param_id_L, 1.0);
  db::Device *l2 = new db::Device (ind, "l2");
  l2->set_parameter_value (db::DeviceClassInductor::param_id_L, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (l1);
  circuit->add_device (l2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  l1->connect_terminal (db::DeviceClassResistor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  l1->connect_terminal (db::DeviceClassResistor::terminal_id_B, n2);
  l2->connect_terminal (db::DeviceClassResistor::terminal_id_A, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  l2->connect_terminal (db::DeviceClassResistor::terminal_id_B, n3);
  circuit->connect_pin (pin_b.id (), n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D l1 (A=n1,B=n2) [L=1]\n"
    "  D l2 (A=n2,B=n3) [L=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D l1 (A=n1,B=n3) [L=4]\n"
  );
};

TEST(12_ParallelInductors)
{
  db::DeviceClassInductor *ind = new db::DeviceClassInductor ();

  db::Netlist nl;
  nl.add_device_class (ind);

  db::Device *l1 = new db::Device (ind, "l1");
  l1->set_parameter_value (db::DeviceClassInductor::param_id_L, 2.0);
  db::Device *l2 = new db::Device (ind, "l2");
  l2->set_parameter_value (db::DeviceClassInductor::param_id_L, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (l1);
  circuit->add_device (l2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  l1->connect_terminal (db::DeviceClassInductor::terminal_id_A, n1);
  l2->connect_terminal (db::DeviceClassInductor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  l1->connect_terminal (db::DeviceClassInductor::terminal_id_B, n2);
  l2->connect_terminal (db::DeviceClassInductor::terminal_id_B, n2);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D l1 (A=n1,B=n2) [L=2]\n"
    "  D l2 (A=n1,B=n2) [L=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D l1 (A=n1,B=n2) [L=1.2]\n"
  );
};

TEST(13_SerialCapacitors)
{
  db::DeviceClassCapacitor *cap = new db::DeviceClassCapacitor ();

  db::Netlist nl;
  nl.add_device_class (cap);

  db::Device *c1 = new db::Device (cap, "c1");
  c1->set_parameter_value (db::DeviceClassCapacitor::param_id_C, 2.0);
  db::Device *c2 = new db::Device (cap, "c2");
  c2->set_parameter_value (db::DeviceClassCapacitor::param_id_C, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (c1);
  circuit->add_device (c2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  c1->connect_terminal (db::DeviceClassCapacitor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  c1->connect_terminal (db::DeviceClassCapacitor::terminal_id_B, n2);
  c2->connect_terminal (db::DeviceClassCapacitor::terminal_id_A, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  c2->connect_terminal (db::DeviceClassCapacitor::terminal_id_B, n3);
  circuit->connect_pin (pin_b.id (), n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D c1 (A=n1,B=n2) [C=2]\n"
    "  D c2 (A=n2,B=n3) [C=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D c1 (A=n1,B=n3) [C=1.2]\n"
  );
};

TEST(14_ParallelCapacitors)
{
  db::DeviceClassCapacitor *cap = new db::DeviceClassCapacitor ();

  db::Netlist nl;
  nl.add_device_class (cap);

  db::Device *c1 = new db::Device (cap, "c1");
  c1->set_parameter_value (db::DeviceClassCapacitor::param_id_C, 1.0);
  db::Device *c2 = new db::Device (cap, "c2");
  c2->set_parameter_value (db::DeviceClassCapacitor::param_id_C, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (c1);
  circuit->add_device (c2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  c1->connect_terminal (db::DeviceClassCapacitor::terminal_id_A, n1);
  c2->connect_terminal (db::DeviceClassCapacitor::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  c1->connect_terminal (db::DeviceClassCapacitor::terminal_id_B, n2);
  c2->connect_terminal (db::DeviceClassCapacitor::terminal_id_B, n2);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D c1 (A=n1,B=n2) [C=1]\n"
    "  D c2 (A=n1,B=n2) [C=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D c1 (A=n1,B=n2) [C=4]\n"
  );
};

TEST(15_SerialDiodes)
{
  db::DeviceClassDiode *diode = new db::DeviceClassDiode ();

  db::Netlist nl;
  nl.add_device_class (diode);

  db::Device *d1 = new db::Device (diode, "d1");
  d1->set_parameter_value (db::DeviceClassDiode::param_id_A, 2.0);
  db::Device *d2 = new db::Device (diode, "d2");
  d2->set_parameter_value (db::DeviceClassDiode::param_id_A, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassDiode::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  d1->connect_terminal (db::DeviceClassDiode::terminal_id_C, n2);
  d2->connect_terminal (db::DeviceClassDiode::terminal_id_A, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  d2->connect_terminal (db::DeviceClassDiode::terminal_id_C, n3);
  circuit->connect_pin (pin_b.id (), n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D d1 (A=n1,C=n2) [A=2]\n"
    "  D d2 (A=n2,C=n3) [A=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  //  serial diodes are not combined!

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n3):\n"
    "  D d1 (A=n1,C=n2) [A=2]\n"
    "  D d2 (A=n2,C=n3) [A=3]\n"
  );
};

TEST(16_ParallelDiodes)
{
  db::DeviceClassDiode *diode = new db::DeviceClassDiode ();

  db::Netlist nl;
  nl.add_device_class (diode);

  db::Device *d1 = new db::Device (diode, "d1");
  d1->set_parameter_value (db::DeviceClassDiode::param_id_A, 1.0);
  db::Device *d2 = new db::Device (diode, "d2");
  d2->set_parameter_value (db::DeviceClassDiode::param_id_A, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassDiode::terminal_id_A, n1);
  d2->connect_terminal (db::DeviceClassDiode::terminal_id_A, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassDiode::terminal_id_C, n2);
  d2->connect_terminal (db::DeviceClassDiode::terminal_id_C, n2);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D d1 (A=n1,C=n2) [A=1]\n"
    "  D d2 (A=n1,C=n2) [A=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D d1 (A=n1,C=n2) [A=4]\n"
  );
};

TEST(17_AntiParallelDiodes)
{
  db::DeviceClassDiode *diode = new db::DeviceClassDiode ();

  db::Netlist nl;
  nl.add_device_class (diode);

  db::Device *d1 = new db::Device (diode, "d1");
  d1->set_parameter_value (db::DeviceClassDiode::param_id_A, 1.0);
  db::Device *d2 = new db::Device (diode, "d2");
  d2->set_parameter_value (db::DeviceClassDiode::param_id_A, 3.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassDiode::terminal_id_A, n1);
  d2->connect_terminal (db::DeviceClassDiode::terminal_id_C, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassDiode::terminal_id_C, n2);
  d2->connect_terminal (db::DeviceClassDiode::terminal_id_A, n2);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D d1 (A=n1,C=n2) [A=1]\n"
    "  D d2 (A=n2,C=n1) [A=3]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  //  anti-parallel diodes are not combined

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2):\n"
    "  D d1 (A=n1,C=n2) [A=1]\n"
    "  D d2 (A=n2,C=n1) [A=3]\n"
  );
};

TEST(20_ParallelMOS3Transistors)
{
  db::DeviceClassMOS3Transistor *cls = new db::DeviceClassMOS3Transistor ();

  db::Netlist nl;
  nl.add_device_class (cls);

  db::Device *d1 = new db::Device (cls, "d1");
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_L, 0.5);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_W, 1.0);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AS, 2.0);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AD, 3.0);
  db::Device *d2 = new db::Device (cls, "d2");
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_L, 0.5);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_W, 2.0);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AS, 3.0);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AD, 4.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c = circuit->add_pin ("C");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_S, n1);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_S, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_D, n2);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_D, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  circuit->connect_pin (pin_c.id (), n3);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_G, n3);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_G, n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3):\n"
    "  D d1 (S=n1,G=n3,D=n2) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3,D=n2) [L=0.5,W=2,AS=3,AD=4]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3):\n"
    "  D d1 (S=n1,G=n3,D=n2) [L=0.5,W=3,AS=5,AD=7]\n"
  );
};

TEST(21_AntiParallelMOS3Transistors)
{
  db::DeviceClassMOS3Transistor *cls = new db::DeviceClassMOS3Transistor ();

  db::Netlist nl;
  nl.add_device_class (cls);

  db::Device *d1 = new db::Device (cls, "d1");
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_L, 0.5);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_W, 1.0);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AS, 2.0);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AD, 3.0);
  db::Device *d2 = new db::Device (cls, "d2");
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_L, 0.5);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_W, 2.0);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AS, 3.0);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AD, 4.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c = circuit->add_pin ("C");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_S, n1);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_D, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_D, n2);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_S, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  circuit->connect_pin (pin_c.id (), n3);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_G, n3);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_G, n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3):\n"
    "  D d1 (S=n1,G=n3,D=n2) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n2,G=n3,D=n1) [L=0.5,W=2,AS=3,AD=4]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3):\n"
    "  D d1 (S=n1,G=n3,D=n2) [L=0.5,W=3,AS=5,AD=7]\n"
  );
};

TEST(22_ParallelMOS3TransistorsDisconnectedGates)
{
  db::DeviceClassMOS3Transistor *cls = new db::DeviceClassMOS3Transistor ();

  db::Netlist nl;
  nl.add_device_class (cls);

  db::Device *d1 = new db::Device (cls, "d1");
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_L, 0.5);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_W, 1.0);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AS, 2.0);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AD, 3.0);
  db::Device *d2 = new db::Device (cls, "d2");
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_L, 0.5);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_W, 2.0);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AS, 3.0);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AD, 4.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c1 = circuit->add_pin ("C1");
  db::Pin pin_c2 = circuit->add_pin ("C2");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_S, n1);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_S, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_D, n2);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_D, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  circuit->connect_pin (pin_c1.id (), n3);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_G, n3);

  db::Net *n4 = new db::Net ("n4");
  circuit->add_net (n4);
  circuit->connect_pin (pin_c2.id (), n4);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_G, n4);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C1=n3,C2=n4):\n"
    "  D d1 (S=n1,G=n3,D=n2) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n4,D=n2) [L=0.5,W=2,AS=3,AD=4]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  //  because of the disconnected gates, devices will no be joined:

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C1=n3,C2=n4):\n"
    "  D d1 (S=n1,G=n3,D=n2) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n4,D=n2) [L=0.5,W=2,AS=3,AD=4]\n"
  );
};

TEST(23_ParallelMOS3TransistorsDifferentLength)
{
  db::DeviceClassMOS3Transistor *cls = new db::DeviceClassMOS3Transistor ();

  db::Netlist nl;
  nl.add_device_class (cls);

  db::Device *d1 = new db::Device (cls, "d1");
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_L, 0.5);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_W, 1.0);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AS, 2.0);
  d1->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AD, 3.0);
  db::Device *d2 = new db::Device (cls, "d2");
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_L, 0.75);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_W, 2.0);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AS, 3.0);
  d2->set_parameter_value (db::DeviceClassMOS3Transistor::param_id_AD, 4.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c = circuit->add_pin ("C");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_S, n1);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_S, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_D, n2);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_D, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  circuit->connect_pin (pin_c.id (), n3);
  d1->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_G, n3);
  d2->connect_terminal (db::DeviceClassMOS3Transistor::terminal_id_G, n3);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3):\n"
    "  D d1 (S=n1,G=n3,D=n2) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3,D=n2) [L=0.75,W=2,AS=3,AD=4]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  //  because of different length, the devices will not be combined:

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3):\n"
    "  D d1 (S=n1,G=n3,D=n2) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3,D=n2) [L=0.75,W=2,AS=3,AD=4]\n"
  );
};

TEST(30_ParallelMOS4Transistors)
{
  db::DeviceClassMOS4Transistor *cls = new db::DeviceClassMOS4Transistor ();

  db::Netlist nl;
  nl.add_device_class (cls);

  db::Device *d1 = new db::Device (cls, "d1");
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.5);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 1.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 2.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 3.0);
  db::Device *d2 = new db::Device (cls, "d2");
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.5);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 2.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 3.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 4.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c = circuit->add_pin ("C");
  db::Pin pin_d = circuit->add_pin ("D");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n1);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n2);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  circuit->connect_pin (pin_c.id (), n3);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3);

  db::Net *n0 = new db::Net ("n0");
  circuit->add_net (n0);
  circuit->connect_pin (pin_d.id (), n0);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3,D=n0):\n"
    "  D d1 (S=n1,G=n3,D=n2,B=n0) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3,D=n2,B=n0) [L=0.5,W=2,AS=3,AD=4]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3,D=n0):\n"
    "  D d1 (S=n1,G=n3,D=n2,B=n0) [L=0.5,W=3,AS=5,AD=7]\n"
  );
};

TEST(31_AntiParallelMOS4Transistors)
{
  db::DeviceClassMOS4Transistor *cls = new db::DeviceClassMOS4Transistor ();

  db::Netlist nl;
  nl.add_device_class (cls);

  db::Device *d1 = new db::Device (cls, "d1");
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.5);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 1.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 2.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 3.0);
  db::Device *d2 = new db::Device (cls, "d2");
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.5);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 2.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 3.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 4.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c = circuit->add_pin ("C");
  db::Pin pin_d = circuit->add_pin ("D");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n1);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n2);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  circuit->connect_pin (pin_c.id (), n3);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3);

  db::Net *n0 = new db::Net ("n0");
  circuit->add_net (n0);
  circuit->connect_pin (pin_d.id (), n0);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3,D=n0):\n"
    "  D d1 (S=n1,G=n3,D=n2,B=n0) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n2,G=n3,D=n1,B=n0) [L=0.5,W=2,AS=3,AD=4]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3,D=n0):\n"
    "  D d1 (S=n1,G=n3,D=n2,B=n0) [L=0.5,W=3,AS=5,AD=7]\n"
  );
};

TEST(32_ParallelMOS4TransistorsDisconnectedGates)
{
  db::DeviceClassMOS4Transistor *cls = new db::DeviceClassMOS4Transistor ();

  db::Netlist nl;
  nl.add_device_class (cls);

  db::Device *d1 = new db::Device (cls, "d1");
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.5);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 1.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 2.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 3.0);
  db::Device *d2 = new db::Device (cls, "d2");
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.5);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 2.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 3.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 4.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c1 = circuit->add_pin ("C1");
  db::Pin pin_c2 = circuit->add_pin ("C2");
  db::Pin pin_d = circuit->add_pin ("D");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n1);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n2);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n2);

  db::Net *n3a = new db::Net ("n3a");
  circuit->add_net (n3a);
  circuit->connect_pin (pin_c1.id (), n3a);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3a);

  db::Net *n3b = new db::Net ("n3b");
  circuit->add_net (n3b);
  circuit->connect_pin (pin_c2.id (), n3b);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3b);

  db::Net *n0 = new db::Net ("n0");
  circuit->add_net (n0);
  circuit->connect_pin (pin_d.id (), n0);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C1=n3a,C2=n3b,D=n0):\n"
    "  D d1 (S=n1,G=n3a,D=n2,B=n0) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3b,D=n2,B=n0) [L=0.5,W=2,AS=3,AD=4]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  //  not combined because gate is different:

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C1=n3a,C2=n3b,D=n0):\n"
    "  D d1 (S=n1,G=n3a,D=n2,B=n0) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3b,D=n2,B=n0) [L=0.5,W=2,AS=3,AD=4]\n"
  );
};

TEST(33_ParallelMOS4TransistorsDisconnectedBulk)
{
  db::DeviceClassMOS4Transistor *cls = new db::DeviceClassMOS4Transistor ();

  db::Netlist nl;
  nl.add_device_class (cls);

  db::Device *d1 = new db::Device (cls, "d1");
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.5);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 1.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 2.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 3.0);
  db::Device *d2 = new db::Device (cls, "d2");
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.5);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 2.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 3.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 4.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c = circuit->add_pin ("C");
  db::Pin pin_d1 = circuit->add_pin ("D1");
  db::Pin pin_d2 = circuit->add_pin ("D2");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n1);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n2);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  circuit->connect_pin (pin_c.id (), n3);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3);

  db::Net *n0a = new db::Net ("n0a");
  circuit->add_net (n0a);
  circuit->connect_pin (pin_d1.id (), n0a);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0a);

  db::Net *n0b = new db::Net ("n0b");
  circuit->add_net (n0b);
  circuit->connect_pin (pin_d2.id (), n0b);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0b);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3,D1=n0a,D2=n0b):\n"
    "  D d1 (S=n1,G=n3,D=n2,B=n0a) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3,D=n2,B=n0b) [L=0.5,W=2,AS=3,AD=4]\n"
  );

  //  not combined because bulk is different:

  nl.combine_devices ();
  nl.purge ();

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3,D1=n0a,D2=n0b):\n"
    "  D d1 (S=n1,G=n3,D=n2,B=n0a) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3,D=n2,B=n0b) [L=0.5,W=2,AS=3,AD=4]\n"
  );
};

TEST(34_ParallelMOS4TransistorsDifferentLength)
{
  db::DeviceClassMOS4Transistor *cls = new db::DeviceClassMOS4Transistor ();

  db::Netlist nl;
  nl.add_device_class (cls);

  db::Device *d1 = new db::Device (cls, "d1");
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.5);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 1.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 2.0);
  d1->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 3.0);
  db::Device *d2 = new db::Device (cls, "d2");
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_L, 0.75);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_W, 2.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AS, 3.0);
  d2->set_parameter_value (db::DeviceClassMOS4Transistor::param_id_AD, 4.0);

  db::Circuit *circuit = new db::Circuit ();
  nl.add_circuit (circuit);

  db::Pin pin_a = circuit->add_pin ("A");
  db::Pin pin_b = circuit->add_pin ("B");
  db::Pin pin_c = circuit->add_pin ("C");
  db::Pin pin_d = circuit->add_pin ("D");

  circuit->add_device (d1);
  circuit->add_device (d2);

  db::Net *n1 = new db::Net ("n1");
  circuit->add_net (n1);
  circuit->connect_pin (pin_a.id (), n1);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n1);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_S, n1);

  db::Net *n2 = new db::Net ("n2");
  circuit->add_net (n2);
  circuit->connect_pin (pin_b.id (), n2);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n2);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_D, n2);

  db::Net *n3 = new db::Net ("n3");
  circuit->add_net (n3);
  circuit->connect_pin (pin_c.id (), n3);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_G, n3);

  db::Net *n0 = new db::Net ("n0");
  circuit->add_net (n0);
  circuit->connect_pin (pin_d.id (), n0);
  d1->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0);
  d2->connect_terminal (db::DeviceClassMOS4Transistor::terminal_id_B, n0);

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3,D=n0):\n"
    "  D d1 (S=n1,G=n3,D=n2,B=n0) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3,D=n2,B=n0) [L=0.75,W=2,AS=3,AD=4]\n"
  );

  nl.combine_devices ();
  nl.purge ();

  //  not combined because length is different:

  EXPECT_EQ (nl.to_string (),
    "Circuit  (A=n1,B=n2,C=n3,D=n0):\n"
    "  D d1 (S=n1,G=n3,D=n2,B=n0) [L=0.5,W=1,AS=2,AD=3]\n"
    "  D d2 (S=n1,G=n3,D=n2,B=n0) [L=0.75,W=2,AS=3,AD=4]\n"
  );
};