v811_spc009/test/vts/drivers/resource/hidl_handle_driver/VtsHidlHandleDriverTest.cpp

//
// Copyright 2018 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.
//

#include "hidl_handle_driver/VtsHidlHandleDriver.h"

#include <errno.h>
#include <fcntl.h>
#include <gtest/gtest.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

using namespace std;

static constexpr const char* kTestFilePath = "/data/local/tmp/test.txt";

namespace android {
namespace vts {

// Unit test to test operations on hidl_memory_driver.
class HidlHandleDriverUnitTest : public ::testing::Test {
 protected:
  virtual void SetUp() {
    // Register handle objects.
    client1_id_ = handle_driver_.CreateFileHandle(string(kTestFilePath),
                                                  O_RDWR | O_CREAT | O_TRUNC,
                                                  S_IRWXG, vector<int>());
    client2_id_ = handle_driver_.CreateFileHandle(string(kTestFilePath),
                                                  O_RDONLY, 0, vector<int>());
    ASSERT_NE(client1_id_, -1);
    ASSERT_NE(client2_id_, -1);
  }

  virtual void TearDown() {
    ASSERT_TRUE(handle_driver_.UnregisterHidlHandle(client1_id_));
    ASSERT_TRUE(handle_driver_.UnregisterHidlHandle(client2_id_));
    // Delete files for testing.
    remove(kTestFilePath);
  }

  VtsHidlHandleDriver handle_driver_;
  int client1_id_;
  int client2_id_;
};

// Tests trying to write to an invalid handle object.
TEST_F(HidlHandleDriverUnitTest, InvalidHandleId) {
  // Invalid ID: 42, tries to read 10 bytes.
  ASSERT_EQ(handle_driver_.WriteFile(42, nullptr, 10), -1);
}

// Tests reader doesn't have the permission to edit test.txt.
TEST_F(HidlHandleDriverUnitTest, ReaderInvalidWrite) {
  char write_data[10];
  ASSERT_EQ(handle_driver_.WriteFile(client2_id_, write_data, 10), -1);
}

// Tests unregistering a handle and using that handle after returns error.
TEST_F(HidlHandleDriverUnitTest, UnregisterHandle) {
  int new_id = handle_driver_.CreateFileHandle(string(kTestFilePath), O_RDONLY,
                                               0, vector<int>());
  // Reading 0 bytes should work, because handle object is found.
  ASSERT_EQ(handle_driver_.ReadFile(new_id, nullptr, 0), 0);

  // Now unregister the handle.
  ASSERT_TRUE(handle_driver_.UnregisterHidlHandle(new_id));
  // Read 0 bytes again, this time should fail because handle object is deleted.
  ASSERT_EQ(handle_driver_.ReadFile(new_id, nullptr, 0), -1);
}

// Tests simple read/write operations on the same file from two clients.
TEST_F(HidlHandleDriverUnitTest, SimpleReadWrite) {
  string write_data = "Hello World!";

  // Writer writes to test.txt.
  ASSERT_EQ(handle_driver_.WriteFile(
                client1_id_, static_cast<const void*>(write_data.c_str()),
                write_data.length()),
            write_data.length());

  // Reader reads from test.txt.
  char read_data[write_data.length()];
  ASSERT_EQ(handle_driver_.ReadFile(client2_id_, static_cast<void*>(read_data),
                                    write_data.length()),
            write_data.length());

  ASSERT_TRUE(write_data == string(read_data, write_data.length()));
}

// Tests large read/write interaction between reader and writer.
// Writer keeps adding "abcd" at the end of the file.
// After every iteration, reader should read back one extra repeated "abcd".
TEST_F(HidlHandleDriverUnitTest, LargeReadWrite) {
  static constexpr size_t NUM_ITERS = 10;
  const string write_data = "abcd";
  string curr_correct_data = "";
  char read_data[write_data.length() * NUM_ITERS];
  char* curr_read_data_ptr = read_data;

  for (int i = 0; i < NUM_ITERS; i++) {
    // Writer writes to test1.txt.
    ASSERT_EQ(handle_driver_.WriteFile(
                  client1_id_, static_cast<const void*>(write_data.c_str()),
                  write_data.length()),
              write_data.length());

    // Reader reads from test1.txt.
    ASSERT_EQ(handle_driver_.ReadFile(client2_id_,
                                      static_cast<void*>(curr_read_data_ptr),
                                      write_data.length()),
              write_data.length());

    string curr_read_data = string(read_data, write_data.length() * (i + 1));
    curr_correct_data += write_data;
    curr_read_data_ptr += write_data.length();
    ASSERT_TRUE(curr_read_data == curr_correct_data);
  }
}

}  // namespace vts
}  // namespace android