Commit f56b2300 authored by Ben Walker's avatar Ben Walker Committed by Jim Harris
Browse files

test: Simplify the mock library 



Unify the regular mocks and the pointer mocks. Simplify
several of the #defines.

Change-Id: Ica8c69dbb70a685a55b5961b73fd7872f451c305
Signed-off-by: default avatarBen Walker <benjamin.walker@intel.com>
Reviewed-on: https://review.gerrithub.io/418884


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Chandler-Test-Pool: SPDK Automated Test System <sys_sgsw@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarChangpeng Liu <changpeng.liu@intel.com>
parent d5de73e0

include/spdk_internal/mock.h

+22 −31
Original line number Diff line number Diff line
@@ -36,41 +36,44 @@ 


#include "spdk/stdinc.h"



/* used to signify pass through */

#define MOCK_PASS_THRU (0xdeadbeef)

#define MOCK_PASS_THRU_P (void*)0xdeadbeef

/* helper for initializing struct value with mock macros */

#define MOCK_STRUCT_INIT(...) \

	{ __VA_ARGS__ }



#define DEFINE_RETURN_MOCK(fn, ret) \

	bool ut_ ## fn ## _mocked = false; \

	ret ut_ ## fn



/*

 * For controlling mocked function behavior, setting

 * and getting values from the stub, the _P macros are

 * for mocking functions that return pointer values.

 */

#define MOCK_SET(fn, ret, val) \

	ut_ ## fn = (ret)val



#define MOCK_SET_P(fn, ret, val) \

	ut_p_ ## fn = (ret)val

#define MOCK_SET(fn, val) \

	ut_ ## fn ## _mocked = true; \

	ut_ ## fn = val



#define MOCK_GET(fn) \

	ut_ ## fn



#define MOCK_GET_P(fn) \

	ut_p_ ## fn

#define MOCK_CLEAR(fn) \

	ut_ ## fn ## _mocked = false;



#define MOCK_CLEAR_P(fn) \

	ut_ ## fn ## _mocked = false; \

	ut_ ## fn = NULL;



/* for declaring function protoypes for wrappers */

#define DECLARE_WRAPPER(fn, ret, args) \

	extern bool ut_ ## fn ## _mocked; \

	extern ret ut_ ## fn; \

	ret __wrap_ ## fn args; ret __real_ ## fn args;



/* for defining the implmentation of wrappers for syscalls */

#define DEFINE_WRAPPER(fn, ret, dargs, pargs, val) \

	ret ut_ ## fn = val; \

