webrtc/system_wrappers/source/data_log_unittest.cc - src - Git at Google

 /*
  *  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 "webrtc/system_wrappers/interface/data_log.h"

 #include <map>
 #include <string>

 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/system_wrappers/interface/data_log_c.h"
 #include "webrtc/system_wrappers/source/data_log_c_helpers_unittest.h"

 using ::webrtc::DataLog;

 // A class for storing the values expected from a log table column when
 // verifying a log table file.
 struct ExpectedValues {
  public:
   ExpectedValues()
     : values(),
       multi_value_length(1) {
   }

   ExpectedValues(std::vector<std::string> expected_values,
                  int expected_multi_value_length)
     : values(expected_values),
       multi_value_length(expected_multi_value_length) {
   }

   std::vector<std::string> values;
   int multi_value_length;
 };

 typedef std::map<std::string, ExpectedValues> ExpectedValuesMap;

 // A static class used for parsing and verifying data log files.
 class DataLogParser {
  public:
   // Verifies that the log table stored in the file "log_file" corresponds to
   // the cells and columns specified in "columns".
   static int VerifyTable(FILE* log_file, const ExpectedValuesMap& columns) {
     int row = 0;
     char line_buffer[kMaxLineLength];
     char* ret = fgets(line_buffer, kMaxLineLength, log_file);
     EXPECT_FALSE(ret == NULL);
     if (ret == NULL)
       return -1;

     std::string line(line_buffer, kMaxLineLength);
     VerifyHeader(line, columns);
     while (fgets(line_buffer, kMaxLineLength, log_file) != NULL) {
       line = std::string(line_buffer, kMaxLineLength);
       size_t line_position = 0;

       for (ExpectedValuesMap::const_iterator it = columns.begin();
            it != columns.end(); ++it) {
         std::string str = ParseElement(line, &line_position,
                                        it->second.multi_value_length);
         EXPECT_EQ(str, it->second.values[row]);
         if (str != it->second.values[row])
           return -1;
       }
       ++row;
     }
     return 0;
   }

   // Verifies the table header stored in "line" to correspond with the header
   // specified in "columns".
   static int VerifyHeader(const std::string& line,
                           const ExpectedValuesMap& columns) {
     size_t line_position = 0;
     for (ExpectedValuesMap::const_iterator it = columns.begin();
          it != columns.end(); ++it) {
       std::string str = ParseElement(line, &line_position,
                                      it->second.multi_value_length);
       EXPECT_EQ(str, it->first);
       if (str != it->first)
         return -1;
     }
     return 0;
   }

   // Parses out and returns one element from the string "line", which contains
   // one line read from a log table file. An element can either be a column
   // header or a cell of a row.
   static std::string ParseElement(const std::string& line,
                                   size_t* line_position,
                                   int multi_value_length) {
     std::string parsed_cell;
     parsed_cell = "";
     for (int i = 0; i < multi_value_length; ++i) {
       size_t next_separator = line.find(',', *line_position);
       EXPECT_NE(next_separator, std::string::npos);
       if (next_separator == std::string::npos)
         break;
       parsed_cell += line.substr(*line_position,
                                  next_separator - *line_position + 1);
       *line_position = next_separator + 1;
     }
     return parsed_cell;
   }

   // This constant defines the maximum line length the DataLogParser can
   // parse.
   enum { kMaxLineLength = 100 };
 };

 TEST(TestDataLog, CreateReturnTest) {
   for (int i = 0; i < 10; ++i)
     ASSERT_EQ(DataLog::CreateLog(), 0);
   ASSERT_EQ(DataLog::AddTable(DataLog::Combine("a proper table", 1)), 0);
   for (int i = 0; i < 10; ++i)
     DataLog::ReturnLog();
   ASSERT_LT(DataLog::AddTable(DataLog::Combine("table failure", 1)), 0);
 }

 TEST(TestDataLog, VerifyCombineMethod) {
   EXPECT_EQ(std::string("a proper table_1"),
             DataLog::Combine("a proper table", 1));
 }

 TEST(TestDataLog, VerifySingleTable) {
   DataLog::CreateLog();
   DataLog::AddTable(DataLog::Combine("table", 1));
   DataLog::AddColumn(DataLog::Combine("table", 1), "arrival", 1);
   DataLog::AddColumn(DataLog::Combine("table", 1), "timestamp", 1);
   DataLog::AddColumn(DataLog::Combine("table", 1), "size", 5);
   uint32_t sizes[5] = {1400, 1500, 1600, 1700, 1800};
   for (int i = 0; i < 10; ++i) {
     DataLog::InsertCell(DataLog::Combine("table", 1), "arrival",
                         static_cast<double>(i));
     DataLog::InsertCell(DataLog::Combine("table", 1), "timestamp",
                         static_cast<int64_t>(4354 + i));
     DataLog::InsertCell(DataLog::Combine("table", 1), "size", sizes, 5);
     DataLog::NextRow(DataLog::Combine("table", 1));
   }
   DataLog::ReturnLog();
   // Verify file
   FILE* table = fopen("table_1.txt", "r");
   ASSERT_FALSE(table == NULL);
   // Read the column names and verify with the expected columns.
   // Note that the columns are written to file in alphabetical order.
   // Data expected from parsing the file
   const int kNumberOfRows = 10;
   std::string string_arrival[kNumberOfRows] = {
     "0,", "1,", "2,", "3,", "4,",
     "5,", "6,", "7,", "8,", "9,"
   };
   std::string string_timestamp[kNumberOfRows] = {
     "4354,", "4355,", "4356,", "4357,",
     "4358,", "4359,", "4360,", "4361,",
     "4362,", "4363,"
   };
   std::string string_sizes = "1400,1500,1600,1700,1800,";
   ExpectedValuesMap expected;
   expected["arrival,"] = ExpectedValues(
                            std::vector<std::string>(string_arrival,
                                                     string_arrival +
                                                     kNumberOfRows),
                            1);
   expected["size[5],,,,,"] = ExpectedValues(
                                std::vector<std::string>(10, string_sizes), 5);
   expected["timestamp,"] = ExpectedValues(
                              std::vector<std::string>(string_timestamp,
                                                       string_timestamp +
                                                       kNumberOfRows),
                              1);
   ASSERT_EQ(DataLogParser::VerifyTable(table, expected), 0);
   fclose(table);
 }

 TEST(TestDataLog, VerifyMultipleTables) {
   DataLog::CreateLog();
   DataLog::AddTable(DataLog::Combine("table", 2));
   DataLog::AddTable(DataLog::Combine("table", 3));
   DataLog::AddColumn(DataLog::Combine("table", 2), "arrival", 1);
   DataLog::AddColumn(DataLog::Combine("table", 2), "timestamp", 1);
   DataLog::AddColumn(DataLog::Combine("table", 2), "size", 1);
   DataLog::AddTable(DataLog::Combine("table", 4));
   DataLog::AddColumn(DataLog::Combine("table", 3), "timestamp", 1);
   DataLog::AddColumn(DataLog::Combine("table", 3), "arrival", 1);
   DataLog::AddColumn(DataLog::Combine("table", 4), "size", 1);
   for (int32_t i = 0; i < 10; ++i) {
     DataLog::InsertCell(DataLog::Combine("table", 2), "arrival",
                         static_cast<int32_t>(i));
     DataLog::InsertCell(DataLog::Combine("table", 2), "timestamp",
                         static_cast<int32_t>(4354 + i));
     DataLog::InsertCell(DataLog::Combine("table", 2), "size",
                         static_cast<int32_t>(1200 + 10 * i));
     DataLog::InsertCell(DataLog::Combine("table", 3), "timestamp",
                         static_cast<int32_t>(4354 + i));
     DataLog::InsertCell(DataLog::Combine("table", 3), "arrival",
                         static_cast<int32_t>(i));
     DataLog::InsertCell(DataLog::Combine("table", 4), "size",
                         static_cast<int32_t>(1200 + 10 * i));
     DataLog::NextRow(DataLog::Combine("table", 4));
     DataLog::NextRow(DataLog::Combine("table", 2));
     DataLog::NextRow(DataLog::Combine("table", 3));
   }
   DataLog::ReturnLog();

   // Data expected from parsing the file
   const int kNumberOfRows = 10;
   std::string string_arrival[kNumberOfRows] = {
     "0,", "1,", "2,", "3,", "4,",
     "5,", "6,", "7,", "8,", "9,"
   };
   std::string string_timestamp[kNumberOfRows] = {
     "4354,", "4355,", "4356,", "4357,",
     "4358,", "4359,", "4360,", "4361,",
     "4362,", "4363,"
   };
   std::string string_size[kNumberOfRows] = {
     "1200,", "1210,", "1220,", "1230,",
     "1240,", "1250,", "1260,", "1270,",
     "1280,", "1290,"
   };

   // Verify table 2
   {
     FILE* table = fopen("table_2.txt", "r");
     ASSERT_FALSE(table == NULL);
     ExpectedValuesMap expected;
     expected["arrival,"] = ExpectedValues(
                              std::vector<std::string>(string_arrival,
                                                       string_arrival +
                                                       kNumberOfRows),
                              1);
     expected["size,"] = ExpectedValues(
                           std::vector<std::string>(string_size,
                                                    string_size + kNumberOfRows),
                           1);
     expected["timestamp,"] = ExpectedValues(
                                std::vector<std::string>(string_timestamp,
                                                         string_timestamp +
                                                         kNumberOfRows),
                                1);
     ASSERT_EQ(DataLogParser::VerifyTable(table, expected), 0);
     fclose(table);
   }

   // Verify table 3
   {
     FILE* table = fopen("table_3.txt", "r");
     ASSERT_FALSE(table == NULL);
     ExpectedValuesMap expected;
     expected["arrival,"] = ExpectedValues(
                              std::vector<std::string>(string_arrival,
                                                       string_arrival +
                                                       kNumberOfRows),
                              1);
     expected["timestamp,"] = ExpectedValues(
                                std::vector<std::string>(string_timestamp,
                                                         string_timestamp +
                                                         kNumberOfRows),
                                1);
     ASSERT_EQ(DataLogParser::VerifyTable(table, expected), 0);
     fclose(table);
   }

   // Verify table 4
   {
     FILE* table = fopen("table_4.txt", "r");
     ASSERT_FALSE(table == NULL);
     ExpectedValuesMap expected;
     expected["size,"] = ExpectedValues(
                           std::vector<std::string>(string_size,
                                                    string_size +
                                                    kNumberOfRows),
                           1);
     ASSERT_EQ(DataLogParser::VerifyTable(table, expected), 0);
     fclose(table);
   }
 }

 TEST(TestDataLogCWrapper, VerifyCWrapper) {
   // Simply call all C wrapper log functions through the C helper unittests.
   // Main purpose is to make sure that the linkage is correct.

   EXPECT_EQ(0, WebRtcDataLogCHelper_TestCreateLog());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestCombine());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestAddTable());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestAddColumn());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_int());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_int());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_float());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_float());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_double());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_double());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_int32());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_int32());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_uint32());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_uint32());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_int64());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_int64());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
   EXPECT_EQ(0, WebRtcDataLogCHelper_TestReturnLog());
 }
	/*
	* 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 "webrtc/system_wrappers/interface/data_log.h"

	#include <map>
	#include <string>

	#include "testing/gtest/include/gtest/gtest.h"
	#include "webrtc/system_wrappers/interface/data_log_c.h"
	#include "webrtc/system_wrappers/source/data_log_c_helpers_unittest.h"

	using ::webrtc::DataLog;

	// A class for storing the values expected from a log table column when
	// verifying a log table file.
	struct ExpectedValues {
	public:
	ExpectedValues()
	: values(),
	multi_value_length(1) {
	}

	ExpectedValues(std::vector<std::string> expected_values,
	int expected_multi_value_length)
	: values(expected_values),
	multi_value_length(expected_multi_value_length) {
	}

	std::vector<std::string> values;
	int multi_value_length;
	};

	typedef std::map<std::string, ExpectedValues> ExpectedValuesMap;

	// A static class used for parsing and verifying data log files.
	class DataLogParser {
	public:
	// Verifies that the log table stored in the file "log_file" corresponds to
	// the cells and columns specified in "columns".
	static int VerifyTable(FILE* log_file, const ExpectedValuesMap& columns) {
	int row = 0;
	char line_buffer[kMaxLineLength];
	char* ret = fgets(line_buffer, kMaxLineLength, log_file);
	EXPECT_FALSE(ret == NULL);
	if (ret == NULL)
	return -1;

	std::string line(line_buffer, kMaxLineLength);
	VerifyHeader(line, columns);
	while (fgets(line_buffer, kMaxLineLength, log_file) != NULL) {
	line = std::string(line_buffer, kMaxLineLength);
	size_t line_position = 0;

	for (ExpectedValuesMap::const_iterator it = columns.begin();
	it != columns.end(); ++it) {
	std::string str = ParseElement(line, &line_position,
	it->second.multi_value_length);
	EXPECT_EQ(str, it->second.values[row]);
	if (str != it->second.values[row])
	return -1;
	}
	++row;
	}
	return 0;
	}

	// Verifies the table header stored in "line" to correspond with the header
	// specified in "columns".
	static int VerifyHeader(const std::string& line,
	const ExpectedValuesMap& columns) {
	size_t line_position = 0;
	for (ExpectedValuesMap::const_iterator it = columns.begin();
	it != columns.end(); ++it) {
	std::string str = ParseElement(line, &line_position,
	it->second.multi_value_length);
	EXPECT_EQ(str, it->first);
	if (str != it->first)
	return -1;
	}
	return 0;
	}

	// Parses out and returns one element from the string "line", which contains
	// one line read from a log table file. An element can either be a column
	// header or a cell of a row.
	static std::string ParseElement(const std::string& line,
	size_t* line_position,
	int multi_value_length) {
	std::string parsed_cell;
	parsed_cell = "";
	for (int i = 0; i < multi_value_length; ++i) {
	size_t next_separator = line.find(',', *line_position);
	EXPECT_NE(next_separator, std::string::npos);
	if (next_separator == std::string::npos)
	break;
	parsed_cell += line.substr(*line_position,
	next_separator - *line_position + 1);
	*line_position = next_separator + 1;
	}
	return parsed_cell;
	}

	// This constant defines the maximum line length the DataLogParser can
	// parse.
	enum { kMaxLineLength = 100 };
	};

	TEST(TestDataLog, CreateReturnTest) {
	for (int i = 0; i < 10; ++i)
	ASSERT_EQ(DataLog::CreateLog(), 0);
	ASSERT_EQ(DataLog::AddTable(DataLog::Combine("a proper table", 1)), 0);
	for (int i = 0; i < 10; ++i)
	DataLog::ReturnLog();
	ASSERT_LT(DataLog::AddTable(DataLog::Combine("table failure", 1)), 0);
	}

	TEST(TestDataLog, VerifyCombineMethod) {
	EXPECT_EQ(std::string("a proper table_1"),
	DataLog::Combine("a proper table", 1));
	}

	TEST(TestDataLog, VerifySingleTable) {
	DataLog::CreateLog();
	DataLog::AddTable(DataLog::Combine("table", 1));
	DataLog::AddColumn(DataLog::Combine("table", 1), "arrival", 1);
	DataLog::AddColumn(DataLog::Combine("table", 1), "timestamp", 1);
	DataLog::AddColumn(DataLog::Combine("table", 1), "size", 5);
	uint32_t sizes[5] = {1400, 1500, 1600, 1700, 1800};
	for (int i = 0; i < 10; ++i) {
	DataLog::InsertCell(DataLog::Combine("table", 1), "arrival",
	static_cast<double>(i));
	DataLog::InsertCell(DataLog::Combine("table", 1), "timestamp",
	static_cast<int64_t>(4354 + i));
	DataLog::InsertCell(DataLog::Combine("table", 1), "size", sizes, 5);
	DataLog::NextRow(DataLog::Combine("table", 1));
	}
	DataLog::ReturnLog();
	// Verify file
	FILE* table = fopen("table_1.txt", "r");
	ASSERT_FALSE(table == NULL);
	// Read the column names and verify with the expected columns.
	// Note that the columns are written to file in alphabetical order.
	// Data expected from parsing the file
	const int kNumberOfRows = 10;
	std::string string_arrival[kNumberOfRows] = {
	"0,", "1,", "2,", "3,", "4,",
	"5,", "6,", "7,", "8,", "9,"
	};
	std::string string_timestamp[kNumberOfRows] = {
	"4354,", "4355,", "4356,", "4357,",
	"4358,", "4359,", "4360,", "4361,",
	"4362,", "4363,"
	};
	std::string string_sizes = "1400,1500,1600,1700,1800,";
	ExpectedValuesMap expected;
	expected["arrival,"] = ExpectedValues(
	std::vector<std::string>(string_arrival,
	string_arrival +
	kNumberOfRows),
	1);
	expected["size[5],,,,,"] = ExpectedValues(
	std::vector<std::string>(10, string_sizes), 5);
	expected["timestamp,"] = ExpectedValues(
	std::vector<std::string>(string_timestamp,
	string_timestamp +
	kNumberOfRows),
	1);
	ASSERT_EQ(DataLogParser::VerifyTable(table, expected), 0);
	fclose(table);
	}

	TEST(TestDataLog, VerifyMultipleTables) {
	DataLog::CreateLog();
	DataLog::AddTable(DataLog::Combine("table", 2));
	DataLog::AddTable(DataLog::Combine("table", 3));
	DataLog::AddColumn(DataLog::Combine("table", 2), "arrival", 1);
	DataLog::AddColumn(DataLog::Combine("table", 2), "timestamp", 1);
	DataLog::AddColumn(DataLog::Combine("table", 2), "size", 1);
	DataLog::AddTable(DataLog::Combine("table", 4));
	DataLog::AddColumn(DataLog::Combine("table", 3), "timestamp", 1);
	DataLog::AddColumn(DataLog::Combine("table", 3), "arrival", 1);
	DataLog::AddColumn(DataLog::Combine("table", 4), "size", 1);
	for (int32_t i = 0; i < 10; ++i) {
	DataLog::InsertCell(DataLog::Combine("table", 2), "arrival",
	static_cast<int32_t>(i));
	DataLog::InsertCell(DataLog::Combine("table", 2), "timestamp",
	static_cast<int32_t>(4354 + i));
	DataLog::InsertCell(DataLog::Combine("table", 2), "size",
	static_cast<int32_t>(1200 + 10 * i));
	DataLog::InsertCell(DataLog::Combine("table", 3), "timestamp",
	static_cast<int32_t>(4354 + i));
	DataLog::InsertCell(DataLog::Combine("table", 3), "arrival",
	static_cast<int32_t>(i));
	DataLog::InsertCell(DataLog::Combine("table", 4), "size",
	static_cast<int32_t>(1200 + 10 * i));
	DataLog::NextRow(DataLog::Combine("table", 4));
	DataLog::NextRow(DataLog::Combine("table", 2));
	DataLog::NextRow(DataLog::Combine("table", 3));
	}
	DataLog::ReturnLog();

	// Data expected from parsing the file
	const int kNumberOfRows = 10;
	std::string string_arrival[kNumberOfRows] = {
	"0,", "1,", "2,", "3,", "4,",
	"5,", "6,", "7,", "8,", "9,"
	};
	std::string string_timestamp[kNumberOfRows] = {
	"4354,", "4355,", "4356,", "4357,",
	"4358,", "4359,", "4360,", "4361,",
	"4362,", "4363,"
	};
	std::string string_size[kNumberOfRows] = {
	"1200,", "1210,", "1220,", "1230,",
	"1240,", "1250,", "1260,", "1270,",
	"1280,", "1290,"
	};

	// Verify table 2
	{
	FILE* table = fopen("table_2.txt", "r");
	ASSERT_FALSE(table == NULL);
	ExpectedValuesMap expected;
	expected["arrival,"] = ExpectedValues(
	std::vector<std::string>(string_arrival,
	string_arrival +
	kNumberOfRows),
	1);
	expected["size,"] = ExpectedValues(
	std::vector<std::string>(string_size,
	string_size + kNumberOfRows),
	1);
	expected["timestamp,"] = ExpectedValues(
	std::vector<std::string>(string_timestamp,
	string_timestamp +
	kNumberOfRows),
	1);
	ASSERT_EQ(DataLogParser::VerifyTable(table, expected), 0);
	fclose(table);
	}

	// Verify table 3
	{
	FILE* table = fopen("table_3.txt", "r");
	ASSERT_FALSE(table == NULL);
	ExpectedValuesMap expected;
	expected["arrival,"] = ExpectedValues(
	std::vector<std::string>(string_arrival,
	string_arrival +
	kNumberOfRows),
	1);
	expected["timestamp,"] = ExpectedValues(
	std::vector<std::string>(string_timestamp,
	string_timestamp +
	kNumberOfRows),
	1);
	ASSERT_EQ(DataLogParser::VerifyTable(table, expected), 0);
	fclose(table);
	}

	// Verify table 4
	{
	FILE* table = fopen("table_4.txt", "r");
	ASSERT_FALSE(table == NULL);
	ExpectedValuesMap expected;
	expected["size,"] = ExpectedValues(
	std::vector<std::string>(string_size,
	string_size +
	kNumberOfRows),
	1);
	ASSERT_EQ(DataLogParser::VerifyTable(table, expected), 0);
	fclose(table);
	}
	}

	TEST(TestDataLogCWrapper, VerifyCWrapper) {
	// Simply call all C wrapper log functions through the C helper unittests.
	// Main purpose is to make sure that the linkage is correct.

	EXPECT_EQ(0, WebRtcDataLogCHelper_TestCreateLog());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestCombine());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestAddTable());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestAddColumn());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_int());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_int());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_float());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_float());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_double());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_double());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_int32());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_int32());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_uint32());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_uint32());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertCell_int64());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestInsertArray_int64());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestNextRow());
	EXPECT_EQ(0, WebRtcDataLogCHelper_TestReturnLog());
	}