#include <MetricRegex.h>

Inheritance diagram for Nektar::MetricRegex:

Public Member Functions
	~MetricRegex () override

Public Member Functions inherited from Nektar::Metric
	Metric (TiXmlElement *metric, bool generate)
	Constructor. More...

virtual	~Metric ()=default

bool	Test (std::istream &pStdout, std::istream &pStderr)
	Calls a metric's `v_Test` function (or `v_Generate` if `m_generate`). More...

void	Generate (std::istream &pStdout, std::istream &pStderr)

std::string	GetType ()
	Return metric type. More...

int	GetID ()
	Return metric ID. More...

bool	SupportsAverage () const
	Return whether this metric supports averaging results from multiple runs. More...

Static Public Member Functions
static MetricSharedPtr	create (TiXmlElement *metric, bool generate)

Static Public Attributes
static std::string	type

Protected Member Functions
	MetricRegex (TiXmlElement *metric, bool generate)
	Constructor. More...

bool	v_Test (std::istream &pStdout, std::istream &pStderr) override
	Test output against a regex expression and set of matches. More...

void	v_Generate (std::istream &pStdout, std::istream &pStderr) override
	Test output against a regex expression and set of matches. More...

virtual bool	v_Test (std::istream &pStdout, std::istream &pStderr)=0
	Virtual function to test the metric. Should be redefined in derived classes. More...

virtual void	v_Generate (std::istream &pStdout, std::istream &pSrderr)=0
	Virtual function to generate the metric. Should be redefined in derived classes. More...

Protected Attributes
std::regex	m_regex
	Storage for the boost regex. More...

std::vector< std::vector< MetricRegexFieldValue > >	m_matches
	Stores the multiple matches defined in each <MATCH> tag. More...

bool	m_unordered = false
	If true, regex matches may be in any order in output. More...

bool	m_useStderr = false
	If true, use stderr for testing/generation instead of stdout. More...

Protected Attributes inherited from Nektar::Metric
int	m_id
	Stores the ID of this metric. More...

std::string	m_type
	Stores the type of this metric (uppercase). More...

bool	m_generate
	Determines whether to generate this metric or not. More...

bool	m_average = false
	Indicates whether a metric supports averaging results from multiple runs. More...

TiXmlElement *	m_metric
	Pointer to XML structure containing metric definition. More...

Detailed Description

Definition at line 66 of file MetricRegex.h.

Constructor & Destructor Documentation

◆ ~MetricRegex()

Nektar::MetricRegex::~MetricRegex ( )

inlineoverride

Definition at line 69 of file MetricRegex.h.

70 {

71 }

◆ MetricRegex()

Nektar::MetricRegex::MetricRegex	(	TiXmlElement *	metric,
		bool	generate
	)

protected

Constructor.

Definition at line 51 of file MetricRegex.cpp.

    : Metric(metric, generate)
{
    // If we are a derived class, do nothing
    if (m_type != "REGEX")
    {
        return;
    }
 
    // Parse Regex expression
    TiXmlElement *regex = metric->FirstChildElement("regex");
    ASSERTL0(regex, "No Regex defined.");
    ASSERTL0(regex->GetText(), "Failed to get text");
    m_regex = std::regex(regex->GetText(), std::regex::ECMAScript);
 
    // Parse matching values if not generating.
    if (m_generate)
    {
        return;
    }
 
    TiXmlElement *matches = metric->FirstChildElement("matches");
    ASSERTL0(matches, "No matches defined.");
    TiXmlElement *match = matches->FirstChildElement("match");
    while (match)
    {
        std::vector<MetricRegexFieldValue> tmp;
        TiXmlElement *field = match->FirstChildElement("field");
        while (field)
        {
            MetricRegexFieldValue v;
            v.m_value           = field->GetText();
            v.m_useTolerance    = false;
            v.m_useIntTolerance = false;
 
            const char *tol = field->Attribute("tolerance");
            if (tol)
            {
                v.m_useTolerance = true;
                v.m_tolerance    = atof(tol);
            }
 
            const char *intTol = field->Attribute("inttolerance");
            if (intTol)
            {
                v.m_useIntTolerance = true;
                v.m_intTolerance    = atoi(intTol);
            }
 
            ASSERTL0(!(intTol && tol),
                     "Cannot use both integer and double tolerances.");
 
            tmp.push_back(v);
            field = field->NextSiblingElement("field");
        }
        m_matches.push_back(tmp);
 
        match = match->NextSiblingElement("match");
    }
}

