software_log_generated_tests.cpp

Go to the documentation of this file.

#include <assert.h>
#include "../../../../tests/catch2/catch.hpp"
#include "../generated/logCodes.hpp"
#include "../types/software_log.hpp"
#include "../types/generated/software_log_generated.h"
#include "../types/flatbuffer_log.hpp"
 
/*
 * GENERATED TEST FILE for types/software_log.hpp 
 * generated by generateTemplateCatch2Tests.py
 */
 
const char * softwareLogFile_0 = "16o2v225kf"; // dummy file
const uint32_t softwareLogLine_0 = 2104871043; // dummy line
const int32_t softwareLogErrnoCode_0 = -759937723; // dummy errnoCode
const int32_t softwareLogOtherCode_0 = -1277624151; // dummy otherCode
const char * softwareLogExplanation_0 = "ywgtnage2v"; // dummy explanation
 
 
/** Class to encapsulate software_log flatbuffer data using
 ** => types/software_log.hpp
 ** => types/generated/software_log_generated.h
 **/
class CSoftwareLog_0
{
public:
  // Saved input parameter value; unused
  char * m_saveSlFile;
  uint32_t m_saveSlLine;
  int32_t m_saveSlErrnoCode;
  int32_t m_saveSlOtherCode;
  char * m_saveSlExplanation;
 
  // Parameters retrieved from flatbuffer
  char * m_file;
  uint32_t m_line;
  int32_t m_errnoCode;
  int32_t m_otherCode;
  char * m_explanation;
 
  // Flatbuffers verifier success/failure
  bool m_verify{false};
 
  // flatbuffer data length; used in ::verify
  int L;
 
  // Constructor
  CSoftwareLog_0(char * file_, uint32_t line_, int32_t errnoCode_, int32_t otherCode_, char * explanation_) {
    // Save input parameters
    m_saveSlFile = file_;
    m_saveSlLine = line_;
    m_saveSlErrnoCode = errnoCode_;
    m_saveSlOtherCode = otherCode_;
    m_saveSlExplanation = explanation_;
 
    // Create the flatbuffer messageT using the input parameters
    auto sl = MagAOX::logger::software_log::messageT(file_, line_, errnoCode_, otherCode_, explanation_);
 
    // Retrieve flatbuffer pointer (if not an empty_log type) and length
    void* buffPtr = sl.builder.GetBufferPointer();
    L = MagAOX::logger::software_log::length(sl);
 
    // Retrieve the flatbuffer parameters for Catch2 comparison below
    size_t fileStrLen = strlen(MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str()) + 1;
    m_file = (char *) malloc(fileStrLen);
    strncpy(m_file, MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str(), fileStrLen);
    m_line = MagAOX::logger::GetSoftware_log_fb(buffPtr)->line();
    m_errnoCode = MagAOX::logger::GetSoftware_log_fb(buffPtr)->errnoCode();
    m_otherCode = MagAOX::logger::GetSoftware_log_fb(buffPtr)->otherCode();
    size_t explanationStrLen = strlen(MagAOX::logger::GetSoftware_log_fb(buffPtr)->explanation()->c_str()) + 1;
    m_explanation = (char *) malloc(explanationStrLen);
    strncpy(m_explanation, MagAOX::logger::GetSoftware_log_fb(buffPtr)->explanation()->c_str(), explanationStrLen);
 
    // Run the software_log verifier
    m_verify = verify(sl);
  }
 
  // Run the flatbuffer Verifier for this log type
  // - requires bufferPtrT (shared_ptr<char*>) to full log entry
  //   comprising log header plus flatbuffer log message
  bool verify(const typename MagAOX::logger::software_log::messageT& msg) {
 
    // Timestamp, prioriy (use nominal value here)
    flatlogs::timespecX tsx{0,0};
    flatlogs::logPrioT prio{flatlogs::logPrio::LOG_DEFAULT};
 
    // Create full log: log header(*); log message (+)
    // * Log level (priority)
    // * Event code (implicit in <MagAOX::logger::type>)
    // * Timestamp
    // * Message size (variable length; 1, 2, or 8 bytes)
    // + Message (variable length)
 
    // N.G. allocates space and writes pointer value to logBuffer
    flatlogs::bufferPtrT logBuffer;
    flatlogs::logHeader::createLog<MagAOX::logger::software_notice>(logBuffer
                                                             , tsx, msg
                                                             , prio);
    // Run full log through flatbuffer Verifier
    return MagAOX::logger::software_log::verify(logBuffer,L);
  }
};
 
