Add env-var to set initial log-levels

name of environment variable: DLT_INITIAL_LOG_LEVEL

Syntax:
   <apid1>:<ctid1>:<loglevel1>;<apid2>:<ctid2>:<loglevel2>;...
   apid: application id (up to 4 chars), if empty all applications will match
   ctid: context id (up to 4 chars), if empty all contexts will match
   loglevel: either -1..6 or a symbolic name (default, off, fatal, error,
                                              warning, info, debug, verbose)

Examples:
DLT_INITIAL_LOG_LEVEL=TEST:LOG:0
-> turn off logging for appid TEST and contextid LOG

DLT_INITIAL_LOG_LEVEL=:LOG:warn
-> for contexts with name "LOG" set log-level to warning (3)

DLT_INITIAL_LOG_LEVEL=::VERBOSE
-> set log-level of all contexts to VERBOSE

DLT_INITIAL_LOG_LEVEL=::VERBOSE;TEST:LOG:3
-> set log-level of all contexts to VERBOSE except TEST:LOG, set this to WARNING

dlt-example-user: add option -l to specify log-level to be used when sending messages
Signed-off-by: Stefan Vacek <stefan.vacek@intel.com>

2 files changed, 542 insertions, 0 deletions

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 5cdc25f..c40e681 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -12,7 +12,9 @@ add_executable(gtest_dlt_common gtest_dlt_common.cpp)
 add_executable(gtest_dlt_user gtest_dlt_user.cpp)
 add_executable(gtest_dlt_daemon_common gtest_dlt_daemon_common.cpp ../src/daemon/dlt_daemon_common.c)
 add_executable(dlt_test_receiver dlt_test_receiver.c)
+add_executable(dlt_env_ll_unit_test dlt_env_ll_unit_test.cpp)
 target_link_libraries(gtest_dlt_common gtest gtest_main dlt)
 target_link_libraries(gtest_dlt_user gtest gtest_main dlt)
 target_link_libraries(gtest_dlt_daemon_common gtest gtest_main dlt)
 target_link_libraries(dlt_test_receiver dlt)
