MachineTester Class Reference

#include <MachineTester.hh>

Inheritance diagram for MachineTester:

Collaboration diagram for MachineTester:

Public Member Functions
	MachineTester (const TTAMachine::Machine &machine)
virtual	~MachineTester ()
virtual bool	canConnect (const TTAMachine::Socket &socket, const TTAMachine::Segment &segment)
virtual bool	canConnect (const TTAMachine::Socket &socket, const TTAMachine::Port &port)
virtual bool	canBridge (const TTAMachine::Bus &source, const TTAMachine::Bus &destination)
virtual bool	canSetDirection (const TTAMachine::Socket &socket, TTAMachine::Socket::Direction direction)
bool	connectionExists () const
bool	illegalRegistration () const
bool	loop () const
TTAMachine::Bus *	branchedBus () const
bool	wrongSocketDirection () const
bool	maxConnections () const
bool	unknownSocketDirection () const
bool	noConnections () const
TTAMachine::Port *	sameDirSocketConnection (TTAMachine::Socket::Direction direction) const
TTAMachine::Port *	forbiddenSocketDirection (TTAMachine::Socket::Direction direction) const
bool	registerFilePortAlreadyConnected () const

Static Public Member Functions
static bool	isValidComponentName (const std::string &name)

Private Member Functions
	MachineTester (const MachineTester &tester)
MachineTester &	operator= (const MachineTester &tester)
void	clearState ()
bool	legalPortConnections (const TTAMachine::Socket &socket, TTAMachine::Socket::Direction direction)

Static Private Member Functions
static bool	areInSameChain (const TTAMachine::Bus &bus1, const TTAMachine::Bus &bus2)

Private Attributes
const TTAMachine::Machine *	machine_
	The machine on which the tests are carried out. More...
bool	connectionExists_
	Indicates if the reason for the last test failure is that the tested connection already exists. More...
bool	rfPortAlreadyConnected_
	Indicates if the reason for failure is that a port of register file is already connected to a particular socket. More...
bool	illegalRegistration_
	Indicates if the reason for last test failure was illegal registration. More...
bool	loop_
	Indicates if the reason for failure when trying to bridge two busses is that a loop in the bus chain would be created. More...
const TTAMachine::Bus *	branchedBus_
	If the reason for failure when trying to bridge two busses is that a branch in the bus chain would be created, this is the branched bus. More...
bool	wrongSocketDirection_
	Indicates if the reason for failure when trying to connect a socket to a port was that the direction of the socket is incompatible with the direction of other sockets connected to the port. More...
bool	maxConnections_
	Indicates if the reason for failure when trying to connect a socket to a port was that this connection would exceed the maximum number of connections allowed for a port. More...
bool	unknownDir_
	Indicates if tried to set the socket direction to Socket::UNKNOWN. More...
bool	noConnections_
	Indicates if the reason for failure when tried to set socket direction was that the socket has no segment connections. More...
TTAMachine::Port *	sameDirInputSocketConn_
	If the reason for failure when tried to set socket direction to input was that the socket is connected to a port that already has an input socket connected, this is the port. More...
TTAMachine::Port *	sameDirOutputSocketConn_
	If the reason for failure when tried to set socket direction to output was that the socket is connected to a port that already has an output socket connected, this is the port. More...
TTAMachine::Port *	forbiddenInputSocketDir_
	If the reason for failure when tried to set socket direction to input was the socket is connected to a unit that cannot be connected to an input socket, this is the port of the unit. More...

Detailed Description

MachineTester is a class that implements all the API needed for diagnostics of machine model.

Definition at line 46 of file MachineTester.hh.

Constructor & Destructor Documentation

MachineTester() [1/2]

MachineTester::MachineTester

(

const TTAMachine::Machine &

machine

)

Constructor.

Parameters

machine

The machine on which the tests are done.

Definition at line 57 of file MachineTester.cc.

                                                   :
    machine_(&machine) {
 
    clearState();
}

References clearState().

Here is the call graph for this function:

~MachineTester()

MachineTester::~MachineTester ( )

virtual

Destructor.

Definition at line 67 of file MachineTester.cc.

                              {
}

