scriptparser.cpp File Reference

#include <boost/test/unit_test.hpp>
#include <boost/test/data/test_case.hpp>
#include <boost/timer/timer.hpp>
#include <ored/scripting/scriptparser.hpp>
#include <ored/scripting/astprinter.hpp>
#include <ored/scripting/asttoscriptconverter.hpp>
#include <ored/scripting/randomastgenerator.hpp>
#include <oret/toplevelfixture.hpp>
#include <iostream>
#include <iomanip>

Go to the source code of this file.

Functions
	BOOST_DATA_TEST_CASE (testScriptParsing, boost::unit_test::data::make(scriptData), testScript)
	BOOST_DATA_TEST_CASE (testRoundTrip, boost::unit_test::data::make(scriptData), testScript)
	BOOST_AUTO_TEST_CASE (testRandomRoundTrip)
	BOOST_AUTO_TEST_CASE (generateRandomScript, *boost::unit_test::disabled())
	BOOST_AUTO_TEST_CASE (testInteractive, *boost::unit_test::disabled())

Function Documentation

BOOST_DATA_TEST_CASE() [1/2]

BOOST_DATA_TEST_CASE	(	testScriptParsing	,
		boost::unit_test::data::make(scriptData)	,
		testScript
	)

Definition at line 538 of file scriptparser.cpp.

                                                                                        {
 
    BOOST_TEST_MESSAGE("Testing Script Parser...");
 
    ScriptParser parser(testScript.script);
    if (parser.success()) {
        BOOST_TEST_MESSAGE("Parsing succeeded\n" << to_string(parser.ast()));
    } else {
        BOOST_TEST_MESSAGE("Parsing failed\n" << parser.error());
    }
    BOOST_REQUIRE(parser.success());
    BOOST_CHECK_EQUAL(to_string(parser.ast(), false), testScript.expectedAST);
}

Here is the call graph for this function:

BOOST_DATA_TEST_CASE() [2/2]

BOOST_DATA_TEST_CASE	(	testRoundTrip	,
		boost::unit_test::data::make(scriptData)	,
		testScript
	)

Definition at line 552 of file scriptparser.cpp.

                                                                                    {
 
    BOOST_TEST_MESSAGE("Testing Script Parser AST->Script->AST Roundtrip...");
 
    ScriptParser parser(testScript.script);
    BOOST_REQUIRE(parser.success());
    std::string script = to_script(parser.ast());
    BOOST_TEST_MESSAGE("Generated script:\n<<<<<<<<<<\n" + script + "\n>>>>>>>>>>");
    ScriptParser parser2(script);
    BOOST_REQUIRE(parser2.success());
    BOOST_CHECK_EQUAL(to_string(parser.ast(), false), to_string(parser2.ast(), false));
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [1/3]

BOOST_AUTO_TEST_CASE

(

testRandomRoundTrip

)

Definition at line 565 of file scriptparser.cpp.

                                          {
 
    BOOST_TEST_MESSAGE("Testing Script Parser Random AST->Script->AST Roundtrip...");
 
    std::vector<std::tuple<Size, Size, Size>> testSizes;
    testSizes.push_back(std::make_tuple(1, 5, 1000));
    testSizes.push_back(std::make_tuple(5, 5, 1000));
    testSizes.push_back(std::make_tuple(10, 5, 1000));
    testSizes.push_back(std::make_tuple(1, 10, 1000));
    testSizes.push_back(std::make_tuple(5, 10, 1000));
    testSizes.push_back(std::make_tuple(10, 10, 100));
 
    for (auto const& t : testSizes) {
        BOOST_TEST_MESSAGE("Testing Script Parser Random AST->Script->AST RoundTrip (len="
                           << std::get<0>(t) << ", "
                           << "dep=" << std::get<1>(t) << ", n=" << std::get<2>(t) << ")");
        Size maxLen = 0;
        double avgLen = 0.0, avgTiming = 0.0, maxTiming = 0.0;
        for (Size i = 0; i < std::get<2>(t); ++i) {
            auto ast = generateRandomAST(std::get<0>(t), std::get<1>(t), 42 + i);
            std::string script = to_script(ast);
            maxLen = std::max(script.length(), maxLen);
            avgLen += static_cast<double>(script.length()) / static_cast<double>(std::get<2>(t));
            boost::timer::cpu_timer timer;
            ScriptParser parser(script);
            if (!parser.success()) {
                BOOST_TEST_MESSAGE("Error while parsing script: " << parser.error());
            }
            BOOST_REQUIRE(parser.success());
            double timing = timer.elapsed().wall * 1e-9;
            maxTiming = std::max(timing, maxTiming);
            avgTiming += timing / static_cast<double>(std::get<2>(t));
            BOOST_CHECK_EQUAL(to_string(ast, false), to_string(parser.ast(), false));
        }
        BOOST_TEST_MESSAGE("Finished, script size avg = " << avgLen << ", max = " << maxLen
                                                          << ", timing avg = " << avgTiming * 1E3
                                                          << " ms, max = " << maxTiming * 1E3 << " ms");
    }
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [2/3]

BOOST_AUTO_TEST_CASE	(	generateRandomScript	,
		*	boost::unit_test::disabled()
	)

Definition at line 605 of file scriptparser.cpp.

                                                                      {
 
    // not a test, just for convenience, to be removed at some stage...
 
    BOOST_TEST_MESSAGE("Creating randomg script based on LEN, DEP and SEED env variables");
 
    if (getenv("LEN") && getenv("DEP") && getenv("SEED")) {
        auto ast = generateRandomAST(atoi(getenv("LEN")), atoi(getenv("DEP")), atoi(getenv("SEED")));
        std::string script = to_script(ast);
        BOOST_TEST_MESSAGE("Generated script:\n<<<<<<<<<<\n" + script + "\n>>>>>>>>>>");
    }
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [3/3]

BOOST_AUTO_TEST_CASE	(	testInteractive	,
		*	boost::unit_test::disabled()
	)

Definition at line 618 of file scriptparser.cpp.

                                                                 {
 
    // not a test, just for convenience, to be removed at some stage...
 
    BOOST_TEST_MESSAGE("Running Script Parser on INPUT env variable...");
 
    std::string script = "IF x==2 THEN y=1; ELSE z=2; END;";
    if (auto c = getenv("INPUT"))
        script = std::string(c);
 
    ScriptParser parser(script);
    if (parser.success()) {
        std::cout << "Parsing succeeded\n" << to_string(parser.ast()) << std::endl;
    } else {
        std::cout << "Parsing failed\n" << parser.error();
    }
}

Here is the call graph for this function: