Auth segfault fix (#1046)

disa6302 · web-flow · commit 4c4afff63f33 · 2023-08-16T10:42:48.000-07:00
* Auth segfault fix

* Added unit tests
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -11,7 +11,7 @@ on:
 
 jobs:
   mac-os-build-clang:
-    runs-on: macos-13
+    runs-on: macos-11
     env:
       AWS_KVS_LOG_LEVEL: 2
     permissions:
@@ -23,6 +23,7 @@ jobs:
       - name: Install dependencies
         run: |
           brew install pkg-config openssl cmake gstreamer log4cplus
+          brew unlink openssl
       - name: Build repository
         run: |
           mkdir build && cd build
@@ -42,7 +43,7 @@ jobs:
           ./tst/producerTest
 
   mac-os-build-gcc:
-    runs-on: macos-13
+    runs-on: macos-12
     permissions:
       id-token: write
       contents: read
@@ -56,6 +57,7 @@ jobs:
       - name: Install dependencies
         run: |
           brew install pkg-config openssl cmake gstreamer log4cplus
+          brew unlink openssl
       - name: Build repository
         run: |
           mkdir build && cd build
diff --git a/CMake/Dependencies/libkvscproducer-CMakeLists.txt b/CMake/Dependencies/libkvscproducer-CMakeLists.txt
@@ -7,7 +7,7 @@ include(ExternalProject)
 # clone repo only
 ExternalProject_Add(libkvscproducer-download
 	GIT_REPOSITORY    https://github.com/awslabs/amazon-kinesis-video-streams-producer-c.git
-	GIT_TAG           a3dd1d08600854e249dab5760752451e5daca9e4
+	GIT_TAG           release-1.5.0
 	SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/kvscproducer-src"
 	BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/kvscproducer-build"
 	CONFIGURE_COMMAND ""
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -3,7 +3,7 @@ set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMake;${CMAKE_MODULE_PATH}")
 include(Utilities)
 project(KinesisVideoProducerCpp)
 
-project(KinesisVideoProducerCpp VERSION 3.3.1)
+project(KinesisVideoProducerCpp VERSION 3.4.0)
 
 set(CMAKE_CXX_STANDARD 11)
 include(GNUInstallDirs)
@@ -27,7 +27,7 @@ option(MEMORY_SANITIZER "Build with MemorySanitizer" OFF)
 option(THREAD_SANITIZER "Build with ThreadSanitizer" OFF)
 option(UNDEFINED_BEHAVIOR_SANITIZER "Build with UndefinedBehaviorSanitizer" OFF)
 
-add_definitions(-DVERSION_STRING=\"${PROJECT_VERSION}\")
+add_definitions(-DCPP_VERSION_STRING=\"${PROJECT_VERSION}\")
 
 set(CMAKE_MACOSX_RPATH TRUE)
 get_filename_component(ROOT "${CMAKE_CURRENT_SOURCE_DIR}" ABSOLUTE)
diff --git a/src/Auth.cpp b/src/Auth.cpp
@@ -90,6 +90,7 @@ DeviceCertToTokenFunc CredentialProvider::deviceCertToTokenCallback() {
 
 STATUS CredentialProvider::getStreamingTokenHandler(UINT64 custom_data, PCHAR stream_name, STREAM_ACCESS_MODE access_mode, PServiceCallContext p_service_call_context) {
     LOG_DEBUG("getStreamingTokenHandler invoked");
+    STATUS status = STATUS_SUCCESS;
     UNUSED_PARAM(stream_name);
     UNUSED_PARAM(access_mode);
 
@@ -111,14 +112,25 @@ STATUS CredentialProvider::getStreamingTokenHandler(UINT64 custom_data, PCHAR st
     freeAwsCredentials(&this_obj->security_token_);
 
     // Store the buffer so we can release it at the end
-    createAwsCredentials((PCHAR) access_key.c_str(), access_key_len, (PCHAR) secret_key.c_str(), secret_key_len,
-                         (PCHAR) session_token.c_str(), session_token_len, expiration, &this_obj->security_token_);
+    if(IS_EMPTY_STRING(session_token.c_str())) {
+        status = createAwsCredentials((PCHAR) access_key.c_str(), access_key_len, (PCHAR) secret_key.c_str(), secret_key_len,
+                             nullptr, 0, expiration, &this_obj->security_token_);
 
-    STATUS status = getStreamingTokenResultEvent(
-            p_service_call_context->customData, SERVICE_CALL_RESULT_OK,
-            reinterpret_cast<PBYTE>(this_obj->security_token_),
-            this_obj->security_token_->size,
-            expiration);
+    } else {
+        status = createAwsCredentials((PCHAR) access_key.c_str(), access_key_len, (PCHAR) secret_key.c_str(), secret_key_len,
+                             (PCHAR) session_token.c_str(), session_token_len, expiration, &this_obj->security_token_);
+
+    }
+
+    if(STATUS_SUCCEEDED(status)) {
+        status = getStreamingTokenResultEvent(
+                p_service_call_context->customData, SERVICE_CALL_RESULT_OK,
+                reinterpret_cast<PBYTE>(this_obj->security_token_),
+                this_obj->security_token_->size,
+                expiration);
+    } else {
+        LOG_ERROR("getStreamingTokenHandler failed with code " << std::hex << status);
+    }
 
     return status;
 }
@@ -127,10 +139,11 @@ STATUS CredentialProvider::getSecurityTokenHandler(UINT64 custom_data, PBYTE* pp
     LOG_DEBUG("getSecurityTokenHandler invoked");
 
     auto this_obj = reinterpret_cast<CredentialProvider*>(custom_data);
-
+    STATUS status = STATUS_SUCCESS;
     Credentials credentials;
     this_obj->getCredentials(credentials);
 
+
     auto access_key = credentials.getAccessKey();
     auto access_key_len = access_key.length();
     auto secret_key = credentials.getSecretKey();
@@ -145,13 +158,26 @@ STATUS CredentialProvider::getSecurityTokenHandler(UINT64 custom_data, PBYTE* pp
     *p_expiration = credentials.getExpiration().count() * HUNDREDS_OF_NANOS_IN_A_SECOND;
 
     // Store the buffer so we can release it at the end
-    createAwsCredentials((PCHAR) access_key.c_str(), access_key_len, (PCHAR) secret_key.c_str(), secret_key_len,
-            (PCHAR) session_token.c_str(), session_token_len, *p_expiration, &this_obj->security_token_);
+    if(IS_EMPTY_STRING(session_token.c_str())) {
+        // Store the buffer so we can release it at the end
+        status = createAwsCredentials((PCHAR) access_key.c_str(), access_key_len, (PCHAR) secret_key.c_str(), secret_key_len,
+                             nullptr, 0, *p_expiration, &this_obj->security_token_);
 
-    *pp_token = (PBYTE) (this_obj->security_token_);
-    *p_size = this_obj->security_token_->size;
+    } else {
+        // Store the buffer so we can release it at the end
+        status = createAwsCredentials((PCHAR) access_key.c_str(), access_key_len, (PCHAR) secret_key.c_str(), secret_key_len,
+                             (PCHAR) session_token.c_str(), session_token_len, *p_expiration, &this_obj->security_token_);
 
-    return STATUS_SUCCESS;
+    }
+
+    if(STATUS_SUCCEEDED(status)) {
+        *pp_token = (PBYTE) (this_obj->security_token_);
+        *p_size = this_obj->security_token_->size;
+    } else {
+        LOG_ERROR("getSecurityTokenHandler failed with code " << std::hex << status);
+    }
+
+    return status;
 }
 
 } // namespace video
diff --git a/src/gstreamer/gstkvssink.h b/src/gstreamer/gstkvssink.h
@@ -57,8 +57,8 @@ G_BEGIN_DECLS
   (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_KVS_SINK))
 #define GST_KVS_SINK_CAST(obj) ((GstKvsSink *)obj)
 
-#ifdef VERSION_STRING
-#define KVSSINK_USER_AGENT_POSTFIX_VERSION VERSION_STRING
+#ifdef CPP_VERSION_STRING
+#define KVSSINK_USER_AGENT_POSTFIX_VERSION CPP_VERSION_STRING
 #else
 #define KVSSINK_USER_AGENT_POSTFIX_VERSION "UNKNOWN"
 #endif
diff --git a/tst/ProducerApiTest.cpp b/tst/ProducerApiTest.cpp
@@ -140,10 +140,45 @@ PVOID ProducerTestBase::basicProducerRoutine(KinesisVideoStream* kinesis_video_s
     return NULL;
 }
 
+TEST_F(ProducerApiTest, invalid_credentials)
+{
+    std::unique_ptr<Credentials> credentials;
+    std::unique_ptr<CredentialProvider> credential_provider;
+    credentials.reset(new Credentials("",
+                                      "SecretKey",
+                                      "SessionToken",
+                                      std::chrono::seconds(TEST_STREAMING_TOKEN_DURATION_IN_SECONDS)));
+
+    credential_provider.reset(new TestCredentialProvider(*credentials.get(), TEST_STREAMING_TOKEN_DURATION_IN_SECONDS));
+    EXPECT_THROW(CreateProducer(std::move(credential_provider)), std::runtime_error);
+
+    credentials.reset(new Credentials("AccessKey",
+                                      "",
+                                      "SessionToken",
+                                      std::chrono::seconds(TEST_STREAMING_TOKEN_DURATION_IN_SECONDS)));
+    credential_provider.reset(new TestCredentialProvider(*credentials.get(), TEST_STREAMING_TOKEN_DURATION_IN_SECONDS));
+    EXPECT_THROW(CreateProducer(std::move(credential_provider)), std::runtime_error);
+
+    credentials.reset(new Credentials("",
+                                      "",
+                                      "SessionToken",
+                                      std::chrono::seconds(TEST_STREAMING_TOKEN_DURATION_IN_SECONDS)));
+    credential_provider.reset(new TestCredentialProvider(*credentials.get(), TEST_STREAMING_TOKEN_DURATION_IN_SECONDS));
+    EXPECT_THROW(CreateProducer(std::move(credential_provider)), std::runtime_error);
+
+    credentials.reset(new Credentials("AccessKey",
+                                      "SecretKey",
+                                      "",
+                                      std::chrono::seconds(TEST_STREAMING_TOKEN_DURATION_IN_SECONDS)));
+    credential_provider.reset(new TestCredentialProvider(*credentials.get(), TEST_STREAMING_TOKEN_DURATION_IN_SECONDS));
+    CreateProducer(std::move(credential_provider)); // expect no exception thrown since empty session token is allowed
+}
+
 TEST_F(ProducerApiTest, create_free_stream)
 {
     // Check if it's run with the env vars set if not bail out
     if (!access_key_set_) {
+        LOG_WARN("Creds not set");
         return;
     }
 
@@ -181,6 +216,7 @@ TEST_F(ProducerApiTest, DISABLED_create_produce_offline_stream)
 {
     // Check if it's run with the env vars set if not bail out
     if (!access_key_set_) {
+        LOG_WARN("Creds not set");
         return;
     }
 
@@ -224,6 +260,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream)
 {
     // Check if it's run with the env vars set if not bail out
     if (!access_key_set_) {
+        LOG_WARN("Creds not set");
         return;
     }
 
@@ -280,7 +317,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream)
         EXPECT_TRUE(kinesis_video_stream->stopSync()) << "Timed out awaiting for the stream stop notification";
         EXPECT_TRUE(gProducerApiTest->stop_called_) << "Status of stopped state " << gProducerApiTest->stop_called_;
 
-        kinesis_video_producer_->freeStream(move(streams_[0]));
+        kinesis_video_producer_->freeStream(std::move(streams_[0]));
         streams_[0] = nullptr;
     }
 }
@@ -289,6 +326,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream_endpoint_cached)
 {
     // Check if it's run with the env vars set if not bail out
     if (!access_key_set_) {
+        LOG_WARN("Creds not set");
         return;
     }
 
@@ -345,7 +383,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream_endpoint_cached)
         EXPECT_TRUE(kinesis_video_stream->stopSync()) << "Timed out awaiting for the stream stop notification";
         EXPECT_TRUE(gProducerApiTest->stop_called_) << "Status of stopped state " << gProducerApiTest->stop_called_;
 
-        kinesis_video_producer_->freeStream(move(streams_[0]));
+        kinesis_video_producer_->freeStream(std::move(streams_[0]));
         streams_[0] = nullptr;
     }
 }
@@ -354,6 +392,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream_all_cached)
 {
     // Check if it's run with the env vars set if not bail out
     if (!access_key_set_) {
+        LOG_WARN("Creds not set");
         return;
     }
 
@@ -410,7 +449,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream_all_cached)
         EXPECT_TRUE(kinesis_video_stream->stopSync()) << "Timed out awaiting for the stream stop notification";
         EXPECT_TRUE(gProducerApiTest->stop_called_) << "Status of stopped state " << gProducerApiTest->stop_called_;
 
