media/mtp/tests/MtpFfsHandle_test.cpp - platform/frameworks/av - Git at Google

 /*
  * Copyright 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #define LOG_TAG "MtpFfsHandle_test.cpp"

 #include <android-base/unique_fd.h>
 #include <android-base/test_utils.h>
 #include <fcntl.h>
 #include <gtest/gtest.h>
 #include <memory>
 #include <random>
 #include <string>
 #include <unistd.h>
 #include <utils/Log.h>

 #include "MtpFfsHandle.h"

 namespace android {

 constexpr int MAX_FILE_CHUNK_SIZE = 3 * 1024 * 1024;

 constexpr int TEST_PACKET_SIZE = 512;
 constexpr int SMALL_MULT = 30;
 constexpr int MED_MULT = 510;

 static const std::string dummyDataStr =
     "/*\n * Copyright 2015 The Android Open Source Project\n *\n * Licensed un"
     "der the Apache License, Version 2.0 (the \"License\");\n * you may not us"
     "e this file except in compliance with the License.\n * You may obtain a c"
     "opy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE"
     "-2.0\n *\n * Unless required by applicable law or agreed to in writing, s"
     "oftware\n * distributed under the License is distributed on an \"AS IS\" "
     "BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express o"
     "r implied.\n * Se";

 /**
  * Functional tests for the MtpFfsHandle class. Ensures header and data integrity
  * by mocking ffs endpoints as pipes to capture input / output.
  */
 class MtpFfsHandleTest : public ::testing::Test {
 protected:
     std::unique_ptr<IMtpHandle> handle;

     // Pipes for reading endpoint data
     android::base::unique_fd bulk_in;
     android::base::unique_fd bulk_out;
     android::base::unique_fd intr;

     TemporaryFile dummy_file;

     MtpFfsHandleTest() {
         int fd[2];
         handle = std::unique_ptr<IMtpHandle>(get_ffs_handle());
         MtpFfsHandle *ffs_handle = static_cast<MtpFfsHandle*>(handle.get());
         EXPECT_TRUE(ffs_handle != NULL);

         EXPECT_EQ(pipe(fd), 0);
         EXPECT_EQ(fcntl(fd[0], F_SETPIPE_SZ, 1048576), 1048576);
         bulk_in.reset(fd[0]);
         ffs_handle->mBulkIn.reset(fd[1]);

         EXPECT_EQ(pipe(fd), 0);
         EXPECT_EQ(fcntl(fd[0], F_SETPIPE_SZ, 1048576), 1048576);
         bulk_out.reset(fd[1]);
         ffs_handle->mBulkOut.reset(fd[0]);

         EXPECT_EQ(pipe(fd), 0);
         intr.reset(fd[0]);
         ffs_handle->mIntr.reset(fd[1]);

         ffs_handle->mBuffer1.resize(MAX_FILE_CHUNK_SIZE);
         ffs_handle->mBuffer2.resize(MAX_FILE_CHUNK_SIZE);
     }

     ~MtpFfsHandleTest() {}
 };

 TEST_F(MtpFfsHandleTest, testRead) {
     EXPECT_EQ(write(bulk_out, dummyDataStr.c_str(), TEST_PACKET_SIZE), TEST_PACKET_SIZE);
     char buf[TEST_PACKET_SIZE + 1];
     buf[TEST_PACKET_SIZE] = '\0';
     EXPECT_EQ(handle->read(buf, TEST_PACKET_SIZE), TEST_PACKET_SIZE);
     EXPECT_STREQ(buf, dummyDataStr.c_str());
 }

 TEST_F(MtpFfsHandleTest, testWrite) {
     char buf[TEST_PACKET_SIZE + 1];
     buf[TEST_PACKET_SIZE] = '\0';
     EXPECT_EQ(handle->write(dummyDataStr.c_str(), TEST_PACKET_SIZE), TEST_PACKET_SIZE);
     EXPECT_EQ(read(bulk_in, buf, TEST_PACKET_SIZE), TEST_PACKET_SIZE);
     EXPECT_STREQ(buf, dummyDataStr.c_str());
 }

 TEST_F(MtpFfsHandleTest, testReceiveFileSmall) {
     std::stringstream ss;
     mtp_file_range mfr;
     int size = TEST_PACKET_SIZE * SMALL_MULT;
     char buf[size + 1];
     buf[size] = '\0';

     mfr.length = size;
     mfr.fd = dummy_file.fd;
     for (int i = 0; i < SMALL_MULT; i++)
         ss << dummyDataStr;

     EXPECT_EQ(write(bulk_out, ss.str().c_str(), size), size);
     EXPECT_EQ(handle->receiveFile(mfr, false), 0);

     EXPECT_EQ(read(dummy_file.fd, buf, size), size);

     EXPECT_STREQ(buf, ss.str().c_str());
 }

 TEST_F(MtpFfsHandleTest, testReceiveFileMed) {
     std::stringstream ss;
     mtp_file_range mfr;
     int size = TEST_PACKET_SIZE * MED_MULT;
     char buf[size + 1];
     buf[size] = '\0';

     mfr.length = size;
     mfr.fd = dummy_file.fd;
     for (int i = 0; i < MED_MULT; i++)
         ss << dummyDataStr;

     EXPECT_EQ(write(bulk_out, ss.str().c_str(), size), size);
     EXPECT_EQ(handle->receiveFile(mfr, false), 0);

     EXPECT_EQ(read(dummy_file.fd, buf, size), size);

     EXPECT_STREQ(buf, ss.str().c_str());
 }

 TEST_F(MtpFfsHandleTest, testSendFileSmall) {
     std::stringstream ss;
     mtp_file_range mfr;
     mfr.command = 42;
     mfr.transaction_id = 1337;
     mfr.offset = 0;
     int size = TEST_PACKET_SIZE * SMALL_MULT;
     char buf[size + sizeof(mtp_data_header) + 1];
     buf[size + sizeof(mtp_data_header)] = '\0';

     mfr.length = size;
     mfr.fd = dummy_file.fd;
     for (int i = 0; i < SMALL_MULT; i++)
         ss << dummyDataStr;

     EXPECT_EQ(write(dummy_file.fd, ss.str().c_str(), size), size);
     EXPECT_EQ(handle->sendFile(mfr), 0);

     EXPECT_EQ(read(bulk_in, buf, size + sizeof(mtp_data_header)),
             static_cast<long>(size + sizeof(mtp_data_header)));

     struct mtp_data_header *header = reinterpret_cast<struct mtp_data_header*>(buf);
     EXPECT_STREQ(buf + sizeof(mtp_data_header), ss.str().c_str());
     EXPECT_EQ(header->length, static_cast<unsigned int>(size + sizeof(mtp_data_header)));
     EXPECT_EQ(header->type, static_cast<unsigned int>(2));
     EXPECT_EQ(header->command, static_cast<unsigned int>(42));
     EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
 }

 TEST_F(MtpFfsHandleTest, testSendFileMed) {
     std::stringstream ss;
     mtp_file_range mfr;
     mfr.command = 42;
     mfr.transaction_id = 1337;
     mfr.offset = 0;
     int size = TEST_PACKET_SIZE * MED_MULT;
     char buf[size + sizeof(mtp_data_header) + 1];
     buf[size + sizeof(mtp_data_header)] = '\0';

     mfr.length = size;
     mfr.fd = dummy_file.fd;
     for (int i = 0; i < MED_MULT; i++)
         ss << dummyDataStr;

     EXPECT_EQ(write(dummy_file.fd, ss.str().c_str(), size), size);
     EXPECT_EQ(handle->sendFile(mfr), 0);

     EXPECT_EQ(read(bulk_in, buf, size + sizeof(mtp_data_header)),
             static_cast<long>(size + sizeof(mtp_data_header)));

     struct mtp_data_header *header = reinterpret_cast<struct mtp_data_header*>(buf);
     EXPECT_STREQ(buf + sizeof(mtp_data_header), ss.str().c_str());
     EXPECT_EQ(header->length, static_cast<unsigned int>(size + sizeof(mtp_data_header)));
     EXPECT_EQ(header->type, static_cast<unsigned int>(2));
     EXPECT_EQ(header->command, static_cast<unsigned int>(42));
     EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
 }

 TEST_F(MtpFfsHandleTest, testSendFileMedPartial) {
     std::stringstream ss;
     mtp_file_range mfr;
     mfr.fd = dummy_file.fd;
     mfr.command = 42;
     mfr.transaction_id = 1337;
     int size = TEST_PACKET_SIZE * MED_MULT;
     char buf[size + 1];
     buf[size] = '\0';

     for (int i = 0; i < MED_MULT; i++)
         ss << dummyDataStr;

     EXPECT_EQ(write(dummy_file.fd, ss.str().c_str(), size), size);

     std::random_device rd;
     std::mt19937 gen(rd());
     std::uniform_int_distribution<> dis(1, TEST_PACKET_SIZE);
     int offset = 0;
     while (offset != size) {
         mfr.offset = offset;
         int length = std::min(size - offset, dis(gen));
         mfr.length = length;
         char temp_buf[length + sizeof(mtp_data_header)];
         EXPECT_EQ(handle->sendFile(mfr), 0);

         EXPECT_EQ(read(bulk_in, temp_buf, length + sizeof(mtp_data_header)),
                 static_cast<long>(length + sizeof(mtp_data_header)));

         struct mtp_data_header *header = reinterpret_cast<struct mtp_data_header*>(temp_buf);
         EXPECT_EQ(header->length, static_cast<unsigned int>(length + sizeof(mtp_data_header)));
         EXPECT_EQ(header->type, static_cast<unsigned int>(2));
         EXPECT_EQ(header->command, static_cast<unsigned int>(42));
         EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
         memcpy(buf + offset, temp_buf + sizeof(mtp_data_header), length);
         offset += length;
     }
     EXPECT_STREQ(buf, ss.str().c_str());
 }

 TEST_F(MtpFfsHandleTest, testSendFileEmpty) {
     mtp_file_range mfr;
     mfr.command = 42;
     mfr.transaction_id = 1337;
     mfr.offset = 0;
     int size = 0;
     char buf[size + sizeof(mtp_data_header) + 1];
     buf[size + sizeof(mtp_data_header)] = '\0';

     mfr.length = size;
     mfr.fd = dummy_file.fd;

     EXPECT_EQ(handle->sendFile(mfr), 0);

     EXPECT_EQ(read(bulk_in, buf, size + sizeof(mtp_data_header)),
             static_cast<long>(size + sizeof(mtp_data_header)));

     struct mtp_data_header *header = reinterpret_cast<struct mtp_data_header*>(buf);
     EXPECT_EQ(header->length, static_cast<unsigned int>(size + sizeof(mtp_data_header)));
     EXPECT_EQ(header->type, static_cast<unsigned int>(2));
     EXPECT_EQ(header->command, static_cast<unsigned int>(42));
     EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
 }

 TEST_F(MtpFfsHandleTest, testSendEvent) {
     struct mtp_event event;
     event.length = TEST_PACKET_SIZE;
     event.data = const_cast<char*>(dummyDataStr.c_str());
     char buf[TEST_PACKET_SIZE + 1];
     buf[TEST_PACKET_SIZE] = '\0';

     handle->sendEvent(event);
     read(intr, buf, TEST_PACKET_SIZE);
     EXPECT_STREQ(buf, dummyDataStr.c_str());
 }

 } // namespace android
	/*
	* Copyright 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#define LOG_TAG "MtpFfsHandle_test.cpp"

	#include <android-base/unique_fd.h>
	#include <android-base/test_utils.h>
	#include <fcntl.h>
	#include <gtest/gtest.h>
	#include <memory>
	#include <random>
	#include <string>
	#include <unistd.h>
	#include <utils/Log.h>

	#include "MtpFfsHandle.h"

	namespace android {

	constexpr int MAX_FILE_CHUNK_SIZE = 3 * 1024 * 1024;

	constexpr int TEST_PACKET_SIZE = 512;
	constexpr int SMALL_MULT = 30;
	constexpr int MED_MULT = 510;

	static const std::string dummyDataStr =
	"/\n Copyright 2015 The Android Open Source Project\n \n Licensed un"
	"der the Apache License, Version 2.0 (the \"License\");\n * you may not us"
	"e this file except in compliance with the License.\n * You may obtain a c"
	"opy of the License at\n \n http://www.apache.org/licenses/LICENSE"
	"-2.0\n \n Unless required by applicable law or agreed to in writing, s"
	"oftware\n * distributed under the License is distributed on an \"AS IS\" "
	"BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express o"
	"r implied.\n * Se";

	/**
	* Functional tests for the MtpFfsHandle class. Ensures header and data integrity
	* by mocking ffs endpoints as pipes to capture input / output.
	*/
	class MtpFfsHandleTest : public ::testing::Test {
	protected:
	std::unique_ptr<IMtpHandle> handle;

	// Pipes for reading endpoint data
	android::base::unique_fd bulk_in;
	android::base::unique_fd bulk_out;
	android::base::unique_fd intr;

	TemporaryFile dummy_file;

	MtpFfsHandleTest() {
	int fd[2];
	handle = std::unique_ptr<IMtpHandle>(get_ffs_handle());
	MtpFfsHandle ffs_handle = static_cast<MtpFfsHandle>(handle.get());
	EXPECT_TRUE(ffs_handle != NULL);

	EXPECT_EQ(pipe(fd), 0);
	EXPECT_EQ(fcntl(fd[0], F_SETPIPE_SZ, 1048576), 1048576);
	bulk_in.reset(fd[0]);
	ffs_handle->mBulkIn.reset(fd[1]);

	EXPECT_EQ(pipe(fd), 0);
	EXPECT_EQ(fcntl(fd[0], F_SETPIPE_SZ, 1048576), 1048576);
	bulk_out.reset(fd[1]);
	ffs_handle->mBulkOut.reset(fd[0]);

	EXPECT_EQ(pipe(fd), 0);
	intr.reset(fd[0]);
	ffs_handle->mIntr.reset(fd[1]);

	ffs_handle->mBuffer1.resize(MAX_FILE_CHUNK_SIZE);
	ffs_handle->mBuffer2.resize(MAX_FILE_CHUNK_SIZE);
	}

	~MtpFfsHandleTest() {}
	};

	TEST_F(MtpFfsHandleTest, testRead) {
	EXPECT_EQ(write(bulk_out, dummyDataStr.c_str(), TEST_PACKET_SIZE), TEST_PACKET_SIZE);
	char buf[TEST_PACKET_SIZE + 1];
	buf[TEST_PACKET_SIZE] = '\0';
	EXPECT_EQ(handle->read(buf, TEST_PACKET_SIZE), TEST_PACKET_SIZE);
	EXPECT_STREQ(buf, dummyDataStr.c_str());
	}

	TEST_F(MtpFfsHandleTest, testWrite) {
	char buf[TEST_PACKET_SIZE + 1];
	buf[TEST_PACKET_SIZE] = '\0';
	EXPECT_EQ(handle->write(dummyDataStr.c_str(), TEST_PACKET_SIZE), TEST_PACKET_SIZE);
	EXPECT_EQ(read(bulk_in, buf, TEST_PACKET_SIZE), TEST_PACKET_SIZE);
	EXPECT_STREQ(buf, dummyDataStr.c_str());
	}

	TEST_F(MtpFfsHandleTest, testReceiveFileSmall) {
	std::stringstream ss;
	mtp_file_range mfr;
	int size = TEST_PACKET_SIZE * SMALL_MULT;
	char buf[size + 1];
	buf[size] = '\0';

	mfr.length = size;
	mfr.fd = dummy_file.fd;
	for (int i = 0; i < SMALL_MULT; i++)
	ss << dummyDataStr;

	EXPECT_EQ(write(bulk_out, ss.str().c_str(), size), size);
	EXPECT_EQ(handle->receiveFile(mfr, false), 0);

	EXPECT_EQ(read(dummy_file.fd, buf, size), size);

	EXPECT_STREQ(buf, ss.str().c_str());
	}

	TEST_F(MtpFfsHandleTest, testReceiveFileMed) {
	std::stringstream ss;
	mtp_file_range mfr;
	int size = TEST_PACKET_SIZE * MED_MULT;
	char buf[size + 1];
	buf[size] = '\0';

	mfr.length = size;
	mfr.fd = dummy_file.fd;
	for (int i = 0; i < MED_MULT; i++)
	ss << dummyDataStr;

	EXPECT_EQ(write(bulk_out, ss.str().c_str(), size), size);
	EXPECT_EQ(handle->receiveFile(mfr, false), 0);

	EXPECT_EQ(read(dummy_file.fd, buf, size), size);

	EXPECT_STREQ(buf, ss.str().c_str());
	}

	TEST_F(MtpFfsHandleTest, testSendFileSmall) {
	std::stringstream ss;
	mtp_file_range mfr;
	mfr.command = 42;
	mfr.transaction_id = 1337;
	mfr.offset = 0;
	int size = TEST_PACKET_SIZE * SMALL_MULT;
	char buf[size + sizeof(mtp_data_header) + 1];
	buf[size + sizeof(mtp_data_header)] = '\0';

	mfr.length = size;
	mfr.fd = dummy_file.fd;
	for (int i = 0; i < SMALL_MULT; i++)
	ss << dummyDataStr;

	EXPECT_EQ(write(dummy_file.fd, ss.str().c_str(), size), size);
	EXPECT_EQ(handle->sendFile(mfr), 0);

	EXPECT_EQ(read(bulk_in, buf, size + sizeof(mtp_data_header)),
	static_cast<long>(size + sizeof(mtp_data_header)));

	struct mtp_data_header header = reinterpret_cast<struct mtp_data_header>(buf);
	EXPECT_STREQ(buf + sizeof(mtp_data_header), ss.str().c_str());
	EXPECT_EQ(header->length, static_cast<unsigned int>(size + sizeof(mtp_data_header)));
	EXPECT_EQ(header->type, static_cast<unsigned int>(2));
	EXPECT_EQ(header->command, static_cast<unsigned int>(42));
	EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
	}

	TEST_F(MtpFfsHandleTest, testSendFileMed) {
	std::stringstream ss;
	mtp_file_range mfr;
	mfr.command = 42;
	mfr.transaction_id = 1337;
	mfr.offset = 0;
	int size = TEST_PACKET_SIZE * MED_MULT;
	char buf[size + sizeof(mtp_data_header) + 1];
	buf[size + sizeof(mtp_data_header)] = '\0';

	mfr.length = size;
	mfr.fd = dummy_file.fd;
	for (int i = 0; i < MED_MULT; i++)
	ss << dummyDataStr;

	EXPECT_EQ(write(dummy_file.fd, ss.str().c_str(), size), size);
	EXPECT_EQ(handle->sendFile(mfr), 0);

	EXPECT_EQ(read(bulk_in, buf, size + sizeof(mtp_data_header)),
	static_cast<long>(size + sizeof(mtp_data_header)));

	struct mtp_data_header header = reinterpret_cast<struct mtp_data_header>(buf);
	EXPECT_STREQ(buf + sizeof(mtp_data_header), ss.str().c_str());
	EXPECT_EQ(header->length, static_cast<unsigned int>(size + sizeof(mtp_data_header)));
	EXPECT_EQ(header->type, static_cast<unsigned int>(2));
	EXPECT_EQ(header->command, static_cast<unsigned int>(42));
	EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
	}

	TEST_F(MtpFfsHandleTest, testSendFileMedPartial) {
	std::stringstream ss;
	mtp_file_range mfr;
	mfr.fd = dummy_file.fd;
	mfr.command = 42;
	mfr.transaction_id = 1337;
	int size = TEST_PACKET_SIZE * MED_MULT;
	char buf[size + 1];
	buf[size] = '\0';

	for (int i = 0; i < MED_MULT; i++)
	ss << dummyDataStr;

	EXPECT_EQ(write(dummy_file.fd, ss.str().c_str(), size), size);

	std::random_device rd;
	std::mt19937 gen(rd());
	std::uniform_int_distribution<> dis(1, TEST_PACKET_SIZE);
	int offset = 0;
	while (offset != size) {
	mfr.offset = offset;
	int length = std::min(size - offset, dis(gen));
	mfr.length = length;
	char temp_buf[length + sizeof(mtp_data_header)];
	EXPECT_EQ(handle->sendFile(mfr), 0);

	EXPECT_EQ(read(bulk_in, temp_buf, length + sizeof(mtp_data_header)),
	static_cast<long>(length + sizeof(mtp_data_header)));

	struct mtp_data_header header = reinterpret_cast<struct mtp_data_header>(temp_buf);
	EXPECT_EQ(header->length, static_cast<unsigned int>(length + sizeof(mtp_data_header)));
	EXPECT_EQ(header->type, static_cast<unsigned int>(2));
	EXPECT_EQ(header->command, static_cast<unsigned int>(42));
	EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
	memcpy(buf + offset, temp_buf + sizeof(mtp_data_header), length);
	offset += length;
	}
	EXPECT_STREQ(buf, ss.str().c_str());
	}

	TEST_F(MtpFfsHandleTest, testSendFileEmpty) {
	mtp_file_range mfr;
	mfr.command = 42;
	mfr.transaction_id = 1337;
	mfr.offset = 0;
	int size = 0;
	char buf[size + sizeof(mtp_data_header) + 1];
	buf[size + sizeof(mtp_data_header)] = '\0';

	mfr.length = size;
	mfr.fd = dummy_file.fd;

	EXPECT_EQ(handle->sendFile(mfr), 0);

	EXPECT_EQ(read(bulk_in, buf, size + sizeof(mtp_data_header)),
	static_cast<long>(size + sizeof(mtp_data_header)));

	struct mtp_data_header header = reinterpret_cast<struct mtp_data_header>(buf);
	EXPECT_EQ(header->length, static_cast<unsigned int>(size + sizeof(mtp_data_header)));
	EXPECT_EQ(header->type, static_cast<unsigned int>(2));
	EXPECT_EQ(header->command, static_cast<unsigned int>(42));
	EXPECT_EQ(header->transaction_id, static_cast<unsigned int>(1337));
	}

	TEST_F(MtpFfsHandleTest, testSendEvent) {
	struct mtp_event event;
	event.length = TEST_PACKET_SIZE;
	event.data = const_cast<char*>(dummyDataStr.c_str());
	char buf[TEST_PACKET_SIZE + 1];
	buf[TEST_PACKET_SIZE] = '\0';

	handle->sendEvent(event);
	read(intr, buf, TEST_PACKET_SIZE);
	EXPECT_STREQ(buf, dummyDataStr.c_str());
	}

	} // namespace android