#define DEFINE_WRAPPER(fn, ret, dargs, pargs) \

	DEFINE_RETURN_MOCK(fn, ret); \

	__attribute__((used)) ret __wrap_ ## fn dargs \

	{ \

		if (ut_ ## fn == (ret)MOCK_PASS_THRU) { \

		if (!ut_ ## fn ## _mocked) { \

			return __real_ ## fn pargs; \

		} else { \

			return MOCK_GET(fn); \
@@ -79,6 +82,7 @@ 


/* DEFINE_STUB is for defining the implmentation of stubs for SPDK funcs. */

#define DEFINE_STUB(fn, ret, dargs, val) \

	bool ut_ ## fn ## _mocked = true; \

	ret ut_ ## fn = val; \

	ret fn dargs; \

	ret fn dargs \
@@ -86,16 +90,6 @@ 
		return MOCK_GET(fn); \

	}



/* DEFINE_STUB_P macro is for stubs that return pointer values */

#define DEFINE_STUB_P(fn, ret, dargs, val) \

	ret ut_ ## fn = val; \

	ret* ut_p_ ## fn = &(ut_ ## fn); \

	ret* fn dargs; \

	ret* fn dargs \

	{ \

		return MOCK_GET_P(fn); \

	}



/* DEFINE_STUB_V macro is for stubs that don't have a return value */

#define DEFINE_STUB_V(fn, dargs) \

	void fn dargs; \
@@ -103,15 +97,12 @@ 
	{ \

	}



/* DEFINE_STUB_VP macro is for stubs that return void pointer values */

#define DEFINE_STUB_VP(fn, dargs, val) \

	void* ut_p_ ## fn = val; \

	void* fn dargs; \

	void* fn dargs \

	{ \

		return MOCK_GET_P(fn); \

#define HANDLE_RETURN_MOCK(fn) \

	if (ut_ ## fn ## _mocked) { \

		return ut_ ## fn; \

	}





/* declare wrapper protos (alphabetically please) here */

DECLARE_WRAPPER(calloc, void *, (size_t nmemb, size_t size));

lib/ut_mock/mock.c

+4 −4
Original line number Diff line number Diff line
@@ -33,13 +33,13 @@ 


#include "spdk_internal/mock.h"



DEFINE_WRAPPER(calloc, void *, (size_t nmemb, size_t size), (nmemb, size), (void *)MOCK_PASS_THRU)

DEFINE_WRAPPER(calloc, void *, (size_t nmemb, size_t size), (nmemb, size))



DEFINE_WRAPPER(pthread_mutex_init, int,

	       (pthread_mutex_t *mtx, const pthread_mutexattr_t *attr),

	       (mtx, attr), MOCK_PASS_THRU)

	       (mtx, attr))



DEFINE_WRAPPER(pthread_mutexattr_init, int,

	       (pthread_mutexattr_t *attr), (attr), MOCK_PASS_THRU)

	       (pthread_mutexattr_t *attr), (attr))



DEFINE_WRAPPER(pthread_self, pthread_t, (void), (), (pthread_t)MOCK_PASS_THRU)
 
DEFINE_WRAPPER(pthread_self, pthread_t, (void), ())

test/common/lib/test_env.c

+90 −83
Original line number Diff line number Diff line
@@ -38,64 +38,39 @@ 
#include "spdk/env.h"

#include "spdk/queue.h"



/*

 * NOTE:

 * Functions in this file are mocks for SPDK based functions

 * and work conceptually in the same way that mocks work in

 * /lib/ut_mock. However, the globals that control the behavior

 * of the mock are defined here, with each function, as

 * opposed to being defined as part of the macro that defines

 * the stub or wrapper for other types of functions. Be sure

 * to use the correct global variable naming convention when

 * working with these functions. See /lib/ut_mock for details.

 */



/*

 * these stubs have a return value set with one of the MOCK_SET macros

 */

DEFINE_STUB(spdk_process_is_primary, bool, (void), true)



DEFINE_STUB_VP(spdk_memzone_lookup, (const char *name), NULL)

DEFINE_STUB(spdk_memzone_lookup, void *, (const char *name), NULL)



/*

 * these mocks don't fit well with the library macro model because

 * they do 'something' other than just return a pre-set value

 * These mocks don't use the DEFINE_STUB macros because

 * their default implementation is more complex.

 */



/* setup the mock control to pass thru by default */

void *ut_p_spdk_memzone_reserve = MOCK_PASS_THRU_P;

DEFINE_RETURN_MOCK(spdk_memzone_reserve, void *);

void *

spdk_memzone_reserve(const char *name, size_t len, int socket_id, unsigned flags)

{

	if (ut_p_spdk_memzone_reserve &&

	    ut_p_spdk_memzone_reserve == MOCK_PASS_THRU_P) {

	HANDLE_RETURN_MOCK(spdk_memzone_reserve);



	return malloc(len);

	} else {

		return ut_p_spdk_memzone_reserve;

	}

}



/* setup the mock control to pass thru by default */

void *ut_p_spdk_memzone_reserve_aligned = MOCK_PASS_THRU_P;

DEFINE_RETURN_MOCK(spdk_memzone_reserve_aligned, void *);

void *

spdk_memzone_reserve_aligned(const char *name, size_t len, int socket_id,

			     unsigned flags, unsigned align)

{

	if (ut_p_spdk_memzone_reserve_aligned &&

	    ut_p_spdk_memzone_reserve_aligned == MOCK_PASS_THRU_P) {

	HANDLE_RETURN_MOCK(spdk_memzone_reserve_aligned);



	return malloc(len);

	} else {

		return ut_p_spdk_memzone_reserve_aligned;

	}

}



int ut_spdk_dma_malloc = (int)MOCK_PASS_THRU;

void *ut_p_spdk_dma_malloc = &ut_spdk_dma_malloc;

DEFINE_RETURN_MOCK(spdk_dma_malloc, void *);

void *

spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr)

