ros2/openvehicle-api
3
0
Fork 0
mirror of https://github.com/eclipse-openvehicle-api/openvehicle-api.git synced 2026-08-30 12:15:12 +00:00
Code Issues Packages Projects Releases 1 Wiki Activity

connection between 2 systems and bug fixes (#14)

Browse Source
This commit is contained in:
tompzf
2026-07-03 14:53:48 +02:00
committed by GitHub
parent 0fb5660d27
commit 46842200f1
284 changed files with 35200 additions and 8265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

289
tests/unit_tests/toml_parser/make_inline_standard.cpp Normal file
View File

@@ -0,0 +1,289 @@
/********************************************************************************
* Copyright (c) 2025-2026 ZF Friedrichshafen AG
*
* This program and the accompanying materials are made available under the
* terms of the Apache License Version 2.0 which is available at
* https://www.apache.org/licenses/LICENSE-2.0
*
* SPDX-License-Identifier: Apache-2.0
*
* Contributors:
* Erik Verhoeven - initial implementation
********************************************************************************/
#include <functional>
#include <gtest/gtest.h>
#include <limits>
#include "../../../global/localmemmgr.h"
#include "../../../sdv_services/core/toml_parser/exception.h"
#include "../../../sdv_services/core/toml_parser/miscellaneous.h"
#include "../../../sdv_services/core/toml_parser/parser_toml.h"
#include <support/toml.h>
TEST(MakeInline, Value)
{
std::string ssTomlIn = R"toml(value1 = 1)toml";
std::string ssTomlOut = R"toml(value1 = 1)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, Value)
{
std::string ssTomlIn = R"toml(value1 = 1)toml";
std::string ssTomlOut = R"toml(value1 = 1)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_FALSE(parser.Root().CanMakeStandard());
EXPECT_FALSE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeInline, Array)
{
std::string ssTomlIn = R"toml(value1 = ["abc", "def", "ghi"])toml";
std::string ssTomlOut = R"toml(value1 = ["abc", "def", "ghi"])toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, Array)
{
std::string ssTomlIn = R"toml(value1 = ["abc", "def", "ghi"])toml";
std::string ssTomlOut = R"toml(value1 = ["abc", "def", "ghi"])toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_FALSE(parser.Root().CanMakeStandard());
EXPECT_FALSE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeInline, StandardTable)
{
std::string ssTomlIn = R"toml([table1]
value = 1)toml";
std::string ssTomlOut = R"toml(table1 = {value = 1})toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, StandardTable)
{
std::string ssTomlIn = R"toml([table1]
value = 1)toml";
std::string ssTomlOut = R"toml([table1]
value = 1)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeStandard());
EXPECT_TRUE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeInline, InlineTable)
{
std::string ssTomlIn = R"toml(table1 = {value = 1})toml";
std::string ssTomlOut = R"toml(table1 = {value = 1})toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, InlineTable)
{
std::string ssTomlIn = R"toml(table1 = {value = 1})toml";
std::string ssTomlOut = R"toml([table1]
value = 1)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeStandard());
EXPECT_TRUE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeInline, StandardTableArray)
{
std::string ssTomlIn = R"toml([[table_array1]]
value = 1)toml";
std::string ssTomlOut = R"toml(table_array1 = [{value = 1}])toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, StandardTableArray)
{
std::string ssTomlIn = R"toml([[table_array1]]
value = 1)toml";
std::string ssTomlOut = R"toml([[table_array1]]
value = 1)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeStandard());
EXPECT_TRUE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeInline, InlineTableArray)
{
std::string ssTomlIn = R"toml(table_array1 = [{value = 1}])toml";
std::string ssTomlOut = R"toml(table_array1 = [{value = 1}])toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, InlineTableArray)
{
std::string ssTomlIn = R"toml(table_array1 = [{value = 1}])toml";
std::string ssTomlOut = R"toml([[table_array1]]
value = 1)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeStandard());
EXPECT_TRUE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeInline, StandardTableImplicit)
{
std::string ssTomlIn = R"toml([root_table.table1]
value = 1)toml";
std::string ssTomlOut = R"toml(root_table.table1 = {value = 1})toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, StandardTableImplicit)
{
std::string ssTomlIn = R"toml([root_table.table1]
value = 1)toml";
std::string ssTomlOut = R"toml([root_table.table1]
value = 1)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeStandard());
EXPECT_TRUE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeInline, InlineTableImplicit)
{
std::string ssTomlIn = R"toml(root_table.table1 = {value = 1})toml";
std::string ssTomlOut = R"toml(root_table.table1 = {value = 1})toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, InlineTableImplicit)
{
std::string ssTomlIn = R"toml(root_table.table1 = {value = 1})toml";
std::string ssTomlOut = R"toml([root_table.table1]
value = 1)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeStandard());
EXPECT_TRUE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeInline, StandardTableNested)
{
std::string ssTomlIn = R"toml([table1]
value1 = 1
[table1.table2]
value2 = 2
[table1.table3.table4]
value3 = 3
value4 = 4)toml";
std::string ssTomlOut = R"toml(table1 = {value1 = 1, table2 = {value2 = 2}, table3.table4 = {value3 = 3, value4 = 4}})toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, StandardTableNested)
{
std::string ssTomlIn = R"toml([table1]
value = 1
[table1.table2]
value = 2)toml";
std::string ssTomlOut = R"toml([table1]
value = 1
[table1.table2]
value = 2)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeStandard());
EXPECT_TRUE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeInline, InlineTableNested)
{
std::string ssTomlIn = R"toml(table1 = {value = 1, table2 = {value = 2}})toml";
std::string ssTomlOut = R"toml(table1 = {value = 1, table2 = {value = 2}})toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeInline());
EXPECT_TRUE(parser.Root().MakeInline());
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}
TEST(MakeStandard, InlineTableNested)
{
std::string ssTomlIn = R"toml(table1 = {value = 1, table2 = {value = 2}})toml";
std::string ssTomlOut = R"toml([table1]
value = 1
[table1.table2]
value = 2)toml";
toml_parser::CParser parser(ssTomlIn);
EXPECT_TRUE(parser.Root().CanMakeStandard());
EXPECT_TRUE(parser.Root().MakeStandard(true));
std::string ssOut = parser.Root().GetTOML();
EXPECT_EQ(ssTomlOut, ssOut);
}