-        kinesis_video_producer_->freeStream(move(streams_[0]));
+        kinesis_video_producer_->freeStream(std::move(streams_[0]));
         streams_[0] = nullptr;
     }
 }
@@ -419,6 +458,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_reset_stream_endpoint_cached)
 {
     // Check if it's run with the env vars set if not bail out
     if (!access_key_set_) {
+        LOG_WARN("Creds not set");
         return;
     }
 
@@ -478,14 +518,15 @@ TEST_F(ProducerApiTest, create_produce_start_stop_reset_stream_endpoint_cached)
         kinesis_video_stream->resetStream();
     }
 
-    kinesis_video_producer_->freeStream(move(streams_[0]));
+    kinesis_video_producer_->freeStream(std::move(streams_[0]));
     streams_[0] = nullptr;
 }
 
 TEST_F(ProducerApiTest, create_produce_start_stop_reset_stream_all_cached)
 {
     // Check if it's run with the env vars set if not bail out
     if (!access_key_set_) {
+        LOG_WARN("Creds not set");
         return;
     }
 
@@ -545,14 +586,15 @@ TEST_F(ProducerApiTest, create_produce_start_stop_reset_stream_all_cached)
         kinesis_video_stream->resetStream();
     }
 
-    kinesis_video_producer_->freeStream(move(streams_[0]));
+    kinesis_video_producer_->freeStream(std::move(streams_[0]));
     streams_[0] = nullptr;
 }
 
 TEST_F(ProducerApiTest, create_produce_stream)
 {
     // Check if it's run with the env vars set if not bail out
     if (!access_key_set_) {
+        LOG_WARN("Creds not set");
         return;
     }
 
@@ -631,6 +673,7 @@ TEST_F(ProducerApiTest, create_caching_endpoing_produce_stream)
 {
     // Check if it's run with the env vars set if not bail out
     if (!access_key_set_) {
+        LOG_WARN("Creds not set");
         return;
     }
 
@@ -692,7 +735,7 @@ TEST_F(ProducerApiTest, exceed_max_track_count)
     stream_definition->addTrack(1, testTrackName, testCodecId, MKV_TRACK_INFO_TYPE_VIDEO);
     stream_definition->addTrack(2, testTrackName, testCodecId, MKV_TRACK_INFO_TYPE_AUDIO);
     stream_definition->addTrack(3, testTrackName, testCodecId, MKV_TRACK_INFO_TYPE_VIDEO);
-    EXPECT_ANY_THROW(kinesis_video_producer_->createStream(move(stream_definition)));
+    EXPECT_ANY_THROW(kinesis_video_producer_->createStream(std::move(stream_definition)));
 }
 
 TEST_F(ProducerApiTest, segment_uuid_variations)
@@ -732,7 +775,7 @@ TEST_F(ProducerApiTest, segment_uuid_variations)
             vector<uint8_t>(),
             DEFAULT_TRACK_ID));
 
