Skip to content

Commit 6b1c764

Browse files
adazem009adazem009
committed
Use results from Value in LLVMCodeBuilder test
1 parent c36984b commit 6b1c764

File tree

1 file changed

+75
-75
lines changed

1 file changed

+75
-75
lines changed

‎test/dev/llvm/llvmcodebuilder_test.cpp‎

Lines changed: 75 additions & 75 deletions
Original file line numberDiff line numberDiff line change
@@ -226,7 +226,7 @@ TEST_F(LLVMCodeBuilderTest, Add)
226226
{
227227
std::string expected;
228228

229-
auto addOpTest = [this, &expected](Value v1, Value v2, double expectedResult) {
229+
auto addOpTest = [this, &expected](Value v1, Value v2) {
230230
createBuilder(true);
231231

232232
m_builder->addConstValue(v1);
@@ -241,7 +241,7 @@ TEST_F(LLVMCodeBuilderTest, Add)
241241
m_builder->createAdd();
242242
m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
243243

244-
std::string str = Value(expectedResult).toString() + '\n';
244+
std::string str = (v1 + v2).toString() + '\n';
245245
std::string expected = str + str;
246246

247247
auto code = m_builder->finalize();
@@ -254,25 +254,25 @@ TEST_F(LLVMCodeBuilderTest, Add)
254254
ASSERT_THAT(testing::internal::GetCapturedStdout(), Eq(expected)) << quotes1 << v1.toString() << quotes1 << " " << quotes2 << v2.toString() << quotes2;
255255
};
256256

257-
addOpTest(50, 25, 75);
258-
addOpTest(-500, 25, -475);
259-
addOpTest(-500, -25, -525);
260-
addOpTest("2.54", "6.28", 8.82);
261-
addOpTest(2.54, "-6.28", -3.74);
262-
addOpTest(true, true, 2);
263-
addOpTest("Infinity", "Infinity", std::numeric_limits<double>::infinity());
264-
addOpTest("Infinity", "-Infinity", std::numeric_limits<double>::quiet_NaN());
265-
addOpTest("-Infinity", "Infinity", std::numeric_limits<double>::quiet_NaN());
266-
addOpTest("-Infinity", "-Infinity", -std::numeric_limits<double>::infinity());
267-
addOpTest(1, "NaN", 1);
268-
addOpTest("NaN", 1, 1);
257+
addOpTest(50, 25);
258+
addOpTest(-500, 25);
259+
addOpTest(-500, -25);
260+
addOpTest("2.54", "6.28");
261+
addOpTest(2.54, "-6.28");
262+
addOpTest(true, true);
263+
addOpTest("Infinity", "Infinity");
264+
addOpTest("Infinity", "-Infinity");
265+
addOpTest("-Infinity", "Infinity");
266+
addOpTest("-Infinity", "-Infinity");
267+
addOpTest(1, "NaN");
268+
addOpTest("NaN", 1);
269269
}
270270

271271
TEST_F(LLVMCodeBuilderTest, Subtract)
272272
{
273273
std::string expected;
274274

275-
auto addOpTest = [this, &expected](Value v1, Value v2, double expectedResult) {
275+
auto addOpTest = [this, &expected](Value v1, Value v2) {
276276
createBuilder(true);
277277

278278
m_builder->addConstValue(v1);
@@ -287,7 +287,7 @@ TEST_F(LLVMCodeBuilderTest, Subtract)
287287
m_builder->createSub();
288288
m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
289289

290-
std::string str = Value(expectedResult).toString() + '\n';
290+
std::string str = (v1 - v2).toString() + '\n';
291291
std::string expected = str + str;
292292

293293
auto code = m_builder->finalize();
@@ -300,25 +300,25 @@ TEST_F(LLVMCodeBuilderTest, Subtract)
300300
ASSERT_THAT(testing::internal::GetCapturedStdout(), Eq(expected)) << quotes1 << v1.toString() << quotes1 << " " << quotes2 << v2.toString() << quotes2;
301301
};
302302

303-
addOpTest(50, 25, 25);
304-
addOpTest(-500, 25, -525);
305-
addOpTest(-500, -25, -475);
306-
addOpTest("2.54", "6.28", -3.74);
307-
addOpTest(2.54, "-6.28", 8.82);
308-
addOpTest(true, true, 0);
309-
addOpTest("Infinity", "Infinity", std::numeric_limits<double>::quiet_NaN());
310-
addOpTest("Infinity", "-Infinity", std::numeric_limits<double>::infinity());
311-
addOpTest("-Infinity", "Infinity", -std::numeric_limits<double>::infinity());
312-
addOpTest("-Infinity", "-Infinity", std::numeric_limits<double>::quiet_NaN());
313-
addOpTest(1, "NaN", 1);
314-
addOpTest("NaN", 1, -1);
303+
addOpTest(50, 25);
304+
addOpTest(-500, 25);
305+
addOpTest(-500, -25);
306+
addOpTest("2.54", "6.28");
307+
addOpTest(2.54, "-6.28");
308+
addOpTest(true, true);
309+
addOpTest("Infinity", "Infinity");
310+
addOpTest("Infinity", "-Infinity");
311+
addOpTest("-Infinity", "Infinity");
312+
addOpTest("-Infinity", "-Infinity");
313+
addOpTest(1, "NaN");
314+
addOpTest("NaN", 1);
315315
}
316316

317317
TEST_F(LLVMCodeBuilderTest, Multiply)
318318
{
319319
std::string expected;
320320

321-
auto addOpTest = [this, &expected](Value v1, Value v2, double expectedResult) {
321+
auto addOpTest = [this, &expected](Value v1, Value v2) {
322322
createBuilder(true);
323323

324324
m_builder->addConstValue(v1);
@@ -333,7 +333,7 @@ TEST_F(LLVMCodeBuilderTest, Multiply)
333333
m_builder->createMul();
334334
m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
335335

336-
std::string str = Value(expectedResult).toString() + '\n';
336+
std::string str = (v1 * v2).toString() + '\n';
337337
std::string expected = str + str;
338338

339339
auto code = m_builder->finalize();
@@ -346,30 +346,30 @@ TEST_F(LLVMCodeBuilderTest, Multiply)
346346
ASSERT_THAT(testing::internal::GetCapturedStdout(), Eq(expected)) << quotes1 << v1.toString() << quotes1 << " " << quotes2 << v2.toString() << quotes2;
347347
};
348348

349-
addOpTest(50, 2, 100);
350-
addOpTest(-500, 25, -12500);
351-
addOpTest("-500", -25, 12500);
352-
addOpTest("2.54", "6.28", 15.9512);
353-
addOpTest(true, true, 1);
354-
addOpTest("Infinity", "Infinity", std::numeric_limits<double>::infinity());
355-
addOpTest("Infinity", 0, std::numeric_limits<double>::quiet_NaN());
356-
addOpTest("Infinity", 2, std::numeric_limits<double>::infinity());
357-
addOpTest("Infinity", -2, -std::numeric_limits<double>::infinity());
358-
addOpTest("Infinity", "-Infinity", -std::numeric_limits<double>::infinity());
359-
addOpTest("-Infinity", "Infinity", -std::numeric_limits<double>::infinity());
360-
addOpTest("-Infinity", 0, std::numeric_limits<double>::quiet_NaN());
361-
addOpTest("-Infinity", 2, -std::numeric_limits<double>::infinity());
362-
addOpTest("-Infinity", -2, std::numeric_limits<double>::infinity());
363-
addOpTest("-Infinity", "-Infinity", std::numeric_limits<double>::infinity());
364-
addOpTest(1, "NaN", 0);
365-
addOpTest("NaN", 1, 0);
349+
addOpTest(50, 2);
350+
addOpTest(-500, 25);
351+
addOpTest("-500", -25);
352+
addOpTest("2.54", "6.28");
353+
addOpTest(true, true);
354+
addOpTest("Infinity", "Infinity");
355+
addOpTest("Infinity", 0);
356+
addOpTest("Infinity", 2);
357+
addOpTest("Infinity", -2);
358+
addOpTest("Infinity", "-Infinity");
359+
addOpTest("-Infinity", "Infinity");
360+
addOpTest("-Infinity", 0);
361+
addOpTest("-Infinity", 2);
362+
addOpTest("-Infinity", -2);
363+
addOpTest("-Infinity", "-Infinity");
364+
addOpTest(1, "NaN");
365+
addOpTest("NaN", 1);
366366
}
367367

368368
TEST_F(LLVMCodeBuilderTest, Divide)
369369
{
370370
std::string expected;
371371

372-
auto addOpTest = [this, &expected](Value v1, Value v2, double expectedResult) {
372+
auto addOpTest = [this, &expected](Value v1, Value v2) {
373373
createBuilder(true);
374374

375375
m_builder->addConstValue(v1);
@@ -384,7 +384,7 @@ TEST_F(LLVMCodeBuilderTest, Divide)
384384
m_builder->createDiv();
385385
m_builder->addFunctionCall("test_print_string", Compiler::StaticType::Void, { Compiler::StaticType::String });
386386

387-
std::string str = Value(expectedResult).toString() + '\n';
387+
std::string str = (v1 / v2).toString() + '\n';
388388
std::string expected = str + str;
389389

390390
auto code = m_builder->finalize();
@@ -397,32 +397,32 @@ TEST_F(LLVMCodeBuilderTest, Divide)
397397
ASSERT_THAT(testing::internal::GetCapturedStdout(), Eq(expected)) << quotes1 << v1.toString() << quotes1 << " " << quotes2 << v2.toString() << quotes2;
398398
};
399399

400-
addOpTest(50, 2, 25);
401-
addOpTest(-500, 25, -20);
402-
addOpTest("-500", -25, 20);
403-
addOpTest("3.5", "2.5", 1.4);
404-
addOpTest(true, true, 1);
405-
addOpTest("Infinity", "Infinity", std::numeric_limits<double>::quiet_NaN());
406-
addOpTest("Infinity", 0, std::numeric_limits<double>::infinity());
407-
addOpTest("Infinity", 2, std::numeric_limits<double>::infinity());
408-
addOpTest("Infinity", -2, -std::numeric_limits<double>::infinity());
409-
addOpTest("Infinity", "-Infinity", std::numeric_limits<double>::quiet_NaN());
410-
addOpTest("-Infinity", "Infinity", std::numeric_limits<double>::quiet_NaN());
411-
addOpTest("-Infinity", 0, -std::numeric_limits<double>::infinity());
412-
addOpTest("-Infinity", 2, -std::numeric_limits<double>::infinity());
413-
addOpTest("-Infinity", -2, std::numeric_limits<double>::infinity());
414-
addOpTest("-Infinity", "-Infinity", std::numeric_limits<double>::quiet_NaN());
415-
addOpTest(0, "Infinity", 0);
416-
addOpTest(2, "Infinity", 0);
417-
addOpTest(-2, "Infinity", 0);
418-
addOpTest(0, "-Infinity", 0);
419-
addOpTest(2, "-Infinity", 0);
420-
addOpTest(-2, "-Infinity", 0);
421-
addOpTest(1, "NaN", std::numeric_limits<double>::infinity());
422-
addOpTest("NaN", 1, 0);
423-
addOpTest(5, 0, std::numeric_limits<double>::infinity());
424-
addOpTest(-5, 0, -std::numeric_limits<double>::infinity());
425-
addOpTest(0, 0, std::numeric_limits<double>::quiet_NaN());
400+
addOpTest(50, 2);
401+
addOpTest(-500, 25);
402+
addOpTest("-500", -25);
403+
addOpTest("3.5", "2.5");
404+
addOpTest(true, true);
405+
addOpTest("Infinity", "Infinity");
406+
addOpTest("Infinity", 0);
407+
addOpTest("Infinity", 2);
408+
addOpTest("Infinity", -2);
409+
addOpTest("Infinity", "-Infinity");
410+
addOpTest("-Infinity", "Infinity");
411+
addOpTest("-Infinity", 0);
412+
addOpTest("-Infinity", 2);
413+
addOpTest("-Infinity", -2);
414+
addOpTest("-Infinity", "-Infinity");
415+
addOpTest(0, "Infinity");
416+
addOpTest(2, "Infinity");
417+
addOpTest(-2, "Infinity");
418+
addOpTest(0, "-Infinity");
419+
addOpTest(2, "-Infinity");
420+
addOpTest(-2, "-Infinity");
421+
addOpTest(1, "NaN");
422+
addOpTest("NaN", 1);
423+
addOpTest(5, 0);
424+
addOpTest(-5, 0);
425+
addOpTest(0, 0);
426426
}
427427

428428
TEST_F(LLVMCodeBuilderTest, EqualComparison)

0 commit comments

Comments
 (0)