MachineTester() [2/2]

MachineTester::MachineTester ( const MachineTester &  tester )

private

Member Function Documentation

areInSameChain()

bool MachineTester::areInSameChain ( const TTAMachine::Bus &  bus1, const TTAMachine::Bus &  bus2  )

staticprivate

Checks if the given buses are in the same bus chain.

Parameters

bus1	The first bus.
bus2	The second bus.

Returns

True if they are in the same chain, otherwise false.

Definition at line 521 of file MachineTester.cc.

                                                              {
 
    if (&bus1 == &bus2) {
        return true;
    }
 
    const Bus* bus = &bus1;
    while (bus->hasPreviousBus()) {
        bus = bus->previousBus();
        if (bus == &bus2) {
            return true;
        }
    }
 
    bus = &bus1;
    while (bus->hasNextBus()) {
        bus = bus->nextBus();
        if (bus == &bus2) {
            return true;
        }
    }
 
    return false;
}

References TTAMachine::Bus::hasNextBus(), TTAMachine::Bus::hasPreviousBus(), TTAMachine::Bus::nextBus(), and TTAMachine::Bus::previousBus().

Referenced by canBridge().

Here is the call graph for this function:

branchedBus()

Bus * MachineTester::branchedBus

(

)

const

If the reason for failure when tried to join two buses by a bridge was a branched bus chain, returns the bus that was going to be branched. Otherwise returns NULL.

Returns

The branched bus.

Definition at line 380 of file MachineTester.cc.

                                 {
    if (branchedBus_ == NULL) {
        return NULL;
    } else {
        return const_cast<Bus*>(branchedBus_);
    }
}

References branchedBus_.

Referenced by MachineTestReporter::bridgingError().

canBridge()

bool MachineTester::canBridge ( const TTAMachine::Bus &  source, const TTAMachine::Bus &  destination  )

virtual

Checks if the given source and destination buses can be joined by a new bridge.

If the test has negative outcome, the reason for it can be queried using the following functions: illegalRegistration, loop, connectionExists, branchedBus.

Parameters

source	The source bus of the bridge.
destination	The destination bus of the bridge.

Returns

True if the can be created, otherwise false.

Reimplemented in DummyMachineTester.

Definition at line 203 of file MachineTester.cc.

                                                                  {
 
    clearState();
 
    // check registration of the buses
    if (source.machine() != machine_ || destination.machine() != machine_) {
        illegalRegistration_ = true;
        return false;
    }
 
    if (&source == &destination) {
        return false;
    }
 
    // check if there already exists an equal bridge
    if (source.canWrite(destination)) {
        connectionExists_ = true;
        return false;
    } else if (destination.canWrite(source)) {
        // if an opposite bridge already exists between the buses, the new
        // bridge can be created
        return true;
    }
 
    // check if a loop would be created
 
    // Buses cannot be joined by a new bridge if they are already in the same
    // chain and are not adjacent. If they are adjacent then it is possible
    // to join them in order the create a bidirection bridge.
    if (areInSameChain(source, destination)) {
        bool adjacent = false;
        if (source.hasNextBus()) {
            if (source.nextBus() == &destination) {
                adjacent = true;
            }
        }
        if (source.hasPreviousBus()) {
            if (source.previousBus() == &destination) {
                adjacent = true;
            }
        }
        if (!adjacent) {
            loop_ = true;
            return false;
        }
    }
 
    // check that a branch will not be created
    if (source.hasNextBus() && source.hasPreviousBus()) {
        if (source.nextBus() != &destination &&
            source.previousBus() != &destination) {
            branchedBus_ = &source;
            return false;
        }
    }
    if (destination.hasNextBus() && destination.hasPreviousBus()) {
        if (destination.nextBus() != &source &&
            destination.previousBus() != &source) {
            branchedBus_ = &destination;
            return false;
        }
    }
 
    return true;
}

References areInSameChain(), branchedBus_, TTAMachine::Bus::canWrite(), clearState(), connectionExists_, TTAMachine::Bus::hasNextBus(), TTAMachine::Bus::hasPreviousBus(), illegalRegistration_, loop_, TTAMachine::Component::machine(), machine_, TTAMachine::Bus::nextBus(), and TTAMachine::Bus::previousBus().

