Skip to content

Commit 330d386

Browse files
agarnyagarny
committed
Added a test for a very big CellML file.
Note that the test is disabled since it performs repeated parse/analyse/generate loops, which take several minutes to complete. So, it should be enabled only when needed, and not as part of our regular test suite.
1 parent 387274c commit 330d386

4 files changed

Lines changed: 43733 additions & 0 deletions

File tree

‎tests/bindings/javascript/generator.test.js‎

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,8 @@ See the License for the specific language governing permissions and
1414
limitations under the License.
1515
*/
1616

17+
const fs = require('fs')
18+
const path = require('path')
1719
const loadLibCellML = require('libcellml.js/libcellml.common')
1820
const { basicModel } = require('./resources')
1921

@@ -83,4 +85,88 @@ describe("Generator tests", () => {
8385
const equation_line_2 = libcellml.Generator.equationCodeByProfile(a.analyserModel().analyserEquation(0).ast(), gp)
8486
expect(equation_line_2.length).toBe(14)
8587
})
88+
/*
89+
test('Very big model multiple times', () => {
90+
const issueFingerprint = (logger) => {
91+
let fingerprint = ''
92+
let issueCount = 0
93+
94+
const count = logger.issueCount()
95+
for (let i = 0; i < count; ++i) {
96+
const issue = logger.issue(i)
97+
98+
++issueCount
99+
100+
fingerprint += `${issue.level()}|`
101+
fingerprint += `${issue.referenceRule()}|`
102+
fingerprint += `${issue.item().type()}|`
103+
fingerprint += `${issue.url()}|`
104+
fingerprint += `${issue.description()}\n`
105+
}
106+
107+
return `issues=${issueCount}\n${fingerprint}`
108+
}
109+
110+
const veryBigModel = fs.readFileSync(path.resolve(__dirname, "../../../../tests/resources/very_big_model.cellml"), "utf8")
111+
112+
const parser = new libcellml.Parser(false)
113+
const printer = new libcellml.Printer()
114+
const analyser = new libcellml.Analyser()
115+
const generator = new libcellml.Generator()
116+
117+
let baselineParserFingerprint = ''
118+
let baselinePrintedModel = ''
119+
let baselineAnalyserFingerprint = ''
120+
let baselineAnalyserModelType = libcellml.AnalyserModel.Type.UNKNOWN
121+
let baselineInterfaceCode = ''
122+
let baselineImplementationCode = ''
123+
124+
for (let i = 0; i < 10; ++i) {
125+
const model = parser.parseModel(veryBigModel)
126+
127+
expect(model).not.toBeNull()
128+
129+
const parserFingerprint = issueFingerprint(parser)
130+
const printedModel = printer.printModel(model)
131+
132+
analyser.analyseModel(model)
133+
134+
const analyserFingerprint = issueFingerprint(analyser)
135+
const analyserModel = analyser.analyserModel()
136+
137+
expect(analyserModel).not.toBeNull()
138+
139+
const interfaceCode = generator.interfaceCode(analyserModel)
140+
const implementationCode = generator.implementationCode(analyserModel)
141+
142+
if (i === 0) {
143+
baselineParserFingerprint = parserFingerprint
144+
baselinePrintedModel = printedModel
145+
baselineAnalyserFingerprint = analyserFingerprint
146+
baselineAnalyserModelType = analyserModel.type()
147+
baselineInterfaceCode = interfaceCode
148+
baselineImplementationCode = implementationCode
149+
} else {
150+
expect(parserFingerprint).toBe(baselineParserFingerprint)
151+
expect(printedModel).toBe(baselinePrintedModel)
152+
expect(analyserFingerprint).toBe(baselineAnalyserFingerprint)
153+
expect(analyserModel.type()).toBe(baselineAnalyserModelType)
154+
expect(interfaceCode).toBe(baselineInterfaceCode)
155+
expect(implementationCode).toBe(baselineImplementationCode)
156+
}
157+
158+
// Clean up the model and analyser model before the next iteration. Indeed, if we don't do this, then we end
159+
// up with 10 models and 10 analyser models in memory at the same time, which causes the test to run out of
160+
// memory.
161+
162+
analyserModel.delete()
163+
model.delete()
164+
}
165+
166+
generator.delete()
167+
analyser.delete()
168+
printer.delete()
169+
parser.delete()
170+
})
171+
*/
86172
})

‎tests/bindings/python/test_generator.py‎

Lines changed: 74 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,80 @@ def test_algebraic_eqn_computed_var_on_rhs(self):
5252
self.assertEqual("x = a", Generator.equationCode(am.analyserEquation(0).ast()))
5353
self.assertEqual("x = a", Generator_equationCode(am.analyserEquation(0).ast()))
5454

