diff --git a/configure.ac b/configure.ac
index fcd7279..7a4b277 100644
--- a/configure.ac
+++ b/configure.ac
@@ -173,6 +173,7 @@ AC_CONFIG_FILES([Makefile
 		 test/Makefile
 		 test/api_test/Makefile
                  test/cunit/Makefile
+		 test/cunit/buffer/Makefile
 		 pkgconfig/libodp.pc])
 
 AC_SEARCH_LIBS([timer_create],[rt posix4])
diff --git a/test/cunit/Makefile.am b/test/cunit/Makefile.am
index 4014bed..04c94b2 100644
--- a/test/cunit/Makefile.am
+++ b/test/cunit/Makefile.am
@@ -3,6 +3,8 @@ include $(top_srcdir)/test/Makefile.inc
 AM_CFLAGS += -I$(CUNIT_PATH)/include
 AM_LDFLAGS += -L$(CUNIT_PATH)/lib
 
+SUBDIRS = buffer
+
 if ODP_CUNIT_ENABLED
 TESTS = ${bin_PROGRAMS}
 check_PROGRAMS = ${bin_PROGRAMS}
diff --git a/test/cunit/buffer/Makefile.am b/test/cunit/buffer/Makefile.am
new file mode 100644
index 0000000..071a701
--- /dev/null
+++ b/test/cunit/buffer/Makefile.am
@@ -0,0 +1,11 @@
+include $(top_srcdir)/test/Makefile.inc
+
+if ODP_CUNIT_ENABLED
+bin_PROGRAMS = odp_buffer_test
+odp_buffer_test_LDFLAGS = $(AM_LDFLAGS) -static -lcunit
+endif
+
+dist_odp_buffer_test_SOURCES = odp_buffer_pool_test.c \
+								odp_buffer_test.c \
+								odp_packet_test.c \
+								odp_buffer_testsuites.c
diff --git a/test/cunit/buffer/odp_buffer_pool_test.c b/test/cunit/buffer/odp_buffer_pool_test.c
new file mode 100644
index 0000000..cd7711e
--- /dev/null
+++ b/test/cunit/buffer/odp_buffer_pool_test.c
@@ -0,0 +1,213 @@
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:	BSD-3-Clause
+ */
+
+#include "odp_buffer_testsuites.h"
+
+static int pool_name_number = 1;
+static const int default_buffer_size = 1500;
+static const int default_buffer_num = 1000;
+
+odp_buffer_pool_t pool_create(int buf_num, int buf_size, int buf_type)
+{
+	odp_buffer_pool_t pool;
+	char pool_name[ODP_BUFFER_POOL_NAME_LEN];
+	odp_buffer_pool_param_t params = {
+			.buf_size  = buf_size,
+			.buf_align = ODP_CACHE_LINE_SIZE,
+			.num_bufs  = buf_num,
+			.buf_type  = buf_type,
+	};
+
+	snprintf(pool_name, sizeof(pool_name),
+		 "test_buffer_pool-%d", pool_name_number++);
+
+	pool = odp_buffer_pool_create(pool_name, ODP_SHM_INVALID, &params);
+	CU_ASSERT_FATAL(pool != ODP_BUFFER_POOL_INVALID);
+
+	return pool;
+}
+
+static void pool_create_destroy_type(int type)
+{
+	odp_buffer_pool_t pool;
+	pool = pool_create(default_buffer_num, default_buffer_size, type);
+
+	CU_ASSERT(odp_buffer_pool_destroy(pool) == 0);
+}
+
+static void pool_create_destroy_raw(void)
+{
+	pool_create_destroy_type(ODP_BUFFER_TYPE_RAW);
+}
+
+static void pool_create_destroy_packet(void)
+{
+	pool_create_destroy_type(ODP_BUFFER_TYPE_PACKET);
+}
+
+static void pool_create_destroy_timeout(void)
+{
+	pool_create_destroy_type(ODP_BUFFER_TYPE_TIMEOUT);
+}
+
+static void pool_create_destroy_any(void)
+{
+	pool_create_destroy_type(ODP_BUFFER_TYPE_ANY);
+}
+
+static void pool_create_destroy_raw_shm(void)
+{
+	odp_buffer_pool_t pool;
+	odp_shm_t test_shm;
+	odp_buffer_pool_param_t params = {
+			.buf_size  = 1500,
+			.buf_align = ODP_CACHE_LINE_SIZE,
+			.num_bufs  = 10,
+			.buf_type  = ODP_BUFFER_TYPE_RAW,
+	};
+
+	test_shm = odp_shm_reserve("test_shm",
+				   params.buf_size * params.num_bufs * 2,
+				   ODP_CACHE_LINE_SIZE,
+				   0);
+	CU_ASSERT_FATAL(test_shm != ODP_SHM_INVALID);
+
+	pool = odp_buffer_pool_create("test_shm_pool", test_shm, &params);
+	CU_ASSERT_FATAL(pool != ODP_BUFFER_POOL_INVALID);
+
+	CU_ASSERT(odp_buffer_pool_destroy(pool) == 0);
+	CU_ASSERT(odp_shm_free(test_shm) == 0);
+}
+
+static void pool_lookup_info_print(void)
+{
+	odp_buffer_pool_t pool;
+	const char pool_name[] = "pool_for_lookup_test";
+	odp_buffer_pool_info_t info;
+	odp_shm_t shm;
+	odp_buffer_pool_param_t params = {
+			.buf_size  = default_buffer_size,
+			.buf_align = ODP_CACHE_LINE_SIZE,
+			.num_bufs  = default_buffer_num,
+			.buf_type  = ODP_BUFFER_TYPE_RAW,
+	};
+
+	pool = odp_buffer_pool_create(pool_name, ODP_SHM_INVALID, &params);
+	CU_ASSERT_FATAL(pool != ODP_BUFFER_POOL_INVALID);
+
+	pool = odp_buffer_pool_lookup(pool_name);
+	CU_ASSERT_FATAL(pool != ODP_BUFFER_POOL_INVALID);
+
+	CU_ASSERT_FATAL(odp_buffer_pool_info(pool, &shm, &info) == 0);
+	CU_ASSERT(shm == ODP_SHM_INVALID);
+	CU_ASSERT(strncmp(pool_name, info.name, sizeof(pool_name)) == 0);
+	CU_ASSERT(params.buf_size <= info.params.buf_size);
+	CU_ASSERT(params.buf_align <= info.params.buf_align);
+	CU_ASSERT(params.num_bufs <= info.params.num_bufs);
+	CU_ASSERT(params.buf_type == info.params.buf_type);
+
+	odp_buffer_pool_print(pool);
+
+	CU_ASSERT(odp_buffer_pool_destroy(pool) == 0);
+}
+
+static void pool_alloc_buffer_type(int type)
+{
+	odp_buffer_pool_t pool;
+	const int buf_num = 3;
+	const size_t buf_size = 1500;
+	odp_buffer_t buffer[buf_num];
+	int buf_index;
+	char wrong_type = 0, wrong_size = 0;
+
+	pool = pool_create(buf_num, buf_size, type);
+	odp_buffer_pool_print(pool);
+
+	/* Try to allocate buf_num buffers from the pool */
+	for (buf_index = 0; buf_index < buf_num; buf_index++) {
+		buffer[buf_index] = odp_buffer_alloc(pool);
+		if (buffer[buf_index] == ODP_BUFFER_INVALID)
+			break;
+		if (odp_buffer_type(buffer[buf_index]) != type)
+			wrong_type = 1;
+		if (odp_buffer_size(buffer[buf_index]) < buf_size)
+			wrong_size = 1;
+		if (wrong_type || wrong_size)
+			odp_buffer_print(buffer[buf_index]);
+	}
+
+	/* Check that the pool had at least buf_num buffers */
+	CU_ASSERT(buf_index == buf_num);
+	/* buf_index points out of buffer[] or it point to an invalid buffer */
+	buf_index--;
+
+	/* Check that the pool had correct buffers */
+	CU_ASSERT(wrong_type == 0);
+	CU_ASSERT(wrong_size == 0);
+
+	for (; buf_index >= 0; buf_index--)
+		odp_buffer_free(buffer[buf_index]);
+
+	CU_ASSERT(odp_buffer_pool_destroy(pool) == 0);
+}
+
+static void pool_alloc_buffer_raw(void)
+{
+	pool_alloc_buffer_type(ODP_BUFFER_TYPE_RAW);
+}
+
+static void pool_alloc_buffer_packet(void)
+{
+	pool_alloc_buffer_type(ODP_BUFFER_TYPE_PACKET);
+}
+
+static void pool_alloc_buffer_timeout(void)
+{
+	pool_alloc_buffer_type(ODP_BUFFER_TYPE_TIMEOUT);
+}
+
+static void pool_alloc_buffer_any(void)
+{
+	pool_alloc_buffer_type(ODP_BUFFER_TYPE_ANY);
+}
+
+static void pool_free_buffer(void)
+{
+	odp_buffer_pool_t pool;
+	odp_buffer_t buffer;
+	pool = pool_create(1, 64, ODP_BUFFER_TYPE_RAW);
+
+	/* Allocate the only buffer from the pool */
+	buffer = odp_buffer_alloc(pool);
+	CU_ASSERT_FATAL(buffer != ODP_BUFFER_INVALID);
+
+	/** @todo: is it correct to assume the pool had only one buffer? */
+	CU_ASSERT_FATAL(odp_buffer_alloc(pool) == ODP_BUFFER_INVALID)
+
+	odp_buffer_free(buffer);
+
+	/* Check that the buffer was returned back to the pool */
+	buffer = odp_buffer_alloc(pool);
+	CU_ASSERT_FATAL(buffer != ODP_BUFFER_INVALID);
+
+	odp_buffer_free(buffer);
+	CU_ASSERT(odp_buffer_pool_destroy(pool) == 0);
+}
+
+CU_TestInfo buffer_pool_tests[] = {
+	_CU_TEST_INFO(pool_create_destroy_raw),
+	_CU_TEST_INFO(pool_create_destroy_packet),
+	_CU_TEST_INFO(pool_create_destroy_timeout),
+	_CU_TEST_INFO(pool_create_destroy_any),
+	_CU_TEST_INFO(pool_create_destroy_raw_shm),
+	_CU_TEST_INFO(pool_lookup_info_print),
+	_CU_TEST_INFO(pool_alloc_buffer_raw),
+	_CU_TEST_INFO(pool_alloc_buffer_packet),
+	_CU_TEST_INFO(pool_alloc_buffer_timeout),
+	_CU_TEST_INFO(pool_alloc_buffer_any),
+	_CU_TEST_INFO(pool_free_buffer),
+	CU_TEST_INFO_NULL,
+};
diff --git a/test/cunit/buffer/odp_buffer_test.c b/test/cunit/buffer/odp_buffer_test.c
new file mode 100644
index 0000000..e4a6b68
--- /dev/null
+++ b/test/cunit/buffer/odp_buffer_test.c
@@ -0,0 +1,52 @@
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:	BSD-3-Clause
+ */
+
+#include "odp_buffer_testsuites.h"
+
+static odp_buffer_pool_t raw_pool;
+static odp_buffer_t raw_buffer = ODP_BUFFER_INVALID;
+static const size_t raw_buffer_size = 1500;
+
+int buffer_tests_init(void)
+{
+	odp_buffer_pool_param_t params = {
+			.buf_size  = raw_buffer_size,
+			.buf_align = ODP_CACHE_LINE_SIZE,
+			.num_bufs  = 100,
+			.buf_type  = ODP_BUFFER_TYPE_RAW,
+	};
+
+	raw_pool = odp_buffer_pool_create("raw_pool", ODP_SHM_INVALID, &params);
+	if (raw_pool == ODP_BUFFER_POOL_INVALID)
+		return -1;
+	raw_buffer = odp_buffer_alloc(raw_pool);
+	if (raw_buffer == ODP_BUFFER_INVALID)
+		return -1;
+	return 0;
+}
+
+int buffer_tests_finalize(void)
+{
+	odp_buffer_free(raw_buffer);
+	if (odp_buffer_pool_destroy(raw_pool) != 0)
+		return -1;
+	return 0;
+}
+
+static void buffer_management_basic(void)
+{
+	CU_ASSERT(odp_buffer_is_valid(raw_buffer) == 1);
+	CU_ASSERT(odp_buffer_pool(raw_buffer) != ODP_BUFFER_POOL_INVALID);
+	CU_ASSERT(odp_buffer_type(raw_buffer) == ODP_BUFFER_TYPE_RAW);
+	CU_ASSERT(odp_buffer_size(raw_buffer) >= raw_buffer_size);
+	CU_ASSERT(odp_buffer_addr(raw_buffer) != NULL);
+	odp_buffer_print(raw_buffer);
+}
+
+CU_TestInfo buffer_tests[] = {
+	_CU_TEST_INFO(buffer_management_basic),
+	CU_TEST_INFO_NULL,
+};
diff --git a/test/cunit/buffer/odp_buffer_testsuites.c b/test/cunit/buffer/odp_buffer_testsuites.c
new file mode 100644
index 0000000..ac28c58
--- /dev/null
+++ b/test/cunit/buffer/odp_buffer_testsuites.c
@@ -0,0 +1,51 @@
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:	BSD-3-Clause
+ */
+
+#include "odp_buffer_testsuites.h"
+
+static CU_SuiteInfo suites[] = {
+	{ .pName = "buffer Pool tests",
+			.pTests = buffer_pool_tests,
+	},
+	{ .pName = "buffer tests",
+			.pTests = buffer_tests,
+			.pInitFunc = buffer_tests_init,
+			.pCleanupFunc = buffer_tests_finalize,
+	},
+	{ .pName = "packet tests",
+			.pTests = packet_tests,
+			.pInitFunc = packet_tests_init,
+			.pCleanupFunc = packet_tests_finalize,
+	},
+	CU_SUITE_INFO_NULL,
+};
+
+int main(void)
+{
+	if (odp_init_global(NULL, NULL)) {
+		ODP_ERR("ODP global init failed.\n");
+		return -1;
+	}
+	odp_init_local();
+
+	printf("\tODP version: %s\n", odp_version_api_str());
+
+	/* initialize the CUnit test registry */
+	if (CUE_SUCCESS != CU_initialize_registry())
+		return CU_get_error();
+
+	/* register suites */
+	CU_register_suites(suites);
+	/* Run all tests using the CUnit Basic interface */
+	CU_basic_set_mode(CU_BRM_VERBOSE);
+	CU_basic_run_tests();
+	CU_cleanup_registry();
+
+	odp_term_local();
+	odp_term_global();
+
+	return CU_get_error();
+}
diff --git a/test/cunit/buffer/odp_buffer_testsuites.h b/test/cunit/buffer/odp_buffer_testsuites.h
new file mode 100644
index 0000000..774c58a
--- /dev/null
+++ b/test/cunit/buffer/odp_buffer_testsuites.h
@@ -0,0 +1,30 @@
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:	BSD-3-Clause
+ */
+
+#ifndef ODP_BUFFER_TESTSUITES_H_
+#define ODP_BUFFER_TESTSUITES_H_
+
+#include <odp.h>
+#include <odph_packet.h>
+#include <CUnit/CUnit.h>
+#include <CUnit/Basic.h>
+
+/* Helper macro for CU_TestInfo initialization */
+#define _CU_TEST_INFO(test_func) {#test_func, test_func}
+
+extern CU_TestInfo buffer_pool_tests[];
+extern CU_TestInfo buffer_tests[];
+extern CU_TestInfo packet_tests[];
+
+extern int buffer_tests_init(void);
+extern int buffer_tests_finalize(void);
+
+extern int packet_tests_init(void);
+extern int packet_tests_finalize(void);
+
+odp_buffer_pool_t pool_create(int buf_num, int buf_size, int buf_type);
+
+#endif /* ODP_BUFFER_TESTSUITES_H_ */
diff --git a/test/cunit/buffer/odp_packet_test.c b/test/cunit/buffer/odp_packet_test.c
new file mode 100644
index 0000000..79753a9
--- /dev/null
+++ b/test/cunit/buffer/odp_packet_test.c
@@ -0,0 +1,337 @@
+/* Copyright (c) 2014, Linaro Limited
+ * All rights reserved.
+ *
+ * SPDX-License-Identifier:	BSD-3-Clause
+ */
+
+#include "odp_buffer_testsuites.h"
+/* #define TEST_PACKET_SEGMENTS */
+
+static odp_buffer_pool_t packet_pool;
+static const size_t packet_size = 1500;
+odp_packet_t test_packet;
+
+int packet_tests_init(void)
+{
+	odp_buffer_pool_param_t params = {
+			.buf_size  = packet_size,
+			.buf_align = ODP_CACHE_LINE_SIZE,
+			.num_bufs  = 100,
+			.buf_type  = ODP_BUFFER_TYPE_PACKET,
+	};
+
+	packet_pool = odp_buffer_pool_create("packet_pool", ODP_SHM_INVALID,
+					     &params);
+	if (packet_pool == ODP_BUFFER_POOL_INVALID)
+		return -1;
+
+	test_packet = odph_packet_alloc(packet_pool);
+	if (odph_packet_is_valid(test_packet) == 0)
+		return -1;
+
+	return 0;
+}
+
+int packet_tests_finalize(void)
+{
+	odph_packet_free(test_packet);
+	if (odp_buffer_pool_destroy(packet_pool) != 0)
+		return -1;
+	return 0;
+}
+
+static void packet_alloc_free(void)
+{
+	odp_buffer_pool_t pool;
+	odp_packet_t packet;
+	pool = pool_create(1, 64, ODP_BUFFER_TYPE_PACKET);
+
+	/* Allocate the only buffer from the pool */
+	packet = odph_packet_alloc(pool);
+	CU_ASSERT_FATAL(packet != ODP_PACKET_INVALID);
+
+	/** @todo: is it correct to assume the pool had only one buffer? */
+	CU_ASSERT_FATAL(odph_packet_alloc(pool) == ODP_PACKET_INVALID)
+
+	odph_packet_free(packet);
+
+	/* Check that the buffer was returned back to the pool */
+	packet = odph_packet_alloc(pool);
+	CU_ASSERT_FATAL(packet != ODP_PACKET_INVALID);
+
+	odph_packet_free(packet);
+	CU_ASSERT(odp_buffer_pool_destroy(pool) == 0);
+}
+
+static void packet_management_basic(void)
+{
+	CU_ASSERT(odph_packet_is_valid(test_packet) == 1);
+	/** @todo: What is the expected packet length? */
+	CU_ASSERT(odp_packet_addr(test_packet) != NULL);
+	CU_ASSERT(odp_packet_data(test_packet) != NULL);
+	odp_packet_print(test_packet);
+}
+
+static void packet_length(void)
+{
+	CU_ASSERT(odp_packet_get_len(test_packet) == packet_size);
+	odp_packet_set_len(test_packet, packet_size / 2);
+	CU_ASSERT(odp_packet_get_len(test_packet) == packet_size / 2);
+	odp_packet_init(test_packet);
+	CU_ASSERT(odp_packet_get_len(test_packet) == packet_size);
+}
+
+static void packet_context(void)
+{
+	char context = 2;
+	void *prev_context;
+
+	prev_context = odp_packet_get_ctx(test_packet);
+	odp_packet_set_ctx(test_packet, &context);
+	CU_ASSERT(odp_packet_get_ctx(test_packet) == &context);
+	odp_packet_set_ctx(test_packet, prev_context);
+	odp_packet_init(test_packet);
+}
+
+static void packet_buffer_conversion(void)
+{
+	odp_packet_t tmp_packet;
+	odp_buffer_t test_buffer;
+
+	test_buffer = odp_packet_to_buffer(test_packet);
+	CU_ASSERT_FATAL(test_buffer != ODP_BUFFER_INVALID);
+	CU_ASSERT(odp_buffer_type(test_buffer) == ODP_BUFFER_TYPE_PACKET);
+	CU_ASSERT(odp_buffer_size(test_buffer) >= packet_size);
+
+	tmp_packet = odp_packet_from_buffer(test_buffer);
+	CU_ASSERT_FATAL(tmp_packet != ODP_PACKET_INVALID);
+	/** @todo: Need an API to compare packets */
+}
+
+static void packet_layer_offsets(void)
+{
+	odp_packet_t packet = test_packet;
+	uint8_t *l2_addr, *l3_addr, *l4_addr;
+	const size_t l2_off = 2;
+	const size_t l3_off = l2_off + 14;
+	const size_t l4_off = l3_off + 14;
+	/* Set offsets to the same value */
+	odp_packet_set_l2_offset(packet, l2_off);
+	odp_packet_set_l3_offset(packet, l2_off);
+	odp_packet_set_l4_offset(packet, l2_off);
+
+	/* Addresses should be the same */
+	l2_addr = odp_packet_l2(packet);
+	l3_addr = odp_packet_l3(packet);
+	l4_addr = odp_packet_l4(packet);
+	CU_ASSERT(l2_addr != NULL);
+	CU_ASSERT(l2_addr == l3_addr);
+	CU_ASSERT(l2_addr == l4_addr);
+
+	/* Set offsets to the different values */
+	odp_packet_set_l2_offset(packet, l2_off);
+	CU_ASSERT(odp_packet_l2_offset(packet) == l2_off);
+	odp_packet_set_l3_offset(packet, l3_off);
+	CU_ASSERT(odp_packet_l3_offset(packet) == l3_off);
+	odp_packet_set_l4_offset(packet, l4_off);
+	CU_ASSERT(odp_packet_l4_offset(packet) == l4_off);
+
+	/* Addresses should not be the same */
+	l2_addr = odp_packet_l2(packet);
+	CU_ASSERT(l2_addr != NULL);
+	l3_addr = odp_packet_l3(packet);
+	CU_ASSERT(l3_addr != NULL);
+	l4_addr = odp_packet_l4(packet);
+	CU_ASSERT(l4_addr != NULL);
+
+	CU_ASSERT(l2_addr != l3_addr);
+	CU_ASSERT(l2_addr != l4_addr);
+	CU_ASSERT(l3_addr != l4_addr);
+}
+
+#ifdef TEST_PACKET_SEGMENTS
+static void _test_one_segment(odp_packet_t packet,
+			      odp_packet_seg_t segment,
+			      odp_packet_seg_info_t *info)
+{
+	size_t headroom, tailroom;
+
+	CU_ASSERT(odp_packet_seg_info(packet, segment, info) == 0);
+	CU_ASSERT(info->addr != NULL);
+	CU_ASSERT(info->data != NULL);
+	CU_ASSERT(info->data >= info->addr);
+	CU_ASSERT(info->size != 0);
+
+	CU_ASSERT(odp_packet_seg_addr(packet, segment) == info->addr);
+	CU_ASSERT(odp_packet_seg_size(packet, segment) == info->size);
+	CU_ASSERT(odp_packet_seg_data(packet, segment) == info->data);
+	CU_ASSERT(odp_packet_seg_data_len(packet, segment) == info->data_len);
+
+	headroom = odp_packet_seg_headroom(packet, segment);
+	tailroom = odp_packet_seg_tailroom(packet, segment);
+	CU_ASSERT(info->size ==
+			info->data_len + headroom + tailroom);
+}
+
+static void packet_segments(void)
+{
+	int segment_count, seg_index;
+	size_t data_size, buf_size;
+	odp_packet_seg_t segment;
+	odp_packet_t packet = test_packet;
+	odp_packet_seg_info_t seg_info;
+
+	CU_ASSERT(odph_packet_is_valid(packet) == 1);
+
+	segment_count = odp_packet_seg_count(packet);
+	CU_ASSERT(segment_count != 0);
+
+	if (!odp_packet_is_segmented(packet)) {
+		CU_ASSERT(segment_count == 1);
+	}
+
+	segment = ODP_PACKET_SEG_INVALID;
+	buf_size = 0;
+	data_size = 0;
+	for (seg_index = 0; seg_index < segment_count; seg_index++) {
+		segment = odp_packet_seg(packet, seg_index);
+		if (segment == ODP_PACKET_SEG_INVALID)
+			break;
+		_test_one_segment(packet, segment, &seg_info);
+
+		buf_size += seg_info.size;
+		data_size += seg_info.data_len;
+		/** @todo: touch memory in a segment */
+	}
+
+	CU_ASSERT(seg_index == segment_count);
+	CU_ASSERT(buf_size == odp_buffer_size(odp_packet_to_buffer(packet)));
+	CU_ASSERT(data_size == odp_packet_get_len(packet));
+
+	segment = ODP_PACKET_SEG_INVALID;
+	buf_size = 0;
+	data_size = 0;
+	for (seg_index = 0; seg_index < segment_count; seg_index++) {
+		segment = odp_packet_seg_next(packet, segment);
+
+		if (segment == ODP_PACKET_SEG_INVALID)
+			break;
+		_test_one_segment(packet, segment, &seg_info);
+
+		buf_size += seg_info.size;
+		data_size += seg_info.data_len;
+		/** @todo: touch memory in a segment */
+	}
+
+	CU_ASSERT(seg_index == segment_count);
+	CU_ASSERT(buf_size == odp_buffer_size(odp_packet_to_buffer(packet)));
+	CU_ASSERT(data_size == odp_packet_get_len(packet));
+
+	if (seg_index == segment_count) {
+		segment = odp_packet_seg_next(packet, segment);
+		CU_ASSERT(segment == ODP_PACKET_SEG_INVALID);
+	}
+}
+
+static void _verify_headroom_shift(odp_packet_t packet,
+				   odp_packet_seg_t segment,
+				   int shift)
+{
+	size_t room = odp_packet_seg_headroom(packet, segment);
+	size_t data_len = odp_packet_seg_data_len(packet, segment);
+	char *data = odp_packet_seg_data(packet, segment);
+	void *addr;
+
+	if (shift > 0)
+		addr = odp_packet_seg_push_head(packet, segment, shift);
+	else
+		addr = odp_packet_seg_pull_head(packet, segment, -shift);
+
+	CU_ASSERT(addr != NULL);
+	CU_ASSERT(odp_packet_seg_headroom(packet, segment) == room - shift);
+	CU_ASSERT(odp_packet_seg_data_len(packet, segment) == data_len + shift);
+	CU_ASSERT(odp_packet_seg_data(packet, segment) == addr);
+	CU_ASSERT(addr == data + shift);
+}
+
+static void _verify_tailroom_shift(odp_packet_t packet,
+				   odp_packet_seg_t segment,
+				   int shift)
+{
+	size_t room = odp_packet_seg_tailroom(packet, segment);
+	int len;
+	size_t data_len = odp_packet_seg_data_len(packet, segment);
+
+	if (shift > 0)
+		len = odp_packet_seg_push_tail(packet, segment, shift);
+	else
+		len = odp_packet_seg_pull_tail(packet, segment, -shift);
+
+	CU_ASSERT(len != -1);
+	CU_ASSERT(odp_packet_seg_tailroom(packet, segment) == room - shift);
+	/** @todo: tail push/pull return int, but data_len is size_t */
+	CU_ASSERT(len == (int)data_len + shift);
+	CU_ASSERT((int)odp_packet_seg_data_len(packet, segment) == len);
+}
+
+static void packet_segment_headroom(void)
+{
+	odp_packet_seg_t segment;
+	odp_packet_t packet = test_packet;
+	size_t room;
+	size_t data_len;
+	int shift = 1;
+
+	segment = odp_packet_seg(packet, 0);
+	CU_ASSERT_FATAL(segment != ODP_PACKET_SEG_INVALID);
+	room = odp_packet_seg_headroom(packet, segment);
+	data_len = odp_packet_seg_data_len(packet, segment);
+
+	/** @todo: Specification doesn't specify what room size to expect */
+	if (room == 0 && data_len > 0)
+		shift = -shift;
+	else if (room == 0)
+		CU_FAIL_FATAL("No space for headroom manipulation");
+
+	_verify_headroom_shift(packet, segment,  shift);
+	_verify_headroom_shift(packet, segment, -shift);
+}
+
+static void packet_segment_tailroom(void)
+{
+	odp_packet_seg_t segment;
+	odp_packet_t packet = test_packet;
+	size_t room;
+	size_t data_len;
+	int shift = 1;
+
+	segment = odp_packet_seg(test_packet, 0);
+	CU_ASSERT_FATAL(segment != ODP_PACKET_SEG_INVALID);
+	room = odp_packet_seg_tailroom(packet, segment);
+	data_len = odp_packet_seg_data_len(packet, segment);
+
+	/** @todo: Specification doesn't specify what room size to expect */
+	if (room == 0 && data_len > 0)
+		shift = -shift;
+	else if (room == 0)
+		CU_FAIL_FATAL("No space for tailroom manipulation");
+
+	_verify_tailroom_shift(packet, segment,  shift);
+	_verify_tailroom_shift(packet, segment, -shift);
+}
+#endif /* TEST_PACKET_SEGMENTS */
+
+CU_TestInfo packet_tests[] = {
+	_CU_TEST_INFO(packet_alloc_free),
+	_CU_TEST_INFO(packet_management_basic),
+	_CU_TEST_INFO(packet_length),
+	_CU_TEST_INFO(packet_context),
+	_CU_TEST_INFO(packet_buffer_conversion),
+	_CU_TEST_INFO(packet_layer_offsets),
+#ifdef TEST_PACKET_SEGMENTS
+	_CU_TEST_INFO(packet_segments),
+	_CU_TEST_INFO(packet_segment_headroom),
+	_CU_TEST_INFO(packet_segment_tailroom),
+#endif /* TEST_PACKET_SEGMENTS */
+	CU_TEST_INFO_NULL,
+};