Referenced by TTAMachine::Bridge::Bridge(), AddBridgeCmd::Do(), TTAMachine::Bridge::loadState(), BridgeDialog::onInputBus(), BridgeDialog::onOK(), and BridgeDialog::updateBusChoices().

Here is the call graph for this function:

canConnect() [1/2]

bool MachineTester::canConnect ( const TTAMachine::Socket &  socket, const TTAMachine::Port &  port  )

virtual

Checks if the given socket can be connected to the given port.

If false is returned, the reason for the test failure can be queried using the following functions: illegalRegistration, connectionExists, wrongSocketDirection, maxConnections.

Parameters

socket	The socket.
port	The port.

Returns

True if the connection can be made, otherwise false.

Reimplemented in DummyMachineTester.

Definition at line 127 of file MachineTester.cc.

                                                                {
 
    clearState();
 
    // check registration
    if (socket.machine() != machine_ ||
        port.parentUnit()->machine() != machine_) {
        illegalRegistration_ = true;
        return false;
    }
 
    // check the existing connections of the port
    Socket* inputSocket = port.inputSocket();
    Socket* outputSocket = port.outputSocket();
    Socket* firstUnconnected = port.unconnectedSocket(0);
    Socket* secondUnconnected = port.unconnectedSocket(1);
 
    if (inputSocket == &socket || outputSocket == &socket ||
        firstUnconnected == &socket || secondUnconnected == &socket) {
        connectionExists_ = true;
        return false;
    }
 
    if ((inputSocket != NULL && socket.direction() == Socket::INPUT) ||
        (outputSocket != NULL && socket.direction() == Socket::OUTPUT)) {
        wrongSocketDirection_ = true;
        return false;
    }
    if (port.socketCount() == 2) {
        maxConnections_ = true;
        return false;
    }
 
    // check the special cases of allowed socket directions
    Unit* parentUnit = port.parentUnit();
    if (dynamic_cast<ImmediateUnit*>(parentUnit) != NULL) {
        assert(port.socketCount() <= 1);
        if (port.socketCount() == 1) {
            maxConnections_ = true;
            return false;
        }
        if (socket.direction() == Socket::INPUT) {
            wrongSocketDirection_ = true;
            return false;
        }
    }
 
    // ports of a register file cannot be connected to same socket
    RegisterFile* parentRf = dynamic_cast<RegisterFile*>(parentUnit);
    if (parentRf != NULL) {
        for (int i = 0; i < parentRf->portCount(); i++) {
            Port* rfPort = parentRf->port(i);
            if (rfPort->isConnectedTo(socket)) {
                rfPortAlreadyConnected_ = true;
                return false;
            }
        }
    }
 
    return true;
}

References assert, clearState(), connectionExists_, TTAMachine::Socket::direction(), illegalRegistration_, TTAMachine::Port::inputSocket(), TTAMachine::Port::isConnectedTo(), TTAMachine::Component::machine(), machine_, maxConnections_, TTAMachine::Port::outputSocket(), TTAMachine::Port::parentUnit(), TTAMachine::BaseRegisterFile::port(), TTAMachine::Unit::portCount(), rfPortAlreadyConnected_, TTAMachine::Port::socketCount(), TTAMachine::Port::unconnectedSocket(), and wrongSocketDirection_.

Here is the call graph for this function:

canConnect() [2/2]

bool MachineTester::canConnect ( const TTAMachine::Socket &  socket, const TTAMachine::Segment &  segment  )

virtual

Tests if the given socket can be connected to the given segment.

After calling this function, the reason for a test failure can be queried. Functions for querying the possible reasons are: connectionExists, illegalRegistration, sameDirSocketConnection, forbiddenSocketDirection.

Note that only the first reason encountered is recorded.

Parameters

socket	The socket.
segment	The segment.

Returns

True if the connection can be made.

Reimplemented in DummyMachineTester.

