GoogleCloudPlatform · coryan · Feb 8, 2021 · Feb 4, 2021 · Feb 7, 2021 · Feb 8, 2021
@@ -15,4 +15,5 @@ cmake-build-*/
 # Ignore Visual Studio Code files
 .vsbuild/
 .vscode/
+build/
 
@@ -51,6 +51,12 @@ add_library(
     site/tips_retry/tips_retry.cc
     site/tips_scopes/tips_scopes.cc)
 functions_framework_cpp_add_common_options(functions_framework_examples)
+if (MSVC)
+    set_property(
+        SOURCE site/tips_gcp_apis/tips_gcp_apis.cc site/env_vars/env_vars.cc
+        APPEND
+        PROPERTY COMPILE_DEFINITIONS _CRT_SECURE_NO_WARNINGS)
+endif ()
 target_link_libraries(
     functions_framework_examples fmt::fmt functions-framework-cpp::framework
     google-cloud-cpp::pubsub google-cloud-cpp::storage)

@@ -32,6 +32,10 @@ if (BUILD_TESTING)
         string(REPLACE ".cc" "" target "${target}")
         add_executable("${target}" ${fname})
         functions_framework_cpp_add_common_options(${target})
+        if (MSVC)
+            target_compile_definitions(${target}
+                                       PRIVATE "_CRT_SECURE_NO_WARNINGS")
+        endif ()
         target_link_libraries(
             ${target}
             PRIVATE functions_framework_examples

@@ -38,6 +38,12 @@ HttpResponse HttpGet(std::string const& url, std::string const& payload);
 
 char const* argv0 = nullptr;
 
+auto ExePath(bfs::path const& filename) {
+  static auto const kPath = std::vector<bfs::path>{
+      bfs::canonical(argv0).make_preferred().parent_path()};
+  return bp::search_path(filename, kPath);
+}
+
 class HttpIntegrationTest : public ::testing::Test {
  protected:
   void SetUp() override {
@@ -47,8 +53,7 @@ class HttpIntegrationTest : public ::testing::Test {
       return;
     }
     curl_global_init(CURL_GLOBAL_ALL);
-    auto const exe = bfs::path(argv0).parent_path() / "http_integration_server";
-    auto server = bp::child(exe, "--port=8030");
+    auto server = bp::child(ExePath("http_integration_server"), "--port=8030");
     url_ = "http://localhost:8030";
     ASSERT_TRUE(WaitForServerReady(url_));
     process_ = std::move(server);

@@ -37,15 +37,19 @@ HttpResponse HttpEvent(std::string const& url, std::string const& payload);
 
 char const* argv0 = nullptr;
 
+auto ExePath(bfs::path const& filename) {
+  static auto const kPath = std::vector<bfs::path>{
+      bfs::canonical(argv0).make_preferred().parent_path()};
+  return bp::search_path(filename, kPath);
+}
+
 class PubsubIntegrationTest : public ::testing::Test {
  protected:
   void SetUp() override {
     curl_global_init(CURL_GLOBAL_ALL);
 
-    auto const exe =
-        bfs::path(argv0).parent_path() / "pubsub_integration_server";
-    auto server =
-        bp::child(exe, "--port=8040", (bp::std_out & bp::std_err) > child_log_);
+    auto server = bp::child(ExePath("pubsub_integration_server"), "--port=8040",
+                            (bp::std_out & bp::std_err) > child_log_);
     ASSERT_TRUE(WaitForServerReady("http://localhost:8040/"));
     process_ = std::move(server);
   }

@@ -38,15 +38,20 @@ HttpResponse HttpEvent(std::string const& url, std::string const& payload);
 
 char const* argv0 = nullptr;
 
+auto ExePath(bfs::path const& filename) {
+  static auto const kPath = std::vector<bfs::path>{
+      bfs::canonical(argv0).make_preferred().parent_path()};
+  return bp::search_path(filename, kPath);
+}
+
 class StorageIntegrationTest : public ::testing::Test {
  protected:
   void SetUp() override {
     curl_global_init(CURL_GLOBAL_ALL);
 
-    auto const exe =
-        bfs::path(argv0).parent_path() / "storage_integration_server";
     auto server =
-        bp::child(exe, "--port=8050", (bp::std_out & bp::std_err) > child_log_);
+        bp::child(ExePath("storage_integration_server"), "--port=8050",
+                  (bp::std_out & bp::std_err) > child_log_);
     ASSERT_TRUE(WaitForServerReady("http://localhost:8050/"));
     process_ = std::move(server);
   }

@@ -13,12 +13,12 @@
 // limitations under the License.
 
 #include "google/cloud/functions/internal/parse_cloud_event_json.h"
+#include "google/cloud/functions/internal/setenv.h"
 #include "google/cloud/functions/cloud_event.h"
 #include "google/cloud/functions/http_request.h"
 #include "google/cloud/functions/http_response.h"
 #include <gmock/gmock.h>
 #include <nlohmann/json.hpp>
-#include <stdlib.h>  // NOLINT - we need the POSIX header, for setenv.
 
 namespace gcf = ::google::cloud::functions;
 extern gcf::HttpResponse hello_world_content(gcf::HttpRequest request);
@@ -286,11 +286,11 @@ TEST(ExamplesSiteTest, ConceptsStateless) {
 }
 
 TEST(ExamplesSiteTest, EnvVars) {
-  unsetenv("FOO");
+  google::cloud::functions_internal::SetEnv("FOO", std::nullopt);
   auto actual = env_vars(gcf::HttpRequest{});
   EXPECT_THAT(actual.payload(), AllOf(HasSubstr("FOO"), HasSubstr("not set")));
 
-  setenv("FOO", "test-value", 1);
+  google::cloud::functions_internal::SetEnv("FOO", "test-value");
   actual = env_vars(gcf::HttpRequest{});
   EXPECT_THAT(actual.payload(), HasSubstr("test-value"));
 }
@@ -309,16 +309,17 @@ TEST(ExamplesSiteTest, TipsGcpApis) {
   GTEST_SKIP();
 #endif  // __has_feature(thread_sanitizer)
 #endif  // defined(__has_feature)
-  unsetenv("GCP_PROJECT");
+  google::cloud::functions_internal::SetEnv("GCP_PROJECT", std::nullopt);
   EXPECT_THROW(tips_gcp_apis(gcf::HttpRequest{}), std::runtime_error);
 
-  setenv("GCP_PROJECT", "test-unused", 1);
+  google::cloud::functions_internal::SetEnv("GCP_PROJECT", "test-unused");
   EXPECT_THROW(tips_gcp_apis(gcf::HttpRequest{}), std::exception);
   EXPECT_THROW(
       tips_gcp_apis(gcf::HttpRequest{}.set_payload(nlohmann::json({}).dump())),
       std::runtime_error);
 
-  setenv("PUBSUB_EMULATOR_HOST", "localhost:1", 1);
+  google::cloud::functions_internal::SetEnv("PUBSUB_EMULATOR_HOST",
+                                            "localhost:1");
   auto const actual = tips_gcp_apis(gcf::HttpRequest{}.set_payload(
       nlohmann::json({{"topic", "test-unused"}}).dump()));
   EXPECT_EQ(actual.result(), gcf::HttpResponse::kInternalServerError);

@@ -47,6 +47,8 @@ add_library(
     internal/parse_cloud_event_json.h
     internal/parse_options.cc
     internal/parse_options.h
+    internal/setenv.cc
+    internal/setenv.h
     internal/version_info.h
     internal/wrap_request.cc
     internal/wrap_request.h
@@ -56,6 +58,12 @@ add_library(
     version.cc
     version.h)
 functions_framework_cpp_add_common_options(functions_framework_cpp)
+if (MSVC)
+    set_property(
+        SOURCE internal/parse_options.cc
+        APPEND
+        PROPERTY COMPILE_DEFINITIONS "_CRT_SECURE_NO_WARNINGS")
+endif ()
 target_include_directories(functions_framework_cpp
                            PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>)
 target_include_directories(functions_framework_cpp SYSTEM

@@ -83,9 +83,14 @@ char const* argv0 = nullptr;
 auto constexpr kServer = "echo_server";
 auto constexpr kConformanceServer = "http_conformance";
 
+auto ExePath(bfs::path const& filename) {
+  static auto const kPath = std::vector<bfs::path>{
+      bfs::canonical(argv0).make_preferred().parent_path()};
+  return bp::search_path(filename, kPath);
+}
+
 TEST(RunIntegrationTest, Basic) {
-  auto const exe = bfs::path(argv0).parent_path() / kServer;
-  auto server = bp::child(exe, "--port=8010");
+  auto server = bp::child(ExePath(kServer), "--port=8010");
   auto result = WaitForServerReady("localhost", "8010");
   ASSERT_EQ(result, 0);
 
@@ -121,9 +126,9 @@ TEST(RunIntegrationTest, Basic) {
 }
 
 TEST(RunIntegrationTest, ExceptionLogsToStderr) {
-  auto const exe = bfs::path(argv0).parent_path() / kServer;
   bp::ipstream child_stderr;
-  auto server = bp::child(exe, "--port=8010", bp::std_err > child_stderr);
+  auto server =
+      bp::child(ExePath(kServer), "--port=8010", bp::std_err > child_stderr);
   auto result = WaitForServerReady("localhost", "8010");
   ASSERT_EQ(result, 0);
 
@@ -145,11 +150,11 @@ TEST(RunIntegrationTest, ExceptionLogsToStderr) {
 }
 
 TEST(RunIntegrationTest, OutputIsFlushed) {
-  auto const exe = bfs::path(argv0).parent_path() / kServer;
   bp::ipstream child_stderr;
   bp::ipstream child_stdout;
-  auto server = bp::child(exe, "--port=8010", bp::std_err > child_stderr,
-                          bp::std_out > child_stdout);
+  auto server =
+      bp::child(ExePath(kServer), "--port=8010", bp::std_err > child_stderr,
+                bp::std_out > child_stdout);
   auto result = WaitForServerReady("localhost", "8010");
   ASSERT_EQ(result, 0);
 
@@ -176,8 +181,7 @@ TEST(RunIntegrationTest, OutputIsFlushed) {
 }
 
 TEST(RunIntegrationTest, ConformanceSmokeTest) {
-  auto const exe = bfs::path(argv0).parent_path() / kConformanceServer;
-  auto server = bp::child(exe, "--port=8010");
+  auto server = bp::child(ExePath(kConformanceServer), "--port=8010");
   auto result = WaitForServerReady("localhost", "8010");
   ASSERT_EQ(result, 0);
 

@@ -170,9 +170,14 @@ char const* argv0 = nullptr;
 auto constexpr kServer = "cloud_event_handler";
 auto constexpr kConformanceServer = "cloud_event_conformance";
 
+auto ExePath(bfs::path const& filename) {
+  static auto const kPath = std::vector<bfs::path>{
+      bfs::canonical(argv0).make_preferred().parent_path()};
+  return bp::search_path(filename, kPath);
+}
+
 TEST(RunIntegrationTest, Basic) {
-  auto const exe = bfs::path(argv0).parent_path() / kServer;
-  auto server = bp::child(exe, "--port=8020");
+  auto server = bp::child(ExePath(kServer), "--port=8020");
   auto result = WaitForServerReady("localhost", "8020");
   ASSERT_EQ(result, 0);
 
@@ -202,8 +207,7 @@ TEST(RunIntegrationTest, Basic) {
 }
 
 TEST(RunIntegrationTest, Batch) {
-  auto const exe = bfs::path(argv0).parent_path() / kServer;
-  auto server = bp::child(exe, "--port=8020");
+  auto server = bp::child(ExePath(kServer), "--port=8020");
   auto result = WaitForServerReady("localhost", "8020");
   ASSERT_EQ(result, 0);
 
@@ -218,8 +222,7 @@ TEST(RunIntegrationTest, Batch) {
 }
 
 TEST(RunIntegrationTest, Binary) {
-  auto const exe = bfs::path(argv0).parent_path() / kServer;
-  auto server = bp::child(exe, "--port=8020");
+  auto server = bp::child(ExePath(kServer), "--port=8020");
   auto result = WaitForServerReady("localhost", "8020");
   ASSERT_EQ(result, 0);
 
@@ -234,9 +237,9 @@ TEST(RunIntegrationTest, Binary) {
 }
 
 TEST(RunIntegrationTest, ExceptionLogsToStderr) {
-  auto const exe = bfs::path(argv0).parent_path() / kServer;
   bp::ipstream child_stderr;
-  auto server = bp::child(exe, "--port=8020", bp::std_err > child_stderr);
+  auto server =
+      bp::child(ExePath(kServer), "--port=8020", bp::std_err > child_stderr);
   auto result = WaitForServerReady("localhost", "8020");
   ASSERT_EQ(result, 0);
 
@@ -258,11 +261,11 @@ TEST(RunIntegrationTest, ExceptionLogsToStderr) {
 }
 
 TEST(RunIntegrationTest, OutputIsFlushed) {
-  auto const exe = bfs::path(argv0).parent_path() / kServer;
   bp::ipstream child_stderr;
   bp::ipstream child_stdout;
-  auto server = bp::child(exe, "--port=8020", bp::std_err > child_stderr,
-                          bp::std_out > child_stdout);
+  auto server =
+      bp::child(ExePath(kServer), "--port=8020", bp::std_err > child_stderr,
+                bp::std_out > child_stdout);
   auto result = WaitForServerReady("localhost", "8020");
   ASSERT_EQ(result, 0);
 
@@ -289,8 +292,7 @@ TEST(RunIntegrationTest, OutputIsFlushed) {
 }
 
 TEST(RunIntegrationTest, ConformanceSmokeTest) {
-  auto const exe = bfs::path(argv0).parent_path() / kConformanceServer;
-  auto server = bp::child(exe, "--port=8020");
+  auto server = bp::child(ExePath(kConformanceServer), "--port=8020");
   auto result = WaitForServerReady("localhost", "8020");
   ASSERT_EQ(result, 0);
 

@@ -14,11 +14,14 @@
 
 #include "google/cloud/functions/internal/compiler_info.h"
 #include <gmock/gmock.h>
+#include <regex>
 
 namespace google::cloud::functions_internal {
 inline namespace FUNCTIONS_FRAMEWORK_CPP_NS {
 namespace {
 
+using ::testing::Contains;
+
 TEST(CompilerInfo, CompilerId) {
   auto const cn = CompilerId();
   EXPECT_NE(cn, "");
@@ -30,8 +33,12 @@ TEST(CompilerInfo, CompilerId) {
 TEST(CompilerInfo, CompilerVersion) {
   auto const cv = CompilerVersion();
   EXPECT_NE(cv, "");
-  // Look for something that looks vaguely like an X.Y version number.
-  EXPECT_THAT(cv, ::testing::ContainsRegex(R"([0-9]+.[0-9]+)"));
+  // Look for something that looks vaguely like an X.Y version number. Cannot
+  // use ::testing::ContainsRegex() because that does not work when GTest is
+  // compiled under MSVC.
+  EXPECT_THAT(cv, Contains('.'));
+  EXPECT_TRUE(std::regex_search(cv, std::regex(R"([0-9]+\.[0-9]+)")))
+      << "version=" << cv;
 }
 
 TEST(CompilerInfo, LanguageVersion) {

@@ -114,7 +114,8 @@ TEST(FrameworkTest, Http) {
         argc, argv, std::move(f), [&shutdown]() { return shutdown.load(); },
         [&port_p](int port) mutable { port_p.set_value(port); });
   };
-  auto done = std::async(std::launch::async, run, kTestArgc, kTestArgv, hello);
+  auto done = std::async(std::launch::async, run, static_cast<int>(kTestArgc),
+                         kTestArgv, hello);
 
   auto port = port_f.get();
   auto actual = HttpGet("localhost", std::to_string(port), "/say/hello");
@@ -146,7 +147,8 @@ TEST(FrameworkTest, CloudEvent) {
         argc, argv, std::move(f), [&shutdown]() { return shutdown.load(); },
         [&port_p](int port) mutable { port_p.set_value(port); });
   };
-  auto done = std::async(std::launch::async, run, kTestArgc, kTestArgv, hello);
+  auto done = std::async(std::launch::async, run, static_cast<int>(kTestArgc),
+                         kTestArgv, hello);
 
   auto port = port_f.get();
   auto actual = CloudEventGet("localhost", std::to_string(port), "/");
@@ -163,7 +165,8 @@ TEST(FrameworkTest, CloudEvent) {
 
 TEST(FrameworkTest, CloudEventInvalidPort) {
   auto const exit_code = ::google::cloud::functions::Run(
-      kTestInvalidArgc, kTestInvalidArgv, functions::UserCloudEventFunction{});
+      static_cast<int>(kTestInvalidArgc), kTestInvalidArgv,
+      functions::UserCloudEventFunction{});
   EXPECT_NE(exit_code, 0);
 }