testharness.h

Go to the documentation of this file.

/* ------------------------------------------------------------------------- */
/* file testharness.h                                                                 */
/* ------------------------------------------------------------------------- */
/*   Copyright (C) 2011 Peter Milne, D-TACQ Solutions Ltd
 *                      <Peter dot Milne at D hyphen TACQ dot com>
 *  Created on: Sep 25, 2011
 *      Author: pgm

    http://www.d-tacq.com

    This program is free software; you can redistribute it and/or modify
    it under the terms of Version 2 of the GNU General Public License
    as published by the Free Software Foundation;

    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., 675 Mass Ave, Cambridge, MA 02139, USA.                */
/* ------------------------------------------------------------------------- */

/** @file testharness.h - test harness Outputs, Inputs.
 *
 */

#ifndef TESTHARNESS_H_
#define TESTHARNESS_H_



class Outputs {
        /**< Outputs: testharness example outputs. */
        const int ao_count;
        int ao_len;
        short* ao_buf;
        unsigned long long do_buf[2];

public:
        short *getAO(int ii) {
                int offset = (ii*ao_count)%ao_len;

                return ao_buf+offset;
        }
        /** re-uses same set of 32 DO, two values. */
        unsigned *getDO(int ii){
                return (unsigned*)&do_buf[ii&1];
        }


        Outputs(int _ao_count = 32, int do_count = 32) :
                ao_count(_ao_count)
        {
                const char* aofn;
                if ((aofn = getenv("LL_OUTPUTS")) != 0){
                        struct stat buf;
                        int rc;

                        rc = stat(aofn, &buf);
                        if (rc == 0){
                                ao_len = buf.st_size/sizeof(short);
                                ao_buf = new short [ao_len];
                                FILE *fp = fopen(aofn, "r");
                                assert(fp);
                                fread(ao_buf, ao_len, sizeof(short), fp);
                                fclose(fp);
                        }else{
                                perror(aofn);
                                exit(errno);
                        }
                }else{
                        ao_len = ao_count;
                        ao_buf = new short[ao_len];
                        for (int ii = 0; ii != ao_count; ++ii){
                                ao_buf[ii] = 500*ii;
                        }
                }

                do_buf[0] = 0ULL;
                do_buf[1] = ~0ULL;
        }

        ~Outputs() {
                delete [] ao_buf;
        }
};

class Inputs {
        const int samples;
        const int ai_count;
        const int di_count;
        const int status_count;
        short *ai;
        unsigned *di;
        unsigned *status;

        static void writeFile(const char* fname, void* buf, int nbytes){
                FILE *fp = fopen(fname, "w");
                assert(fp);
                fwrite(buf, nbytes, 1, fp);
                fclose(fp);
        }
public:
        short *getAI(int ii){
                return ai + ii*ai_count;
        }
        unsigned *getDI(int ii){
                return di + ii*di_count/32;
        }
        unsigned *getStatus(int ii){
                return status+ii*status_count;
        }
        Inputs(int _samples, int _ai_count = 96, int _di_count = 32,
                        int _status_count = 16) :
                samples(_samples),
                ai_count(_ai_count),
                di_count(_di_count),
                status_count(_status_count)

        {
                ai = znew<short>(samples*ai_count);
                di = znew<unsigned>(samples*di_count/BITS_PER_DX_WORD);
                status = znew<unsigned>(samples*status_count);
        }
        ~Inputs()
        {
                writeFile("ai.dat", ai, samples*ai_count*sizeof(short));
                writeFile("di.dat", di, samples*di_count/BITS_PER_DX_WORD*sizeof(unsigned));
                writeFile("status.dat", status, samples*status_count*sizeof(unsigned));

                delete [] ai;
                delete [] di;
                delete [] status;
        }
};


#endif /* TESTHARNESS_H_ */