Definition at line 86 of file MachineTester.cc.

                                                                      {
 
    clearState();
 
    if (socket.machine() != machine_) {
        illegalRegistration_ = true;
        return false;
    }
    if (segment.parentBus()->machine() != machine_) {
        illegalRegistration_ = true;
        return false;
    }
    if (socket.isConnectedTo(segment)) {
        connectionExists_ = true;
        return false;
    }
 
    // check that the direction of the socket can be set if needed
    if (socket.segmentCount() == 0) {
        if (!legalPortConnections(socket, Socket::INPUT) &&
            !legalPortConnections(socket, Socket::OUTPUT)) {
            return false;
        }
    }
 
    return true;
}

References clearState(), connectionExists_, illegalRegistration_, TTAMachine::Socket::isConnectedTo(), legalPortConnections(), TTAMachine::Component::machine(), machine_, TTAMachine::Segment::parentBus(), and TTAMachine::Socket::segmentCount().

Referenced by TTAMachine::Socket::attachBus(), TTAMachine::Port::attachSocket(), TTAMachine::Segment::attachSocket(), FullyConnectedCheck::attachSocketToAllBusses(), ProDePortEditPolicy::canHandle(), ProDeSegmentEditPolicy::canHandle(), ProDeSocketEditPolicy::canHandle(), RemoveUnconnectedComponents::checkFUPorts(), RemoveUnconnectedComponents::checkRFPorts(), FullyConnectedCheck::connectFUPort(), FullyConnectedCheck::connectIUPort(), FullyConnectedCheck::connectRFPort(), FullyConnectedCheck::connectSpecialRegisterPort(), SocketDialog::onAttach(), FullyConnectedCheck::socketAttachedToAllBusses(), IUPortDialog::updateSocket(), SRPortDialog::updateSockets(), FUPortDialog::updateSockets(), and RFPortDialog::updateSockets().

Here is the call graph for this function:

canSetDirection()

bool MachineTester::canSetDirection ( const TTAMachine::Socket &  socket, TTAMachine::Socket::Direction  direction  )

virtual

Checks if the direction of the given socket can be set to the given value.

Takes into account the ports that are directly connected to the given socket only. The reason for error can be queried for using the following functions: unknownSocketDirection, noConnections, sameDirSocketConnection, forbiddenSocketDirection.

Parameters

socket	The socket.
direction	The new direction of the socket.

Returns

True if the direction can be set, otherwise false.

Reimplemented in DummyMachineTester.

Definition at line 283 of file MachineTester.cc.

                               {
 
    clearState();
 
    if (direction == Socket::UNKNOWN) {
        unknownDir_ = true;
        return false;
    }
    if (socket.segmentCount() == 0) {
        noConnections_ = true;
        return false;
    }
    if (direction == socket.direction()) {
        return true;
    }
 
    return legalPortConnections(socket, direction);
}

References clearState(), TTAMachine::Socket::direction(), legalPortConnections(), noConnections_, TTAMachine::Socket::segmentCount(), UNKNOWN, and unknownDir_.

Referenced by TTAMachine::Socket::attachBus(), and TTAMachine::Socket::setDirection().

Here is the call graph for this function:

clearState()

void MachineTester::clearState ( )

private

Clears the state of the object.

Definition at line 497 of file MachineTester.cc.

                          {
    connectionExists_ = false;
    rfPortAlreadyConnected_ = false;
    illegalRegistration_ = false;
    loop_ = false;
    branchedBus_ = NULL;
    wrongSocketDirection_ = false;
    maxConnections_ = false;
    unknownDir_ = false;
    noConnections_ = false;
    sameDirInputSocketConn_ = NULL;
    sameDirOutputSocketConn_ = NULL;
    forbiddenInputSocketDir_ = NULL;
}

References branchedBus_, connectionExists_, forbiddenInputSocketDir_, illegalRegistration_, loop_, maxConnections_, noConnections_, rfPortAlreadyConnected_, sameDirInputSocketConn_, sameDirOutputSocketConn_, unknownDir_, and wrongSocketDirection_.

Referenced by canBridge(), canConnect(), canSetDirection(), and MachineTester().

connectionExists()

bool MachineTester::connectionExists