-    EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(move(stream_definition)));
+    EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(std::move(stream_definition)));
     kinesis_video_producer_->freeStreams();
 
     // Valid
@@ -768,7 +811,7 @@ TEST_F(ProducerApiTest, segment_uuid_variations)
             vector<uint8_t>(),
             DEFAULT_TRACK_ID));
 
-    EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(move(stream_definition)));
+    EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(std::move(stream_definition)));
     kinesis_video_producer_->freeStreams();
 
     // invalid - larger
@@ -804,7 +847,7 @@ TEST_F(ProducerApiTest, segment_uuid_variations)
             vector<uint8_t>(),
             DEFAULT_TRACK_ID));
 
-    EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(move(stream_definition)));
+    EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(std::move(stream_definition)));
     kinesis_video_producer_->freeStreams();
 
     // shorter length
diff --git a/tst/ProducerFunctionalityTest.cpp b/tst/ProducerFunctionalityTest.cpp
diff --git a/tst/ProducerTestFixture.h b/tst/ProducerTestFixture.h

Original file line number	Diff line number	Diff line change
`@@ -140,10 +140,45 @@ PVOID ProducerTestBase::basicProducerRoutine(KinesisVideoStream* kinesis_video_s`
`140`	`140`	`return NULL;`
`141`	`141`	`}`
`142`	`142`
	`143`	`+TEST_F(ProducerApiTest, invalid_credentials)`
	`144`	`+{`
	`145`	`+ std::unique_ptr<Credentials> credentials;`
	`146`	`+ std::unique_ptr<CredentialProvider> credential_provider;`
	`147`	`+ credentials.reset(new Credentials("",`
	`148`	`+ "SecretKey",`
	`149`	`+ "SessionToken",`
	`150`	`+ std::chrono::seconds(TEST_STREAMING_TOKEN_DURATION_IN_SECONDS)));`
	`151`	`+`
	`152`	`+ credential_provider.reset(new TestCredentialProvider(*credentials.get(), TEST_STREAMING_TOKEN_DURATION_IN_SECONDS));`
	`153`	`+ EXPECT_THROW(CreateProducer(std::move(credential_provider)), std::runtime_error);`
	`154`	`+`
	`155`	`+ credentials.reset(new Credentials("AccessKey",`
	`156`	`+ "",`
	`157`	`+ "SessionToken",`
	`158`	`+ std::chrono::seconds(TEST_STREAMING_TOKEN_DURATION_IN_SECONDS)));`
	`159`	`+ credential_provider.reset(new TestCredentialProvider(*credentials.get(), TEST_STREAMING_TOKEN_DURATION_IN_SECONDS));`
	`160`	`+ EXPECT_THROW(CreateProducer(std::move(credential_provider)), std::runtime_error);`
	`161`	`+`
	`162`	`+ credentials.reset(new Credentials("",`
	`163`	`+ "",`
	`164`	`+ "SessionToken",`
	`165`	`+ std::chrono::seconds(TEST_STREAMING_TOKEN_DURATION_IN_SECONDS)));`
	`166`	`+ credential_provider.reset(new TestCredentialProvider(*credentials.get(), TEST_STREAMING_TOKEN_DURATION_IN_SECONDS));`
	`167`	`+ EXPECT_THROW(CreateProducer(std::move(credential_provider)), std::runtime_error);`
	`168`	`+`
	`169`	`+ credentials.reset(new Credentials("AccessKey",`
	`170`	`+ "SecretKey",`
	`171`	`+ "",`
	`172`	`+ std::chrono::seconds(TEST_STREAMING_TOKEN_DURATION_IN_SECONDS)));`
	`173`	`+ credential_provider.reset(new TestCredentialProvider(*credentials.get(), TEST_STREAMING_TOKEN_DURATION_IN_SECONDS));`
	`174`	`+ CreateProducer(std::move(credential_provider)); // expect no exception thrown since empty session token is allowed`
	`175`	`+}`
	`176`	`+`
