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

Commit b8e20f55 authored by Colin Cross's avatar Colin Cross
Browse files

Compile some tests for the host 

Compile some tests for the host to ease debugging with valgrind or gdb.

Bug: 27208635
Change-Id: Ib46fcfa333ceb721f26efca00b2fa60b9fba44e6
parent a996c296

libmemunreachable/Allocator.cpp

+2 −2
Original line number Diff line number Diff line
@@ -370,11 +370,11 @@ void* HeapImpl::Alloc(size_t size) { 
}



void* HeapImpl::AllocLocked(size_t size) {

  if (__predict_false(size > kMaxBucketAllocationSize)) {

  if (size > kMaxBucketAllocationSize) {

    return MapAlloc(size);

  }

  int bucket = size_to_bucket(size);

  if (__predict_false(free_chunks_[bucket].empty())) {

  if (free_chunks_[bucket].empty()) {

    Chunk *chunk = new Chunk(this, bucket);

    free_chunks_[bucket].insert(chunk->node_);

  }

libmemunreachable/Android.mk

+17 −0
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ memunreachable_srcs := \ 


memunreachable_test_srcs := \

   tests/Allocator_test.cpp \

   tests/DisableMalloc_test.cpp \

   tests/HeapWalker_test.cpp \

   tests/MemUnreachable_test.cpp \

   tests/ThreadCapture_test.cpp \
@@ -41,3 +42,19 @@ LOCAL_CLANG := true 
LOCAL_SHARED_LIBRARIES := libmemunreachable libbase liblog



include $(BUILD_NATIVE_TEST)



include $(CLEAR_VARS)



LOCAL_MODULE := memunreachable_test

LOCAL_SRC_FILES := \

   Allocator.cpp \

   HeapWalker.cpp  \

   tests/Allocator_test.cpp \

   tests/HeapWalker_test.cpp \

   tests/HostMallocStub.cpp \



LOCAL_CFLAGS := -std=c++14 -Wall -Wextra -Werror

LOCAL_CLANG := true

LOCAL_SHARED_LIBRARIES := libbase liblog



include $(BUILD_HOST_NATIVE_TEST)

libmemunreachable/ScopedAlarm.h

+1 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#define LIBMEMUNREACHABLE_SCOPED_ALARM_H_



#include <signal.h>

#include <sys/time.h>



#include <chrono>

#include <functional>

libmemunreachable/bionic.h

+2 −0
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ 
#define LIBMEMUNREACHABLE_BIONIC_H_



#include <sys/cdefs.h>

#include <stdint.h>

#include <stdlib.h>



__BEGIN_DECLS

libmemunreachable/tests/Allocator_test.cpp

+0 −99
Original line number Diff line number Diff line
@@ -15,12 +15,6 @@ 
 */



#include <Allocator.h>

#include <sys/time.h>



#include <chrono>

#include <functional>

#include <list>

#include <vector>



#include <gtest/gtest.h>

#include <ScopedDisableMalloc.h>
@@ -28,8 +22,6 @@ 


std::function<void()> ScopedAlarm::func_;



using namespace std::chrono_literals;



class AllocatorTest : public testing::Test {

 protected:

  AllocatorTest() : heap(), disable_malloc_() {}
@@ -180,94 +172,3 @@ TEST_F(AllocatorTest, unique) { 


  ASSERT_NE(ptr, nullptr);

}
 


class DisableMallocTest : public ::testing::Test {

 protected:

  void alarm(std::chrono::microseconds us) {

    std::chrono::seconds s = std::chrono::duration_cast<std::chrono::seconds>(us);

    itimerval t = itimerval();

    t.it_value.tv_sec = s.count();

    t.it_value.tv_usec = (us - s).count();

    setitimer(ITIMER_REAL, &t, NULL);

  }

};



TEST_F(DisableMallocTest, reenable) {

  ASSERT_EXIT({

    alarm(100ms);

    void *ptr1 = malloc(128);

    ASSERT_NE(ptr1, nullptr);

    free(ptr1);

    {

      ScopedDisableMalloc disable_malloc;

    }

    void *ptr2 = malloc(128);

    ASSERT_NE(ptr2, nullptr);

    free(ptr2);

    _exit(1);

  }, ::testing::ExitedWithCode(1), "");

}



TEST_F(DisableMallocTest, deadlock_allocate) {

  ASSERT_DEATH({

    void *ptr = malloc(128);

    ASSERT_NE(ptr, nullptr);

    free(ptr);

    {

      alarm(100ms);

      ScopedDisableMalloc disable_malloc;

      void* ptr = malloc(128);

      ASSERT_NE(ptr, nullptr);

      free(ptr);

    }

  }, "");

}



TEST_F(DisableMallocTest, deadlock_new) {

  ASSERT_DEATH({

    char* ptr = new(char);

    ASSERT_NE(ptr, nullptr);

    delete(ptr);

    {

      alarm(100ms);

      ScopedDisableMalloc disable_malloc;

      char* ptr = new(char);

      ASSERT_NE(ptr, nullptr);

      delete(ptr);

    }

  }, "");

}



TEST_F(DisableMallocTest, deadlock_delete) {

  ASSERT_DEATH({

    char* ptr = new(char);

    ASSERT_NE(ptr, nullptr);

    {

      alarm(250ms);

      ScopedDisableMalloc disable_malloc;

      delete(ptr);

    }

  }, "");

}



TEST_F(DisableMallocTest, deadlock_free) {

  ASSERT_DEATH({

    void *ptr = malloc(128);

    ASSERT_NE(ptr, nullptr);

    {

      alarm(100ms);

      ScopedDisableMalloc disable_malloc;

      free(ptr);

    }

  }, "");

}



TEST_F(DisableMallocTest, deadlock_fork) {

  ASSERT_DEATH({

    {

      alarm(100ms);

      ScopedDisableMalloc disable_malloc;

      fork();

    }

  }, "");

}