References ASSERTL0, FilterPython_Function::field, Nektar::Metric::m_generate, Nektar::MetricRegexFieldValue::m_intTolerance, m_matches, m_regex, Nektar::MetricRegexFieldValue::m_tolerance, Nektar::Metric::m_type, Nektar::MetricRegexFieldValue::m_useIntTolerance, Nektar::MetricRegexFieldValue::m_useTolerance, and Nektar::MetricRegexFieldValue::m_value.

Referenced by create().

Member Function Documentation

◆ create()

static MetricSharedPtr Nektar::MetricRegex::create	(	TiXmlElement *	metric,
		bool	generate
	)

inlinestatic

Definition at line 73 of file MetricRegex.h.

    {
        return MetricSharedPtr(new MetricRegex(metric, generate));
    }

References MetricRegex().

◆ v_Generate()

void Nektar::MetricRegex::v_Generate	(	std::istream &	pStdout,
		std::istream &	pStderr
	)

overrideprotectedvirtual

Test output against a regex expression and set of matches.

Implements Nektar::Metric.

Definition at line 268 of file MetricRegex.cpp.

{
    boost::ignore_unused(pStderr);
 
    // Select istream to use.
    std::istream &is = m_useStderr ? pStderr : pStdout;
 
    std::smatch matches;
 
    // Process output file line by line searching for regex matches
    std::string line;
    while (getline(is, line))
    {
        // Test to see if we have a match on this line.
        if (std::regex_match(line, matches, m_regex))
        {
            // Error if no fields in regex then throw an error.
            ASSERTL0(matches.size() != 1, "No test sections in regex!");
 
            vector<MetricRegexFieldValue> okValues;
 
            for (int i = 1; i < matches.size(); ++i)
            {
                // Create new field.
                MetricRegexFieldValue okValue;
                okValue.m_useTolerance = false;
                okValue.m_value =
                    std::string(matches[i].first, matches[i].second);
                okValues.push_back(okValue);
            }
 
            m_matches.push_back(okValues);
        }
    }
 
    // If we are not a derived class then create a new structure.
    if (m_type == "REGEX")
    {
        // Remove matches if they already exist.
        TiXmlElement *matches = m_metric->FirstChildElement("matches");
        if (matches)
        {
            ASSERTL0(m_metric->RemoveChild(matches),
                     "Couldn't remove matches from metric!");
        }
 
        // Create new matches element.
        matches = new TiXmlElement("matches");
        m_metric->LinkEndChild(matches);
 
        for (int i = 0; i < m_matches.size(); ++i)
        {
            TiXmlElement *match = new TiXmlElement("match");
            matches->LinkEndChild(match);
 
            for (int j = 0; j < m_matches[i].size(); ++j)
            {
                TiXmlElement *field = new TiXmlElement("field");
                match->LinkEndChild(field);
 
                field->SetAttribute("id", boost::lexical_cast<std::string>(j));
 
                if (m_matches[i][j].m_useTolerance)
                {
                    field->SetAttribute("tolerance",
                                        boost::lexical_cast<std::string>(
                                            m_matches[i][j].m_tolerance));
                }
 
                field->LinkEndChild(new TiXmlText(m_matches[i][j].m_value));
            }
        }
    }
}

References ASSERTL0, FilterPython_Function::field, m_matches, Nektar::Metric::m_metric, m_regex, Nektar::Metric::m_type, m_useStderr, Nektar::MetricRegexFieldValue::m_useTolerance, and Nektar::MetricRegexFieldValue::m_value.

Referenced by Nektar::MetricEigenvalue::v_Generate(), Nektar::MetricL2::v_Generate(), Nektar::MetricLInf::v_Generate(), Nektar::MetricPrecon::v_Generate(), and Nektar::MetricPyUnitTest::v_Generate().

◆ v_Test()

bool Nektar::MetricRegex::v_Test	(	std::istream &	pStdout,
		std::istream &	pStderr
	)

