diff --git a/src/video_engine/main/test/AutoTest/automated/vie_api_integration_test.cc b/src/video_engine/main/test/AutoTest/automated/vie_api_integration_test.cc new file mode 100644 index 000000000..1db4f04b5 --- /dev/null +++ b/src/video_engine/main/test/AutoTest/automated/vie_api_integration_test.cc @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +/** + * Runs "extended" integration tests. + */ + +#include "gtest/gtest.h" + +#include "vie_integration_test_base.h" +#include "vie_autotest.h" + +namespace { + +class ViEApiIntegrationTest: public ViEIntegrationTest { +}; + +TEST_F(ViEApiIntegrationTest, RunsBaseTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViEBaseAPITest()); +} + +TEST_F(ViEApiIntegrationTest, RunsCaptureTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViECaptureAPITest()); +} + +TEST_F(ViEApiIntegrationTest, RunsCodecTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViECodecAPITest()); +} + +TEST_F(ViEApiIntegrationTest, RunsEncryptionTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViEEncryptionAPITest()); +} + +TEST_F(ViEApiIntegrationTest, RunsFileTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViEFileAPITest()); +} + +TEST_F(ViEApiIntegrationTest, RunsImageProcessTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViEImageProcessAPITest()); +} + +TEST_F(ViEApiIntegrationTest, RunsNetworkTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViENetworkAPITest()); +} + +TEST_F(ViEApiIntegrationTest, RunsRenderTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViERenderAPITest()); +} + +TEST_F(ViEApiIntegrationTest, RunsRtpRtcpTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViERtpRtcpAPITest()); +} +} diff --git a/src/video_engine/main/test/AutoTest/automated/vie_extended_integration_test.cc b/src/video_engine/main/test/AutoTest/automated/vie_extended_integration_test.cc new file mode 100644 index 000000000..b1b5e8762 --- /dev/null +++ b/src/video_engine/main/test/AutoTest/automated/vie_extended_integration_test.cc @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +/** + * Runs "extended" integration tests. + */ + +#include "gtest/gtest.h" + +#include "vie_integration_test_base.h" +#include "vie_autotest.h" + +namespace { + +class ViEExtendedIntegrationTest: public ViEIntegrationTest { +}; + +TEST_F(ViEExtendedIntegrationTest, RunsBaseTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViEBaseExtendedTest()); +} + +TEST_F(ViEExtendedIntegrationTest, RunsCaptureTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViECaptureExtendedTest()); +} + +TEST_F(ViEExtendedIntegrationTest, RunsCodecTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViECodecExtendedTest()); +} + +TEST_F(ViEExtendedIntegrationTest, RunsEncryptionTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViEEncryptionExtendedTest()); +} + +TEST_F(ViEExtendedIntegrationTest, RunsFileTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViEFileExtendedTest()); +} + +TEST_F(ViEExtendedIntegrationTest, RunsImageProcessTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViEImageProcessExtendedTest()); +} + +TEST_F(ViEExtendedIntegrationTest, RunsNetworkTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViENetworkExtendedTest()); +} + +TEST_F(ViEExtendedIntegrationTest, RunsRenderTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViERenderExtendedTest()); +} + +TEST_F(ViEExtendedIntegrationTest, RunsRtpRtcpTestWithoutErrors) { + ASSERT_EQ(0, tests_->ViERtpRtcpExtendedTest()); +} +} diff --git a/src/video_engine/main/test/AutoTest/automated/vie_integration_test_base.cc b/src/video_engine/main/test/AutoTest/automated/vie_integration_test_base.cc new file mode 100644 index 000000000..2624f5064 --- /dev/null +++ b/src/video_engine/main/test/AutoTest/automated/vie_integration_test_base.cc @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "vie_integration_test_base.h" + +#include "vie_autotest.h" +#include "vie_autotest_window_manager_interface.h" +#include "vie_window_creator.h" + +void ViEIntegrationTest::SetUpTestCase() { + window_creator_ = new ViEWindowCreator(); + + ViEAutoTestWindowManagerInterface* window_manager = + window_creator_->CreateTwoWindows(); + + // Create the test cases + tests_ = new ViEAutoTest(window_manager->GetWindow1(), + window_manager->GetWindow2(), + ViETest::kUseGTestExpectsForTestErrors); +} + +void ViEIntegrationTest::TearDownTestCase() { + window_creator_->TerminateWindows(); + + delete tests_; + delete window_creator_; +} + +ViEWindowCreator* ViEIntegrationTest::window_creator_ = NULL; +ViEAutoTest* ViEIntegrationTest::tests_ = NULL; diff --git a/src/video_engine/main/test/AutoTest/automated/vie_integration_test_base.h b/src/video_engine/main/test/AutoTest/automated/vie_integration_test_base.h new file mode 100644 index 000000000..8b9612071 --- /dev/null +++ b/src/video_engine/main/test/AutoTest/automated/vie_integration_test_base.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef SRC_VIDEO_ENGINE_MAIN_TEST_AUTOTEST_AUTOMATED_VIE_INTEGRATION_TEST_BASE_H_ +#define SRC_VIDEO_ENGINE_MAIN_TEST_AUTOTEST_AUTOMATED_VIE_INTEGRATION_TEST_BASE_H_ + +#include "gtest/gtest.h" + +class ViEWindowCreator; +class ViEAutoTest; + +// Meant to be interited by standard integration tests based on +// ViEAutoTest. +class ViEIntegrationTest: public testing::Test { + public: + // Intitializes a suitable webcam on the system and launches + // two windows in a platform-dependent manner. + static void SetUpTestCase(); + + // Releases anything allocated by SetupTestCase. + static void TearDownTestCase(); + + protected: + static ViEWindowCreator* window_creator_; + static ViEAutoTest* tests_; +}; + +#endif // SRC_VIDEO_ENGINE_MAIN_TEST_AUTOTEST_AUTOMATED_VIE_INTEGRATION_TEST_BASE_H_ diff --git a/src/video_engine/main/test/AutoTest/automated/vie_standard_integration_test.cc b/src/video_engine/main/test/AutoTest/automated/vie_standard_integration_test.cc index b9d2fb09a..dae66f20f 100644 --- a/src/video_engine/main/test/AutoTest/automated/vie_standard_integration_test.cc +++ b/src/video_engine/main/test/AutoTest/automated/vie_standard_integration_test.cc @@ -16,38 +16,19 @@ */ #include "gtest/gtest.h" + #include "vie_autotest.h" #include "vie_autotest_window_manager_interface.h" +#include "vie_integration_test_base.h" #include "vie_window_creator.h" namespace { -class ViEStandardIntegrationTest: public testing::Test { +class ViEStandardIntegrationTest: public ViEIntegrationTest { public: - static void SetUpTestCase() { - window_creator_ = new ViEWindowCreator(); - - ViEAutoTestWindowManagerInterface* window_manager = - window_creator_->CreateTwoWindows(); - - // Create the test cases - tests_ = new ViEAutoTest(window_manager->GetWindow1(), - window_manager->GetWindow2()); - } - - static void TearDownTestCase() { - window_creator_->TerminateWindows(); - - delete tests_; - delete window_creator_; - } - - protected: - static ViEWindowCreator* window_creator_; - static ViEAutoTest* tests_; }; -TEST_F(ViEStandardIntegrationTest, RunsBaseStandardTestWithoutErrors) { +TEST_F(ViEStandardIntegrationTest, RunsBaseTestWithoutErrors) { ASSERT_EQ(0, tests_->ViEBaseStandardTest()); } @@ -82,8 +63,4 @@ TEST_F(ViEStandardIntegrationTest, RunsRenderTestWithoutErrors) { TEST_F(ViEStandardIntegrationTest, RunsRtpRctpTestWithoutErrors) { ASSERT_EQ(0, tests_->ViERtpRtcpStandardTest()); } - -ViEAutoTest* ViEStandardIntegrationTest::tests_ = NULL; -ViEWindowCreator* ViEStandardIntegrationTest::window_creator_ = NULL; - } diff --git a/src/video_engine/main/test/AutoTest/interface/vie_autotest.h b/src/video_engine/main/test/AutoTest/interface/vie_autotest.h index 352deb3b1..dd019a695 100644 --- a/src/video_engine/main/test/AutoTest/interface/vie_autotest.h +++ b/src/video_engine/main/test/AutoTest/interface/vie_autotest.h @@ -33,6 +33,8 @@ #include "vie_errors.h" #include "video_render_defines.h" +#include "vie_autotest_defines.h" + #ifndef WEBRTC_ANDROID #include #endif @@ -40,7 +42,8 @@ class ViEAutoTest { public: - ViEAutoTest(void* window1, void* window2); + ViEAutoTest(void* window1, void* window2, + ViETest::TestErrorMode testErrorMode); ~ViEAutoTest(); int ViEStandardTest(); @@ -139,6 +142,17 @@ public: int ViERtpRtcpAPITest(); private: + // Finds a suitable capture device (e.g. camera) on the current system. + // Details about the found device are filled into the out parameters. + // If this operation fails, device_id is assigned a negative value + // and number_of_errors is incremented. + void FindCaptureDeviceOnSystem(webrtc::ViECapture* capture, + WebRtc_UWord8* device_name, + const unsigned int kDeviceNameLength, + int* device_id, + int* number_of_errors, + webrtc::VideoCaptureModule** device_video); + void PrintAudioCodec(const webrtc::CodecInst audioCodec); void PrintVideoCodec(const webrtc::VideoCodec videoCodec); diff --git a/src/video_engine/main/test/AutoTest/interface/vie_autotest_defines.h b/src/video_engine/main/test/AutoTest/interface/vie_autotest_defines.h index 683a8fbf9..fa4128591 100644 --- a/src/video_engine/main/test/AutoTest/interface/vie_autotest_defines.h +++ b/src/video_engine/main/test/AutoTest/interface/vie_autotest_defines.h @@ -21,6 +21,7 @@ #include #include "engine_configurations.h" +#include "gtest/gtest.h" #if defined(_WIN32) #include @@ -58,162 +59,163 @@ #define DEFAULT_INCOMING_FILE_NAME "IncomingFile.avi" #define DEFAULT_OUTGOING_FILE_NAME "OutgoingFile.avi" -enum -{ - KAutoTestSleepTimeMs = 5000 +enum { + KAutoTestSleepTimeMs = 5000 }; -struct AutoTestSize -{ - unsigned int width; - unsigned int height; - AutoTestSize() : - width(0), - height(0) - {} - AutoTestSize(unsigned int iWidth, unsigned int iHeight) : - width(iWidth), - height(iHeight) - {} +struct AutoTestSize { + unsigned int width; + unsigned int height; + AutoTestSize() : + width(0), height(0) { + } + AutoTestSize(unsigned int iWidth, unsigned int iHeight) : + width(iWidth), height(iHeight) { + } }; -struct AutoTestOrigin -{ - unsigned int x; - unsigned int y; - AutoTestOrigin() : - x(0), - y(0) - {} - AutoTestOrigin(unsigned int iX, unsigned int iY) : - x(iX), - y(iY) - {} +struct AutoTestOrigin { + unsigned int x; + unsigned int y; + AutoTestOrigin() : + x(0), y(0) { + } + AutoTestOrigin(unsigned int iX, unsigned int iY) : + x(iX), y(iY) { + } }; -struct AutoTestRect -{ - AutoTestSize size; - AutoTestOrigin origin; - AutoTestRect() : - size(), - origin() - {} +struct AutoTestRect { + AutoTestSize size; + AutoTestOrigin origin; + AutoTestRect() : + size(), origin() { + } - AutoTestRect(unsigned int iX, unsigned int iY, unsigned int iWidth, - unsigned int iHeight) : - size(iX, iY), - origin(iWidth, iHeight) - {} + AutoTestRect(unsigned int iX, unsigned int iY, unsigned int iWidth, unsigned int iHeight) : + size(iX, iY), origin(iWidth, iHeight) { + } - void Copy(AutoTestRect iRect) - { - origin.x = iRect.origin.x; - origin.y = iRect.origin.y; - size.width = iRect.size.width; - size.height = iRect.size.height; - } + void Copy(AutoTestRect iRect) { + origin.x = iRect.origin.x; + origin.y = iRect.origin.y; + size.width = iRect.size.width; + size.height = iRect.size.height; + } }; // ============================================ -class ViETest -{ -protected: - static FILE* _logFile; - enum - { - KMaxLogSize = 512 - }; - static char* _logStr; +class ViETest { public: + enum TestErrorMode { + kUseGTestExpectsForTestErrors, kUseAssertsForTestErrors + }; - static int Init() - { + // The test error mode tells how we should assert when an error + // occurs, provided that VIE_ASSERT_ERROR is defined. + static int Init(TestErrorMode test_error_mode) { #ifdef VIE_LOG_TO_FILE - _logFile = fopen(VIE_LOG_FILE_NAME, "w+t"); + log_file_ = fopen(VIE_LOG_FILE_NAME, "w+t"); #else - _logFile = NULL; + log_file_ = NULL; #endif - _logStr = new char[KMaxLogSize]; - memset(_logStr, 0, KMaxLogSize); - return 0; + log_str_ = new char[kMaxLogSize]; + memset(log_str_, 0, kMaxLogSize); + + test_error_mode_ = test_error_mode; + return 0; + } + + static int Terminate() { + if (log_file_) { + fclose(log_file_); + log_file_ = NULL; } - - static int Terminate() - { - if (_logFile) - { - fclose(_logFile); - _logFile = NULL; - } - if (_logStr) - { - delete[] _logStr; - _logStr = NULL; - } - return 0; + if (log_str_) { + delete[] log_str_; + log_str_ = NULL; } + return 0; + } - static void Log(const char* fmt, ...) - { - va_list va; - va_start(va, fmt); - memset(_logStr, 0, KMaxLogSize); - vsprintf(_logStr, fmt, va); - va_end(va); + static void Log(const char* fmt, ...) { + va_list va; + va_start(va, fmt); + memset(log_str_, 0, kMaxLogSize); + vsprintf(log_str_, fmt, va); + va_end(va); + WriteToSuitableOutput(log_str_); + } + + // Writes to a suitable output, depending on platform and log mode. + static void WriteToSuitableOutput(const char* message) { #ifdef VIE_LOG_TO_FILE - if (_logFile) - { - fwrite(_logStr, 1, strlen(_logStr), _logFile); - fwrite("\n", 1, 1, _logFile); - fflush(_logFile); - } + if (log_file_) + { + fwrite(log_str_, 1, strlen(log_str_), log_file_); + fwrite("\n", 1, 1, log_file_); + fflush(log_file_); + } #endif #ifdef VIE_LOG_TO_STDOUT #if WEBRTC_ANDROID - __android_log_write(ANDROID_LOG_DEBUG, "*WebRTCN*", _logStr); + __android_log_write(ANDROID_LOG_DEBUG, "*WebRTCN*", log_str_); #else - printf("%s\n",_logStr); + printf("%s\n", log_str_); #endif #endif + } + + static int TestError(bool expr) { + if (!expr) { + AssertError(""); + return 1; } + return 0; + } - static int TestError(bool expr) - { - if (!expr) - { -#ifdef VIE_ASSERT_ERROR - assert(expr); -#endif - return 1; - } - return 0; - } - - static int TestError(bool expr, const char* fmt, ...) - { - - if (!expr) - { - va_list va; - va_start(va, fmt); - memset(_logStr, 0, KMaxLogSize); - vsprintf(_logStr, fmt, va); + static int TestError(bool expr, const char* fmt, ...) { + if (!expr) { + va_list va; + va_start(va, fmt); + memset(log_str_, 0, kMaxLogSize); + vsprintf(log_str_, fmt, va); #ifdef WEBRTC_ANDROID - __android_log_write(ANDROID_LOG_ERROR, "*WebRTCN*", _logStr); + __android_log_write(ANDROID_LOG_ERROR, "*WebRTCN*", log_str_); #endif - Log(_logStr); - va_end(va); + WriteToSuitableOutput(log_str_); + va_end(va); -#ifdef VIE_ASSERT_ERROR - assert(false); -#endif - return 1; - } - return 0; + AssertError(log_str_); + return 1; } + return 0; + } + +private: + static void AssertError(const char* message) { +#ifdef VIE_ASSERT_ERROR + if (test_error_mode_ == kUseAssertsForTestErrors) { + assert(false); + } else if (test_error_mode_ == kUseGTestExpectsForTestErrors) { + // Note that the failure gets added here, but information about where + // the real error occurred is usually in the message. + ADD_FAILURE() << message ; + } else { + assert(false && "Internal test framework logical error: unknown mode"); + } +#endif + } + + static FILE* log_file_; + enum { + kMaxLogSize = 512 + }; + static char* log_str_; + + static TestErrorMode test_error_mode_; }; // milliseconds @@ -223,24 +225,24 @@ public: #define AutoTestSleep(x) usleep(x * 1000) #elif defined(WEBRTC_LINUX) namespace { -void Sleep(unsigned long x) { - timespec t; - t.tv_sec = x/1000; - t.tv_nsec = (x-(x/1000)*1000)*1000000; - nanosleep(&t,NULL); -} + void Sleep(unsigned long x) { + timespec t; + t.tv_sec = x/1000; + t.tv_nsec = (x-(x/1000)*1000)*1000000; + nanosleep(&t,NULL); + } } #define AutoTestSleep ::Sleep #endif #ifdef WEBRTC_ANDROID namespace { -void Sleep(unsigned long x) { - timespec t; - t.tv_sec = x/1000; - t.tv_nsec = (x-(x/1000)*1000)*1000000; - nanosleep(&t,NULL); -} + void Sleep(unsigned long x) { + timespec t; + t.tv_sec = x/1000; + t.tv_nsec = (x-(x/1000)*1000)*1000000; + nanosleep(&t,NULL); + } } #define AutoTestSleep ::Sleep @@ -249,13 +251,11 @@ void Sleep(unsigned long x) { #define VIE_TEST_FILES_ROOT "/tmp/" #endif -namespace -{ -FILE* OpenTestFile(const char* fileName) -{ - char filePath[256]; - sprintf(filePath,"%s%s",VIE_TEST_FILES_ROOT,fileName); - return fopen(filePath,"rb"); +namespace { +FILE* OpenTestFile(const char* fileName) { + char filePath[256]; + sprintf(filePath, "%s%s", VIE_TEST_FILES_ROOT, fileName); + return fopen(filePath, "rb"); } } #endif // WEBRTC_VIDEO_ENGINE_MAIN_TEST_AUTOTEST_INTERFACE_VIE_AUTOTEST_DEFINES_H_ diff --git a/src/video_engine/main/test/AutoTest/interface/vie_autotest_main.h b/src/video_engine/main/test/AutoTest/interface/vie_autotest_main.h index ba73c684b..10629869c 100644 --- a/src/video_engine/main/test/AutoTest/interface/vie_autotest_main.h +++ b/src/video_engine/main/test/AutoTest/interface/vie_autotest_main.h @@ -18,7 +18,7 @@ class ViEAutoTestMain public: ViEAutoTestMain(); bool BeginOSIndependentTesting(); - bool GetAnswer(int index, std::string& answer); + bool GetAnswer(int index, std::string* answer); int GetClassTestSelection(); bool GetNextAnswer(std::string& answer); bool IsUsingAnswerFile(); diff --git a/src/video_engine/main/test/AutoTest/source/vie_autotest.cc b/src/video_engine/main/test/AutoTest/source/vie_autotest.cc index 8fa1799b8..4713938b6 100644 --- a/src/video_engine/main/test/AutoTest/source/vie_autotest.cc +++ b/src/video_engine/main/test/AutoTest/source/vie_autotest.cc @@ -19,10 +19,12 @@ #include #include "video_render.h" -FILE* ViETest::_logFile = NULL; -char* ViETest::_logStr = NULL; +FILE* ViETest::log_file_ = NULL; +char* ViETest::log_str_ = NULL; +ViETest::TestErrorMode ViETest::test_error_mode_; -ViEAutoTest::ViEAutoTest(void* window1, void* window2) : +ViEAutoTest::ViEAutoTest(void* window1, void* window2, + ViETest::TestErrorMode testErrorMode) : _window1(window1), _window2(window2), _renderType(webrtc::kRenderDefault), @@ -34,7 +36,7 @@ ViEAutoTest::ViEAutoTest(void* window1, void* window2) : assert(_vrm1); assert(_vrm2); - ViETest::Init(); + ViETest::Init(testErrorMode); } ViEAutoTest::~ViEAutoTest() diff --git a/src/video_engine/main/test/AutoTest/source/vie_autotest_base.cc b/src/video_engine/main/test/AutoTest/source/vie_autotest_base.cc index d7649d46d..200d09c5a 100644 --- a/src/video_engine/main/test/AutoTest/source/vie_autotest_base.cc +++ b/src/video_engine/main/test/AutoTest/source/vie_autotest_base.cc @@ -12,20 +12,20 @@ // vie_autotest_base.cc // -#include "vie_autotest_defines.h" #include "vie_autotest.h" + +#include "vie_autotest_defines.h" #include "engine_configurations.h" #include "video_capture_factory.h" -int ViEAutoTest::ViEBaseStandardTest() -{ +int ViEAutoTest::ViEBaseStandardTest() { ViETest::Log(" "); ViETest::Log("========================================"); ViETest::Log(" ViEBase Standard Test"); - //*************************************************************** - // Begin create/initialize WebRTC Video Engine for testing - //*************************************************************** + // *************************************************************** + // Begin create/initialize WebRTC Video Engine for testing + // *************************************************************** int error = 0; int numberOfErrors = 0; @@ -37,6 +37,7 @@ int ViEAutoTest::ViEBaseStandardTest() numberOfErrors += ViETest::TestError(ptrViE != NULL, "ERROR: %s at line %d", __FUNCTION__, __LINE__); + #ifdef WEBRTC_ANDROID error = ptrViE->SetTraceFile("/sdcard/ViEBaseStandardTest_trace.txt"); numberOfErrors += ViETest::TestError(error == 0, @@ -47,159 +48,102 @@ int ViEAutoTest::ViEBaseStandardTest() numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); #endif - webrtc::ViEBase* ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE); + webrtc::ViEBase *ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE); numberOfErrors += ViETest::TestError(ptrViEBase != NULL, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - error = ptrViEBase->Init(); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - //*************************************************************** - // Engine ready. Begin testing class - //*************************************************************** - + // *************************************************************** + // Engine ready. Begin testing class + // *************************************************************** int videoChannel = -1; error = ptrViEBase->CreateChannel(videoChannel); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - webrtc::ViECapture* ptrViECapture = webrtc::ViECapture::GetInterface(ptrViE); + webrtc::ViECapture *ptrViECapture = + webrtc::ViECapture::GetInterface(ptrViE); numberOfErrors += ViETest::TestError(ptrViECapture != NULL, "ERROR: %s at line %d", __FUNCTION__, __LINE__); webrtc::VideoCaptureModule* vcpm(NULL); - const unsigned int KMaxDeviceNameLength = 128; - const unsigned int KMaxUniqueIdLength = 256; WebRtc_UWord8 deviceName[KMaxDeviceNameLength]; memset(deviceName, 0, KMaxDeviceNameLength); - WebRtc_UWord8 uniqueId[KMaxUniqueIdLength]; - memset(uniqueId, 0, KMaxUniqueIdLength); - bool captureDeviceSet = false; - int captureId = 0; - webrtc::VideoCaptureModule::DeviceInfo* devInfo = - webrtc::VideoCaptureFactory::CreateDeviceInfo(0); + int captureId; - for (unsigned int captureIdx = 0; - captureIdx < devInfo->NumberOfDevices(); - captureIdx++) - { - error = devInfo->GetDeviceName(captureIdx, deviceName, - KMaxDeviceNameLength, uniqueId, - KMaxUniqueIdLength); - numberOfErrors += ViETest::TestError(error == 0, - "ERROR: %s at line %d", - __FUNCTION__, __LINE__); - - vcpm = webrtc::VideoCaptureFactory::Create( - 4571, uniqueId); - vcpm->AddRef(); - numberOfErrors += ViETest::TestError(vcpm != NULL, - "ERROR: %s at line %d", - __FUNCTION__, __LINE__); - - error = ptrViECapture->AllocateCaptureDevice(*vcpm, captureId); - if (error == 0) - { - ViETest::Log("Using capture device: %s, captureId: %d.", - deviceName, captureId); - captureDeviceSet = true; - break; - } - else - { - vcpm->Release(); - vcpm = NULL; - } - } - delete devInfo; - - numberOfErrors+= ViETest::TestError( - captureDeviceSet, - "ERROR: %s at line %d - Could not set capture device", - __FUNCTION__, __LINE__); + FindCaptureDeviceOnSystem(ptrViECapture, + deviceName, + KMaxDeviceNameLength, + &captureId, + &numberOfErrors, + &vcpm); error = ptrViECapture->ConnectCaptureDevice(captureId, videoChannel); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - error = ptrViECapture->StartCapture(captureId); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - webrtc::ViERTP_RTCP* ptrViERtpRtcp = + webrtc::ViERTP_RTCP *ptrViERtpRtcp = webrtc::ViERTP_RTCP::GetInterface(ptrViE); numberOfErrors += ViETest::TestError(ptrViE != NULL, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - error = ptrViERtpRtcp->SetRTCPStatus(videoChannel, webrtc::kRtcpCompound_RFC4585); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - error = ptrViERtpRtcp->SetKeyFrameRequestMethod( - videoChannel, webrtc::kViEKeyFrameRequestPliRtcp); + error = ptrViERtpRtcp-> + SetKeyFrameRequestMethod(videoChannel, + webrtc::kViEKeyFrameRequestPliRtcp); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - error = ptrViERtpRtcp->SetTMMBRStatus(videoChannel, true); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - webrtc::ViERender* ptrViERender = webrtc::ViERender::GetInterface(ptrViE); + webrtc::ViERender *ptrViERender = webrtc::ViERender::GetInterface(ptrViE); numberOfErrors += ViETest::TestError(ptrViERender != NULL, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - error = ptrViERender->RegisterVideoRenderModule(*_vrm1); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - error = ptrViERender->AddRenderer(captureId, _window1, 0, 0.0, 0.0, 1.0, - 1.0); + error = ptrViERender->AddRenderer(captureId, _window1, 0, 0.0, + 0.0, 1.0, 1.0); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - error = ptrViERender->StartRender(captureId); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - error = ptrViERender->RegisterVideoRenderModule(*_vrm2); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - error = ptrViERender->AddRenderer(videoChannel, _window2, 1, 0.0, 0.0, 1.0, - 1.0); + error = ptrViERender->AddRenderer(videoChannel, _window2, 1, 0.0, 0.0, + 1.0, 1.0); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - error = ptrViERender->StartRender(videoChannel); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - webrtc::ViECodec* ptrViECodec = webrtc::ViECodec::GetInterface(ptrViE); + webrtc::ViECodec *ptrViECodec = webrtc::ViECodec::GetInterface(ptrViE); numberOfErrors += ViETest::TestError(ptrViECodec != NULL, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - webrtc::VideoCodec videoCodec; memset(&videoCodec, 0, sizeof(webrtc::VideoCodec)); - for (int idx = 0; idx < ptrViECodec->NumberOfCodecs(); idx++) - { + for (int idx = 0; idx < ptrViECodec->NumberOfCodecs(); idx++) { error = ptrViECodec->GetCodec(idx, videoCodec); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); // try to keep the test frame size small when I420 - if (videoCodec.codecType == webrtc::kVideoCodecI420) - { + if (videoCodec.codecType == webrtc::kVideoCodecI420) { videoCodec.width = 176; videoCodec.height = 144; error = ptrViECodec->SetSendCodec(videoChannel, videoCodec); @@ -213,65 +157,52 @@ int ViEAutoTest::ViEBaseStandardTest() "ERROR: %s at line %d", __FUNCTION__, __LINE__); } - - webrtc::ViENetwork* ptrViENetwork = + webrtc::ViENetwork *ptrViENetwork = webrtc::ViENetwork::GetInterface(ptrViE); numberOfErrors += ViETest::TestError(ptrViENetwork != NULL, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - char version[1024] = ""; error = ptrViEBase->GetVersion(version); - ViETest::Log("\nUsing WebRTC Video Engine version: %s", version); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - const char* ipAddress = "127.0.0.1"; + const char *ipAddress = "127.0.0.1"; unsigned short rtpPortListen = 6000; unsigned short rtpPortSend = 6000; - - rtpPortListen = 6100; rtpPortSend = 6100; - error = ptrViENetwork->SetLocalReceiver(videoChannel, rtpPortListen); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - error = ptrViEBase->StartReceive(videoChannel); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - error = ptrViENetwork->SetSendDestination(videoChannel, ipAddress, - rtpPortSend); + error = ptrViENetwork->SetSendDestination(videoChannel, + ipAddress, rtpPortSend); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - error = ptrViEBase->StartSend(videoChannel); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - - error = ptrViERender->MirrorRenderStream(captureId, true, false, true); numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - // Call started ViETest::Log("Call started"); - ViETest::Log("You should see a mirrored local preview from camera %s in " - "window 1 and the remote video in window 2.", - deviceName); + ViETest::Log( + "You should see a mirrored local preview from camera %s" + " in window 1 and the remote video in window 2.", deviceName); - //*************************************************************** - // Finished initializing engine. Begin testing - //*************************************************************** + // *************************************************************** + // Finished initializing engine. Begin testing + // *************************************************************** AutoTestSleep(KAutoTestSleepTimeMs); - //*************************************************************** - // Testing finished. Tear down Video Engine - //*************************************************************** + // *************************************************************** + // Testing finished. Tear down Video Engine + // *************************************************************** // Shut down error = ptrViEBase->StopReceive(videoChannel); @@ -358,8 +289,7 @@ int ViEAutoTest::ViEBaseStandardTest() "ERROR: %s at line %d", __FUNCTION__, __LINE__); - if (numberOfErrors > 0) - { + if (numberOfErrors > 0) { // Test failed ViETest::Log(" "); ViETest::Log(" ERROR ViEBase Standard Test FAILED!"); @@ -376,8 +306,7 @@ int ViEAutoTest::ViEBaseStandardTest() return 0; } -int ViEAutoTest::ViEBaseExtendedTest() -{ +int ViEAutoTest::ViEBaseExtendedTest() { // Start with standard test ViEBaseAPITest(); ViEBaseStandardTest(); @@ -394,16 +323,14 @@ int ViEAutoTest::ViEBaseExtendedTest() return 0; } -int ViEAutoTest::ViEBaseAPITest() -{ +int ViEAutoTest::ViEBaseAPITest() { ViETest::Log(" "); ViETest::Log("========================================"); ViETest::Log(" ViEBase API Test"); - - //*************************************************************** - // Begin create/initialize WebRTC Video Engine for testing - //*************************************************************** + // *************************************************************** + // Begin create/initialize WebRTC Video Engine for testing + // *************************************************************** int error = 0; int numberOfErrors = 0; @@ -429,9 +356,9 @@ int ViEAutoTest::ViEBaseAPITest() ptrViEBase = webrtc::ViEBase::GetInterface(ptrViE); numberOfErrors += ViETest::TestError(ptrViEBase != NULL); - //*************************************************************** - // Engine ready. Begin testing class - //*************************************************************** + // *************************************************************** + // Engine ready. Begin testing class + // *************************************************************** char version[1024] = ""; error = ptrViEBase->GetVersion(version); @@ -515,9 +442,9 @@ int ViEAutoTest::ViEBaseAPITest() numberOfErrors += ViETest::TestError(error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); - //*************************************************************** - // Testing finished. Tear down Video Engine - //*************************************************************** + // *************************************************************** + // Testing finished. Tear down Video Engine + // *************************************************************** error = ptrViEBase->DisconnectAudioChannel(videoChannel + 5); numberOfErrors += ViETest::TestError(error != 0, "ERROR: %s at line %d", @@ -556,8 +483,7 @@ int ViEAutoTest::ViEBaseAPITest() "ERROR: %s at line %d", __FUNCTION__, __LINE__); - if (numberOfErrors > 0) - { + if (numberOfErrors > 0) { ViETest::Log(" "); ViETest::Log(" ERROR ViEBase API Test FAILED! "); ViETest::Log(" Number of errors: %d", numberOfErrors); @@ -574,3 +500,48 @@ int ViEAutoTest::ViEBaseAPITest() return 0; } + +void ViEAutoTest::FindCaptureDeviceOnSystem( + webrtc::ViECapture* capture, + WebRtc_UWord8* device_name, + unsigned int device_name_length, + int* device_id, + int* number_of_errors, + webrtc::VideoCaptureModule** device_video) { + + bool capture_device_set = false; + webrtc::VideoCaptureModule::DeviceInfo *dev_info = + webrtc::VideoCaptureFactory::CreateDeviceInfo(0); + + const unsigned int kMaxUniqueIdLength = 256; + WebRtc_UWord8 unique_id[kMaxUniqueIdLength]; + memset(unique_id, 0, kMaxUniqueIdLength); + + for (unsigned int i = 0; i < dev_info->NumberOfDevices(); i++) { + int error = dev_info->GetDeviceName(i, device_name, device_name_length, + unique_id, kMaxUniqueIdLength); + *number_of_errors += ViETest::TestError( + error == 0, "ERROR: %s at line %d", __FUNCTION__, __LINE__); + *device_video = + webrtc::VideoCaptureFactory::Create(4571, unique_id); + + *number_of_errors += ViETest::TestError( + *device_video != NULL, "ERROR: %s at line %d", __FUNCTION__, __LINE__); + (*device_video)->AddRef(); + + error = capture->AllocateCaptureDevice(**device_video, *device_id); + if (error == 0) { + ViETest::Log("Using capture device: %s, captureId: %d.", + device_name, *device_id); + capture_device_set = true; + break; + } else { + (*device_video)->Release(); + (*device_video) = NULL; + } + } + delete dev_info; + *number_of_errors += ViETest::TestError( + capture_device_set, "ERROR: %s at line %d - Could not set capture device", + __FUNCTION__, __LINE__); +} diff --git a/src/video_engine/main/test/AutoTest/source/vie_autotest_linux.cc b/src/video_engine/main/test/AutoTest/source/vie_autotest_linux.cc index ec6f9c642..c6625bbf5 100644 --- a/src/video_engine/main/test/AutoTest/source/vie_autotest_linux.cc +++ b/src/video_engine/main/test/AutoTest/source/vie_autotest_linux.cc @@ -24,36 +24,29 @@ #include "critical_section_wrapper.h" #include "thread_wrapper.h" -ViEAutoTestWindowManager::ViEAutoTestWindowManager() : - _hdsp1(NULL), - _hdsp2(NULL) -{ +ViEAutoTestWindowManager::ViEAutoTestWindowManager() + : _hdsp1(NULL), + _hdsp2(NULL) { } -ViEAutoTestWindowManager::~ViEAutoTestWindowManager() -{ +ViEAutoTestWindowManager::~ViEAutoTestWindowManager() { TerminateWindows(); } -void* ViEAutoTestWindowManager::GetWindow1() -{ - return (void*) _hwnd1; +void* ViEAutoTestWindowManager::GetWindow1() { + return reinterpret_cast(_hwnd1); } -void* ViEAutoTestWindowManager::GetWindow2() -{ - return (void*) _hwnd2; +void* ViEAutoTestWindowManager::GetWindow2() { + return reinterpret_cast(_hwnd2); } -int ViEAutoTestWindowManager::TerminateWindows() -{ - if (_hdsp1) - { +int ViEAutoTestWindowManager::TerminateWindows() { + if (_hdsp1) { ViEDestroyWindow(&_hwnd1, _hdsp1); _hdsp1 = NULL; } - if (_hdsp2) - { + if (_hdsp2) { ViEDestroyWindow(&_hwnd2, _hdsp2); _hdsp2 = NULL; } @@ -63,14 +56,15 @@ int ViEAutoTestWindowManager::TerminateWindows() int ViEAutoTestWindowManager::CreateWindows(AutoTestRect window1Size, AutoTestRect window2Size, void* window1Title, - void* window2Title) -{ + void* window2Title) { ViECreateWindow(&_hwnd1, &_hdsp1, window1Size.origin.x, window1Size.origin.y, window1Size.size.width, - window1Size.size.height, (char*) window1Title); + window1Size.size.height, + reinterpret_cast(window1Title)); ViECreateWindow(&_hwnd2, &_hdsp2, window2Size.origin.x, window2Size.origin.y, window2Size.size.width, - window2Size.size.height, (char*) window2Title); + window2Size.size.height, + reinterpret_cast(window2Title)); return 0; } @@ -78,13 +72,12 @@ int ViEAutoTestWindowManager::CreateWindows(AutoTestRect window1Size, int ViEAutoTestWindowManager::ViECreateWindow(Window *outWindow, Display **outDisplay, int xpos, int ypos, int width, int height, - char* title) -{ + char* title) { int screen; XEvent evnt; - XSetWindowAttributes xswa; // window attribute struct - XVisualInfo vinfo; // screen visual info struct - unsigned long mask; // attribute mask + XSetWindowAttributes xswa; // window attribute struct + XVisualInfo vinfo; // screen visual info struct + unsigned long mask; // attribute mask // get connection handle to xserver Display* _display = XOpenDisplay(NULL); @@ -92,13 +85,12 @@ int ViEAutoTestWindowManager::ViECreateWindow(Window *outWindow, // get screen number screen = DefaultScreen(_display); - // put desired visual info for the screen in vinfo - // TODO: more display settings should be allowed - if (XMatchVisualInfo(_display, screen, 24, TrueColor, &vinfo) != 0) - { - //printf( "Screen visual info match!\n" ); + // put desired visual info for the screen in vinfo + // TODO(unknown): more display settings should be allowed + if (XMatchVisualInfo(_display, screen, 24, TrueColor, &vinfo) != 0) { + // printf( "Screen visual info match!\n" ); } - // set window attributes + // set window attributes xswa.colormap = XCreateColormap(_display, DefaultRootWindow(_display), vinfo.visual, AllocNone); xswa.event_mask = StructureNotifyMask | ExposureMask; @@ -116,17 +108,15 @@ int ViEAutoTestWindowManager::ViECreateWindow(Window *outWindow, XStoreName(_display, _window, title); XSetIconName(_display, _window, title); - // make x report events for mask + // make x report events for mask XSelectInput(_display, _window, StructureNotifyMask); // map the window to the display XMapWindow(_display, _window); // wait for map event - do - { + do { XNextEvent(_display, &evnt); - } while (evnt.type != MapNotify || evnt.xmap.event != _window); *outWindow = _window; @@ -134,21 +124,19 @@ int ViEAutoTestWindowManager::ViECreateWindow(Window *outWindow, return 0; } -int ViEAutoTestWindowManager::ViEDestroyWindow(Window *window, Display *display) -{ +int ViEAutoTestWindowManager::ViEDestroyWindow(Window *window, + Display *display) { XUnmapWindow(display, *window); XDestroyWindow(display, *window); XSync(display, false); return 0; } -bool ViEAutoTestWindowManager::SetTopmostWindow() -{ +bool ViEAutoTestWindowManager::SetTopmostWindow() { return 0; } -int main(int argc, char** argv) -{ +int main(int argc, char** argv) { // This command-line flag is a transitory solution until we // managed to rewrite all tests to GUnit tests. This flag is // currently only supported in Linux. diff --git a/src/video_engine/main/test/AutoTest/source/vie_autotest_main.cc b/src/video_engine/main/test/AutoTest/source/vie_autotest_main.cc index 50ae66b0a..ebe972690 100644 --- a/src/video_engine/main/test/AutoTest/source/vie_autotest_main.cc +++ b/src/video_engine/main/test/AutoTest/source/vie_autotest_main.cc @@ -13,29 +13,29 @@ * */ -#include "vie_window_creator.h" -#include "vie_autotest_window_manager_interface.h" - -#include "vie_autotest.h" #include "vie_autotest_main.h" -ViEAutoTestMain::ViEAutoTestMain() : - _answers(), - _answersCount(0), - _useAnswerFile() -{ +#include "vie_autotest_window_manager_interface.h" +#include "vie_window_creator.h" +#include "vie_autotest.h" + +ViEAutoTestMain::ViEAutoTestMain() + : _answers(), + _answersCount(0), + _useAnswerFile() { } -bool ViEAutoTestMain::BeginOSIndependentTesting() -{ +bool ViEAutoTestMain::BeginOSIndependentTesting() { // Create the windows ViEWindowCreator windowCreator; ViEAutoTestWindowManagerInterface* windowManager = windowCreator.CreateTwoWindows(); // Create the test cases - ViEAutoTest vieAutoTest(windowManager->GetWindow1(), - windowManager->GetWindow2()); + ViEAutoTest + vieAutoTest(windowManager->GetWindow1(), + windowManager->GetWindow2(), + ViETest::kUseAssertsForTestErrors); ViETest::Log(" ============================== "); ViETest::Log(" WebRTC ViE 3.x Autotest "); @@ -43,8 +43,7 @@ bool ViEAutoTestMain::BeginOSIndependentTesting() int testType = 0; int testErrors = 0; - do - { + do { ViETest::Log("Test types: "); ViETest::Log("\t 0. Quit"); ViETest::Log("\t 1. All standard tests (delivery test)"); @@ -58,14 +57,10 @@ bool ViEAutoTestMain::BeginOSIndependentTesting() ViETest::Log("\t 9. Simulcast in loopback"); ViETest::Log("Select type of test: "); - if (_useAnswerFile) - { - //GetNextAnswer(str); - } - else - { - if (scanf("%d", &testType) <= 0) - { + if (_useAnswerFile) { + // GetNextAnswer(str); + } else { + if (scanf("%d", &testType) <= 0) { ViETest::Log("ERROR: unable to read selection. Try again\n"); testType = -1; getchar(); @@ -74,8 +69,13 @@ bool ViEAutoTestMain::BeginOSIndependentTesting() getchar(); } ViETest::Log(""); - switch (testType) - { + + if (testType < 0 || testType > 8) { + ViETest::Log("ERROR: Invalid selection. Try again\n"); + continue; + } + + switch (testType) { case 0: break; @@ -83,13 +83,10 @@ bool ViEAutoTestMain::BeginOSIndependentTesting() { int deliveryErrors = testErrors; testErrors += vieAutoTest.ViEStandardTest(); - if (testErrors == deliveryErrors) - { + if (testErrors == deliveryErrors) { // No errors found in delivery test, create delivery ViETest::Log("Standard/delivery passed."); - } - else - { + } else { // Didn't pass, don't create delivery files ViETest::Log("\nStandard/delivery test failed!\n"); } @@ -103,44 +100,43 @@ bool ViEAutoTestMain::BeginOSIndependentTesting() testErrors += vieAutoTest.ViEExtendedTest(); break; - case 4: // specific Standard + case 4: // Specific Standard testType = GetClassTestSelection(); - switch (testType) - { - case 1: // base + switch (testType) { + case 1: // base testErrors += vieAutoTest.ViEBaseStandardTest(); break; - case 2: // capture + case 2: // capture testErrors += vieAutoTest.ViECaptureStandardTest(); break; - case 3: // codec + case 3: // codec testErrors += vieAutoTest.ViECodecStandardTest(); break; - case 5: //encryption + case 5: // encryption testErrors += vieAutoTest.ViEEncryptionStandardTest(); break; - case 6: // file + case 6: // file testErrors += vieAutoTest.ViEFileStandardTest(); break; - case 7: // image process + case 7: // image process testErrors += vieAutoTest.ViEImageProcessStandardTest(); break; - case 8: // network + case 8: // network testErrors += vieAutoTest.ViENetworkStandardTest(); break; - case 9: // Render + case 9: // Render testErrors += vieAutoTest.ViERenderStandardTest(); break; - case 10: // RTP/RTCP + case 10: // RTP/RTCP testErrors += vieAutoTest.ViERtpRtcpStandardTest(); break; case 11: @@ -151,91 +147,88 @@ bool ViEAutoTestMain::BeginOSIndependentTesting() } break; - case 5: // specific API + case 5: // specific API testType = GetClassTestSelection(); - switch (testType) - { - case 1: // base + switch (testType) { + case 1: // base testErrors += vieAutoTest.ViEBaseAPITest(); break; - case 2: // capture + case 2: // capture testErrors += vieAutoTest.ViECaptureAPITest(); break; - case 3: // codec + case 3: // codec testErrors += vieAutoTest.ViECodecAPITest(); break; - case 5: //encryption + case 5: // encryption testErrors += vieAutoTest.ViEEncryptionAPITest(); break; - case 6: // file + case 6: // file testErrors += vieAutoTest.ViEFileAPITest(); break; - case 7: // image process + case 7: // image process testErrors += vieAutoTest.ViEImageProcessAPITest(); break; - case 8: // network + case 8: // network testErrors += vieAutoTest.ViENetworkAPITest(); break; - case 9: // Render + case 9: // Render testErrors += vieAutoTest.ViERenderAPITest(); break; - case 10: // RTP/RTCP + case 10: // RTP/RTCP testErrors += vieAutoTest.ViERtpRtcpAPITest(); break; case 11: break; - default: break; } break; - case 6: // specific extended + case 6: // specific extended testType = GetClassTestSelection(); - switch (testType) - { - case 1: // base + switch (testType) { + case 1: // base testErrors += vieAutoTest.ViEBaseExtendedTest(); break; - case 2: // capture + case 2: // capture testErrors += vieAutoTest.ViECaptureExtendedTest(); break; - case 3: // codec + case 3: // codec testErrors += vieAutoTest.ViECodecExtendedTest(); break; - case 5: //encryption + case 5: // encryption testErrors += vieAutoTest.ViEEncryptionExtendedTest(); break; - case 6: // file + case 6: // file testErrors += vieAutoTest.ViEFileExtendedTest(); break; - case 7: // image process + case 7: // image process testErrors += vieAutoTest.ViEImageProcessExtendedTest(); break; - case 8: // network + case 8: // network testErrors += vieAutoTest.ViENetworkExtendedTest(); break; - case 9: // Render + case 9: // Render testErrors += vieAutoTest.ViERenderExtendedTest(); break; - case 10: // RTP/RTCP + case 10: // RTP/RTCP testErrors += vieAutoTest.ViERtpRtcpExtendedTest(); break; case 11: @@ -262,31 +255,27 @@ bool ViEAutoTestMain::BeginOSIndependentTesting() windowCreator.TerminateWindows(); - if (testErrors) - { + if (testErrors) { ViETest::Log("Test done with errors, see ViEAutotestLog.txt for test " "result.\n"); - } - else - { + } else { ViETest::Log("Test done without errors, see ViEAutotestLog.txt for " "test result.\n"); } printf("Press enter to quit..."); char c; - while ((c = getchar()) != '\n' && c != EOF) - /* discard */; + while ((c = getchar()) != '\n' && c != EOF) { + /* discard */ + } return true; } -int ViEAutoTestMain::GetClassTestSelection() -{ +int ViEAutoTestMain::GetClassTestSelection() { int testType = 0; std::string answer; - while (1) - { + while (1) { ViETest::Log("Choose specific test: "); ViETest::Log("\t 1. Base "); ViETest::Log("\t 2. Capture"); @@ -301,18 +290,14 @@ int ViEAutoTestMain::GetClassTestSelection() ViETest::Log("Select type of test: "); int items_read = 0; - if (_useAnswerFile) - { - //GetNextAnswer(answer); - } - else - { + if (_useAnswerFile) { + // GetNextAnswer(answer); + } else { items_read = scanf("%d", &testType); getchar(); } ViETest::Log("\n"); - if (items_read == 1 && testType >= 1 && testType <= 13) - { + if (items_read == 1 && testType >= 1 && testType <= 13) { return testType; } ViETest::Log("ERROR: Invalid selection. Try again"); @@ -321,25 +306,20 @@ int ViEAutoTestMain::GetClassTestSelection() return -1; } -bool ViEAutoTestMain::GetAnswer(int index, std::string& answer) -{ - if (!_useAnswerFile || index > _answersCount) - { +bool ViEAutoTestMain::GetAnswer(int index, std::string* answer) { + if (!_useAnswerFile || index > _answersCount) { return false; } - answer = _answers[index]; + *answer = _answers[index]; return true; } -bool ViEAutoTestMain::IsUsingAnswerFile() -{ - +bool ViEAutoTestMain::IsUsingAnswerFile() { return _useAnswerFile; } -// TODO: write without stl -bool ViEAutoTestMain::UseAnswerFile(const char* fileName) -{ +// TODO(unknown): write without stl +bool ViEAutoTestMain::UseAnswerFile(const char* fileName) { return false; /* _useAnswerFile = false; diff --git a/src/video_engine/main/test/AutoTest/vie_auto_test.gypi b/src/video_engine/main/test/AutoTest/vie_auto_test.gypi index bcd659903..9723f74ad 100644 --- a/src/video_engine/main/test/AutoTest/vie_auto_test.gypi +++ b/src/video_engine/main/test/AutoTest/vie_auto_test.gypi @@ -41,11 +41,14 @@ 'interface/vie_autotest_main.h', 'interface/vie_autotest_window_manager_interface.h', 'interface/vie_autotest_windows.h', - + # Helper classes 'helpers/vie_window_creator.cc', - + # New, fully automated tests + 'automated/vie_api_integration_test.cc', + 'automated/vie_extended_integration_test.cc', + 'automated/vie_integration_test_base.cc', 'automated/vie_standard_integration_test.cc', # Platform independent