Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ffd6c31a authored by Dan Albert's avatar Dan Albert
Browse files

Add tests for read_block_adb. 

These tests aren't completely representative in that they don't run in
the recovery image. We might want to look in to adding a self-test
option to the recovery UI. Until then, these can be run on a normal
device (which is easier to do anyway).

Bug: 19522788
Change-Id: Idb20feb55d10c62905c2480ab1b61a2e4b5f60d8
parent cab0beb9

minadbd/Android.mk

+21 −8
Original line number Diff line number Diff line
@@ -2,6 +2,12 @@ 


LOCAL_PATH:= $(call my-dir)



minadbd_cflags := \

    -Wall -Werror \

    -Wno-unused-parameter \

    -Wno-missing-field-initializers \

    -DADB_HOST=0 \



include $(CLEAR_VARS)



LOCAL_SRC_FILES := \
@@ -9,15 +15,22 @@ LOCAL_SRC_FILES := \ 
    fuse_adb_provider.c \

    services.c \



LOCAL_CFLAGS := \

    -Wall -Werror \

    -Wno-unused-parameter \

    -Wimplicit-function-declaration \

    -DADB_HOST=0 \



LOCAL_MODULE := libminadbd

LOCAL_CFLAGS := $(minadbd_cflags)

LOCAL_CONLY_FLAGS := -Wimplicit-function-declaration

LOCAL_C_INCLUDES := bootable/recovery system/core/adb

LOCAL_WHOLE_STATIC_LIBRARIES := libadbd



LOCAL_MODULE := libminadbd



include $(BUILD_STATIC_LIBRARY)



include $(CLEAR_VARS)



LOCAL_CLANG := true

LOCAL_MODULE := minadbd_test

LOCAL_SRC_FILES := fuse_adb_provider_test.cpp

LOCAL_CFLAGS := $(minadbd_cflags)

LOCAL_C_INCLUDES := $(LOCAL_PATH) system/core/adb

LOCAL_STATIC_LIBRARIES := libminadbd

LOCAL_SHARED_LIBRARIES := liblog libutils



include $(BUILD_NATIVE_TEST)

minadbd/fuse_adb_provider.c

+3 −8
Original line number Diff line number Diff line
@@ -23,16 +23,11 @@ 


#include "adb.h"

#include "adb_io.h"

#include "fuse_adb_provider.h"

#include "fuse_sideload.h"



struct adb_data {

    int sfd;  // file descriptor for the adb channel



    uint64_t file_size;

    uint32_t block_size;

};



static int read_block_adb(void* cookie, uint32_t block, uint8_t* buffer, uint32_t fetch_size) {

int read_block_adb(void* cookie, uint32_t block, uint8_t* buffer,

                   uint32_t fetch_size) {

    struct adb_data* ad = (struct adb_data*)cookie;



    char buf[10];

minadbd/fuse_adb_provider.h

+11 −0
Original line number Diff line number Diff line
@@ -17,10 +17,21 @@ 
#ifndef __FUSE_ADB_PROVIDER_H

#define __FUSE_ADB_PROVIDER_H



#include <stdint.h>



#ifdef __cplusplus

extern "C" {

#endif



struct adb_data {

    int sfd;  // file descriptor for the adb channel



    uint64_t file_size;

    uint32_t block_size;

};



int read_block_adb(void* cookie, uint32_t block, uint8_t* buffer,

                   uint32_t fetch_size);

int run_adb_fuse(int sfd, uint64_t file_size, uint32_t block_size);



#ifdef __cplusplus

minadbd/fuse_adb_provider_test.cpp

0 → 100644
+89 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2015 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 "fuse_adb_provider.h"



#include <gtest/gtest.h>



#include <errno.h>

#include <fcntl.h>

#include <sys/socket.h>



#include <string>



#include "adb_io.h"

#include "utils/file.h"



TEST(fuse_adb_provider, read_block_adb) {

  adb_data data = {};

  int sockets[2];



  ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, sockets));

  data.sfd = sockets[0];



  int host_socket = sockets[1];

  fcntl(host_socket, F_SETFL, O_NONBLOCK);



  const char expected_data[] = "foobar";

  char block_data[sizeof(expected_data)] = {};



  // If we write the result of read_block_adb's request before the request is

  // actually made we can avoid needing an extra thread for this test.

  ASSERT_TRUE(WriteFdExactly(host_socket, expected_data,

                             strlen(expected_data)));



  uint32_t block = 1234U;

  const char expected_block[] = "00001234";

  ASSERT_EQ(0, read_block_adb(reinterpret_cast<void*>(&data), block,

                              reinterpret_cast<uint8_t*>(block_data),

                              sizeof(expected_data) - 1));



  // Check that read_block_adb requested the right block.

  char block_req[sizeof(expected_block)] = {};

  ASSERT_TRUE(ReadFdExactly(host_socket, block_req, 8));

  ASSERT_EQ(0, block_req[8]);

  ASSERT_EQ(8U, strlen(block_req));

  ASSERT_STREQ(expected_block, block_req);



  // Check that read_block_adb returned the right data.

  ASSERT_EQ(0, block_req[8]);

  ASSERT_STREQ(expected_data, block_data);



  // Check that nothing else was written to the socket.

  char tmp;

  errno = 0;

  ASSERT_EQ(-1, read(host_socket, &tmp, 1));

  ASSERT_EQ(EWOULDBLOCK, errno);



  close(sockets[0]);

  close(sockets[1]);

}



TEST(fuse_adb_provider, read_block_adb_fail_write) {

  adb_data data = {};

  int sockets[2];



  ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, sockets));

  data.sfd = sockets[0];



  ASSERT_EQ(0, close(sockets[1]));



  char buf[1];

  ASSERT_EQ(-EIO, read_block_adb(reinterpret_cast<void*>(&data), 0,

                                 reinterpret_cast<uint8_t*>(buf), 1));



  close(sockets[0]);

}