SCENARIO( "Create software_log 0", "[a log item]")
{
    GIVEN("a software_log log code")
    {
        WHEN("random values for fields")
        {
            // Create flatbuffer
            CSoftwareLog_0 sl = CSoftwareLog_0((char *) softwareLogFile_0, softwareLogLine_0, softwareLogErrnoCode_0, softwareLogOtherCode_0, (char *) softwareLogExplanation_0);
            // Compare flatbuffer parameters
            REQUIRE(strcmp(sl.m_file, softwareLogFile_0) == 0);
            REQUIRE(sl.m_line == softwareLogLine_0);
            REQUIRE(sl.m_errnoCode == softwareLogErrnoCode_0);
            REQUIRE(sl.m_otherCode == softwareLogOtherCode_0);
            REQUIRE(strcmp(sl.m_explanation, softwareLogExplanation_0) == 0);
            REQUIRE(sl.m_verify);
        }
    }
}
 
const char * softwareLogFile_1 = "m2yj4dkbqe"; // dummy file
const uint32_t softwareLogLine_1 = 2591561709; // dummy line
const int32_t softwareLogErrnoCode_1 = 1435732986; // dummy errnoCode
const int32_t softwareLogOtherCode_1 = -155782355; // dummy otherCode
const std::string softwareLogExplanation_1 = "kj5v8n8bgk"; // dummy explanation
 
 
/** Class to encapsulate software_log flatbuffer data using
 ** => types/software_log.hpp
 ** => types/generated/software_log_generated.h
 **/
class CSoftwareLog_1
{
public:
  // Saved input parameter value; unused
  char * m_saveSlFile;
  uint32_t m_saveSlLine;
  int32_t m_saveSlErrnoCode;
  int32_t m_saveSlOtherCode;
  std::string m_saveSlExplanation;
 
  // Parameters retrieved from flatbuffer
  char * m_file;
  uint32_t m_line;
  int32_t m_errnoCode;
  int32_t m_otherCode;
  std::string m_explanation;
 
  // Flatbuffers verifier success/failure
  bool m_verify{false};
 
  // flatbuffer data length; used in ::verify
  int L;
 
  // Constructor
  CSoftwareLog_1(char * file_, uint32_t line_, int32_t errnoCode_, int32_t otherCode_, std::string explanation_) {
    // Save input parameters
    m_saveSlFile = file_;
    m_saveSlLine = line_;
    m_saveSlErrnoCode = errnoCode_;
    m_saveSlOtherCode = otherCode_;
    m_saveSlExplanation = explanation_;
 
    // Create the flatbuffer messageT using the input parameters
    auto sl = MagAOX::logger::software_log::messageT(file_, line_, errnoCode_, otherCode_, explanation_);
 
    // Retrieve flatbuffer pointer (if not an empty_log type) and length
    void* buffPtr = sl.builder.GetBufferPointer();
    L = MagAOX::logger::software_log::length(sl);
 
    // Retrieve the flatbuffer parameters for Catch2 comparison below
    size_t fileStrLen = strlen(MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str()) + 1;
    m_file = (char *) malloc(fileStrLen);
    strncpy(m_file, MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str(), fileStrLen);
    m_line = MagAOX::logger::GetSoftware_log_fb(buffPtr)->line();
    m_errnoCode = MagAOX::logger::GetSoftware_log_fb(buffPtr)->errnoCode();
    m_otherCode = MagAOX::logger::GetSoftware_log_fb(buffPtr)->otherCode();
    m_explanation = std::string(MagAOX::logger::GetSoftware_log_fb(buffPtr)->explanation()->c_str());
 
    // Run the software_log verifier
    m_verify = verify(sl);
  }
 