+target_link_libraries(dlt_env_ll_unit_test gtest gtest_main dlt)
diff --git a/tests/dlt_env_ll_unit_test.cpp b/tests/dlt_env_ll_unit_test.cpp
new file mode 100644
index 0000000..f50e603
--- /dev/null
+++ b/tests/dlt_env_ll_unit_test.cpp
@@ -0,0 +1,540 @@
+/*
+@COPYRIGHT_TAG@
+ */
+/**
+ * @file
+ */
+
+
+#include "gtest/gtest.h"
+#include "dlt_user.h"
+#include "dlt_common.h" /* needed for dlt_set_id */
+
+/* simply include the whole file to allow testing it */
+#include "src/lib/dlt_env_ll.c"
+
+
+int main(int argc, char* argv[])
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
+
+
+TEST(DltExtensionTests, extract_id)
+{
+  /* testing valid input */
+  char id[4u];
+
+  char env0[] = "abcd:1234:3";
+  char *tmp = &env0[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), 0);
+  ASSERT_EQ(tmp - &env0[0], 4); // moved 4 bytes
+  ASSERT_EQ(id[0], 'a');
+  ASSERT_EQ(id[1], 'b');
+  ASSERT_EQ(id[2], 'c');
+  ASSERT_EQ(id[3], 'd');
+
+  char env1[] = "abc:1234:3";
+  tmp = &env1[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), 0);
+  ASSERT_EQ(tmp - &env1[0], 3); // moved 3 bytes
+  ASSERT_EQ(id[0], 'a');
+  ASSERT_EQ(id[1], 'b');
+  ASSERT_EQ(id[2], 'c');
+  ASSERT_EQ(id[3], 0);
+
+  char env2[] = "ab:1234:3";
+  tmp = &env2[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), 0);
+  ASSERT_EQ(tmp - &env2[0], 2); // moved 2 bytes
+  ASSERT_EQ(id[0], 'a');
+  ASSERT_EQ(id[1], 'b');
+  ASSERT_EQ(id[2], 0);
+  ASSERT_EQ(id[3], 0);
+
+  char env3[] = "a:1234:3";
+  tmp = &env3[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), 0);
+  ASSERT_EQ(tmp - &env3[0], 1); // moved 1 byte
+  ASSERT_EQ(id[0], 'a');
+  ASSERT_EQ(id[1], 0);
+  ASSERT_EQ(id[2], 0);
+  ASSERT_EQ(id[3], 0);
+
+  char env4[] = ":1234:3";
+  tmp = &env4[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), 0);
+  ASSERT_EQ(tmp - &env4[0], 0); // moved 1 byte
+  ASSERT_EQ(id[0], 0);
+  ASSERT_EQ(id[1], 0);
+  ASSERT_EQ(id[2], 0);
+  ASSERT_EQ(id[3], 0);
+
+  char env5[] = "abcd:1234:3;";
+  tmp = &env5[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), 0);
+  ASSERT_EQ(tmp - &env5[0], 4); // moved 4 bytes
+  ASSERT_EQ(id[0], 'a');
+  ASSERT_EQ(id[1], 'b');
+  ASSERT_EQ(id[2], 'c');
+  ASSERT_EQ(id[3], 'd');
+
+
+  /* testing invalid input */
+  /* - string too long: abcde:
+   * - string too short/missing end: abc
+   * - NULL string: <null>
+   */
+  tmp = NULL;
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), -1);
+
+  char env6[] = "abcd:1234:3";
+  tmp = &env6[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, NULL), -1);
+
+  char invalid0[] = "";
+  tmp = &invalid0[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), -1);
+
+  char invalid1[] = "abcd"; /* missing delimiter */
+  tmp = &invalid1[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), -1);
+
+  char invalid2[] = "abcde"; /* id too long */
+  tmp = &invalid2[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, id), -1);
+}
+
+
+TEST(DltExtensionTests, extract_ll)
+{
+  /* testing valid input */
+  int8_t ll;
+
+  char env_1[] = "-1";
+  char *tmp = &env_1[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), 0);
+  ASSERT_EQ(tmp - &env_1[0], 2); // moved 2 bytes
+  ASSERT_EQ(ll, -1);
+
+  char env0[] = "0;";
+  tmp = &env0[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), 0);
+  ASSERT_EQ(tmp - &env0[0], 1); // moved 1 byte
+  ASSERT_EQ(ll, 0);
+
+  char env1[] = "1;";
+  tmp = &env1[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), 0);
+  ASSERT_EQ(tmp - &env1[0], 1); // moved 1 byte
+  ASSERT_EQ(ll, 1);
+
+  char env2[] = "2;";
+  tmp = &env2[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), 0);
+  ASSERT_EQ(tmp - &env2[0], 1); // moved 1 byte
+  ASSERT_EQ(ll, 2);
+
+  char env3[] = "3;";
+  tmp = &env3[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), 0);
+  ASSERT_EQ(tmp - &env3[0], 1); // moved 1 byte
+  ASSERT_EQ(ll, 3);
+
+  char env4[] = "4;";
+  tmp = &env4[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), 0);
+  ASSERT_EQ(tmp - &env4[0], 1); // moved 1 byte
+  ASSERT_EQ(ll, 4);
+
+  char env5[] = "5;";
+  tmp = &env5[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), 0);
+  ASSERT_EQ(tmp - &env5[0], 1); // moved 1 byte
+  ASSERT_EQ(ll, 5);
+
+  char env6[] = "6;";
+  tmp = &env6[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), 0);
+  ASSERT_EQ(tmp - &env6[0], 1); // moved 1 byte
+  ASSERT_EQ(ll, 6);
+
+  /* testing invalid input */
+  /* - number outside range, e.g. -2, 103
+   * - missing delimiter
+   * - NULL string: <null>
+   */
+  tmp = NULL;
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), -1);
+
+  char env7[] = "abcd:1234:3";
+  tmp = &env7[0];
+  ASSERT_EQ(dlt_env_extract_id(&tmp, NULL), -1);
+
+  char invalid0[] = "";
+  tmp = &invalid0[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), -1);
+
+  char invalid1[] = "-2"; /* outside range */
+  tmp = &invalid1[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), -1);
+
+  char invalid2[] = "8"; /* outside range */
+  tmp = &invalid2[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), -1);
+
+  char invalid3[] = "1e"; /* missing delimiter */
+  tmp = &invalid3[0];
+  ASSERT_EQ(dlt_env_extract_ll(&tmp, &ll), -1);
+}
+
+
+TEST(DltExtensionTests, extract_ll_item)
+{
+  /* testing valid input */
+  dlt_env_ll_item item;
+
+  char env0[] = "abcd:1234:3";
+  char *tmp = &env0[0];
+  ASSERT_EQ(dlt_env_extract_ll_item(&tmp, &item), 0);
+  ASSERT_EQ(tmp - &env0[0], 11); // moved 11 bytes
+  ASSERT_EQ(item.appId[0], 'a');
+  ASSERT_EQ(item.appId[1], 'b');
+  ASSERT_EQ(item.appId[2], 'c');
+  ASSERT_EQ(item.appId[3], 'd');
+  ASSERT_EQ(item.ctxId[0], '1');
+  ASSERT_EQ(item.ctxId[1], '2');
+  ASSERT_EQ(item.ctxId[2], '3');
+  ASSERT_EQ(item.ctxId[3], '4');
+  ASSERT_EQ(item.ll, 3);
+
+  char env1[] = "::-1;";
+  tmp = &env1[0];
+  ASSERT_EQ(dlt_env_extract_ll_item(&tmp, &item), 0);
+  ASSERT_EQ(tmp - &env1[0], 4); // moved 4 bytes
+  ASSERT_EQ(item.appId[0], 0);
+  ASSERT_EQ(item.appId[1], 0);
+  ASSERT_EQ(item.appId[2], 0);
+  ASSERT_EQ(item.appId[3], 0);
+  ASSERT_EQ(item.ctxId[0], 0);
+  ASSERT_EQ(item.ctxId[1], 0);
+  ASSERT_EQ(item.ctxId[2], 0);
+  ASSERT_EQ(item.ctxId[3], 0);
+  ASSERT_EQ(item.ll, -1);
+
+  /* testing invalid input */
+  /* - string too long: abcde:
+   * - string too short/missing end: abc
+   * - NULL string: <null>
+   */
+  tmp = NULL;
+  ASSERT_EQ(dlt_env_extract_ll_item(&tmp, &item), -1);
+
+  char env2[] = "abcd:1234:3";
+  tmp = &env2[0];
+  ASSERT_EQ(dlt_env_extract_ll_item(&tmp, NULL), -1);
+
+  char invalid0[] = "";
+  tmp = &invalid0[0];
+  ASSERT_EQ(dlt_env_extract_ll_item(&tmp, &item), -1);
+
+  char invalid1[] = "abcd:1234:"; /* missing ll */
+  tmp = &invalid1[0];
+  ASSERT_EQ(dlt_env_extract_ll_item(&tmp, &item), -1);
+
+  char invalid2[] = "abcd:1234"; /* missing ll, missing delimiter in ctxId */
+  tmp = &invalid2[0];
+  ASSERT_EQ(dlt_env_extract_ll_item(&tmp, &item), -1);
+
+  char invalid3[] = "abcd:"; /* missing ll, missing delimiter in appId */
+  tmp = &invalid3[0];
+  ASSERT_EQ(dlt_env_extract_ll_item(&tmp, &item), -1);
+
+  char invalid4[] = "abcd"; /* missing ll, missing delimiter in appId */
+  tmp = &invalid4[0];
+  ASSERT_EQ(dlt_env_extract_ll_item(&tmp, &item), -1);
+}
+
+
+TEST(DltExtensionTests, basic_ll_set_handling)
+{
+  dlt_env_init_ll_set(NULL); // must not crash
+  dlt_env_free_ll_set(NULL); // must not crash
+  dlt_env_increase_ll_set(NULL); // must not crash
+
+  dlt_env_ll_set ll_set;
+  dlt_env_init_ll_set(&ll_set);
+  EXPECT_TRUE(NULL != ll_set.item);
+  EXPECT_EQ(DLT_ENV_LL_SET_INCREASE, ll_set.array_size);
+  EXPECT_EQ(0, ll_set.num_elem);
+
+  dlt_env_free_ll_set(&ll_set);
+  EXPECT_TRUE(NULL == ll_set.item);
+  EXPECT_EQ(0, ll_set.array_size);
+  EXPECT_EQ(0, ll_set.num_elem);
+
+  dlt_env_init_ll_set(&ll_set);
+  for (int i = 0; i<DLT_ENV_LL_SET_INCREASE; ++i)
+  {
+    ll_set.item[i].ll = i;
+  }
+  dlt_env_increase_ll_set(&ll_set);
+  EXPECT_EQ(2 * DLT_ENV_LL_SET_INCREASE, ll_set.array_size);
+  for (int i = 0; i<DLT_ENV_LL_SET_INCREASE; ++i)
+  {
+    EXPECT_EQ(ll_set.item[i].ll, i);
+  }
+  dlt_env_free_ll_set(&ll_set);
+  EXPECT_TRUE(NULL == ll_set.item);
+  EXPECT_EQ(0, ll_set.array_size);
+  EXPECT_EQ(0, ll_set.num_elem);
+}
+
+
+TEST(DltExtensionTests, extract_ll_set)
+{
+  /* testing valid input */
+  dlt_env_ll_set ll_set;
+
+  char env0[] = "abcd:1234:3";
+  char *tmp = &env0[0];
+
+  ASSERT_EQ(dlt_env_extract_ll_set(&tmp, &ll_set), 0);
+  EXPECT_EQ(ll_set.array_size, DLT_ENV_LL_SET_INCREASE);
+  EXPECT_EQ(ll_set.num_elem, 1);
+  EXPECT_EQ(ll_set.item[0].ll, 3);
+
+  dlt_env_free_ll_set(&ll_set);
+
+  /* force increasing the list */
+  char env1[] = "abcd:0000:3;abcd:0001:3;abcd:0002:3;abcd:0003:3;abcd:0004:3;abcd:0005:3;abcd:0006:3;abcd:0007:3;abcd:0008:3;abcd:0009:3;abcd:0010:3";
+  tmp = &env1[0];
+  ASSERT_EQ(dlt_env_extract_ll_set(&tmp, &ll_set), 0);
+  EXPECT_EQ(ll_set.array_size, 2 * DLT_ENV_LL_SET_INCREASE);
+  EXPECT_EQ(ll_set.num_elem, 11);
+  for (size_t i = 0; i<ll_set.num_elem; ++i)
+  {
+    EXPECT_EQ(ll_set.item[i].ctxId[3], i%10 + '0');
+  }
+
+  dlt_env_free_ll_set(&ll_set);
+
+  char env2[] = "SINA:SINC:FATAL";
+  tmp = &env2[0];
+
+  ASSERT_EQ(dlt_env_extract_ll_set(&tmp, &ll_set), 0);
+  EXPECT_EQ(ll_set.array_size, DLT_ENV_LL_SET_INCREASE);
+  EXPECT_EQ(ll_set.num_elem, 1);
+  EXPECT_EQ(ll_set.item[0].ll, 1);
+
+  dlt_env_free_ll_set(&ll_set);
+}
+
+
+TEST(DltExtensionTests, ids_match)
+{
+  ASSERT_EQ(1, dlt_env_ids_match("abcd", "abcd"));
+  ASSERT_EQ(0, dlt_env_ids_match("abcd", "abce"));
+  ASSERT_EQ(0, dlt_env_ids_match("abcd", "abee"));
+  ASSERT_EQ(0, dlt_env_ids_match("abcd", "aeee"));
+  ASSERT_EQ(0, dlt_env_ids_match("abcd", "eeee"));
+
+  ASSERT_TRUE(dlt_env_ids_match("abcd", "abcd"));
+  ASSERT_FALSE(dlt_env_ids_match("abcd", "abce"));
+}
+
+
+TEST(DltExtensionTests, get_matching_prio)
+{
+  char apid[5] = "ABCD";
+  char ctid[5] = "1234";
+
+  dlt_env_ll_item test0;
+  dlt_set_id(test0.appId, "");
+  dlt_set_id(test0.ctxId, "");
+  ASSERT_EQ(1, dlt_env_ll_item_get_matching_prio(&test0, apid, ctid));
+
+  dlt_set_id(test0.appId, "");
+  dlt_set_id(test0.ctxId, ctid);
+  ASSERT_EQ(2, dlt_env_ll_item_get_matching_prio(&test0, apid, ctid));
+
+  dlt_set_id(test0.appId, apid);
+  dlt_set_id(test0.ctxId, "");
+  ASSERT_EQ(3, dlt_env_ll_item_get_matching_prio(&test0, apid, ctid));
+
+  dlt_set_id(test0.appId, apid);
+  dlt_set_id(test0.ctxId, ctid);
+  ASSERT_EQ(4, dlt_env_ll_item_get_matching_prio(&test0, apid, ctid));
+
+  dlt_set_id(test0.appId, "EFGH"); /* appId should not match */
+  dlt_set_id(test0.ctxId, ctid);
+  ASSERT_EQ(0, dlt_env_ll_item_get_matching_prio(&test0, apid, ctid));
+
+  ASSERT_EQ(-1, dlt_env_ll_item_get_matching_prio(NULL, apid, ctid));
+  ASSERT_EQ(-1, dlt_env_ll_item_get_matching_prio(&test0, NULL, ctid));
+  ASSERT_EQ(-1, dlt_env_ll_item_get_matching_prio(&test0, apid, NULL));
+}
+
+
+TEST(DltExtensionTests, adjust_ll_from_env)
+{
+  char apid[5] = "ABCD";
+  char ctid[5] = "1234";
+  int ll = 42; /* unrealistic value to see that the ll was not touched */
+
+  dlt_env_ll_set ll_set;
+  dlt_env_init_ll_set(&ll_set);
+  EXPECT_EQ(ll, dlt_env_adjust_ll_from_env(NULL, apid, ctid, ll));    /* orig value in case of error */
+  EXPECT_EQ(ll, dlt_env_adjust_ll_from_env(&ll_set, NULL, ctid, ll)); /* orig value in case of error */
+  EXPECT_EQ(ll, dlt_env_adjust_ll_from_env(&ll_set, apid, NULL, ll)); /* orig value in case of error */
+
+  EXPECT_EQ(ll, dlt_env_adjust_ll_from_env(&ll_set, apid, ctid, ll)); /* an empty set should not match anything */
+
+  dlt_set_id(ll_set.item[0].appId, "DEAD"); /* not matching */
+  dlt_set_id(ll_set.item[0].ctxId, "BEEF");
+  ll_set.item[0].ll = 0;
+  ll_set.num_elem = 1;
+  EXPECT_EQ(ll, dlt_env_adjust_ll_from_env(&ll_set, apid, ctid, ll)); /* not matching anything */
+
+  dlt_set_id(ll_set.item[1].appId, ""); /* empty rule, weakest */
+  dlt_set_id(ll_set.item[1].ctxId, "");
+  ll_set.item[1].ll = 1;
+  ll_set.num_elem = 2;
+  EXPECT_EQ(1, dlt_env_adjust_ll_from_env(&ll_set, apid, ctid, ll));
+
+  dlt_set_id(ll_set.item[2].appId, ""); /* prio 2 */
+  dlt_set_id(ll_set.item[2].ctxId, ctid);
+  ll_set.item[2].ll = 2;
+  ll_set.num_elem = 3;
+  EXPECT_EQ(2, dlt_env_adjust_ll_from_env(&ll_set, apid, ctid, ll));
+
+  dlt_set_id(ll_set.item[3].appId, apid); /* prio 3 */
+  dlt_set_id(ll_set.item[3].ctxId, "");
+  ll_set.item[3].ll = 3;
+  ll_set.num_elem = 4;
+  EXPECT_EQ(3, dlt_env_adjust_ll_from_env(&ll_set, apid, ctid, ll));
+
+  dlt_set_id(ll_set.item[4].appId, apid); /* prio 4 */
+  dlt_set_id(ll_set.item[4].ctxId, ctid);
+  ll_set.item[4].ll = 4;
+  ll_set.num_elem = 5;
+  EXPECT_EQ(4, dlt_env_adjust_ll_from_env(&ll_set, apid, ctid, ll));
+
+  dlt_set_id(ll_set.item[5].appId, apid); /* does not matter item[4] will always match */
+  dlt_set_id(ll_set.item[5].ctxId, "");
+  ll_set.item[5].ll = 5;
+  ll_set.num_elem = 6;
+  EXPECT_EQ(4, dlt_env_adjust_ll_from_env(&ll_set, apid, ctid, ll)); /* remember, item[4] matches */
+
+  dlt_env_free_ll_set(&ll_set);
+}
+
+
+// int dlt_env_helper_to_lower(char **env, char *result, int res_len)
+TEST(DltExtensionTests, dlt_env_helper_to_lower)
+{
+  // default behavior
+  char env0[] = "1238<><<>>>>#$//abcdABCDEDFGHIJKLMNOPQRSTUVWXYZpo;ABcd";
+  char res0[] = "1238<><<>>>>#$//abcdabcdedfghijklmnopqrstuvwxyzpo";
+  char *tmp0 = &env0[0];
+
+  char result0[sizeof(res0)];
+  ASSERT_EQ(0, dlt_env_helper_to_lower(&tmp0, result0, sizeof(result0)));
+  ASSERT_EQ(';', *tmp0); // next char is ';'
+  ASSERT_STREQ(res0, result0); // stops at ';' and is correctly converted
+
+  // default behavior with end of string
+  char env1[] = "1238<><<>>>>#$//abcdABCDEDFGHIJKLMNOPQRSTUVWXYZpo";
+  char res1[] = "1238<><<>>>>#$//abcdabcdedfghijklmnopqrstuvwxyzpo";
+  char *tmp1 = &env1[0];
+
+  char result1[sizeof(res1)];
+  ASSERT_EQ(0, dlt_env_helper_to_lower(&tmp1, result1, sizeof(result1)));
+  ASSERT_EQ(0, *tmp1); // next char is void
+  ASSERT_STREQ(res1, result1); // stops at end-of-string and is correctly converted
+
+  // result string too short
+  char env2[] = "2238<><<>>>>#$//abcdABCDEDFGHIJKLMNOPQRSTUVWXYZpo";
+  char res2[] = "2238<><<>>>>#$//abcdabcdedfg";
+  char *tmp2 = &env2[0];
+
+  char result2[sizeof(res2)];
+  ASSERT_EQ(-1, dlt_env_helper_to_lower(&tmp2, result2, sizeof(result2)));
+  ASSERT_EQ('H', *tmp2); // next char is void
+  ASSERT_STREQ(res2, result2); // stops at end-of-string and is partially converted
+
+  // input string shorter than result
+  char env3[] = "3338<><<>>>>#$//abcdABCDEDFGHIJKLMNOPQRSTUVWXYZpo";
+  char res3[] = "3338<><<>>>>#$//abcdabcdedfghijklmnopqrstuvwxyzpo";
+  char *tmp3 = &env3[0];
+
+  char result3[sizeof(res3)+5];
+  ASSERT_EQ(0, dlt_env_helper_to_lower(&tmp3, result3, sizeof(result3)));
+  ASSERT_EQ(0, *tmp3); // next char is void
+  ASSERT_STREQ(res3, result3); // stops at end-of-string and is correctly converted
+}
+
+
+// int dlt_env_extract_symbolic_ll(char **env, int8_t * ll)
+TEST(DltExtensionTests, dlt_env_extract_symbolic_ll)
+{
+  int8_t result;
+
+  // correct behavior
+  char env0[] = "DEFAULT;off;fatal;error;warning;info;DeBuG;verbose";
+  char *tmp0 = &env0[0];
+
+  ASSERT_EQ(0, dlt_env_extract_symbolic_ll(&tmp0, &result));
+  ASSERT_EQ('o', *tmp0);
+  ASSERT_EQ(-1, result);
+
+  ASSERT_EQ(0, dlt_env_extract_symbolic_ll(&tmp0, &result));
+  ASSERT_EQ('f', *tmp0);
+  ASSERT_EQ(0, result);
+
+  ASSERT_EQ(0, dlt_env_extract_symbolic_ll(&tmp0, &result));
+  ASSERT_EQ('e', *tmp0);
+  ASSERT_EQ(1, result);
+
+  ASSERT_EQ(0, dlt_env_extract_symbolic_ll(&tmp0, &result));
+  ASSERT_EQ('w', *tmp0);
+  ASSERT_EQ(2, result);
+
+  ASSERT_EQ(0, dlt_env_extract_symbolic_ll(&tmp0, &result));
+  ASSERT_EQ('i', *tmp0);
+  ASSERT_EQ(3, result);
+
+  ASSERT_EQ(0, dlt_env_extract_symbolic_ll(&tmp0, &result));
+  ASSERT_EQ('D', *tmp0);
+  ASSERT_EQ(4, result);
+
+  ASSERT_EQ(0, dlt_env_extract_symbolic_ll(&tmp0, &result));
+  ASSERT_EQ('v', *tmp0);
+  ASSERT_EQ(5, result);
+
+  ASSERT_EQ(0, dlt_env_extract_symbolic_ll(&tmp0, &result));
+  ASSERT_EQ(0, *tmp0);
+  ASSERT_EQ(6, result);
+
+
+  // incorrect behavior
+  char env1[] = "DEF";
+  char *tmp1 = &env1[0];
+
+  result = 18;
+  ASSERT_EQ(-1, dlt_env_extract_symbolic_ll(&tmp1, &result));
+  ASSERT_EQ(NULL, *tmp1);
+  ASSERT_EQ(18, result); /* 'result' is not touched */
+
+
+  // incorrect behavior
+  char env2[] = "DEFaultingfBa";
+  char *tmp2 = &env2[0];
+
+  result = 28;
+  ASSERT_EQ(-1, dlt_env_extract_symbolic_ll(&tmp2, &result));
+  ASSERT_EQ('i', *tmp2);
+  ASSERT_EQ(28, result); /* 'result' is not touched */
+}
+