(

)

const

Returns true if the reason for failure of the previous test was that a connection exists already between the components.

Returns

True if a connection exists, otherwise false.

Definition at line 342 of file MachineTester.cc.

                                      {
    return connectionExists_;
}

References connectionExists_.

Referenced by TTAMachine::Port::attachSocket(), MachineTestReporter::bridgingError(), MachineTestReporter::socketPortConnectionError(), and MachineTestReporter::socketSegmentConnectionError().

forbiddenSocketDirection()

Port * MachineTester::forbiddenSocketDirection

(

TTAMachine::Socket::Direction

direction

)

const

If the reason for failure when tried to set socket direction was that the socket was connected to a port of a unit that doesn't allow sockets of such direction to be connected, returns the port. Otherwise returns NULL.

Parameters

direction

The direction that was tried to set.

Returns

The port.

Definition at line 471 of file MachineTester.cc.

                                                                       {
    if (direction == Socket::INPUT) {
        return forbiddenInputSocketDir_;
    } else {
        return NULL;
    }
}

References forbiddenInputSocketDir_.

Referenced by MachineTestReporter::socketDirectionSettingError(), and MachineTestReporter::socketSegmentConnectionError().

illegalRegistration()

bool MachineTester::illegalRegistration

(

)

const

Returns true if the reason for failure of the previous test was illegal registration of components.

Returns

True if the components were not registered to the same machine, otherwise false.

Definition at line 355 of file MachineTester.cc.

                                         {
    return illegalRegistration_;
}

References illegalRegistration_.

Referenced by MachineTestReporter::bridgingError(), MachineTestReporter::socketPortConnectionError(), and MachineTestReporter::socketSegmentConnectionError().

isValidComponentName()

bool MachineTester::isValidComponentName ( const std::string &  name )

static

Checks whether the given string is a valid machine component name.

Parameters

name	The name to check.

Returns

True if the name is valid, otherwise false.

Definition at line 312 of file MachineTester.cc.

                                                         {
 
    if (name.length() == 0) {
        return false;
    }
 
    for (unsigned int i = 0; i < name.length(); i++) {
        char character = name[i];
        if (i == 0) {
            if (!isalpha(character)) {
                return false;
            }
        } else {
            if (!isalpha(character) && !isdigit(character) &&
                character != '_' && character != ':') {
                return false;
            }
        }
    }
    return true;
}

Referenced by TTAMachine::ExecutionPipeline::checkResourceName(), TTAMachine::Component::Component(), TTAMachine::HWOperation::HWOperation(), TTAMachine::Segment::loadStateWithoutReferences(), TTAMachine::Port::loadStateWithoutReferences(), OperationDialog::onAddResource(), BusDialog::onAddSegment(), ImmediateSlotDialog::onAddSlot(), TemplateListDialog::onAddTemplate(), RFPortDialog::onOK(), IUPortDialog::onOK(), RFDialog::onOK(), SRPortDialog::onOK(), FUPortDialog::onOK(), SocketDialog::onOK(), FUDialog::onOK(), IUDialog::onOK(), BusDialog::onOK(), BridgeDialog::onOK(), AddressSpaceDialog::onOK(), OperationDialog::onOK(), GCUDialog::onOK(), TTAMachine::Port::Port(), TTAMachine::Segment::Segment(), TTAMachine::PipelineElement::setName(), TTAMachine::HWOperation::setName(), TTAMachine::Segment::setName(), TTAMachine::Port::setName(), and TTAMachine::Component::setName().

legalPortConnections()

bool MachineTester::legalPortConnections ( const TTAMachine::Socket &  socket, TTAMachine::Socket::Direction  direction  )

private

Checks if the given socket will have legal connections to ports if its direction is changed to the given value.

Parameters

socket	The socket to test.
direction	The direction to test.

Returns

True if the connections will stay legal, otherwise false.

