• for MS, in a DLL
• for gcc, static linking is only supported right now, so this is ignored

• port, name, type
• all names start with a lower case letter
• multiple word names have the spaces squeezed out, letter following the space is made upper case

• submit, reason
• noted by ? ! or () following the name
• the result of the function call is compared to the cell value

• Each data item from the row is put into its associated field or compared to the result of the associated function call.

class DefineSensors : public ColumnFixture
{
         
  public:
    explicit DefineSensors()
      {
      PUBLISH(DefineSensors,std::string,port);
      PUBLISH(DefineSensors,std::string,name);
      PUBLISH(DefineSensors,std::string,type);
      PUBLISH(DefineSensors,std::string,submit);
      PUBLISH(DefineSensors,std::string,reason);
    }

    virtual ~DefineSensors() {};

    std::string submit()
    {
    	MockInputPort* p = new MockInputPort(port);
    	HomeGuardContext::RegisterPort(p);
    	Sensor::SensorType t;
    	if (type == "window")
    		t = Sensor::window;
    	else if (type == "door")
    		t = Sensor::window;
    	else if (type == "fire")
    		t = Sensor::fire;
    	else if (type == "waterlevel")
    		t = Sensor::waterlevel;
    	else
    	{
    		theReason = std::string("Unknown sensor type");
    		return "false";
    	}
    	
    	if (HomeGuardContext::GetHomeGuard()->addSensor(t, name, p))
    	{
    		theReason = "none";
    	   	return "true";
    	}
    	else
    	{
    		theReason = "Rejected by homeguard";
    		return "false";
    	}
    }

    std::string reason()
    {
      return theReason;
    }

  private:

    std::string port;
    std::string name;
    std::string type;
    std::string theReason;
    
    DefineSensors(const DefineSensors&);
    DefineSensors& operator=(const DefineSensors&);
};

#include "Platform.h"
#include "Fit/RowFixture.h"

class EventLogOutput : public RowFixture
{
public:
  EventLogOutput();
  ~EventLogOutput();

	class EventHolder : public Fixture
	{
	public:

	    EventHolder(int sequenceNumber, string event, int parameter)
	    : sequenceNumber(sequenceNumber)
            , event(event)
            , parameter(parameter) 
            { 
        	PUBLISH(EventHolder,int,sequenceNumber);
		PUBLISH(EventHolder,string,event);
		PUBLISH(EventHolder,int,parameter);
	    }

            int sequenceNumber;
            string event;
            int parameter;
	};

	virtual RowFixture::ObjectList query() const
        {
            int sequence = 1;
            rows.push_back(new EventHolder(sequence++, "dummy event", 42));
            rows.push_back(new EventHolder(sequence++, "another dummy", 42));
	    return rows;
        }

	virtual const Fixture	*getTargetClass() const;
        {
	    return &exampleEventHolder;
        }
  private:

      EventHolder exampleEventHolder;
      mutable RowFixture::ObjectList rows;

      EventLogOutput(const EventLogOutput&);
      EventLogOutput& operator=(const EventLogOutput&);
};

• start - initialize a specific action fixture
• check - check that the field specified in cell two has the value specified in cell three
• press - call the function in cell two
• enter - call the function in cell two with cell three as a parameter

#include "Fit/ActionFixture.h"
#include <string>

class FrontPanel : public ActionFixture 
{
public:

    FrontPanel()
    {
        thedigits = "";
        display = "not sure";
        armLed = "not sure";
        
        PUBLISH_ENTER(SetupProblem,std::string,digits);
        
        PUBLISH_COMMAND(SetupProblem,armButton);
        PUBLISH_COMMAND(SetupProblem,enterButton);
        
        PUBLISH_CHECK(SetupProblem,std::string,display);
        PUBLISH_CHECK(SetupProblem,std::string,armLed);
        PUBLISH_CHECK(SetupProblem, std::string, display);      
    }
    
    void armButton() { display = "arm pressed";}
    void enterButton() { display = "enter pressed";}
    
    std::string display;
    std::string armLed;
    std::string thedigits;
    void digits(std::string d) { display = d; }
	
};

#include "Platform.h"
#include "Fit/AppFixtureMaker.h"
#include "Fit/Fixture.h"

#include "FrontPanel.h"
#include "DefineSensors.h"
#include "EventLogOutput.h"

#include <iostream>

AppFixtureMaker::AppFixtureMaker()
{
}

AppFixtureMaker::~AppFixtureMaker()
{
}

Fixture* AppFixtureMaker::Make(const char* name)
{
    PUBLISH_FIXTURE(ActionFixture)
    PUBLISH_FIXTURE(FrontPanel)
    PUBLISH_FIXTURE(DefineSensors)
    PUBLISH_FIXTURE(EventLogOutput)

    return 0;
}