{

	if (ut_p_spdk_dma_malloc &&

	    ut_spdk_dma_malloc == (int)MOCK_PASS_THRU) {

	HANDLE_RETURN_MOCK(spdk_dma_malloc);



	void *buf = NULL;

	if (posix_memalign(&buf, align, size)) {

		return NULL;
@@ -103,65 +78,65 @@ spdk_dma_malloc(size_t size, size_t align, uint64_t *phys_addr) 
	if (phys_addr) {

		*phys_addr = (uint64_t)buf;

	}



	return buf;

	} else {

		return ut_p_spdk_dma_malloc;

	}

}



int ut_spdk_dma_zmalloc = (int)MOCK_PASS_THRU;

void *ut_p_spdk_dma_zmalloc = &ut_spdk_dma_zmalloc;

DEFINE_RETURN_MOCK(spdk_dma_zmalloc, void *);

void *

spdk_dma_zmalloc(size_t size, size_t align, uint64_t *phys_addr)

{

	if (ut_p_spdk_dma_zmalloc &&

	    ut_spdk_dma_zmalloc == (int)MOCK_PASS_THRU) {

	HANDLE_RETURN_MOCK(spdk_dma_zmalloc);



	void *buf = spdk_dma_malloc(size, align, phys_addr);



	if (buf != NULL) {

		memset(buf, 0, size);

	}

	return buf;

	} else {

		return ut_p_spdk_dma_zmalloc;

	}

}



DEFINE_RETURN_MOCK(spdk_dma_malloc_socket, void *);

void *

spdk_dma_malloc_socket(size_t size, size_t align, uint64_t *phys_addr, int socket_id)

{

	HANDLE_RETURN_MOCK(spdk_dma_malloc_socket);



	return spdk_dma_malloc(size, align, phys_addr);

}



DEFINE_RETURN_MOCK(spdk_dma_zmalloc_socket, void *);

void *

spdk_dma_zmalloc_socket(size_t size, size_t align, uint64_t *phys_addr, int socket_id)

{

	HANDLE_RETURN_MOCK(spdk_dma_zmalloc_socket);



	return spdk_dma_zmalloc(size, align, phys_addr);

}



DEFINE_RETURN_MOCK(spdk_dma_realloc, void *);

void *

spdk_dma_realloc(void *buf, size_t size, size_t align, uint64_t *phys_addr)

{

	HANDLE_RETURN_MOCK(spdk_dma_realloc);



	return realloc(buf, size);

}



void spdk_dma_free(void *buf)

void

spdk_dma_free(void *buf)

{

	if (ut_p_spdk_dma_zmalloc &&

	    ut_spdk_dma_zmalloc == (int)MOCK_PASS_THRU) {

	free(buf);

}

}



bool ut_fail_vtophys = false;

uint64_t spdk_vtophys(void *buf)

DEFINE_RETURN_MOCK(spdk_vtophys, uint64_t);

uint64_t

spdk_vtophys(void *buf)

{

	if (ut_fail_vtophys) {

		return (uint64_t) - 1;

	} else {

	HANDLE_RETURN_MOCK(spdk_vtophys);



	return (uintptr_t)buf;

}

}



void

spdk_memzone_dump(FILE *f)
@@ -169,9 +144,12 @@ spdk_memzone_dump(FILE *f) 
	return;

}



DEFINE_RETURN_MOCK(spdk_memzone_free, int);

int

spdk_memzone_free(const char *name)

{

	HANDLE_RETURN_MOCK(spdk_memzone_free);



	return 0;

}
@@ -179,12 +157,15 @@ struct test_mempool { 
	size_t	count;

};



DEFINE_RETURN_MOCK(spdk_mempool_create, struct spdk_mempool *);

struct spdk_mempool *

spdk_mempool_create(const char *name, size_t count,

		    size_t ele_size, size_t cache_size, int socket_id)

