Structural Simulation Toolkit (SST)

The SST Testing Frameworks is a Python-based system built upon the unittest module, modified specifically for SST. It supports Python 2.7 through Python 3.x and requires no 3rd party modules for basic operation.

Key Behaviors

• Automatic Discovery: The system automatically discovers testsuites (though this can be controlled by the user).
• Test Execution: Each testsuite contains multiple tests. While all tests are given the opportunity to run, individual test code may decide to skip a test based on build settings, environment conditions, or specific scenarios.
• Execution Order: There is no guarantee on the order of testsuites or the order of tests within a testsuite. However, by default, all tests within a single testsuite complete before the next testsuite begins (unless concurrent testing is enabled).

TinyXML provides several ways to output XML data, depending on whether you need human readability or network efficiency:

1. Print( FILE* ) and SaveFile(): Uses C-style FILE* streams. It produces "pretty printed" (human-readable) output with whitespace. It is fast and tolerant of some ill-formed XML.
2. operator<<: Uses C++ std::ostream. It produces condensed "network printing" mode without line breaks, ideal for transmission between C++ objects. It is less tolerant of ill-formed XML (requires exactly one root element).
3. TiXmlPrinter: A class used to output to a std::string or memory buffer. This is a more specialized API for custom printing needs.

The Constructor Concept encapsulates one or more valid constructors for a base class using a variadic template Args.... To satisfy this concept, a class must provide:

1. A template function add(): This function registers the derived type to the Base class's registry for all matching constructors.
2. A template type alias is_constructible<T>: This alias defines whether a given type T provides any of the valid constructors for the Base class (e.g., using std::is_constructible).

template <class T> void add(){
  // ... logic to register with Base
  Base::addBuilder(...);
}

template <class T>
using is_constructible = std::is_constructible<T, Args...>;

Standard DOM traversal requires frequent null checks for every element returned. To simplify this, use the TiXmlHandle class, which allows for a more concise, chainable syntax for navigating the tree.

Standard approach:

TiXmlElement* root = document.FirstChildElement( "Document" );
if ( root ) {
    TiXmlElement* element = root->FirstChildElement( "Element" );
    if ( element ) {
        // ...
    }
}

Using TiXmlHandle:

TiXmlHandle docHandle( &document );
TiXmlElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).Child( "Child", 1 ).ToElement();
if ( child2 ) {
    // Finally do something useful
}

Depending on the complexity of your element's instantiation, you can implement one of three constructor patterns:

• SingleCtor: The simplest implementation, representing exactly one valid constructor with a specific set of Args....
• CtorList: Represents a list of multiple possible valid constructors. The class must register builders that match at least one constructor in the list.
• Extended Constructor: Used when a derived class Derived can be created via multiple base classes (e.g., Base1 and Base2, where Base2 inherits from Base1). The constructor for Base2 must register the class T to both itself and the original Base1. In this case, the is_constructible type alias applies only to the most derived base class.

After completing the build and installation process, you can verify that the installation was successful by running the sst-test-core binary located in the bin directory of your installation prefix.

/path/to/sst-core/install/bin/sst-test-core

To build the SST-Core infrastructure from source, follow these steps:

1. Download the SST release or clone the repository from GitHub.
2. Create and enter a build directory.
3. Run cmake pointing to the experimental directory with your desired build directives.
4. Run make to compile the source code. You can use -j for parallel builds or make install to install the built software.

$> cd sstcore-VERSION
$> mkdir build
$> cd build
$> cmake ../experimental
$> make -j
$> make install

While the framework works out-of-the-box, you can install optional 3rd party Python modules to enable advanced features:

• Concurrent Testing: To run tests in multiple threads, install testtools.
• Colorized Output: To enable colorized terminal output, install blessings and pygments.

# For concurrent testing
pip install testtools

# For colorized output
pip install blessings pygments

To build SST-Core on Ubuntu 20.04, install the necessary build tools and OpenMPI via apt, clone the repository, and use autogen.sh to prepare the source tree. Configure the build with a --prefix pointing to your desired installation directory.

DEBIAN_FRONTEND=noninteractive sudo apt install openmpi-bin openmpi-common libtool libtool-bin autoconf python3 python3-dev automake build-essential git
mkdir sst-core && cd sst-core
git clone https://github.com/sstsimulator/sst-core.git sst-core-src
(cd sst-core-src && ./autogen.sh)
mkdir build && cd build
../sst-core-src/configure --prefix=$PWD/../sst-core-install
make install