overrideprotectedvirtual

Test output against a regex expression and set of matches.

Implements Nektar::Metric.

Definition at line 115 of file MetricRegex.cpp.

{
    boost::ignore_unused(pStdout, pStderr);
 
    ASSERTL0(m_matches.size(), "No test conditions defined for Regex.");
 
    // Select istream to use.
    std::istream &is = m_useStderr ? pStderr : pStdout;
 
    std::vector<MetricRegexFieldValue> &okValues = m_matches[0];
    int nMatch                                   = m_matches.size();
    bool success                                 = true;
    bool matchedTol                              = false;
    std::smatch matches;
 
    // Process output file line by line searching for regex matches
    std::string line;
    while (getline(is, line) && m_matches.size() > 0)
    {
        matchedTol = true;
 
        // Test to see if we have a match on this line.
        if (std::regex_match(line, matches, m_regex))
        {
            // Error if no fields in regex then throw an error.
            if (matches.size() == 1)
            {
                cerr << "No test sections in regex!" << endl;
                return false;
            }
 
            // Check each regex capture group in turn
            for (int i = 1; i < matches.size(); ++i)
            {
                // extract the captured string
                std::string match(matches[i].first, matches[i].second);
 
                if (okValues[i - 1].m_useTolerance)
                {
                    double val;
                    try
                    {
                        val = fabs(fabs(boost::lexical_cast<double>(
                                       okValues[i - 1].m_value)) -
                                   fabs(boost::lexical_cast<double>(match)));
                    }
                    catch (boost::bad_lexical_cast &e)
                    {
                        cerr << "Could not convert one of " << match
                             << " (match) or " << okValues[i - 1].m_value
                             << " (comparison value) to double" << endl;
                        success = false;
                        continue;
                    }
 
                    // If the okValues are not within tolerance, failed the
                    // test.
                    if (val > okValues[i - 1].m_tolerance)
                    {
                        if (m_unordered)
                        {
                            matchedTol = false;
                        }
                        else
                        {
                            cerr << "Failed tolerance match." << endl;
                            cerr << "  Expected: " << okValues[i - 1].m_value
                                 << " +/- " << okValues[i - 1].m_tolerance
                                 << endl;
                            cerr << "  Result:   " << match << endl;
                            success = false;
                        }
                    }
                }
                else if (okValues[i - 1].m_useIntTolerance)
                {
                    int val;
                    try
                    {
                        val = abs(
                            boost::lexical_cast<int>(okValues[i - 1].m_value) -
                            boost::lexical_cast<int>(match));
                    }
                    catch (boost::bad_lexical_cast &e)
                    {
                        cerr << "Could not convert one of " << match
                             << " (match) or " << okValues[i - 1].m_value
                             << " (comparison value) to an integer" << endl;
                        success = false;
                        continue;
                    }
 
                    // If the okValues are not within tolerance, failed the
                    // test.
                    if (val > okValues[i - 1].m_intTolerance)
                    {
                        if (m_unordered)
                        {
                            matchedTol = false;
                        }
                        else
                        {
                            cerr << "Failed tolerance match." << endl;
                            cerr << "  Expected: " << okValues[i - 1].m_value
                                 << " +/- " << okValues[i - 1].m_intTolerance
                                 << endl;
                            cerr << "  Result:   " << match << endl;
                            success = false;
                        }
                    }
                }
                else
                {
                    // Case insensitive match.
                    if (!boost::iequals(match, okValues[i - 1].m_value))
                    {
                        if (m_unordered)
                        {
                            matchedTol = false;
                        }
                        else
                        {
                            cerr << "Failed case-insensitive match." << endl;
                            cerr << "  Expected: " << okValues[i - 1].m_value
                                 << endl;
                            cerr << "  Result:   " << match << endl;
                            success = false;
                        }
                    }
                }
            }
 
            // Remove this match from the list of matches.
            if (matchedTol)
            {
                m_matches.erase(m_matches.begin());
            }
        }
    }
 
    if (m_matches.size() != 0)
    {
        cerr << "Expected " << nMatch << " matches but only found "
             << (nMatch - m_matches.size()) << "!" << endl;
        success = false;
    }
 
    return success;
}