  // Run the flatbuffer Verifier for this log type
  // - requires bufferPtrT (shared_ptr<char*>) to full log entry
  //   comprising log header plus flatbuffer log message
  bool verify(const typename MagAOX::logger::software_log::messageT& msg) {
 
    // Timestamp, prioriy (use nominal value here)
    flatlogs::timespecX tsx{0,0};
    flatlogs::logPrioT prio{flatlogs::logPrio::LOG_DEFAULT};
 
    // Create full log: log header(*); log message (+)
    // * Log level (priority)
    // * Event code (implicit in <MagAOX::logger::type>)
    // * Timestamp
    // * Message size (variable length; 1, 2, or 8 bytes)
    // + Message (variable length)
 
    // N.G. allocates space and writes pointer value to logBuffer
    flatlogs::bufferPtrT logBuffer;
    flatlogs::logHeader::createLog<MagAOX::logger::software_notice>(logBuffer
                                                             , tsx, msg
                                                             , prio);
    // Run full log through flatbuffer Verifier
    return MagAOX::logger::software_log::verify(logBuffer,L);
  }
};
 
SCENARIO( "Create software_log 1", "[a log item]")
{
    GIVEN("a software_log log code")
    {
        WHEN("random values for fields")
        {
            // Create flatbuffer
            CSoftwareLog_1 sl = CSoftwareLog_1((char *) softwareLogFile_1, softwareLogLine_1, softwareLogErrnoCode_1, softwareLogOtherCode_1, softwareLogExplanation_1);
            // Compare flatbuffer parameters
            REQUIRE(strcmp(sl.m_file, softwareLogFile_1) == 0);
            REQUIRE(sl.m_line == softwareLogLine_1);
            REQUIRE(sl.m_errnoCode == softwareLogErrnoCode_1);
            REQUIRE(sl.m_otherCode == softwareLogOtherCode_1);
            REQUIRE(sl.m_explanation == softwareLogExplanation_1);
            REQUIRE(sl.m_verify);
        }
    }
}
 
const char * softwareLogFile_2 = "9v9yr0p7q4"; // dummy file
const uint32_t softwareLogLine_2 = 1203444101; // dummy line
const int32_t softwareLogErrnoCode_2 = -1698960755; // dummy errnoCode
 
 
/** Class to encapsulate software_log flatbuffer data using
 ** => types/software_log.hpp
 ** => types/generated/software_log_generated.h
 **/
class CSoftwareLog_2
{
public:
  // Saved input parameter value; unused
  char * m_saveSlFile;
  uint32_t m_saveSlLine;
  int32_t m_saveSlErrnoCode;
 
  // Parameters retrieved from flatbuffer
  char * m_file;
  uint32_t m_line;
  int32_t m_errnoCode;
 
  // Flatbuffers verifier success/failure
  bool m_verify{false};
 
  // flatbuffer data length; used in ::verify
  int L;
 
  // Constructor
  CSoftwareLog_2(char * file_, uint32_t line_, int32_t errnoCode_) {
    // Save input parameters
    m_saveSlFile = file_;
    m_saveSlLine = line_;
    m_saveSlErrnoCode = errnoCode_;
 
    // Create the flatbuffer messageT using the input parameters
    auto sl = MagAOX::logger::software_log::messageT(file_, line_, errnoCode_);
 
    // Retrieve flatbuffer pointer (if not an empty_log type) and length
    void* buffPtr = sl.builder.GetBufferPointer();
    L = MagAOX::logger::software_log::length(sl);
 
    // Retrieve the flatbuffer parameters for Catch2 comparison below
    size_t fileStrLen = strlen(MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str()) + 1;
    m_file = (char *) malloc(fileStrLen);
    strncpy(m_file, MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str(), fileStrLen);
    m_line = MagAOX::logger::GetSoftware_log_fb(buffPtr)->line();
    m_errnoCode = MagAOX::logger::GetSoftware_log_fb(buffPtr)->errnoCode();
 
    // Run the software_log verifier
    m_verify = verify(sl);
  }
 
  // Run the flatbuffer Verifier for this log type
  // - requires bufferPtrT (shared_ptr<char*>) to full log entry
  //   comprising log header plus flatbuffer log message
  bool verify(const typename MagAOX::logger::software_log::messageT& msg) {
 
    // Timestamp, prioriy (use nominal value here)
    flatlogs::timespecX tsx{0,0};
    flatlogs::logPrioT prio{flatlogs::logPrio::LOG_DEFAULT};
 
    // Create full log: log header(*); log message (+)
    // * Log level (priority)
    // * Event code (implicit in <MagAOX::logger::type>)
    // * Timestamp
    // * Message size (variable length; 1, 2, or 8 bytes)
    // + Message (variable length)
 
    // N.G. allocates space and writes pointer value to logBuffer
    flatlogs::bufferPtrT logBuffer;
    flatlogs::logHeader::createLog<MagAOX::logger::software_notice>(logBuffer
                                                             , tsx, msg
                                                             , prio);
    // Run full log through flatbuffer Verifier
    return MagAOX::logger::software_log::verify(logBuffer,L);
  }
};
 