`143`	`177`	`TEST_F(ProducerApiTest, create_free_stream)`
`144`	`178`	`{`
`145`	`179`	`// Check if it's run with the env vars set if not bail out`
`146`	`180`	`if (!access_key_set_) {`
	`181`	`+ LOG_WARN("Creds not set");`
`147`	`182`	`return;`
`148`	`183`	`}`
`149`	`184`
`@@ -181,6 +216,7 @@ TEST_F(ProducerApiTest, DISABLED_create_produce_offline_stream)`
`181`	`216`	`{`
`182`	`217`	`// Check if it's run with the env vars set if not bail out`
`183`	`218`	`if (!access_key_set_) {`
	`219`	`+ LOG_WARN("Creds not set");`
`184`	`220`	`return;`
`185`	`221`	`}`
`186`	`222`
`@@ -224,6 +260,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream)`
`224`	`260`	`{`
`225`	`261`	`// Check if it's run with the env vars set if not bail out`
`226`	`262`	`if (!access_key_set_) {`
	`263`	`+ LOG_WARN("Creds not set");`
`227`	`264`	`return;`
`228`	`265`	`}`
`229`	`266`
`@@ -280,7 +317,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream)`
`280`	`317`	`EXPECT_TRUE(kinesis_video_stream->stopSync()) << "Timed out awaiting for the stream stop notification";`
`281`	`318`	`EXPECT_TRUE(gProducerApiTest->stop_called_) << "Status of stopped state " << gProducerApiTest->stop_called_;`
`282`	`319`
`283`		`- kinesis_video_producer_->freeStream(move(streams_[0]));`
	`320`	`+ kinesis_video_producer_->freeStream(std::move(streams_[0]));`
