353 lines
12 KiB
C++
353 lines
12 KiB
C++
// Copyright The OpenTelemetry Authors
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <chrono>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <string>
|
|
|
|
#include "opentelemetry/sdk/common/env_variables.h"
|
|
|
|
#if defined(_MSC_VER)
|
|
using opentelemetry::sdk::common::setenv;
|
|
using opentelemetry::sdk::common::unsetenv;
|
|
#endif
|
|
|
|
using opentelemetry::sdk::common::GetBoolEnvironmentVariable;
|
|
using opentelemetry::sdk::common::GetDurationEnvironmentVariable;
|
|
using opentelemetry::sdk::common::GetFloatEnvironmentVariable;
|
|
using opentelemetry::sdk::common::GetStringEnvironmentVariable;
|
|
using opentelemetry::sdk::common::GetUintEnvironmentVariable;
|
|
|
|
#ifndef NO_GETENV
|
|
TEST(EnvVarTest, BoolEnvVar)
|
|
{
|
|
unsetenv("BOOL_ENV_VAR_NONE");
|
|
setenv("BOOL_ENV_VAR_EMPTY", "", 1);
|
|
setenv("BOOL_ENV_VAR_T1", "true", 1);
|
|
setenv("BOOL_ENV_VAR_T2", "TRUE", 1);
|
|
setenv("BOOL_ENV_VAR_T3", "TrUe", 1);
|
|
setenv("BOOL_ENV_VAR_F1", "false", 1);
|
|
setenv("BOOL_ENV_VAR_F2", "FALSE", 1);
|
|
setenv("BOOL_ENV_VAR_F3", "FaLsE", 1);
|
|
setenv("BOOL_ENV_VAR_BROKEN", "Maybe ?", 1);
|
|
|
|
bool exists;
|
|
bool value = true;
|
|
|
|
exists = GetBoolEnvironmentVariable("BOOL_ENV_VAR_NONE", value);
|
|
EXPECT_FALSE(exists);
|
|
|
|
value = true;
|
|
exists = GetBoolEnvironmentVariable("BOOL_ENV_VAR_EMPTY", value);
|
|
EXPECT_FALSE(exists);
|
|
EXPECT_FALSE(value);
|
|
|
|
value = false;
|
|
exists = GetBoolEnvironmentVariable("BOOL_ENV_VAR_T1", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_TRUE(value);
|
|
|
|
value = false;
|
|
exists = GetBoolEnvironmentVariable("BOOL_ENV_VAR_T2", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_TRUE(value);
|
|
|
|
value = false;
|
|
exists = GetBoolEnvironmentVariable("BOOL_ENV_VAR_T3", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_TRUE(value);
|
|
|
|
value = true;
|
|
exists = GetBoolEnvironmentVariable("BOOL_ENV_VAR_F1", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_FALSE(value);
|
|
|
|
value = true;
|
|
exists = GetBoolEnvironmentVariable("BOOL_ENV_VAR_F2", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_FALSE(value);
|
|
|
|
value = true;
|
|
exists = GetBoolEnvironmentVariable("BOOL_ENV_VAR_F3", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_FALSE(value);
|
|
|
|
// This raises a warning, not verifying the warning text.
|
|
value = true;
|
|
exists = GetBoolEnvironmentVariable("BOOL_ENV_VAR_BROKEN", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_FALSE(value);
|
|
|
|
unsetenv("BOOL_ENV_VAR_EMPTY");
|
|
unsetenv("BOOL_ENV_VAR_T1");
|
|
unsetenv("BOOL_ENV_VAR_T2");
|
|
unsetenv("BOOL_ENV_VAR_T3");
|
|
unsetenv("BOOL_ENV_VAR_F1");
|
|
unsetenv("BOOL_ENV_VAR_F2");
|
|
unsetenv("BOOL_ENV_VAR_F3");
|
|
unsetenv("BOOL_ENV_VAR_BROKEN");
|
|
}
|
|
|
|
TEST(EnvVarTest, StringEnvVar)
|
|
{
|
|
unsetenv("STRING_ENV_VAR_NONE");
|
|
setenv("STRING_ENV_VAR_EMPTY", "", 1);
|
|
setenv("STRING_ENV_VAR", "my string", 1);
|
|
|
|
bool exists;
|
|
std::string value;
|
|
|
|
exists = GetStringEnvironmentVariable("STRING_ENV_VAR_NONE", value);
|
|
EXPECT_FALSE(exists);
|
|
|
|
exists = GetStringEnvironmentVariable("STRING_ENV_VAR_EMPTY", value);
|
|
EXPECT_FALSE(exists);
|
|
EXPECT_EQ(value, "");
|
|
|
|
value = "poison";
|
|
exists = GetStringEnvironmentVariable("STRING_ENV_VAR", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_EQ(value, "my string");
|
|
|
|
unsetenv("STRING_ENV_VAR_EMPTY");
|
|
unsetenv("STRING_ENV_VAR");
|
|
}
|
|
|
|
TEST(EnvVarTest, DurationEnvVar)
|
|
{
|
|
unsetenv("DURATION_ENV_VAR_NONE");
|
|
setenv("DURATION_ENV_VAR_EMPTY", "", 1);
|
|
setenv("DURATION_ENV_VAR_1", "10ns", 1);
|
|
setenv("DURATION_ENV_VAR_2", "20us", 1);
|
|
setenv("DURATION_ENV_VAR_3", "30ms", 1);
|
|
setenv("DURATION_ENV_VAR_4", "40s", 1);
|
|
setenv("DURATION_ENV_VAR_5", "50m", 1);
|
|
setenv("DURATION_ENV_VAR_6", "60h", 1);
|
|
setenv("DURATION_ENV_VAR_7", "123", 1);
|
|
setenv("DURATION_ENV_VAR_BROKEN_1", "123 ms", 1);
|
|
setenv("DURATION_ENV_VAR_BROKEN_2", "1mississippi", 1);
|
|
|
|
bool exists;
|
|
std::chrono::system_clock::duration poison;
|
|
std::chrono::system_clock::duration value;
|
|
std::chrono::system_clock::duration expected;
|
|
|
|
poison =
|
|
std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::seconds{666});
|
|
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_NONE", value);
|
|
EXPECT_FALSE(exists);
|
|
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_EMPTY", value);
|
|
EXPECT_FALSE(exists);
|
|
|
|
value = poison;
|
|
expected =
|
|
std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::nanoseconds{10});
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_1", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_EQ(value, expected);
|
|
|
|
value = poison;
|
|
expected = std::chrono::duration_cast<std::chrono::system_clock::duration>(
|
|
std::chrono::microseconds{20});
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_2", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_EQ(value, expected);
|
|
|
|
value = poison;
|
|
expected = std::chrono::duration_cast<std::chrono::system_clock::duration>(
|
|
std::chrono::milliseconds{30});
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_3", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_EQ(value, expected);
|
|
|
|
value = poison;
|
|
expected =
|
|
std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::seconds{40});
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_4", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_EQ(value, expected);
|
|
|
|
value = poison;
|
|
expected =
|
|
std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::minutes{50});
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_5", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_EQ(value, expected);
|
|
|
|
value = poison;
|
|
expected =
|
|
std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::hours{60});
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_6", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_EQ(value, expected);
|
|
|
|
value = poison;
|
|
// Deviation from the spec: 123 seconds instead of 123 milliseconds
|
|
expected =
|
|
std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::seconds{123});
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_7", value);
|
|
EXPECT_TRUE(exists);
|
|
EXPECT_EQ(value, expected);
|
|
|
|
// This raises a warning, not verifying the warning text.
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_BROKEN_1", value);
|
|
EXPECT_FALSE(exists);
|
|
|
|
// This raises a warning, not verifying the warning text.
|
|
exists = GetDurationEnvironmentVariable("DURATION_ENV_VAR_BROKEN_2", value);
|
|
EXPECT_FALSE(exists);
|
|
|
|
unsetenv("STRING_ENV_VAR_EMPTY");
|
|
unsetenv("STRING_ENV_VAR_1");
|
|
unsetenv("STRING_ENV_VAR_2");
|
|
unsetenv("STRING_ENV_VAR_3");
|
|
unsetenv("STRING_ENV_VAR_4");
|
|
unsetenv("STRING_ENV_VAR_5");
|
|
unsetenv("STRING_ENV_VAR_6");
|
|
unsetenv("STRING_ENV_VAR_7");
|
|
unsetenv("STRING_ENV_VAR_BROKEN_1");
|
|
unsetenv("STRING_ENV_VAR_BROKEN_2");
|
|
}
|
|
|
|
TEST(EnvVarTest, UintEnvVar)
|
|
{
|
|
unsetenv("UINT_ENV_VAR_NONE");
|
|
setenv("UINT_ENV_VAR_EMPTY", "", 1);
|
|
setenv("UINT_ENV_VAR_POSITIVE_INT", "42", 1);
|
|
setenv("UINT_ENV_VAR_NEGATIVE_INT", "-42", 1);
|
|
setenv("UINT_ENV_VAR_POSITIVE_DEC", "12.34", 1);
|
|
setenv("UINT_ENV_VAR_NEGATIVE_DEC", "-12.34", 1);
|
|
setenv("UINT_ENV_VAR_POSITIVE_INT_MAX", "4294967295", 1);
|
|
setenv("UINT_ENV_VAR_POSITIVE_OVERFLOW", "4294967296", 1);
|
|
setenv("UINT_ENV_VAR_NEGATIVE_INT_MIN", "-2147483648", 1);
|
|
setenv("UINT_ENV_VAR_NEGATIVE_OVERFLOW", "-4294967296", 1);
|
|
setenv("UINT_ENV_VAR_TOO_LARGE_INT", "99999999999999999999", 1);
|
|
setenv("UINT_ENV_VAR_TOO_LARGE_DEC", "3.9999e+99", 1);
|
|
setenv("UINT_ENV_VAR_WITH_NOISE", " \t \n 9.12345678.9", 1);
|
|
setenv("UINT_ENV_VAR_ONLY_SPACES", " ", 1);
|
|
|
|
std::uint32_t value;
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_NONE", value));
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_EMPTY", value));
|
|
|
|
ASSERT_TRUE(GetUintEnvironmentVariable("UINT_ENV_VAR_POSITIVE_INT", value));
|
|
ASSERT_EQ(42, value);
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_NEGATIVE_INT", value));
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_POSITIVE_DEC", value));
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_NEGATIVE_DEC", value));
|
|
|
|
ASSERT_TRUE(GetUintEnvironmentVariable("UINT_ENV_VAR_POSITIVE_INT_MAX", value));
|
|
ASSERT_EQ(4294967295, value);
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_POSITIVE_OVERFLOW", value));
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_NEGATIVE_INT_MIN", value));
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_NEGATIVE_OVERFLOW", value));
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_TOO_LARGE_INT", value));
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_TOO_LARGE_DEC", value));
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_WITH_NOISE", value));
|
|
|
|
ASSERT_FALSE(GetUintEnvironmentVariable("UINT_ENV_VAR_ONLY_SPACES", value));
|
|
|
|
unsetenv("UINT_ENV_VAR_EMPTY");
|
|
unsetenv("UINT_ENV_VAR_POSITIVE_INT");
|
|
unsetenv("UINT_ENV_VAR_NEGATIVE_INT");
|
|
unsetenv("UINT_ENV_VAR_POSITIVE_DEC");
|
|
unsetenv("UINT_ENV_VAR_NEGATIVE_DEC");
|
|
unsetenv("UINT_ENV_VAR_POSITIVE_INT_MAX");
|
|
unsetenv("UINT_ENV_VAR_POSITIVE_OVERFLOW");
|
|
unsetenv("UINT_ENV_VAR_NEGATIVE_INT_MIN");
|
|
unsetenv("UINT_ENV_VAR_NEGATIVE_OVERFLOW");
|
|
unsetenv("UINT_ENV_VAR_TOO_LARGE_INT");
|
|
unsetenv("UINT_ENV_VAR_TOO_LARGE_DEC");
|
|
unsetenv("UINT_ENV_VAR_WITH_NOISE");
|
|
unsetenv("UINT_ENV_VAR_ONLY_SPACES");
|
|
}
|
|
|
|
TEST(EnvVarTest, FloatEnvVar)
|
|
{
|
|
unsetenv("FLOAT_ENV_VAR_NONE");
|
|
setenv("FLOAT_ENV_VAR_EMPTY", "", 1);
|
|
setenv("FLOAT_ENV_VAR_POSITIVE_INT", "42", 1);
|
|
setenv("FLOAT_ENV_VAR_NEGATIVE_INT", "-42", 1);
|
|
setenv("FLOAT_ENV_VAR_POSITIVE_DEC", "12.34", 1);
|
|
setenv("FLOAT_ENV_VAR_NEGATIVE_DEC", "-12.34", 1);
|
|
setenv("FLOAT_ENV_VAR_POSITIVE_INT_MAX", "4294967295", 1);
|
|
setenv("FLOAT_ENV_VAR_POSITIVE_OVERFLOW", "4294967296", 1);
|
|
setenv("FLOAT_ENV_VAR_NEGATIVE_INT_MIN", "-2147483648", 1);
|
|
setenv("FLOAT_ENV_VAR_NEGATIVE_OVERFLOW", "-4294967296", 1);
|
|
setenv("FLOAT_ENV_VAR_TOO_LARGE_INT", "99999999999999999999", 1);
|
|
setenv("FLOAT_ENV_VAR_TOO_LARGE_DEC", "3.9999e+99", 1);
|
|
setenv("FLOAT_ENV_VAR_WITH_NOISE", " \t \n 9.12345678.9", 1);
|
|
setenv("FLOAT_ENV_VAR_ONLY_SPACES", " ", 1);
|
|
|
|
float value;
|
|
|
|
ASSERT_FALSE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_NONE", value));
|
|
|
|
ASSERT_FALSE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_EMPTY", value));
|
|
|
|
ASSERT_TRUE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_POSITIVE_INT", value));
|
|
ASSERT_FLOAT_EQ(42.f, value);
|
|
|
|
ASSERT_TRUE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_NEGATIVE_INT", value));
|
|
ASSERT_FLOAT_EQ(-42.f, value);
|
|
|
|
ASSERT_TRUE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_POSITIVE_DEC", value));
|
|
ASSERT_FLOAT_EQ(12.34f, value);
|
|
|
|
ASSERT_TRUE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_NEGATIVE_DEC", value));
|
|
ASSERT_FLOAT_EQ(-12.34f, value);
|
|
|
|
ASSERT_TRUE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_POSITIVE_INT_MAX", value));
|
|
ASSERT_FLOAT_EQ(4294967295.f, value);
|
|
|
|
ASSERT_TRUE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_POSITIVE_OVERFLOW", value));
|
|
ASSERT_FLOAT_EQ(4294967296.f, value);
|
|
|
|
ASSERT_TRUE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_NEGATIVE_INT_MIN", value));
|
|
ASSERT_FLOAT_EQ(-2147483648.f, value);
|
|
|
|
ASSERT_TRUE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_NEGATIVE_OVERFLOW", value));
|
|
ASSERT_FLOAT_EQ(-4294967296.f, value);
|
|
|
|
ASSERT_TRUE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_TOO_LARGE_INT", value));
|
|
ASSERT_FLOAT_EQ(99999999999999999999.f, value);
|
|
|
|
ASSERT_FALSE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_TOO_LARGE_DEC", value));
|
|
|
|
ASSERT_FALSE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_WITH_NOISE", value));
|
|
|
|
ASSERT_FALSE(GetFloatEnvironmentVariable("FLOAT_ENV_VAR_ONLY_SPACES", value));
|
|
|
|
unsetenv("FLOAT_ENV_VAR_EMPTY");
|
|
unsetenv("FLOAT_ENV_VAR_POSITIVE_INT");
|
|
unsetenv("FLOAT_ENV_VAR_NEGATIVE_INT");
|
|
unsetenv("FLOAT_ENV_VAR_POSITIVE_DEC");
|
|
unsetenv("FLOAT_ENV_VAR_NEGATIVE_DEC");
|
|
unsetenv("FLOAT_ENV_VAR_POSITIVE_INT_MAX");
|
|
unsetenv("FLOAT_ENV_VAR_POSITIVE_OVERFLOW");
|
|
unsetenv("FLOAT_ENV_VAR_NEGATIVE_INT_MIN");
|
|
unsetenv("FLOAT_ENV_VAR_NEGATIVE_OVERFLOW");
|
|
unsetenv("FLOAT_ENV_VAR_TOO_LARGE_INT");
|
|
unsetenv("FLOAT_ENV_VAR_TOO_LARGE_DEC");
|
|
unsetenv("FLOAT_ENV_VAR_WITH_NOISE");
|
|
unsetenv("FLOAT_ENV_VAR_ONLY_SPACES");
|
|
}
|
|
|
|
#endif // NO_GETENV
|