SCENARIO( "Create software_log 2", "[a log item]")
{
    GIVEN("a software_log log code")
    {
        WHEN("random values for fields")
        {
            // Create flatbuffer
            CSoftwareLog_2 sl = CSoftwareLog_2((char *) softwareLogFile_2, softwareLogLine_2, softwareLogErrnoCode_2);
            // Compare flatbuffer parameters
            REQUIRE(strcmp(sl.m_file, softwareLogFile_2) == 0);
            REQUIRE(sl.m_line == softwareLogLine_2);
            REQUIRE(sl.m_errnoCode == softwareLogErrnoCode_2);
            REQUIRE(sl.m_verify);
        }
    }
}
 
const char * softwareLogFile_3 = "mrt7vo2gds"; // dummy file
const uint32_t softwareLogLine_3 = 3196916191; // dummy line
const int32_t softwareLogErrnoCode_3 = -1883955227; // dummy errnoCode
const char * softwareLogExplanation_3 = "5nexm3rfpq"; // dummy explanation
 
 
/** Class to encapsulate software_log flatbuffer data using
 ** => types/software_log.hpp
 ** => types/generated/software_log_generated.h
 **/
class CSoftwareLog_3
{
public:
  // Saved input parameter value; unused
  char * m_saveSlFile;
  uint32_t m_saveSlLine;
  int32_t m_saveSlErrnoCode;
  char * m_saveSlExplanation;
 
  // Parameters retrieved from flatbuffer
  char * m_file;
  uint32_t m_line;
  int32_t m_errnoCode;
  char * m_explanation;
 
  // Flatbuffers verifier success/failure
  bool m_verify{false};
 
  // flatbuffer data length; used in ::verify
  int L;
 
  // Constructor
  CSoftwareLog_3(char * file_, uint32_t line_, int32_t errnoCode_, char * explanation_) {
    // Save input parameters
    m_saveSlFile = file_;
    m_saveSlLine = line_;
    m_saveSlErrnoCode = errnoCode_;
    m_saveSlExplanation = explanation_;
 
    // Create the flatbuffer messageT using the input parameters
    auto sl = MagAOX::logger::software_log::messageT(file_, line_, errnoCode_, explanation_);
 
    // Retrieve flatbuffer pointer (if not an empty_log type) and length
    void* buffPtr = sl.builder.GetBufferPointer();
    L = MagAOX::logger::software_log::length(sl);
 
    // Retrieve the flatbuffer parameters for Catch2 comparison below
    size_t fileStrLen = strlen(MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str()) + 1;
    m_file = (char *) malloc(fileStrLen);
    strncpy(m_file, MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str(), fileStrLen);
    m_line = MagAOX::logger::GetSoftware_log_fb(buffPtr)->line();
    m_errnoCode = MagAOX::logger::GetSoftware_log_fb(buffPtr)->errnoCode();
    size_t explanationStrLen = strlen(MagAOX::logger::GetSoftware_log_fb(buffPtr)->explanation()->c_str()) + 1;
    m_explanation = (char *) malloc(explanationStrLen);
    strncpy(m_explanation, MagAOX::logger::GetSoftware_log_fb(buffPtr)->explanation()->c_str(), explanationStrLen);
 
    // Run the software_log verifier
    m_verify = verify(sl);
  }
 