55+
"""
56+
def test_very_big_model_multiple_times(self):
57+
from libcellml import Analyser
58+
from libcellml import AnalyserModel
59+
from libcellml import Generator
60+
from libcellml import Parser
61+
from libcellml import Printer
62+
from test_resources import file_contents
63+
64+
def issue_fingerprint(logger):
65+
fingerprint = ''
66+
issue_count = 0
67+
68+
for i in range(logger.issueCount()):
69+
issue = logger.issue(i)
70+
71+
issue_count += 1
72+
73+
fingerprint += f"{issue.level()}|"
74+
fingerprint += f"{issue.referenceRule()}|"
75+
fingerprint += f"{issue.item().type()}|"
76+
fingerprint += f"{issue.url()}|"
77+
fingerprint += f"{issue.description()}\n"
78+
79+
return f"issues={issue_count}\n{fingerprint}"
80+
81+
very_big_model = file_contents('very_big_model.cellml')
82+
83+
parser = Parser(False)
84+
printer = Printer()
85+
analyser = Analyser()
86+
generator = Generator()
87+
88+
baseline_parser_fingerprint = ''
89+
baseline_printed_model = ''
90+
baseline_analyser_fingerprint = ''
91+
baseline_analyser_model_type = AnalyserModel.Type.UNKNOWN
92+
baseline_interface_code = ''
93+
baseline_implementation_code = ''
94+
95+
for i in range(10):
96+
model = parser.parseModel(very_big_model)
97+
98+
self.assertIsNotNone(model)
99+
100+
parser_fingerprint = issue_fingerprint(parser)
101+
printed_model = printer.printModel(model)
102+
103+
analyser.analyseModel(model)
104+
105+
analyser_fingerprint = issue_fingerprint(analyser)
106+
analyser_model = analyser.analyserModel()
107+
108+
self.assertIsNotNone(analyser_model)
109+
110+
interface_code = generator.interfaceCode(analyser_model)
111+
implementation_code = generator.implementationCode(analyser_model)
112+
113+
if i == 0:
114+
baseline_parser_fingerprint = parser_fingerprint
115+
baseline_printed_model = printed_model
116+
baseline_analyser_fingerprint = analyser_fingerprint
117+
baseline_analyser_model_type = analyser_model.type()
118+
baseline_interface_code = interface_code
119+
baseline_implementation_code = implementation_code
120+
else:
121+
self.assertEqual(baseline_parser_fingerprint, parser_fingerprint)
122+
self.assertEqual(baseline_printed_model, printed_model)
123+
self.assertEqual(baseline_analyser_fingerprint, analyser_fingerprint)
124+
self.assertEqual(baseline_analyser_model_type, analyser_model.type())
125+
self.assertEqual(baseline_interface_code, interface_code)
126+
self.assertEqual(baseline_implementation_code, implementation_code)
127+
"""
128+
55129

56130
if __name__ == '__main__':
57131
unittest.main()

‎tests/generator/generator.cpp‎

Lines changed: 73 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1754,3 +1754,76 @@ TEST(Generator, generateCodeUsingProfileEnum)
17541754

17551755
EXPECT_EQ_FILE_CONTENTS("generator/algebraic_eqn_computed_var_on_rhs/model.py", generator->implementationCode(analyserModel, libcellml::GeneratorProfile::Profile::PYTHON));
17561756
}
1757+
1758+
/*
1759+
TEST(Generator, veryBigModelMultipleTimes)
1760+
{
1761+
auto issueFingerprint = [](const libcellml::LoggerPtr &logger) {
1762+
std::string fingerprint;
1763+
size_t issueCount = 0;
1764+
1765+
for (size_t i = 0; i < logger->issueCount(); ++i) {
1766+
const auto issue = logger->issue(i);
1767+
1768+
++issueCount;
1769+
1770+
fingerprint += std::to_string(static_cast<int>(issue->level())) + "|";
1771+
fingerprint += std::to_string(static_cast<int>(issue->referenceRule())) + "|";
1772+
fingerprint += std::to_string(static_cast<int>(issue->item()->type())) + "|";
1773+
fingerprint += issue->url() + "|";
1774+
fingerprint += issue->description() + "\n";
1775+
}
1776+
1777+
return "issues=" + std::to_string(issueCount) + "\n" + fingerprint;
1778+
};
1779+
1780+
auto veryBigModel = fileContents("very_big_model.cellml");
1781+
1782+
auto parser = libcellml::Parser::create(false);
1783+
auto printer = libcellml::Printer::create();
1784+
auto analyser = libcellml::Analyser::create();
1785+
auto generator = libcellml::Generator::create();
1786+
1787+
std::string baselineParserFingerprint;
1788+
std::string baselinePrintedModel;
1789+
std::string baselineAnalyserFingerprint;
1790+
auto baselineAnalyserModelType = libcellml::AnalyserModel::Type::UNKNOWN;
1791+
std::string baselineInterfaceCode;
1792+
std::string baselineImplementationCode;
1793+
1794+
for (size_t i = 0; i < 10; ++i) {
1795+
auto model = parser->parseModel(veryBigModel);
1796+
1797+
ASSERT_NE(nullptr, model);
1798+
1799+
const auto parserFingerprint = issueFingerprint(parser);
1800+
const auto printedModel = printer->printModel(model);
1801+
1802+
analyser->analyseModel(model);
1803+
1804+
const auto analyserFingerprint = issueFingerprint(analyser);
1805+
const auto analyserModel = analyser->analyserModel();
1806+
1807+
ASSERT_NE(nullptr, analyserModel);
1808+
1809+
const auto interfaceCode = generator->interfaceCode(analyserModel);
1810+
const auto implementationCode = generator->implementationCode(analyserModel);
1811+
1812+
if (i == 0) {
1813+
baselineParserFingerprint = parserFingerprint;
1814+
baselinePrintedModel = printedModel;
1815+
baselineAnalyserFingerprint = analyserFingerprint;
1816+
baselineAnalyserModelType = analyserModel->type();
1817+
baselineInterfaceCode = interfaceCode;
1818+
baselineImplementationCode = implementationCode;
1819+
} else {
1820+
EXPECT_EQ(baselineParserFingerprint, parserFingerprint);
1821+
EXPECT_EQ(baselinePrintedModel, printedModel);
1822+
EXPECT_EQ(baselineAnalyserFingerprint, analyserFingerprint);
1823+
EXPECT_EQ(baselineAnalyserModelType, analyserModel->type());
1824+
EXPECT_EQ(baselineInterfaceCode, interfaceCode);
1825+
EXPECT_EQ(baselineImplementationCode, implementationCode);
1826+
}
1827+
}
1828+
}
1829+
*/

0 commit comments

Comments
 (0)