mirror of
https://github.com/ethereum/solidity
synced 2023-10-03 13:03:40 +00:00
473 lines
17 KiB
C++
473 lines
17 KiB
C++
/*
|
|
This file is part of solidity.
|
|
|
|
solidity is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
solidity 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 solidity. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
// SPDX-License-Identifier: GPL-3.0
|
|
|
|
#include <test/yulPhaser/TestHelpers.h>
|
|
|
|
#include <tools/yulPhaser/Exceptions.h>
|
|
#include <tools/yulPhaser/Phaser.h>
|
|
|
|
#include <liblangutil/CharStream.h>
|
|
|
|
#include <libsolutil/CommonIO.h>
|
|
|
|
#include <boost/filesystem.hpp>
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
#include <algorithm>
|
|
|
|
using namespace std;
|
|
using namespace solidity::util;
|
|
using namespace solidity::langutil;
|
|
using namespace solidity::yul;
|
|
|
|
namespace fs = boost::filesystem;
|
|
|
|
namespace solidity::phaser::test
|
|
{
|
|
|
|
class GeneticAlgorithmFactoryFixture
|
|
{
|
|
protected:
|
|
GeneticAlgorithmFactory::Options m_options = {
|
|
/* algorithm = */ Algorithm::Random,
|
|
/* minChromosomeLength = */ 50,
|
|
/* maxChromosomeLength = */ 100,
|
|
/* CrossoverChoice = */ CrossoverChoice::Uniform,
|
|
/* uniformCrossoverSwapChance = */ 0.5,
|
|
/* randomElitePoolSize = */ 0.5,
|
|
/* gewepMutationPoolSize = */ 0.1,
|
|
/* gewepCrossoverPoolSize = */ 0.1,
|
|
/* gewepRandomisationChance = */ 0.6,
|
|
/* gewepDeletionVsAdditionChance = */ 0.3,
|
|
/* gewepGenesToRandomise = */ 0.4,
|
|
/* gewepGenesToAddOrDelete = */ 0.2,
|
|
/* classicElitePoolSize = */ 0.0,
|
|
/* classicCrossoverChance = */ 0.75,
|
|
/* classicMutationChance = */ 0.2,
|
|
/* classicDeletionChance = */ 0.2,
|
|
/* classicAdditionChance = */ 0.2,
|
|
};
|
|
};
|
|
|
|
class FixtureWithPrograms
|
|
{
|
|
protected:
|
|
vector<CharStream> m_sourceStreams = {
|
|
CharStream("{}", ""),
|
|
CharStream("{{}}", ""),
|
|
CharStream("{{{}}}", ""),
|
|
};
|
|
vector<Program> m_programs = {
|
|
get<Program>(Program::load(m_sourceStreams[0])),
|
|
get<Program>(Program::load(m_sourceStreams[1])),
|
|
get<Program>(Program::load(m_sourceStreams[2])),
|
|
};
|
|
};
|
|
|
|
class FitnessMetricFactoryFixture: public FixtureWithPrograms
|
|
{
|
|
protected:
|
|
FitnessMetricFactory::Options m_options = {
|
|
/* metric = */ MetricChoice::CodeSize,
|
|
/* metricAggregator = */ MetricAggregatorChoice::Average,
|
|
/* relativeMetricScale = */ 5,
|
|
/* chromosomeRepetitions = */ 1,
|
|
};
|
|
CodeWeights const m_weights{};
|
|
};
|
|
|
|
class PoulationFactoryFixture
|
|
{
|
|
protected:
|
|
shared_ptr<FitnessMetric> m_fitnessMetric = make_shared<ChromosomeLengthMetric>();
|
|
PopulationFactory::Options m_options = {
|
|
/* minChromosomeLength = */ 0,
|
|
/* maxChromosomeLength = */ 0,
|
|
/* population = */ {},
|
|
/* randomPopulation = */ {},
|
|
/* populationFromFile = */ {},
|
|
};
|
|
};
|
|
|
|
BOOST_AUTO_TEST_SUITE(Phaser, *boost::unit_test::label("nooptions"))
|
|
BOOST_AUTO_TEST_SUITE(PhaserTest)
|
|
BOOST_AUTO_TEST_SUITE(GeneticAlgorithmFactoryTest)
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_select_the_right_algorithm_and_pass_the_options_to_it, GeneticAlgorithmFactoryFixture)
|
|
{
|
|
m_options.algorithm = Algorithm::Random;
|
|
unique_ptr<GeneticAlgorithm> algorithm1 = GeneticAlgorithmFactory::build(m_options, 100);
|
|
BOOST_REQUIRE(algorithm1 != nullptr);
|
|
|
|
auto randomAlgorithm = dynamic_cast<RandomAlgorithm*>(algorithm1.get());
|
|
BOOST_REQUIRE(randomAlgorithm != nullptr);
|
|
BOOST_TEST(randomAlgorithm->options().elitePoolSize == m_options.randomElitePoolSize.value());
|
|
BOOST_TEST(randomAlgorithm->options().minChromosomeLength == m_options.minChromosomeLength);
|
|
BOOST_TEST(randomAlgorithm->options().maxChromosomeLength == m_options.maxChromosomeLength);
|
|
|
|
m_options.algorithm = Algorithm::GEWEP;
|
|
unique_ptr<GeneticAlgorithm> algorithm2 = GeneticAlgorithmFactory::build(m_options, 100);
|
|
BOOST_REQUIRE(algorithm2 != nullptr);
|
|
|
|
auto gewepAlgorithm = dynamic_cast<GenerationalElitistWithExclusivePools*>(algorithm2.get());
|
|
BOOST_REQUIRE(gewepAlgorithm != nullptr);
|
|
BOOST_TEST(gewepAlgorithm->options().crossover == m_options.crossover);
|
|
BOOST_TEST(gewepAlgorithm->options().uniformCrossoverSwapChance.has_value());
|
|
BOOST_TEST(gewepAlgorithm->options().uniformCrossoverSwapChance.value() == m_options.uniformCrossoverSwapChance);
|
|
BOOST_TEST(gewepAlgorithm->options().mutationPoolSize == m_options.gewepMutationPoolSize);
|
|
BOOST_TEST(gewepAlgorithm->options().crossoverPoolSize == m_options.gewepCrossoverPoolSize);
|
|
BOOST_TEST(gewepAlgorithm->options().randomisationChance == m_options.gewepRandomisationChance);
|
|
BOOST_TEST(gewepAlgorithm->options().deletionVsAdditionChance == m_options.gewepDeletionVsAdditionChance);
|
|
BOOST_TEST(gewepAlgorithm->options().percentGenesToRandomise == m_options.gewepGenesToRandomise.value());
|
|
BOOST_TEST(gewepAlgorithm->options().percentGenesToAddOrDelete == m_options.gewepGenesToAddOrDelete.value());
|
|
|
|
m_options.algorithm = Algorithm::Classic;
|
|
unique_ptr<GeneticAlgorithm> algorithm3 = GeneticAlgorithmFactory::build(m_options, 100);
|
|
BOOST_REQUIRE(algorithm3 != nullptr);
|
|
|
|
auto classicAlgorithm = dynamic_cast<ClassicGeneticAlgorithm*>(algorithm3.get());
|
|
BOOST_REQUIRE(classicAlgorithm != nullptr);
|
|
BOOST_TEST(classicAlgorithm->options().uniformCrossoverSwapChance.has_value());
|
|
BOOST_TEST(classicAlgorithm->options().uniformCrossoverSwapChance.value() == m_options.uniformCrossoverSwapChance);
|
|
BOOST_TEST(classicAlgorithm->options().elitePoolSize == m_options.classicElitePoolSize);
|
|
BOOST_TEST(classicAlgorithm->options().crossoverChance == m_options.classicCrossoverChance);
|
|
BOOST_TEST(classicAlgorithm->options().mutationChance == m_options.classicMutationChance);
|
|
BOOST_TEST(classicAlgorithm->options().deletionChance == m_options.classicDeletionChance);
|
|
BOOST_TEST(classicAlgorithm->options().additionChance == m_options.classicAdditionChance);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_set_random_algorithm_elite_pool_size_based_on_population_size_if_not_specified, GeneticAlgorithmFactoryFixture)
|
|
{
|
|
m_options.algorithm = Algorithm::Random;
|
|
m_options.randomElitePoolSize = nullopt;
|
|
unique_ptr<GeneticAlgorithm> algorithm = GeneticAlgorithmFactory::build(m_options, 100);
|
|
BOOST_REQUIRE(algorithm != nullptr);
|
|
|
|
auto randomAlgorithm = dynamic_cast<RandomAlgorithm*>(algorithm.get());
|
|
BOOST_REQUIRE(randomAlgorithm != nullptr);
|
|
BOOST_TEST(randomAlgorithm->options().elitePoolSize == 1.0 / 100.0);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_set_gewep_mutation_percentages_based_on_maximum_chromosome_length_if_not_specified, GeneticAlgorithmFactoryFixture)
|
|
{
|
|
m_options.algorithm = Algorithm::GEWEP;
|
|
m_options.gewepGenesToRandomise = nullopt;
|
|
m_options.gewepGenesToAddOrDelete = nullopt;
|
|
m_options.maxChromosomeLength = 125;
|
|
|
|
unique_ptr<GeneticAlgorithm> algorithm = GeneticAlgorithmFactory::build(m_options, 100);
|
|
BOOST_REQUIRE(algorithm != nullptr);
|
|
|
|
auto gewepAlgorithm = dynamic_cast<GenerationalElitistWithExclusivePools*>(algorithm.get());
|
|
BOOST_REQUIRE(gewepAlgorithm != nullptr);
|
|
BOOST_TEST(gewepAlgorithm->options().percentGenesToRandomise == 1.0 / 125.0);
|
|
BOOST_TEST(gewepAlgorithm->options().percentGenesToAddOrDelete == 1.0 / 125.0);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
BOOST_AUTO_TEST_SUITE(FitnessMetricFactoryTest)
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_create_metric_of_the_right_type, FitnessMetricFactoryFixture)
|
|
{
|
|
m_options.metric = MetricChoice::RelativeCodeSize;
|
|
m_options.metricAggregator = MetricAggregatorChoice::Sum;
|
|
unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(m_options, {m_programs[0]}, {nullptr}, m_weights);
|
|
BOOST_REQUIRE(metric != nullptr);
|
|
|
|
auto sumMetric = dynamic_cast<FitnessMetricSum*>(metric.get());
|
|
BOOST_REQUIRE(sumMetric != nullptr);
|
|
BOOST_REQUIRE(sumMetric->metrics().size() == 1);
|
|
BOOST_REQUIRE(sumMetric->metrics()[0] != nullptr);
|
|
|
|
auto relativeProgramSizeMetric = dynamic_cast<RelativeProgramSize*>(sumMetric->metrics()[0].get());
|
|
BOOST_REQUIRE(relativeProgramSizeMetric != nullptr);
|
|
BOOST_TEST(toString(relativeProgramSizeMetric->program()) == toString(m_programs[0]));
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_respect_chromosome_repetitions_option, FitnessMetricFactoryFixture)
|
|
{
|
|
m_options.metric = MetricChoice::CodeSize;
|
|
m_options.metricAggregator = MetricAggregatorChoice::Average;
|
|
m_options.chromosomeRepetitions = 5;
|
|
unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(m_options, {m_programs[0]}, {nullptr}, m_weights);
|
|
BOOST_REQUIRE(metric != nullptr);
|
|
|
|
auto averageMetric = dynamic_cast<FitnessMetricAverage*>(metric.get());
|
|
BOOST_REQUIRE(averageMetric != nullptr);
|
|
BOOST_REQUIRE(averageMetric->metrics().size() == 1);
|
|
BOOST_REQUIRE(averageMetric->metrics()[0] != nullptr);
|
|
|
|
auto programSizeMetric = dynamic_cast<ProgramSize*>(averageMetric->metrics()[0].get());
|
|
BOOST_REQUIRE(programSizeMetric != nullptr);
|
|
BOOST_TEST(programSizeMetric->repetitionCount() == m_options.chromosomeRepetitions);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_set_relative_metric_scale, FitnessMetricFactoryFixture)
|
|
{
|
|
m_options.metric = MetricChoice::RelativeCodeSize;
|
|
m_options.metricAggregator = MetricAggregatorChoice::Average;
|
|
m_options.relativeMetricScale = 10;
|
|
unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(m_options, {m_programs[0]}, {nullptr}, m_weights);
|
|
BOOST_REQUIRE(metric != nullptr);
|
|
|
|
auto averageMetric = dynamic_cast<FitnessMetricAverage*>(metric.get());
|
|
BOOST_REQUIRE(averageMetric != nullptr);
|
|
BOOST_REQUIRE(averageMetric->metrics().size() == 1);
|
|
BOOST_REQUIRE(averageMetric->metrics()[0] != nullptr);
|
|
|
|
auto relativeProgramSizeMetric = dynamic_cast<RelativeProgramSize*>(averageMetric->metrics()[0].get());
|
|
BOOST_REQUIRE(relativeProgramSizeMetric != nullptr);
|
|
BOOST_TEST(relativeProgramSizeMetric->fixedPointPrecision() == m_options.relativeMetricScale);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_create_metric_for_each_input_program, FitnessMetricFactoryFixture)
|
|
{
|
|
unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(
|
|
m_options,
|
|
m_programs,
|
|
vector<shared_ptr<ProgramCache>>(m_programs.size(), nullptr),
|
|
m_weights
|
|
);
|
|
BOOST_REQUIRE(metric != nullptr);
|
|
|
|
auto combinedMetric = dynamic_cast<FitnessMetricCombination*>(metric.get());
|
|
BOOST_REQUIRE(combinedMetric != nullptr);
|
|
BOOST_REQUIRE(combinedMetric->metrics().size() == m_programs.size());
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_pass_program_caches_to_metrics, FitnessMetricFactoryFixture)
|
|
{
|
|
assert(m_programs.size() == 3);
|
|
vector<shared_ptr<ProgramCache>> caches = {
|
|
make_shared<ProgramCache>(m_programs[0]),
|
|
make_shared<ProgramCache>(m_programs[1]),
|
|
make_shared<ProgramCache>(m_programs[2]),
|
|
};
|
|
|
|
m_options.metric = MetricChoice::RelativeCodeSize;
|
|
unique_ptr<FitnessMetric> metric = FitnessMetricFactory::build(m_options, m_programs, caches, m_weights);
|
|
BOOST_REQUIRE(metric != nullptr);
|
|
|
|
auto combinedMetric = dynamic_cast<FitnessMetricCombination*>(metric.get());
|
|
BOOST_REQUIRE(combinedMetric != nullptr);
|
|
BOOST_REQUIRE(combinedMetric->metrics().size() == caches.size());
|
|
|
|
for (size_t i = 0; i < caches.size(); ++i)
|
|
{
|
|
auto programBasedMetric = dynamic_cast<ProgramBasedMetric*>(combinedMetric->metrics()[i].get());
|
|
BOOST_REQUIRE(programBasedMetric != nullptr);
|
|
BOOST_TEST(programBasedMetric->programCache() == caches[i].get());
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
BOOST_AUTO_TEST_SUITE(PopulationFactoryTest)
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_create_an_empty_population_if_no_specific_options_given, PoulationFactoryFixture)
|
|
{
|
|
m_options.population = {};
|
|
m_options.randomPopulation = {};
|
|
m_options.populationFromFile = {};
|
|
BOOST_TEST(
|
|
PopulationFactory::build(m_options, m_fitnessMetric) ==
|
|
Population(m_fitnessMetric, vector<Chromosome>{})
|
|
);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_respect_population_option, PoulationFactoryFixture)
|
|
{
|
|
m_options.population = {"a", "afc", "xadd"};
|
|
BOOST_TEST(
|
|
PopulationFactory::build(m_options, m_fitnessMetric) ==
|
|
Population(m_fitnessMetric, {Chromosome("a"), Chromosome("afc"), Chromosome("xadd")})
|
|
);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_respect_random_population_option, PoulationFactoryFixture)
|
|
{
|
|
m_options.randomPopulation = {5, 3, 2};
|
|
m_options.minChromosomeLength = 5;
|
|
m_options.maxChromosomeLength = 10;
|
|
|
|
auto population = PopulationFactory::build(m_options, m_fitnessMetric);
|
|
|
|
BOOST_TEST(population.individuals().size() == 10);
|
|
BOOST_TEST(all_of(
|
|
population.individuals().begin(),
|
|
population.individuals().end(),
|
|
[](auto const& individual){ return 5 <= individual.chromosome.length() && individual.chromosome.length() <= 10; }
|
|
));
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_respect_population_from_file_option, PoulationFactoryFixture)
|
|
{
|
|
map<string, vector<string>> fileContent = {
|
|
{"a.txt", {"a", "fff", "", "jxccLTa"}},
|
|
{"b.txt", {}},
|
|
{"c.txt", {""}},
|
|
{"d.txt", {"c", "T"}},
|
|
};
|
|
|
|
TemporaryDirectory tempDir;
|
|
for (auto const& [fileName, chromosomes]: fileContent)
|
|
{
|
|
ofstream tmpFile(tempDir.memberPath(fileName));
|
|
for (auto const& chromosome: chromosomes)
|
|
tmpFile << chromosome << endl;
|
|
|
|
m_options.populationFromFile.push_back(tempDir.memberPath(fileName));
|
|
}
|
|
|
|
BOOST_TEST(
|
|
PopulationFactory::build(m_options, m_fitnessMetric) ==
|
|
Population(m_fitnessMetric, {
|
|
Chromosome("a"),
|
|
Chromosome("fff"),
|
|
Chromosome(""),
|
|
Chromosome("jxccLTa"),
|
|
Chromosome(""),
|
|
Chromosome("c"),
|
|
Chromosome("T"),
|
|
})
|
|
);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_throw_FileOpenError_if_population_file_does_not_exist, PoulationFactoryFixture)
|
|
{
|
|
m_options.populationFromFile = {"a-file-that-does-not-exist.abcdefgh"};
|
|
assert(!fs::exists(m_options.populationFromFile[0]));
|
|
|
|
BOOST_CHECK_THROW(PopulationFactory::build(m_options, m_fitnessMetric), FileOpenError);
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_combine_populations_from_all_sources, PoulationFactoryFixture)
|
|
{
|
|
TemporaryDirectory tempDir;
|
|
{
|
|
ofstream tmpFile(tempDir.memberPath("population.txt"));
|
|
tmpFile << "axc" << endl << "fcL" << endl;
|
|
}
|
|
|
|
m_options.population = {"axc", "fcL"};
|
|
m_options.randomPopulation = {2};
|
|
m_options.populationFromFile = {tempDir.memberPath("population.txt")};
|
|
m_options.minChromosomeLength = 3;
|
|
m_options.maxChromosomeLength = 3;
|
|
|
|
auto population = PopulationFactory::build(m_options, m_fitnessMetric);
|
|
|
|
auto begin = population.individuals().begin();
|
|
auto end = population.individuals().end();
|
|
BOOST_TEST(population.individuals().size() == 6);
|
|
BOOST_TEST(all_of(begin, end, [](auto const& individual){ return individual.chromosome.length() == 3; }));
|
|
BOOST_TEST(count(begin, end, Individual(Chromosome("axc"), *m_fitnessMetric)) >= 2);
|
|
BOOST_TEST(count(begin, end, Individual(Chromosome("fcL"), *m_fitnessMetric)) >= 2);
|
|
}
|
|
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
BOOST_AUTO_TEST_SUITE(ProgramCacheFactoryTest)
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_create_cache_for_each_input_program_if_cache_enabled, FixtureWithPrograms)
|
|
{
|
|
ProgramCacheFactory::Options options{/* programCacheEnabled = */ true};
|
|
vector<shared_ptr<ProgramCache>> caches = ProgramCacheFactory::build(options, m_programs);
|
|
assert(m_programs.size() >= 2 && "There must be at least 2 programs for this test to be meaningful");
|
|
|
|
BOOST_TEST(caches.size() == m_programs.size());
|
|
for (size_t i = 0; i < m_programs.size(); ++i)
|
|
{
|
|
BOOST_REQUIRE(caches[i] != nullptr);
|
|
BOOST_TEST(toString(caches[i]->program()) == toString(m_programs[i]));
|
|
}
|
|
}
|
|
|
|
BOOST_FIXTURE_TEST_CASE(build_should_return_nullptr_for_each_input_program_if_cache_disabled, FixtureWithPrograms)
|
|
{
|
|
ProgramCacheFactory::Options options{/* programCacheEnabled = */ false};
|
|
vector<shared_ptr<ProgramCache>> caches = ProgramCacheFactory::build(options, m_programs);
|
|
assert(m_programs.size() >= 2 && "There must be at least 2 programs for this test to be meaningful");
|
|
|
|
BOOST_TEST(caches.size() == m_programs.size());
|
|
for (size_t i = 0; i < m_programs.size(); ++i)
|
|
BOOST_TEST(caches[i] == nullptr);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
BOOST_AUTO_TEST_SUITE(ProgramFactoryTest)
|
|
|
|
BOOST_AUTO_TEST_CASE(build_should_load_programs_from_files)
|
|
{
|
|
TemporaryDirectory tempDir;
|
|
vector<string> sources{"{}", "{{}}", "{{{}}}"};
|
|
ProgramFactory::Options options{
|
|
/* inputFiles = */ {
|
|
tempDir.memberPath("program1.yul"),
|
|
tempDir.memberPath("program2.yul"),
|
|
tempDir.memberPath("program3.yul"),
|
|
},
|
|
/* prefix = */ "",
|
|
};
|
|
|
|
for (size_t i = 0; i < sources.size(); ++i)
|
|
{
|
|
ofstream tmpFile(options.inputFiles[i]);
|
|
tmpFile << sources[i] << endl;
|
|
}
|
|
|
|
vector<Program> programs = ProgramFactory::build(options);
|
|
|
|
BOOST_TEST(programs.size() == sources.size());
|
|
for (size_t i = 0; i < sources.size(); ++i)
|
|
{
|
|
CharStream sourceStream(sources[i], options.inputFiles[i]);
|
|
BOOST_TEST(toString(programs[i]) == toString(get<Program>(Program::load(sourceStream))));
|
|
}
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(build_should_apply_prefix)
|
|
{
|
|
TemporaryDirectory tempDir;
|
|
ProgramFactory::Options options{
|
|
/* inputFiles = */ {tempDir.memberPath("program1.yul")},
|
|
/* prefix = */ "f",
|
|
};
|
|
|
|
CharStream nestedSource("{{{let x:= 1}}}", "");
|
|
Program nestedProgram = get<Program>(Program::load(nestedSource));
|
|
Program flatProgram = get<Program>(Program::load(nestedSource));
|
|
flatProgram.optimise(Chromosome("f").optimisationSteps());
|
|
assert(toString(nestedProgram) != toString(flatProgram));
|
|
|
|
{
|
|
ofstream tmpFile(options.inputFiles[0]);
|
|
tmpFile << nestedSource.source() << endl;
|
|
}
|
|
|
|
vector<Program> programs = ProgramFactory::build(options);
|
|
|
|
BOOST_TEST(programs.size() == 1);
|
|
BOOST_TEST(toString(programs[0]) == toString(flatProgram));
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
BOOST_AUTO_TEST_SUITE_END()
|
|
|
|
}
|