#include <MetricNoWarning.h>

Inheritance diagram for Nektar::MetricNoWarning:

Public Member Functions
	~MetricNoWarning () override

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

virtual	~Metric ()=default

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

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

std::string	GetType ()
	Return metric type.

int	GetID ()
	Return metric ID.

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

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

Static Public Attributes
static std::string	type

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

bool	v_Test (std::istream &pStdout, std::istream &pStderr) override
	Test if the output contains the warning message. If so, the test fails, otherwise, it passes.

void	v_Generate (std::istream &pStdout, std::istream &pStderr) override
	Test if the output contains the warning message. If so, generate the .tst file.

Protected Attributes
std::regex	m_regexWarning {".WARNING."}

std::vector< std::vector< std::string > >	m_matches

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

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

bool	m_generate
	Determines whether to generate this metric or not.

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

TiXmlElement *	m_metric
	Pointer to XML structure containing metric definition.

Detailed Description

Definition at line 45 of file MetricNoWarning.h.

Constructor & Destructor Documentation

◆ ~MetricNoWarning()

Nektar::MetricNoWarning::~MetricNoWarning ( )

inlineoverride

Definition at line 48 of file MetricNoWarning.h.

48{};

◆ MetricNoWarning()

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

protected

Constructor.

Definition at line 84 of file MetricNoWarning.cpp.

    : Metric(metric, generate)
{
    // Check if user has provided custom warning regex, which can contain
    // several matching groups to target specific Warning messages
    TiXmlElement *regex = metric->FirstChildElement("regex");
    if (regex)
    {
        // Check that user provided a regex for this xml tag
        const char *tmp = regex->GetText();
        ASSERTL0(tmp, "No text found in regex tag");
        m_regexWarning = tmp;
    }
 
    // If we generate from output, we don't need to parse the xml file
    if (m_generate)
    {
        return;
    }
 
    // Check if user has provided custom matching groups for regex
    // Note that this is optional, a regex without matching groups is
    // also permissible
    TiXmlElement *matches = metric->FirstChildElement("matches");
    if (matches)
    {
        // Go through all "match" tags
        for (TiXmlElement *match = matches->FirstChildElement("match"); match;
             match               = match->NextSiblingElement("match"))
        {
            // Add vector with regex groups
            m_matches.push_back(std::vector<std::string>());
 
            // Go though all "field" tags
            for (TiXmlElement *field = match->FirstChildElement("field"); field;
                 field               = field->NextSiblingElement("field"))
            {
                // Extract field text (i.e. regex group)
                const char *tmp = field->GetText();
                // Check that user provided a text
                ASSERTL0(tmp, "No text that specifies regex group "
                              "found in field tag");
                m_matches.back().push_back(tmp);
            }
        }
 
        // Check if user provided any match tags
        ASSERTL0(m_matches.size(),
                 "No match tag that specifies "
                 "regex groups was found inside matches tag.");
 
        // Check that all set of regex groups are the same size,
        // i.e. contains the same number of "field" tags
        int size_min = 1E3;
        int size_max = 0;
        for (const auto &match : m_matches)
        {
            size_min = std::min((int)match.size(), size_min);
            size_max = std::max((int)match.size(), size_max);
        }
        ASSERTL0(size_min != 0, "No valid field tags found "
                                "for one of the match tags");
        ASSERTL0(size_min == size_max, "Number of valid field tags "
                                       "not the same for all match tags");
    }
}

References ASSERTL0, Nektar::Metric::m_generate, m_matches, and m_regexWarning.

Member Function Documentation

◆ create()

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

inlinestatic

Definition at line 50 of file MetricNoWarning.h.

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

◆ v_Generate()

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

overrideprotectedvirtual

Test if the output contains the warning message. If so, generate the .tst file.

Implements Nektar::Metric.

Definition at line 217 of file MetricNoWarning.cpp.

{
    boost::ignore_unused(pStderr);
 
    // Check both standard output and error output
    for (std::string line; getline(pStdout, line) || getline(pStderr, line);)
    {
        std::smatch matches;
 
        // Check if regex match against given output
        if (std::regex_search(line, matches, m_regexWarning))
        {
            // If regex groups were not found, continue
            if (matches.size() == 1)
            {
                continue;
            }
 
            // Add vector with regex groups
            m_matches.push_back(std::vector<std::string>());
 
            // Save all regex groups
            for (int i = 1; i < matches.size(); ++i)
            {
                // Construct string object that contains submatch
                std::string submatch(matches[i].first, matches[i].second);
 
                m_matches.back().push_back(submatch);
            }
        }
    }
 
    // 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")
    }
 
    // Add new "matches" tag
    matches = new TiXmlElement("matches");
    m_metric->LinkEndChild(matches);
 
    // Add all "match" tags under "matches" tag
    for (const auto &match_it : m_matches)
    {
        TiXmlElement *match = new TiXmlElement("match");
        matches->LinkEndChild(match);
 
        int j = 0;
        for (const auto &field_it : match_it)
        {
            TiXmlElement *field = new TiXmlElement("field");
            match->LinkEndChild(field);
 
            field->SetAttribute("id", boost::lexical_cast<std::string>(j++));
 
            field->LinkEndChild(new TiXmlText(field_it));
        }
    }
}

References ASSERTL0, m_matches, Nektar::Metric::m_metric, and m_regexWarning.

◆ v_Test()

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

overrideprotectedvirtual

Test if the output contains the warning message. If so, the test fails, otherwise, it passes.

Implements Nektar::Metric.

Definition at line 155 of file MetricNoWarning.cpp.

{
    boost::ignore_unused(pStdout, pStderr);
 
    // Loop over both standard output and error output
    for (std::string line; getline(pStdout, line) || getline(pStderr, line);)
    {
        std::smatch matches;
 
        // Check if regex match against given output
        if (std::regex_search(line, matches, m_regexWarning))
        {
            // Test fails if regex matches line and
            // no matching groups have been specified
            if (!m_matches.size())
            {
                return false;
            }
            // If regex groups are specified, the test fails if any of
            // them matches the groups in "matches"
            for (const auto &match : m_matches)
            {
                bool all_match = false;
                for (int i = 1;
                     i < matches.size() && matches.size() == match.size() + 1;
                     ++i)
                {
                    // Construct string object that contains submatch
                    std::string submatch(matches[i].first, matches[i].second);
 
                    // Compare to specified pattern
                    if (submatch == match[i - 1])
                    {
                        all_match = true;
                        continue;
                    }
                    else
                    {
                        all_match = false;
                        break;
                    }
                }
                if (all_match)
                {
                    return false;
                }
                else
                {
                    continue;
                }
            }
        }
    }
 
    // If we arrived here, the test passed
    return true;
}