Definition at line 556 of file MachineTester.cc.

                               {
 
    for (int i = 0; i < socket.portCount(); i++) {
        Port* port = socket.port(i);
        if (direction == Socket::INPUT && port->inputSocket() != NULL) {
            sameDirInputSocketConn_ = port;
            return false;
        } else if (direction == Socket::OUTPUT &&
                   port->outputSocket() != NULL) {
            sameDirOutputSocketConn_ = port;
            return false;
        }
        Unit* parent = port->parentUnit();
        if (dynamic_cast<ImmediateUnit*>(parent) != NULL &&
            direction == Socket::INPUT) {
            forbiddenInputSocketDir_ = port;
            return false;
        }
    }
 
    return true;
}

References forbiddenInputSocketDir_, TTAMachine::Port::inputSocket(), TTAMachine::Port::outputSocket(), TTAMachine::Port::parentUnit(), TTAMachine::Socket::port(), TTAMachine::Socket::portCount(), sameDirInputSocketConn_, and sameDirOutputSocketConn_.

Referenced by canConnect(), and canSetDirection().

Here is the call graph for this function:

loop()

bool MachineTester::loop

(

)

const

If the reason for failure when tried to join two buses by a bridge was loop in bus chain, returns true. Otherwise returns false.

Returns

True, if loop was the reason for failure.

Definition at line 367 of file MachineTester.cc.

                          {
    return loop_;
}

References loop_.

Referenced by MachineTestReporter::bridgingError().

maxConnections()

bool MachineTester::maxConnections

(

)

const

Checks if maximum number of connections in port was the reason for failure when tried to attach a port to a socket.

Returns

True, if maximum number of connection was the reason, otherwise false.

Definition at line 410 of file MachineTester.cc.

                                    {
    return maxConnections_;
}

References maxConnections_.

Referenced by MachineTestReporter::socketPortConnectionError().

noConnections()

bool MachineTester::noConnections

(

)

const

Returns true if the reason for failure when tried to set socket direction was that the socket has no connections to segments.

Returns

True if the socket has no connections to segments, otherwise false.

Definition at line 437 of file MachineTester.cc.

                                   {
    return noConnections_;
}

References noConnections_.

Referenced by MachineTestReporter::socketDirectionSettingError().

operator=()

MachineTester& MachineTester::operator= ( const MachineTester &  tester )

private

registerFilePortAlreadyConnected()

bool MachineTester::registerFilePortAlreadyConnected

(

)

const

Tells whether the reason for failure when tried to attach a port to a socket was that the parent unit of the port was register file and a port of the register file was already connected to the socket.

Returns

True if that was the reason, otherwise false.

Definition at line 488 of file MachineTester.cc.

                                                      {
    return rfPortAlreadyConnected_;
}

References rfPortAlreadyConnected_.

Referenced by MachineTestReporter::socketPortConnectionError().

sameDirSocketConnection()

Port * MachineTester::sameDirSocketConnection

(

TTAMachine::Socket::Direction

direction

)

const

If the reason for failure when tried to set socket direction was that the socket was connected to a port that was connected to another socket that has the same direction, returns that port. Otherwise returns NULL.

Parameters

direction

The direction that was tried to set.

Returns

The port.

Definition at line 451 of file MachineTester.cc.

                                                                      {
    if (direction == Socket::INPUT) {
        return sameDirInputSocketConn_;
    } else if (direction == Socket::OUTPUT) {
        return sameDirOutputSocketConn_;
    } else {
        return NULL;
    }
}

References sameDirInputSocketConn_, and sameDirOutputSocketConn_.

Referenced by MachineTestReporter::socketDirectionSettingError(), and MachineTestReporter::socketSegmentConnectionError().

unknownSocketDirection()

bool MachineTester::unknownSocketDirection

(

)

const

Returns true if the reason for failure when tried to set socket direction was unknown direction. The direction of socket can never be set to unknown.

Returns

True if the reason for failure was unknown socket direction, otherwise false.

Definition at line 424 of file MachineTester.cc.

                                            {
    return unknownDir_;
}

References unknownDir_.

Referenced by MachineTestReporter::socketDirectionSettingError().

wrongSocketDirection()

bool MachineTester::wrongSocketDirection

(

)

const

Checks if wrong direction of socket was the reason for failure when tried to attach a port to a socket.

Returns

True, if wrong direction of socket was the reason, otherwise false.