`284`	`321`	`streams_[0] = nullptr;`
`285`	`322`	`}`
`286`	`323`	`}`
`@@ -289,6 +326,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream_endpoint_cached)`
`289`	`326`	`{`
`290`	`327`	`// Check if it's run with the env vars set if not bail out`
`291`	`328`	`if (!access_key_set_) {`
	`329`	`+ LOG_WARN("Creds not set");`
`292`	`330`	`return;`
`293`	`331`	`}`
`294`	`332`
`@@ -345,7 +383,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream_endpoint_cached)`
`345`	`383`	`EXPECT_TRUE(kinesis_video_stream->stopSync()) << "Timed out awaiting for the stream stop notification";`
`346`	`384`	`EXPECT_TRUE(gProducerApiTest->stop_called_) << "Status of stopped state " << gProducerApiTest->stop_called_;`
`347`	`385`
`348`		`- kinesis_video_producer_->freeStream(move(streams_[0]));`
	`386`	`+ kinesis_video_producer_->freeStream(std::move(streams_[0]));`
`349`	`387`	`streams_[0] = nullptr;`
`350`	`388`	`}`
`351`	`389`	`}`
`@@ -354,6 +392,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream_all_cached)`
`354`	`392`	`{`
`355`	`393`	`// Check if it's run with the env vars set if not bail out`
`356`	`394`	`if (!access_key_set_) {`
	`395`	`+ LOG_WARN("Creds not set");`