{

	struct test_mempool *mp;



	HANDLE_RETURN_MOCK(spdk_mempool_create);



	mp = calloc(1, sizeof(*mp));

	if (mp == NULL) {

		return NULL;
@@ -203,16 +184,14 @@ spdk_mempool_free(struct spdk_mempool *_mp) 
	free(mp);

}



bool ut_spdk_mempool_get = false;

DEFINE_RETURN_MOCK(spdk_mempool_get, void *);

void *

spdk_mempool_get(struct spdk_mempool *_mp)

{

	struct test_mempool *mp = (struct test_mempool *)_mp;

	void *buf;



	if (ut_spdk_mempool_get) {

		return NULL;

	}

	HANDLE_RETURN_MOCK(spdk_mempool_get);



	if (mp && mp->count == 0) {

		return NULL;
@@ -259,11 +238,14 @@ spdk_mempool_put_bulk(struct spdk_mempool *mp, void **ele_arr, size_t count) 
	}

}



DEFINE_RETURN_MOCK(spdk_mempool_count, size_t);

size_t

spdk_mempool_count(const struct spdk_mempool *_mp)

{

	struct test_mempool *mp = (struct test_mempool *)_mp;



	HANDLE_RETURN_MOCK(spdk_mempool_count);



	if (mp) {

		return mp->count;

	} else {
@@ -280,11 +262,14 @@ struct spdk_ring { 
	TAILQ_HEAD(, spdk_ring_ele) elements;

};



DEFINE_RETURN_MOCK(spdk_ring_create, struct spdk_ring *);

struct spdk_ring *

spdk_ring_create(enum spdk_ring_type type, size_t count, int socket_id)

{

	struct spdk_ring *ring;



	HANDLE_RETURN_MOCK(spdk_ring_create);



	ring = calloc(1, sizeof(*ring));

	if (ring) {

		TAILQ_INIT(&ring->elements);
@@ -293,19 +278,21 @@ spdk_ring_create(enum spdk_ring_type type, size_t count, int socket_id) 
	return ring;

}





void

spdk_ring_free(struct spdk_ring *ring)

{

	free(ring);

}



DEFINE_RETURN_MOCK(spdk_ring_enqueue, size_t);

size_t

spdk_ring_enqueue(struct spdk_ring *ring, void **objs, size_t count)

{

	struct spdk_ring_ele *ele;

	size_t i;



	HANDLE_RETURN_MOCK(spdk_ring_enqueue);



	for (i = 0; i < count; i++) {

		ele = calloc(1, sizeof(*ele));

		if (!ele) {
@@ -319,12 +306,15 @@ spdk_ring_enqueue(struct spdk_ring *ring, void **objs, size_t count) 
	return i;

}



DEFINE_RETURN_MOCK(spdk_ring_dequeue, size_t);

size_t

spdk_ring_dequeue(struct spdk_ring *ring, void **objs, size_t count)

{

	struct spdk_ring_ele *ele, *tmp;

	size_t i = 0;



	HANDLE_RETURN_MOCK(spdk_ring_dequeue);



	if (count == 0) {

		return 0;

	}
@@ -343,27 +333,38 @@ spdk_ring_dequeue(struct spdk_ring *ring, void **objs, size_t count) 


}



uint64_t ut_tsc = 0;

uint64_t spdk_get_ticks(void)

DEFINE_RETURN_MOCK(spdk_get_ticks, uint64_t);

uint64_t

spdk_get_ticks(void)

{

	return ut_tsc;

	HANDLE_RETURN_MOCK(spdk_get_ticks);



	return ut_spdk_get_ticks;

}



uint64_t spdk_get_ticks_hz(void)

DEFINE_RETURN_MOCK(spdk_get_ticks_hz, uint64_t);

uint64_t

spdk_get_ticks_hz(void)

{

	HANDLE_RETURN_MOCK(spdk_get_ticks_hz);



	return 1000000;

}



void spdk_delay_us(unsigned int us)

void

spdk_delay_us(unsigned int us)

{

	ut_tsc += us;

	ut_spdk_get_ticks += us;

}



DEFINE_RETURN_MOCK(spdk_pci_addr_parse, int);

int

spdk_pci_addr_parse(struct spdk_pci_addr *addr, const char *bdf)

{

	unsigned domain, bus, dev, func;



	HANDLE_RETURN_MOCK(spdk_pci_addr_parse);



	if (addr == NULL || bdf == NULL) {

		return -EINVAL;

	}
@@ -396,11 +397,14 @@ spdk_pci_addr_parse(struct spdk_pci_addr *addr, const char *bdf) 
	return 0;

}



DEFINE_RETURN_MOCK(spdk_pci_addr_fmt, int);

int

spdk_pci_addr_fmt(char *bdf, size_t sz, const struct spdk_pci_addr *addr)

{

	int rc;



	HANDLE_RETURN_MOCK(spdk_pci_addr_fmt);



	rc = snprintf(bdf, sz, "%04x:%02x:%02x.%x",

		      addr->domain, addr->bus,

		      addr->dev, addr->func);
@@ -412,9 +416,12 @@ spdk_pci_addr_fmt(char *bdf, size_t sz, const struct spdk_pci_addr *addr) 
	return -1;

}



DEFINE_RETURN_MOCK(spdk_pci_addr_compare, int);

int

spdk_pci_addr_compare(const struct spdk_pci_addr *a1, const struct spdk_pci_addr *a2)

{

	HANDLE_RETURN_MOCK(spdk_pci_addr_compare);



	if (a1->domain > a2->domain) {

		return 1;

	} else if (a1->domain < a2->domain) {

test/common/lib/ut_multithread.c

+10 −4
Original line number Diff line number Diff line
@@ -110,13 +110,19 @@ __stop_poller(struct spdk_poller *poller, void *thread_ctx) 
	free(poller);

}



static uintptr_t g_thread_id = MOCK_PASS_THRU;

#define INVALID_THREAD 0x1000



static uintptr_t g_thread_id = INVALID_THREAD;



static void

set_thread(uintptr_t thread_id)

{

	g_thread_id = thread_id;

	MOCK_SET(pthread_self, pthread_t, (pthread_t)thread_id);

	if (thread_id == INVALID_THREAD) {

		MOCK_CLEAR(pthread_self);

	} else {

		MOCK_SET(pthread_self, (pthread_t)thread_id);

	}

}



int
@@ -141,7 +147,7 @@ allocate_threads(int num_threads) 
		TAILQ_INIT(&g_ut_threads[i].pollers);

	}



	set_thread(MOCK_PASS_THRU);

	set_thread(INVALID_THREAD);

	return 0;

}
@@ -205,7 +211,7 @@ poll_thread(uintptr_t thread_id) 
	uintptr_t original_thread_id;

	TAILQ_HEAD(, ut_poller)	tmp_pollers;



	CU_ASSERT(thread_id != (uintptr_t)MOCK_PASS_THRU);

	CU_ASSERT(thread_id != (uintptr_t)INVALID_THREAD);

	CU_ASSERT(thread_id < g_ut_num_threads);



	original_thread_id = g_thread_id;

test/unit/lib/blob/blob.c/blob_ut.c

+3 −3
Original line number Diff line number Diff line
@@ -1536,12 +1536,12 @@ blob_rw_verify_iov_nomem(void) 
	iov_write[1].iov_len = 5 * 4096;

	iov_write[2].iov_base = payload_write + 6 * 4096;

	iov_write[2].iov_len = 4 * 4096;

	MOCK_SET(calloc, void *, NULL);

	MOCK_SET(calloc, NULL);

	req_count = bs_channel_get_req_count(channel);

	spdk_blob_io_writev(blob, channel, iov_write, 3, 250, 10, blob_op_complete, NULL);

	CU_ASSERT(g_bserrno = -ENOMEM);

	CU_ASSERT(req_count == bs_channel_get_req_count(channel));

	MOCK_SET(calloc, void *, (void *)MOCK_PASS_THRU);

	MOCK_CLEAR(calloc);



	spdk_blob_close(blob, blob_op_complete, NULL);

	CU_ASSERT(g_bserrno == 0);
@@ -4624,7 +4624,7 @@ blob_relations(void) 
	spdk_blob_id blobid, cloneid, snapshotid, cloneid2, snapshotid2;

	int rc;

	size_t count;

	spdk_blob_id ids[10];

	spdk_blob_id ids[10] = {};



	dev = init_dev();

	spdk_bs_opts_init(&bs_opts);