Definition at line 397 of file MachineTester.cc.

                                          {
    return wrongSocketDirection_;
}

References wrongSocketDirection_.

Referenced by MachineTestReporter::socketPortConnectionError().

Member Data Documentation

branchedBus_

const TTAMachine::Bus* MachineTester::branchedBus_

private

If the reason for failure when trying to bridge two busses is that a branch in the bus chain would be created, this is the branched bus.

Definition at line 109 of file MachineTester.hh.

Referenced by branchedBus(), canBridge(), and clearState().

connectionExists_

bool MachineTester::connectionExists_

private

Indicates if the reason for the last test failure is that the tested connection already exists.

Definition at line 97 of file MachineTester.hh.

Referenced by canBridge(), canConnect(), clearState(), and connectionExists().

forbiddenInputSocketDir_

TTAMachine::Port* MachineTester::forbiddenInputSocketDir_

private

If the reason for failure when tried to set socket direction to input was the socket is connected to a unit that cannot be connected to an input socket, this is the port of the unit.

Definition at line 134 of file MachineTester.hh.

Referenced by clearState(), forbiddenSocketDirection(), and legalPortConnections().

illegalRegistration_

bool MachineTester::illegalRegistration_

private

Indicates if the reason for last test failure was illegal registration.

Definition at line 103 of file MachineTester.hh.

Referenced by canBridge(), canConnect(), clearState(), and illegalRegistration().

loop_

bool MachineTester::loop_

private

Indicates if the reason for failure when trying to bridge two busses is that a loop in the bus chain would be created.

Definition at line 106 of file MachineTester.hh.

Referenced by canBridge(), clearState(), and loop().

machine_

const TTAMachine::Machine* MachineTester::machine_

private

The machine on which the tests are carried out.

Definition at line 94 of file MachineTester.hh.

Referenced by canBridge(), and canConnect().

maxConnections_

bool MachineTester::maxConnections_

private

Indicates if the reason for failure when trying to connect a socket to a port was that this connection would exceed the maximum number of connections allowed for a port.

Definition at line 117 of file MachineTester.hh.

Referenced by canConnect(), clearState(), and maxConnections().

noConnections_

bool MachineTester::noConnections_

private

Indicates if the reason for failure when tried to set socket direction was that the socket has no segment connections.

Definition at line 122 of file MachineTester.hh.

Referenced by canSetDirection(), clearState(), and noConnections().

rfPortAlreadyConnected_

bool MachineTester::rfPortAlreadyConnected_

private

Indicates if the reason for failure is that a port of register file is already connected to a particular socket.

Definition at line 100 of file MachineTester.hh.

Referenced by canConnect(), clearState(), and registerFilePortAlreadyConnected().

sameDirInputSocketConn_

TTAMachine::Port* MachineTester::sameDirInputSocketConn_

private

If the reason for failure when tried to set socket direction to input was that the socket is connected to a port that already has an input socket connected, this is the port.

Definition at line 126 of file MachineTester.hh.

Referenced by clearState(), legalPortConnections(), and sameDirSocketConnection().

sameDirOutputSocketConn_

TTAMachine::Port* MachineTester::sameDirOutputSocketConn_

private

If the reason for failure when tried to set socket direction to output was that the socket is connected to a port that already has an output socket connected, this is the port.

Definition at line 130 of file MachineTester.hh.

Referenced by clearState(), legalPortConnections(), and sameDirSocketConnection().

unknownDir_

bool MachineTester::unknownDir_

private

Indicates if tried to set the socket direction to Socket::UNKNOWN.

Definition at line 119 of file MachineTester.hh.

Referenced by canSetDirection(), clearState(), and unknownSocketDirection().

wrongSocketDirection_

bool MachineTester::wrongSocketDirection_

private

Indicates if the reason for failure when trying to connect a socket to a port was that the direction of the socket is incompatible with the direction of other sockets connected to the port.

Definition at line 113 of file MachineTester.hh.

Referenced by canConnect(), clearState(), and wrongSocketDirection().

---

The documentation for this class was generated from the following files:

• MachineTester.hh
• MachineTester.cc