`357`	`396`	`return;`
`358`	`397`	`}`
`359`	`398`
`@@ -410,7 +449,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_stream_all_cached)`
`410`	`449`	`EXPECT_TRUE(kinesis_video_stream->stopSync()) << "Timed out awaiting for the stream stop notification";`
`411`	`450`	`EXPECT_TRUE(gProducerApiTest->stop_called_) << "Status of stopped state " << gProducerApiTest->stop_called_;`
`412`	`451`
`413`		`- kinesis_video_producer_->freeStream(move(streams_[0]));`
	`452`	`+ kinesis_video_producer_->freeStream(std::move(streams_[0]));`
`414`	`453`	`streams_[0] = nullptr;`
`415`	`454`	`}`
`416`	`455`	`}`
`@@ -419,6 +458,7 @@ TEST_F(ProducerApiTest, create_produce_start_stop_reset_stream_endpoint_cached)`
`419`	`458`	`{`
`420`	`459`	`// Check if it's run with the env vars set if not bail out`
`421`	`460`	`if (!access_key_set_) {`
	`461`	`+ LOG_WARN("Creds not set");`
`422`	`462`	`return;`
`423`	`463`	`}`
`424`	`464`
`@@ -478,14 +518,15 @@ TEST_F(ProducerApiTest, create_produce_start_stop_reset_stream_endpoint_cached)`
`478`	`518`	`kinesis_video_stream->resetStream();`
`479`	`519`	`}`
`480`	`520`
`481`		`- kinesis_video_producer_->freeStream(move(streams_[0]));`
	`521`	`+ kinesis_video_producer_->freeStream(std::move(streams_[0]));`