  // Run the flatbuffer Verifier for this log type
  // - requires bufferPtrT (shared_ptr<char*>) to full log entry
  //   comprising log header plus flatbuffer log message
  bool verify(const typename MagAOX::logger::software_log::messageT& msg) {
 
    // Timestamp, prioriy (use nominal value here)
    flatlogs::timespecX tsx{0,0};
    flatlogs::logPrioT prio{flatlogs::logPrio::LOG_DEFAULT};
 
    // Create full log: log header(*); log message (+)
    // * Log level (priority)
    // * Event code (implicit in <MagAOX::logger::type>)
    // * Timestamp
    // * Message size (variable length; 1, 2, or 8 bytes)
    // + Message (variable length)
 
    // N.G. allocates space and writes pointer value to logBuffer
    flatlogs::bufferPtrT logBuffer;
    flatlogs::logHeader::createLog<MagAOX::logger::software_notice>(logBuffer
                                                             , tsx, msg
                                                             , prio);
    // Run full log through flatbuffer Verifier
    return MagAOX::logger::software_log::verify(logBuffer,L);
  }
};
 
SCENARIO( "Create software_log 3", "[a log item]")
{
    GIVEN("a software_log log code")
    {
        WHEN("random values for fields")
        {
            // Create flatbuffer
            CSoftwareLog_3 sl = CSoftwareLog_3((char *) softwareLogFile_3, softwareLogLine_3, softwareLogErrnoCode_3, (char *) softwareLogExplanation_3);
            // Compare flatbuffer parameters
            REQUIRE(strcmp(sl.m_file, softwareLogFile_3) == 0);
            REQUIRE(sl.m_line == softwareLogLine_3);
            REQUIRE(sl.m_errnoCode == softwareLogErrnoCode_3);
            REQUIRE(strcmp(sl.m_explanation, softwareLogExplanation_3) == 0);
            REQUIRE(sl.m_verify);
        }
    }
}
 
const char * softwareLogFile_4 = "d950vv9n35"; // dummy file
const uint32_t softwareLogLine_4 = 4196231796; // dummy line
const int32_t softwareLogErrnoCode_4 = -1595762337; // dummy errnoCode
const std::string softwareLogExplanation_4 = "yoy6ljpmx8"; // dummy explanation
 
 
/** Class to encapsulate software_log flatbuffer data using
 ** => types/software_log.hpp
 ** => types/generated/software_log_generated.h
 **/
class CSoftwareLog_4
{
public:
  // Saved input parameter value; unused
  char * m_saveSlFile;
  uint32_t m_saveSlLine;
  int32_t m_saveSlErrnoCode;
  std::string m_saveSlExplanation;
 
  // Parameters retrieved from flatbuffer
  char * m_file;
  uint32_t m_line;
  int32_t m_errnoCode;
  std::string m_explanation;
 
  // Flatbuffers verifier success/failure
  bool m_verify{false};
 
  // flatbuffer data length; used in ::verify
  int L;
 
  // Constructor
  CSoftwareLog_4(char * file_, uint32_t line_, int32_t errnoCode_, std::string explanation_) {
    // Save input parameters
    m_saveSlFile = file_;
    m_saveSlLine = line_;
    m_saveSlErrnoCode = errnoCode_;
    m_saveSlExplanation = explanation_;
 
    // Create the flatbuffer messageT using the input parameters
    auto sl = MagAOX::logger::software_log::messageT(file_, line_, errnoCode_, explanation_);
 
    // Retrieve flatbuffer pointer (if not an empty_log type) and length
    void* buffPtr = sl.builder.GetBufferPointer();
    L = MagAOX::logger::software_log::length(sl);
 
    // Retrieve the flatbuffer parameters for Catch2 comparison below
    size_t fileStrLen = strlen(MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str()) + 1;
    m_file = (char *) malloc(fileStrLen);
    strncpy(m_file, MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str(), fileStrLen);
    m_line = MagAOX::logger::GetSoftware_log_fb(buffPtr)->line();
    m_errnoCode = MagAOX::logger::GetSoftware_log_fb(buffPtr)->errnoCode();
    m_explanation = std::string(MagAOX::logger::GetSoftware_log_fb(buffPtr)->explanation()->c_str());
 
    // Run the software_log verifier
    m_verify = verify(sl);
  }
 