`482`	`522`	`streams_[0] = nullptr;`
`483`	`523`	`}`
`484`	`524`
`485`	`525`	`TEST_F(ProducerApiTest, create_produce_start_stop_reset_stream_all_cached)`
`486`	`526`	`{`
`487`	`527`	`// Check if it's run with the env vars set if not bail out`
`488`	`528`	`if (!access_key_set_) {`
	`529`	`+ LOG_WARN("Creds not set");`
`489`	`530`	`return;`
`490`	`531`	`}`
`491`	`532`
`@@ -545,14 +586,15 @@ TEST_F(ProducerApiTest, create_produce_start_stop_reset_stream_all_cached)`
`545`	`586`	`kinesis_video_stream->resetStream();`
`546`	`587`	`}`
`547`	`588`
`548`		`- kinesis_video_producer_->freeStream(move(streams_[0]));`
	`589`	`+ kinesis_video_producer_->freeStream(std::move(streams_[0]));`
`549`	`590`	`streams_[0] = nullptr;`
`550`	`591`	`}`
`551`	`592`
`552`	`593`	`TEST_F(ProducerApiTest, create_produce_stream)`
`553`	`594`	`{`
`554`	`595`	`// Check if it's run with the env vars set if not bail out`
`555`	`596`	`if (!access_key_set_) {`
	`597`	`+ LOG_WARN("Creds not set");`
`556`	`598`	`return;`
`557`	`599`	`}`
`558`	`600`
`@@ -631,6 +673,7 @@ TEST_F(ProducerApiTest, create_caching_endpoing_produce_stream)`
`631`	`673`	`{`
`632`	`674`	`// Check if it's run with the env vars set if not bail out`
`633`	`675`	`if (!access_key_set_) {`
	`676`	`+ LOG_WARN("Creds not set");`
`634`	`677`	`return;`
`635`	`678`	`}`
`636`	`679`
`@@ -692,7 +735,7 @@ TEST_F(ProducerApiTest, exceed_max_track_count)`
`692`	`735`	`stream_definition->addTrack(1, testTrackName, testCodecId, MKV_TRACK_INFO_TYPE_VIDEO);`
`693`	`736`	`stream_definition->addTrack(2, testTrackName, testCodecId, MKV_TRACK_INFO_TYPE_AUDIO);`
`694`	`737`	`stream_definition->addTrack(3, testTrackName, testCodecId, MKV_TRACK_INFO_TYPE_VIDEO);`
`695`		`- EXPECT_ANY_THROW(kinesis_video_producer_->createStream(move(stream_definition)));`
	`738`	`+ EXPECT_ANY_THROW(kinesis_video_producer_->createStream(std::move(stream_definition)));`
`696`	`739`	`}`
`697`	`740`
`698`	`741`	`TEST_F(ProducerApiTest, segment_uuid_variations)`
`@@ -732,7 +775,7 @@ TEST_F(ProducerApiTest, segment_uuid_variations)`
`732`	`775`	`vector<uint8_t>(),`
`733`	`776`	`DEFAULT_TRACK_ID));`
`734`	`777`
`735`		`- EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(move(stream_definition)));`
	`778`	`+ EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(std::move(stream_definition)));`
`736`	`779`	`kinesis_video_producer_->freeStreams();`
`737`	`780`
`738`	`781`	`// Valid`
`@@ -768,7 +811,7 @@ TEST_F(ProducerApiTest, segment_uuid_variations)`
`768`	`811`	`vector<uint8_t>(),`
`769`	`812`	`DEFAULT_TRACK_ID));`
`770`	`813`
`771`		`- EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(move(stream_definition)));`
	`814`	`+ EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(std::move(stream_definition)));`
`772`	`815`	`kinesis_video_producer_->freeStreams();`
`773`	`816`
`774`	`817`	`// invalid - larger`
`@@ -804,7 +847,7 @@ TEST_F(ProducerApiTest, segment_uuid_variations)`
`804`	`847`	`vector<uint8_t>(),`
`805`	`848`	`DEFAULT_TRACK_ID));`
`806`	`849`
`807`		`- EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(move(stream_definition)));`
	`850`	`+ EXPECT_NE(nullptr, kinesis_video_producer_->createStreamSync(std::move(stream_definition)));`
`808`	`851`	`kinesis_video_producer_->freeStreams();`
`809`	`852`
`810`	`853`	`// shorter length`