  // Run the flatbuffer Verifier for this log type
  // - requires bufferPtrT (shared_ptr<char*>) to full log entry
  //   comprising log header plus flatbuffer log message
  bool verify(const typename MagAOX::logger::software_log::messageT& msg) {
 
    // Timestamp, prioriy (use nominal value here)
    flatlogs::timespecX tsx{0,0};
    flatlogs::logPrioT prio{flatlogs::logPrio::LOG_DEFAULT};
 
    // Create full log: log header(*); log message (+)
    // * Log level (priority)
    // * Event code (implicit in <MagAOX::logger::type>)
    // * Timestamp
    // * Message size (variable length; 1, 2, or 8 bytes)
    // + Message (variable length)
 
    // N.G. allocates space and writes pointer value to logBuffer
    flatlogs::bufferPtrT logBuffer;
    flatlogs::logHeader::createLog<MagAOX::logger::software_notice>(logBuffer
                                                             , tsx, msg
                                                             , prio);
    // Run full log through flatbuffer Verifier
    return MagAOX::logger::software_log::verify(logBuffer,L);
  }
};
 
SCENARIO( "Create software_log 4", "[a log item]")
{
    GIVEN("a software_log log code")
    {
        WHEN("random values for fields")
        {
            // Create flatbuffer
            CSoftwareLog_4 sl = CSoftwareLog_4((char *) softwareLogFile_4, softwareLogLine_4, softwareLogErrnoCode_4, softwareLogExplanation_4);
            // Compare flatbuffer parameters
            REQUIRE(strcmp(sl.m_file, softwareLogFile_4) == 0);
            REQUIRE(sl.m_line == softwareLogLine_4);
            REQUIRE(sl.m_errnoCode == softwareLogErrnoCode_4);
            REQUIRE(sl.m_explanation == softwareLogExplanation_4);
            REQUIRE(sl.m_verify);
        }
    }
}
 
const char * softwareLogFile_5 = "9lwfgwcepv"; // dummy file
const uint32_t softwareLogLine_5 = 3686290464; // dummy line
const std::string softwareLogExplanation_5 = "9fykbkt3nz"; // dummy explanation
 
 
/** Class to encapsulate software_log flatbuffer data using
 ** => types/software_log.hpp
 ** => types/generated/software_log_generated.h
 **/
class CSoftwareLog_5
{
public:
  // Saved input parameter value; unused
  char * m_saveSlFile;
  uint32_t m_saveSlLine;
  std::string m_saveSlExplanation;
 
  // Parameters retrieved from flatbuffer
  char * m_file;
  uint32_t m_line;
  std::string m_explanation;
 
  // Flatbuffers verifier success/failure
  bool m_verify{false};
 
  // flatbuffer data length; used in ::verify
  int L;
 
  // Constructor
  CSoftwareLog_5(char * file_, uint32_t line_, std::string explanation_) {
    // Save input parameters
    m_saveSlFile = file_;
    m_saveSlLine = line_;
    m_saveSlExplanation = explanation_;
 
    // Create the flatbuffer messageT using the input parameters
    auto sl = MagAOX::logger::software_log::messageT(file_, line_, explanation_);
 
    // Retrieve flatbuffer pointer (if not an empty_log type) and length
    void* buffPtr = sl.builder.GetBufferPointer();
    L = MagAOX::logger::software_log::length(sl);
 
    // Retrieve the flatbuffer parameters for Catch2 comparison below
    size_t fileStrLen = strlen(MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str()) + 1;
    m_file = (char *) malloc(fileStrLen);
    strncpy(m_file, MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str(), fileStrLen);
    m_line = MagAOX::logger::GetSoftware_log_fb(buffPtr)->line();
    m_explanation = std::string(MagAOX::logger::GetSoftware_log_fb(buffPtr)->explanation()->c_str());
 
    // Run the software_log verifier
    m_verify = verify(sl);
  }
 
  // Run the flatbuffer Verifier for this log type
  // - requires bufferPtrT (shared_ptr<char*>) to full log entry
  //   comprising log header plus flatbuffer log message
  bool verify(const typename MagAOX::logger::software_log::messageT& msg) {
 
    // Timestamp, prioriy (use nominal value here)
    flatlogs::timespecX tsx{0,0};
    flatlogs::logPrioT prio{flatlogs::logPrio::LOG_DEFAULT};
 
    // Create full log: log header(*); log message (+)
    // * Log level (priority)
    // * Event code (implicit in <MagAOX::logger::type>)
    // * Timestamp
    // * Message size (variable length; 1, 2, or 8 bytes)
    // + Message (variable length)
 
    // N.G. allocates space and writes pointer value to logBuffer
    flatlogs::bufferPtrT logBuffer;
    flatlogs::logHeader::createLog<MagAOX::logger::software_notice>(logBuffer
                                                             , tsx, msg
                                                             , prio);
    // Run full log through flatbuffer Verifier
    return MagAOX::logger::software_log::verify(logBuffer,L);
  }
};
 
SCENARIO( "Create software_log 5", "[a log item]")
{
    GIVEN("a software_log log code")
    {
        WHEN("random values for fields")
        {
            // Create flatbuffer
            CSoftwareLog_5 sl = CSoftwareLog_5((char *) softwareLogFile_5, softwareLogLine_5, softwareLogExplanation_5);
            // Compare flatbuffer parameters
            REQUIRE(strcmp(sl.m_file, softwareLogFile_5) == 0);
            REQUIRE(sl.m_line == softwareLogLine_5);
            REQUIRE(sl.m_explanation == softwareLogExplanation_5);
            REQUIRE(sl.m_verify);
        }
    }
}
 
const char * softwareLogFile_6 = "371rmso7it"; // dummy file
const uint32_t softwareLogLine_6 = 3010980424; // dummy line
 
 
/** Class to encapsulate software_log flatbuffer data using
 ** => types/software_log.hpp
 ** => types/generated/software_log_generated.h
 **/
class CSoftwareLog_6
{
public:
  // Saved input parameter value; unused
  char * m_saveSlFile;
  uint32_t m_saveSlLine;
 
  // Parameters retrieved from flatbuffer
  char * m_file;
  uint32_t m_line;
 
  // Flatbuffers verifier success/failure
  bool m_verify{false};
 
  // flatbuffer data length; used in ::verify
  int L;
 
  // Constructor
  CSoftwareLog_6(char * file_, uint32_t line_) {
    // Save input parameters
    m_saveSlFile = file_;
    m_saveSlLine = line_;
 
    // Create the flatbuffer messageT using the input parameters
    auto sl = MagAOX::logger::software_log::messageT(file_, line_);
 
    // Retrieve flatbuffer pointer (if not an empty_log type) and length
    void* buffPtr = sl.builder.GetBufferPointer();
    L = MagAOX::logger::software_log::length(sl);
 
    // Retrieve the flatbuffer parameters for Catch2 comparison below
    size_t fileStrLen = strlen(MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str()) + 1;
    m_file = (char *) malloc(fileStrLen);
    strncpy(m_file, MagAOX::logger::GetSoftware_log_fb(buffPtr)->file()->c_str(), fileStrLen);
    m_line = MagAOX::logger::GetSoftware_log_fb(buffPtr)->line();
 
    // Run the software_log verifier
    m_verify = verify(sl);
  }
 
  // Run the flatbuffer Verifier for this log type
  // - requires bufferPtrT (shared_ptr<char*>) to full log entry
  //   comprising log header plus flatbuffer log message
  bool verify(const typename MagAOX::logger::software_log::messageT& msg) {
 
    // Timestamp, prioriy (use nominal value here)
    flatlogs::timespecX tsx{0,0};
    flatlogs::logPrioT prio{flatlogs::logPrio::LOG_DEFAULT};
 
    // Create full log: log header(*); log message (+)
    // * Log level (priority)
    // * Event code (implicit in <MagAOX::logger::type>)
    // * Timestamp
    // * Message size (variable length; 1, 2, or 8 bytes)
    // + Message (variable length)
 
    // N.G. allocates space and writes pointer value to logBuffer
    flatlogs::bufferPtrT logBuffer;
    flatlogs::logHeader::createLog<MagAOX::logger::software_notice>(logBuffer
                                                             , tsx, msg
                                                             , prio);
    // Run full log through flatbuffer Verifier
    return MagAOX::logger::software_log::verify(logBuffer,L);
  }
};
 
SCENARIO( "Create software_log 6", "[a log item]")
{
    GIVEN("a software_log log code")
    {
        WHEN("random values for fields")
        {
            // Create flatbuffer
            CSoftwareLog_6 sl = CSoftwareLog_6((char *) softwareLogFile_6, softwareLogLine_6);
            // Compare flatbuffer parameters
            REQUIRE(strcmp(sl.m_file, softwareLogFile_6) == 0);
            REQUIRE(sl.m_line == softwareLogLine_6);
            REQUIRE(sl.m_verify);
        }
    }
}