diff --git a/tests/benchmarks/app_kernel/src/event_b.c b/tests/benchmarks/app_kernel/src/event_b.c
index 5a9588ae9e2..219974b6408 100644
--- a/tests/benchmarks/app_kernel/src/event_b.c
+++ b/tests/benchmarks/app_kernel/src/event_b.c
@@ -12,13 +12,13 @@
 
 /* #define EVENT_CHECK */
 #ifdef EVENT_CHECK
-static const char EventSignalErr[] = "------------ Error signalling event.\n";
-static const char EventTestErr[] = "------------ Error testing event.\n";
-static const char EventHandlerErr[] = "------------ Error in event handler.\n";
+static const char event_signal_err[] = "----------- Error signalling event.\n";
+static const char event_test_err[] = "----------- Error testing event.\n";
+static const char event_handler_err[] = "----------- Error in event handler\n";
 #endif
 
 /* global Event value */
-volatile int nEventValue;
+volatile int nevent_value;
 
 /*
  * Function prototypes.
@@ -37,17 +37,17 @@ int example_handler (struct k_alert *alert);
  */
 void event_test(void)
 {
-	int nReturn = 0;
-	int nCounter;
+	int nreturn = 0;
+	int ncounter;
 	u32_t et; /* elapsed time */
 
 	PRINT_STRING(dashline, output_file);
 	et = BENCH_START();
-	for (nCounter = 0; nCounter < NR_OF_EVENT_RUNS; nCounter++) {
+	for (ncounter = 0; ncounter < NR_OF_EVENT_RUNS; ncounter++) {
 		k_alert_send(&TEST_EVENT);
 #ifdef EVENT_CHECK
-		if (nReturn != 0) {
-			PRINT_STRING(EventSignalErr, output_file);
+		if (nreturn != 0) {
+			PRINT_STRING(event_signal_err, output_file);
 			return; /* error */
 		}
 #endif /* EVENT_CHECK */
@@ -59,19 +59,19 @@ void event_test(void)
 			SYS_CLOCK_HW_CYCLES_TO_NS_AVG(et, NR_OF_EVENT_RUNS));
 
 	et = BENCH_START();
-	for (nCounter = 0; nCounter < NR_OF_EVENT_RUNS; nCounter++) {
+	for (ncounter = 0; ncounter < NR_OF_EVENT_RUNS; ncounter++) {
 		k_alert_send(&TEST_EVENT);
 #ifdef EVENT_CHECK
-		if (nReturn != 0) {
-			PRINT_STRING(EventSignalErr, output_file);
+		if (nreturn != 0) {
+			PRINT_STRING(event_signal_err, output_file);
 			k_sleep(1);
 			return; /* error */
 		}
 #endif /* EVENT_CHECK */
 		k_alert_recv(&TEST_EVENT, K_NO_WAIT);
 #ifdef EVENT_CHECK
-		if (nReturn != 0) {
-			PRINT_STRING(EventTestErr, output_file);
+		if (nreturn != 0) {
+			PRINT_STRING(event_test_err, output_file);
 			k_sleep(1);
 			return; /* error */
 		}
@@ -84,18 +84,18 @@ void event_test(void)
 			SYS_CLOCK_HW_CYCLES_TO_NS_AVG(et, NR_OF_EVENT_RUNS));
 
 	et = BENCH_START();
-	for (nCounter = 0; nCounter < NR_OF_EVENT_RUNS; nCounter++) {
+	for (ncounter = 0; ncounter < NR_OF_EVENT_RUNS; ncounter++) {
 		k_alert_send(&TEST_EVENT);
 #ifdef EVENT_CHECK
-		if (nReturn != 0) {
-			PRINT_STRING(EventSignalErr, output_file);
+		if (nreturn != 0) {
+			PRINT_STRING(event_signal_err, output_file);
 			return; /* error */
 		}
 #endif /* EVENT_CHECK */
 		k_alert_recv(&TEST_EVENT, K_FOREVER);
 #ifdef EVENT_CHECK
-		if (nReturn != 0) {
-			PRINT_STRING(EventTestErr, output_file);
+		if (nreturn != 0) {
+			PRINT_STRING(event_test_err, output_file);
 			return; /* error */
 		}
 #endif /* EVENT_CHECK */
@@ -109,32 +109,32 @@ void event_test(void)
 	PRINT_STRING("| Signal event with installed handler"
 		 "                                         |\n", output_file);
 	TEST_EVENT.handler = example_handler;
-	if (nReturn != 0) {
+	if (nreturn != 0) {
 		PRINT_F(output_file,
 			"-------- Error installing event handler.\n");
 		k_sleep(1);
 		return; /* error */
 	}
 
-	for (nCounter = 0; nCounter < NR_OF_EVENT_RUNS; nCounter++) {
+	for (ncounter = 0; ncounter < NR_OF_EVENT_RUNS; ncounter++) {
 		k_alert_send(&TEST_EVENT);
 #ifdef EVENT_CHECK
-		if (nReturn != 0) {
-			PRINT_STRING(EventSignalErr, output_file);
+		if (nreturn != 0) {
+			PRINT_STRING(event_signal_err, output_file);
 			k_sleep(1);
 			return; /* error */
 		}
-		if (nEventValue != TEST_EVENT.send_count + 1) {
-			PRINT_STRING(EventHandlerErr, output_file);
+		if (nevent_value != TEST_EVENT.send_count + 1) {
+			PRINT_STRING(event_handler_err, output_file);
 			k_sleep(1);
 			return; /* error */
 		}
 #endif /* EVENT_CHECK */
-		nEventValue = 0;
+		nevent_value = 0;
 	}
 
 	TEST_EVENT.handler = NULL;
-	if (nReturn != 0) {
+	if (nreturn != 0) {
 		PRINT_F(output_file, "Error removing event handler.\n");
 		k_sleep(1);
 		return; /* error */
@@ -160,7 +160,7 @@ void event_test(void)
 int example_handler (struct k_alert *alert)
 {
 	ARG_UNUSED(alert);
-	nEventValue = alert->send_count + 1;
+	nevent_value = alert->send_count + 1;
 
 	return 1;
 }
diff --git a/tests/benchmarks/app_kernel/src/mailbox_b.c b/tests/benchmarks/app_kernel/src/mailbox_b.c
index c68e316584e..acbae27c53f 100644
--- a/tests/benchmarks/app_kernel/src/mailbox_b.c
+++ b/tests/benchmarks/app_kernel/src/mailbox_b.c
@@ -10,13 +10,13 @@
 
 #ifdef MAILBOX_BENCH
 
-static struct k_mbox_msg Message;
+static struct k_mbox_msg message;
 
 #ifdef FLOAT
 #define PRINT_HEADER()                                                       \
-	PRINT_STRING                                                           \
+	(PRINT_STRING                                         \
 	   ("|   size(B) |       time/packet (usec)       |          MB/sec" \
-	    "                |\n", output_file)
+	    "                |\n", output_file))
 #define PRINT_ONE_RESULT()                                                   \
 	PRINT_F(output_file, "|%11u|%32.3f|%32f|\n", putsize, puttime / 1000.0,\
 	     (1000.0 * putsize) / puttime)
@@ -24,21 +24,21 @@ static struct k_mbox_msg Message;
 #define PRINT_OVERHEAD()                                                     \
 	PRINT_F(output_file,						\
 	     "| message overhead:  %10.3f     usec/packet                   "\
-	     "            |\n", EmptyMsgPutTime / 1000.0)
+	     "            |\n", empty_msg_put_time / 1000.0)
 
 #define PRINT_XFER_RATE()                                                     \
-	double NettoTransferRate;                                               \
-	NettoTransferRate = 1000.0 * \
-		(putsize >> 1) / (puttime - EmptyMsgPutTime);		\
+	double netto_transfer_rate;                                           \
+	netto_transfer_rate = 1000.0 * \
+		(putsize >> 1) / (puttime - empty_msg_put_time);	\
 	PRINT_F(output_file,						\
 	     "| raw transfer rate:     %10.3f MB/sec (without"		\
-	     " overhead)                 |\n", NettoTransferRate)
+	     " overhead)                 |\n", netto_transfer_rate)
 
 #else
 #define PRINT_HEADER()                                                       \
-	PRINT_STRING                                                            \
+	(PRINT_STRING                                                         \
 	   ("|   size(B) |       time/packet (nsec)       |          KB/sec" \
-	    "                |\n", output_file);
+	    "                |\n", output_file))
 
 #define PRINT_ONE_RESULT()                                                   \
 	PRINT_F(output_file, "|%11u|%32u|%32u|\n", putsize, puttime,	     \
@@ -47,13 +47,13 @@ static struct k_mbox_msg Message;
 #define PRINT_OVERHEAD()                                                     \
 	PRINT_F(output_file,						\
 	     "| message overhead:  %10u     nsec/packet                     "\
-	     "          |\n", EmptyMsgPutTime)
+	     "          |\n", empty_msg_put_time)
 
 #define PRINT_XFER_RATE()                                                    \
 	PRINT_F(output_file, "| raw transfer rate:     %10u KB/sec (without" \
 	     " overhead)                 |\n",                               \
 	     (u32_t)(1000000 * (u64_t)(putsize >> 1)                   \
-	     / (puttime - EmptyMsgPutTime)))
+	     / (puttime - empty_msg_put_time)))
 
 #endif
 
@@ -78,8 +78,8 @@ void mailbox_test(void)
 	u32_t putsize;
 	u32_t puttime;
 	int putcount;
-	unsigned int EmptyMsgPutTime;
-	GetInfo getinfo;
+	unsigned int empty_msg_put_time;
+	struct getinfo getinfo;
 
 	PRINT_STRING(dashline, output_file);
 	PRINT_STRING("|                "
@@ -104,7 +104,7 @@ void mailbox_test(void)
 	/* waiting for ack */
 	k_msgq_get(&MB_COMM, &getinfo, K_FOREVER);
 	PRINT_ONE_RESULT();
-	EmptyMsgPutTime = puttime;
+	empty_msg_put_time = puttime;
 	for (putsize = 8; putsize <= MESSAGE_SIZE; putsize <<= 1) {
 		mailbox_put(putsize, putcount, &puttime);
 		/* waiting for ack */
@@ -132,14 +132,14 @@ void mailbox_put(u32_t size, int count, u32_t *time)
 	int i;
 	unsigned int t;
 
-	Message.rx_source_thread = K_ANY;
-	Message.tx_target_thread = K_ANY;
+	message.rx_source_thread = K_ANY;
+	message.tx_target_thread = K_ANY;
 
 	/* first sync with the receiver */
 	k_sem_give(&SEM0);
 	t = BENCH_START();
 	for (i = 0; i < count; i++) {
-		k_mbox_put(&MAILB1, &Message, K_FOREVER);
+		k_mbox_put(&MAILB1, &message, K_FOREVER);
 	}
 	t = TIME_STAMP_DELTA_GET(t);
 	*time = SYS_CLOCK_HW_CYCLES_TO_NS_AVG(t, count);
diff --git a/tests/benchmarks/app_kernel/src/mailbox_r.c b/tests/benchmarks/app_kernel/src/mailbox_r.c
index 6f52c5f3d23..3d8e7f7587d 100644
--- a/tests/benchmarks/app_kernel/src/mailbox_r.c
+++ b/tests/benchmarks/app_kernel/src/mailbox_r.c
@@ -36,7 +36,7 @@ void mailrecvtask(void)
 	int getsize;
 	unsigned int gettime;
 	int getcount;
-	GetInfo getinfo;
+	struct getinfo getinfo;
 
 	getcount = NR_OF_MBOX_RUNS;
 
diff --git a/tests/benchmarks/app_kernel/src/master.c b/tests/benchmarks/app_kernel/src/master.c
index 4fe63a5d59e..0c32f4fe240 100644
--- a/tests/benchmarks/app_kernel/src/master.c
+++ b/tests/benchmarks/app_kernel/src/master.c
@@ -17,11 +17,11 @@
 #include <tc_util.h>
 #include "master.h"
 
-char Msg[MAX_MSG];
+char msg[MAX_MSG];
 char data_bench[OCTET_TO_SIZEOFUNIT(MESSAGE_SIZE)];
 
 #ifdef PIPE_BENCH
-struct k_pipe *TestPipes[] = {&PIPE_NOBUFF, &PIPE_SMALLBUFF, &PIPE_BIGBUFF};
+struct k_pipe *test_pipes[] = {&PIPE_NOBUFF, &PIPE_SMALLBUFF, &PIPE_BIGBUFF};
 #endif
 char sline[SLINE_LEN + 1];
 const char newline[] = "\n";
@@ -38,7 +38,7 @@ u32_t tm_off;
 /********************************************************************/
 /* static allocation  */
 K_THREAD_DEFINE(RECVTASK, 1024, recvtask, NULL, NULL, NULL, 5, 0, K_NO_WAIT);
-K_THREAD_DEFINE(BENCHTASK, 1024, BenchTask, NULL, NULL, NULL, 6, 0, K_NO_WAIT);
+K_THREAD_DEFINE(BENCHTASK, 1024, bench_task, NULL, NULL, NULL, 6, 0, K_NO_WAIT);
 
 K_MSGQ_DEFINE(DEMOQX1, 1, 500, 4);
 K_MSGQ_DEFINE(DEMOQX4, 4, 500, 4);
@@ -120,7 +120,7 @@ void output_close(void)
  *
  * @return N/A
  */
-void BenchTask(void *p1, void *p2, void *p3)
+void bench_task(void *p1, void *p2, void *p3)
 {
 	int autorun = 0, continuously = 0;
 
@@ -166,5 +166,4 @@ void BenchTask(void *p1, void *p2, void *p3)
  */
 void dummy_test(void)
 {
-	return;
 }
diff --git a/tests/benchmarks/app_kernel/src/master.h b/tests/benchmarks/app_kernel/src/master.h
index f67b67074c7..5a694f75c2c 100644
--- a/tests/benchmarks/app_kernel/src/master.h
+++ b/tests/benchmarks/app_kernel/src/master.h
@@ -48,12 +48,12 @@
 #define NR_OF_EVENT_RUNS  1000
 #define NR_OF_MBOX_RUNS 128
 #define NR_OF_PIPE_RUNS 256
-//#define SEMA_WAIT_TIME (5 * sys_clock_ticks_per_sec)
+/* #define SEMA_WAIT_TIME (5 * sys_clock_ticks_per_sec) */
 #define SEMA_WAIT_TIME (5000)
 /* global data */
-extern char Msg[MAX_MSG];
+extern char msg[MAX_MSG];
 extern char data_bench[OCTET_TO_SIZEOFUNIT(MESSAGE_SIZE)];
-extern struct k_pipe *TestPipes[];
+extern struct k_pipe *test_pipes[];
 extern FILE *output_file;
 extern const char newline[];
 extern char sline[];
@@ -65,11 +65,11 @@ extern char sline[];
 
 
 /* pipe amount of content to receive (0+, 1+, all) */
-typedef enum {
+enum pipe_options {
 	_0_TO_N = 0x0,
 	_1_TO_N = 0x1,
 	_ALL_N  = 0x2,
-} pipe_options;
+};
 
 /* dummy_test is a function that is mapped when we */
 /* do not want to test a specific Benchmark */
@@ -77,7 +77,7 @@ extern void dummy_test(void);
 
 /* other external functions */
 
-extern void BenchTask(void *p1, void *p2, void *p3);
+extern void bench_task(void *p1, void *p2, void *p3);
 extern void recvtask(void *p1, void *p2, void *p3);
 
 #ifdef MAILBOX_BENCH
@@ -189,12 +189,12 @@ static inline u32_t BENCH_START(void)
 	return et;
 }
 
-#define check_result()				\
-{									\
-	if (bench_test_end() < 0) {		\
-		PRINT_OVERFLOW_ERROR();		\
-		return; /* error */			\
-	}								\
+static inline void check_result(void)
+{
+	if (bench_test_end() < 0) {
+		PRINT_OVERFLOW_ERROR();
+		return; /* error */
+	}
 }
 
 
diff --git a/tests/benchmarks/app_kernel/src/pipe_b.c b/tests/benchmarks/app_kernel/src/pipe_b.c
index 9d4dcb2b15c..ff5f99e62a0 100644
--- a/tests/benchmarks/app_kernel/src/pipe_b.c
+++ b/tests/benchmarks/app_kernel/src/pipe_b.c
@@ -13,7 +13,7 @@
 #ifdef FLOAT
 #define PRINT_ALL_TO_N_HEADER_UNIT()                                       \
 	PRINT_STRING("|   size(B) |       time/packet (usec)       |         "\
-		  " MB/sec                |\n", output_file);
+		  " MB/sec                |\n", output_file)
 
 #define PRINT_ALL_TO_N() \
 	PRINT_F(output_file,						\
@@ -25,9 +25,11 @@
 	     (1000.0 * putsize) / puttime[2])
 
 #define PRINT_1_TO_N_HEADER()                                             \
+	do { \
 	PRINT_STRING("|   size(B) |       time/packet (usec)       |        "\
 		  "  MB/sec                |\n", output_file);            \
-	PRINT_STRING(dashline, output_file);
+	PRINT_STRING(dashline, output_file);\
+	} while (0)
 
 #define  PRINT_1_TO_N()                                               \
 	PRINT_F(output_file,						\
@@ -44,7 +46,7 @@
 #else
 #define PRINT_ALL_TO_N_HEADER_UNIT()                                       \
 	PRINT_STRING("|   size(B) |       time/packet (nsec)       |         "\
-		  " KB/sec                |\n", output_file);
+		  " KB/sec                |\n", output_file)
 
 #define PRINT_ALL_TO_N() \
 	PRINT_F(output_file,                                                 \
@@ -53,12 +55,14 @@
 	     puttime[2],                                                  \
 	     (1000000 * putsize) / puttime[0],                            \
 	     (1000000 * putsize) / puttime[1],                            \
-	     (1000000 * putsize) / puttime[2]);
+	     (1000000 * putsize) / puttime[2])
 
 #define PRINT_1_TO_N_HEADER()                                             \
+	do { \
 	PRINT_STRING("|   size(B) |       time/packet (nsec)       |        "\
 		  "  KB/sec                |\n", output_file);            \
-	PRINT_STRING(dashline, output_file);
+	PRINT_STRING(dashline, output_file); \
+	} while (0)
 
 #define  PRINT_1_TO_N()                                              \
 	PRINT_F(output_file,                                            \
@@ -70,13 +74,13 @@
 	     puttime[2],                                             \
 	     (u32_t)((1000000 * (u64_t)putsize) / puttime[0]), \
 	     (u32_t)((1000000 * (u64_t)putsize) / puttime[1]), \
-	     (u32_t)((1000000 * (u64_t)putsize) / puttime[2]));
+	     (u32_t)((1000000 * (u64_t)putsize) / puttime[2]))
 #endif /* FLOAT */
 
 /*
  * Function prototypes.
  */
-int pipeput(struct k_pipe *pipe, pipe_options
+int pipeput(struct k_pipe *pipe, enum pipe_options
 		 option, int size, int count, u32_t *time);
 
 /*
@@ -98,7 +102,7 @@ void pipe_test(void)
 	int		pipe;
 	u32_t	TaskPrio = UINT32_MAX;
 	int		prio;
-	GetInfo	getinfo;
+	struct getinfo	getinfo;
 
 	k_sem_reset(&SEM0);
 	k_sem_give(&STARTRCV);
@@ -128,7 +132,7 @@ void pipe_test(void)
 	for (putsize = 8; putsize <= MESSAGE_SIZE_PIPE; putsize <<= 1) {
 		for (pipe = 0; pipe < 3; pipe++) {
 			putcount = NR_OF_PIPE_RUNS;
-			pipeput(TestPipes[pipe], _ALL_N, putsize, putcount,
+			pipeput(test_pipes[pipe], _ALL_N, putsize, putcount,
 				 &puttime[pipe]);
 
 			/* waiting for ack */
@@ -160,17 +164,17 @@ void pipe_test(void)
 		PRINT_STRING(dashline, output_file);
 
 	for (putsize = 8; putsize <= (MESSAGE_SIZE_PIPE); putsize <<= 1) {
-			putcount = MESSAGE_SIZE_PIPE / putsize;
-			for (pipe = 0; pipe < 3; pipe++) {
-				pipeput(TestPipes[pipe], _1_TO_N, putsize,
-						 putcount, &puttime[pipe]);
-				/* size*count == MESSAGE_SIZE_PIPE */
-				/* waiting for ack */
-				k_msgq_get(&CH_COMM, &getinfo, K_FOREVER);
-				getsize = getinfo.size;
-			}
-			PRINT_1_TO_N();
+		putcount = MESSAGE_SIZE_PIPE / putsize;
+		for (pipe = 0; pipe < 3; pipe++) {
+			pipeput(test_pipes[pipe], _1_TO_N, putsize,
+					 putcount, &puttime[pipe]);
+			/* size*count == MESSAGE_SIZE_PIPE */
+			/* waiting for ack */
+			k_msgq_get(&CH_COMM, &getinfo, K_FOREVER);
+			getsize = getinfo.size;
 		}
+		PRINT_1_TO_N();
+	}
 		PRINT_STRING(dashline, output_file);
 		k_thread_priority_set(k_current_get(), TaskPrio);
 	}
@@ -190,7 +194,7 @@ void pipe_test(void)
  * @param time     Total write time.
  */
 int pipeput(struct k_pipe *pipe,
-	    pipe_options option,
+	    enum pipe_options option,
 	    int size,
 	    int count,
 	    u32_t *time)
@@ -203,22 +207,22 @@ int pipeput(struct k_pipe *pipe,
 	/* first sync with the receiver */
 	k_sem_give(&SEM0);
 	t = BENCH_START();
-	for (i = 0; _1_TO_N == option || (i < count); i++) {
+	for (i = 0; option == _1_TO_N || (i < count); i++) {
 		size_t sizexferd = 0;
 		size_t size2xfer = min(size, size2xfer_total - sizexferd_total);
 		int ret;
-
 		size_t mim_num_of_bytes = 0;
+
 		if (option == _ALL_N) {
 			mim_num_of_bytes = size2xfer;
 		}
 		ret = k_pipe_put(pipe, data_bench, size2xfer,
 				&sizexferd, mim_num_of_bytes, K_FOREVER);
 
-		if (0 != ret) {
+		if (ret != 0) {
 			return 1;
 		}
-		if (_ALL_N == option && sizexferd != size2xfer) {
+		if (option == _ALL_N && sizexferd != size2xfer) {
 			return 1;
 		}
 
@@ -236,7 +240,8 @@ int pipeput(struct k_pipe *pipe,
 	*time = SYS_CLOCK_HW_CYCLES_TO_NS_AVG(t, count);
 	if (bench_test_end() < 0) {
 		if (high_timer_overflow()) {
-	PRINT_STRING("| Timer overflow. Results are invalid            ",
+			PRINT_STRING("| Timer overflow."
+					"Results are invalid            ",
 						 output_file);
 		} else {
 	PRINT_STRING("| Tick occurred. Results may be inaccurate       ",
diff --git a/tests/benchmarks/app_kernel/src/pipe_r.c b/tests/benchmarks/app_kernel/src/pipe_r.c
index 2347bf96fa9..e06aee39f84 100644
--- a/tests/benchmarks/app_kernel/src/pipe_r.c
+++ b/tests/benchmarks/app_kernel/src/pipe_r.c
@@ -15,7 +15,7 @@
 /*
  * Function prototypes.
  */
-int pipeget(struct k_pipe *pipe, pipe_options option,
+int pipeget(struct k_pipe *pipe, enum pipe_options option,
 			int size, int count, unsigned int *time);
 
 /*
@@ -37,14 +37,14 @@ void piperecvtask(void)
 	int getcount;
 	int pipe;
 	int prio;
-	GetInfo getinfo;
+	struct getinfo getinfo;
 
 	/* matching (ALL_N) */
 
 	for (getsize = 8; getsize <= MESSAGE_SIZE_PIPE; getsize <<= 1) {
 		for (pipe = 0; pipe < 3; pipe++) {
 			getcount = NR_OF_PIPE_RUNS;
-			pipeget(TestPipes[pipe], _ALL_N, getsize,
+			pipeget(test_pipes[pipe], _ALL_N, getsize,
 				getcount, &gettime);
 			getinfo.time = gettime;
 			getinfo.size = getsize;
@@ -57,19 +57,19 @@ void piperecvtask(void)
 	for (prio = 0; prio < 2; prio++) {
 		/* non-matching (1_TO_N) */
 	for (getsize = (MESSAGE_SIZE_PIPE); getsize >= 8; getsize >>= 1) {
-			getcount = MESSAGE_SIZE_PIPE / getsize;
-			for (pipe = 0; pipe < 3; pipe++) {
-				/* size*count == MESSAGE_SIZE_PIPE */
-				pipeget(TestPipes[pipe], _1_TO_N,
-						getsize, getcount, &gettime);
-				getinfo.time = gettime;
-				getinfo.size = getsize;
-				getinfo.count = getcount;
-				/* acknowledge to master */
-				k_msgq_put(&CH_COMM, &getinfo, K_FOREVER);
-			}
+		getcount = MESSAGE_SIZE_PIPE / getsize;
+		for (pipe = 0; pipe < 3; pipe++) {
+			/* size*count == MESSAGE_SIZE_PIPE */
+			pipeget(test_pipes[pipe], _1_TO_N,
+					getsize, getcount, &gettime);
+			getinfo.time = gettime;
+			getinfo.size = getsize;
+			getinfo.count = getcount;
+			/* acknowledge to master */
+			k_msgq_put(&CH_COMM, &getinfo, K_FOREVER);
 		}
 	}
+	}
 
 }
 
@@ -86,7 +86,7 @@ void piperecvtask(void)
  * @param count    Number of data chunks.
  * @param time     Total write time.
  */
-int pipeget(struct k_pipe *pipe, pipe_options option, int size, int count,
+int pipeget(struct k_pipe *pipe, enum pipe_options option, int size, int count,
 			unsigned int *time)
 {
 	int i;
@@ -97,7 +97,7 @@ int pipeget(struct k_pipe *pipe, pipe_options option, int size, int count,
 	/* sync with the sender */
 	k_sem_take(&SEM0, K_FOREVER);
 	t = BENCH_START();
-	for (i = 0; _1_TO_N == option || (i < count); i++) {
+	for (i = 0; option == _1_TO_N || (i < count); i++) {
 		size_t sizexferd = 0;
 		size_t size2xfer = min(size, size2xfer_total - sizexferd_total);
 		int ret;
@@ -105,11 +105,11 @@ int pipeget(struct k_pipe *pipe, pipe_options option, int size, int count,
 		ret = k_pipe_get(pipe, data_recv, size2xfer,
 				 &sizexferd, option, K_FOREVER);
 
-		if (0 != ret) {
+		if (ret != 0) {
 			return 1;
 		}
 
-		if (_ALL_N == option && sizexferd != size2xfer) {
+		if (option == _ALL_N  && sizexferd != size2xfer) {
 			return 1;
 		}
 
@@ -127,10 +127,12 @@ int pipeget(struct k_pipe *pipe, pipe_options option, int size, int count,
 	*time = SYS_CLOCK_HW_CYCLES_TO_NS_AVG(t, count);
 	if (bench_test_end() < 0) {
 		if (high_timer_overflow()) {
-			PRINT_STRING("| Timer overflow. Results are invalid            ",
+			PRINT_STRING("| Timer overflow. "
+			"Results are invalid            ",
 						 output_file);
 		} else {
-			PRINT_STRING("| Tick occurred. Results may be inaccurate       ",
+			PRINT_STRING("| Tick occurred. "
+			"Results may be inaccurate       ",
 						 output_file);
 		}
 		PRINT_STRING("                             |\n",
diff --git a/tests/benchmarks/app_kernel/src/receiver.h b/tests/benchmarks/app_kernel/src/receiver.h
index 7e2d5454281..cb4cbbcfa66 100644
--- a/tests/benchmarks/app_kernel/src/receiver.h
+++ b/tests/benchmarks/app_kernel/src/receiver.h
@@ -15,11 +15,11 @@
 #include "master.h"
 
 /* type defines. */
-typedef struct {
+struct getinfo{
 	int count;
 	unsigned int time;
 	int size;
-} GetInfo;
+};
 
 /* global data */
 extern char data_recv[OCTET_TO_SIZEOFUNIT(MESSAGE_SIZE)];
diff --git a/tests/drivers/uart/uart_basic_api/src/test_uart_poll.c b/tests/drivers/uart/uart_basic_api/src/test_uart_poll.c
index c80f674a10f..7f877374577 100644
--- a/tests/drivers/uart/uart_basic_api/src/test_uart_poll.c
+++ b/tests/drivers/uart/uart_basic_api/src/test_uart_poll.c
@@ -32,7 +32,7 @@ static const char *poll_data = "This is a POLL test.\r\n";
 
 static int test_poll_in(void)
 {
-	unsigned char recvChar;
+	unsigned char recv_char;
 	struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
 
 	if (!uart_dev) {
@@ -44,12 +44,12 @@ static int test_poll_in(void)
 
 	/* Verify uart_poll_in() */
 	while (1) {
-		while (uart_poll_in(uart_dev, &recvChar) < 0)
+		while (uart_poll_in(uart_dev, &recv_char) < 0)
 			;
 
-		TC_PRINT("%c", recvChar);
+		TC_PRINT("%c", recv_char);
 
-		if ((recvChar == '\n') || (recvChar == '\r')) {
+		if ((recv_char == '\n') || (recv_char == '\r')) {
 			break;
 		}
 	}
@@ -60,7 +60,7 @@ static int test_poll_in(void)
 static int test_poll_out(void)
 {
 	int i;
-	unsigned char sentChar;
+	unsigned char sent_char;
 	struct device *uart_dev = device_get_binding(UART_DEVICE_NAME);
 
 	if (!uart_dev) {
@@ -70,11 +70,11 @@ static int test_poll_out(void)
 
 	/* Verify uart_poll_out() */
 	for (i = 0; i < strlen(poll_data); i++) {
-		sentChar = uart_poll_out(uart_dev, poll_data[i]);
+		sent_char = uart_poll_out(uart_dev, poll_data[i]);
 
-		if (sentChar != poll_data[i]) {
+		if (sent_char != poll_data[i]) {
 			TC_PRINT("expect send %c, actaul send %c\n",
-						poll_data[i], sentChar);
+						poll_data[i], sent_char);
 			return TC_FAIL;
 		}
 	}
diff --git a/tests/kernel/alert/alert_api/src/test_alert_contexts.c b/tests/kernel/alert/alert_api/src/test_alert_contexts.c
index 8ef0918f75c..877abde2e64 100644
--- a/tests/kernel/alert/alert_api/src/test_alert_contexts.c
+++ b/tests/kernel/alert/alert_api/src/test_alert_contexts.c
@@ -82,7 +82,7 @@ static void alert_recv(void)
 	}
 }
 
-static void tThread_entry(void *p1, void *p2, void *p3)
+static void thread_entry(void *p1, void *p2, void *p3)
 {
 	alert_recv();
 }
@@ -92,14 +92,14 @@ static void thread_alert(void)
 	handler_executed = 0;
 	/**TESTPOINT: thread-thread sync via alert*/
 	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
-				      tThread_entry, NULL, NULL, NULL,
+				      thread_entry, NULL, NULL, NULL,
 				      K_PRIO_PREEMPT(0), 0, 0);
 	alert_send();
 	k_sleep(TIMEOUT);
 	k_thread_abort(tid);
 }
 
-static void tIsr_entry(void *p)
+static void tisr_entry(void *p)
 {
 	alert_send();
 }
@@ -108,7 +108,7 @@ static void isr_alert(void)
 {
 	handler_executed = 0;
 	/**TESTPOINT: thread-isr sync via alert*/
-	irq_offload(tIsr_entry, NULL);
+	irq_offload(tisr_entry, NULL);
 	k_sleep(TIMEOUT);
 	alert_recv();
 }
diff --git a/tests/kernel/critical/src/critical.c b/tests/kernel/critical/src/critical.c
index f30dc0760dd..1f3154d8f46 100644
--- a/tests/kernel/critical/src/critical.c
+++ b/tests/kernel/critical/src/critical.c
@@ -18,8 +18,8 @@
 #define NUM_MILLISECONDS        5000
 #define TEST_TIMEOUT            20000
 
-static u32_t criticalVar;
-static u32_t altTaskIterations;
+static u32_t critical_var;
+static u32_t alt_task_iterations;
 
 static struct k_work_q offload_work_q;
 static K_THREAD_STACK_DEFINE(offload_work_q_stack,
@@ -40,19 +40,19 @@ K_SEM_DEFINE(TEST_SEM, 0, UINT_MAX);
  *
  * @brief Routine to be called from a workqueue
  *
- * This routine increments the global variable <criticalVar>.
+ * This routine increments the global variable <critical_var>.
  *
  * @return 0
  */
 
-void criticalRtn(struct k_work *unused)
+void critical_rtn(struct k_work *unused)
 {
 	volatile u32_t x;
 
 	ARG_UNUSED(unused);
 
-	x = criticalVar;
-	criticalVar = x + 1;
+	x = critical_var;
+	critical_var = x + 1;
 
 }
 
@@ -65,7 +65,7 @@ void criticalRtn(struct k_work *unused)
  * @return number of critical section calls made by task
  */
 
-u32_t criticalLoop(u32_t count)
+u32_t critical_loop(u32_t count)
 {
 	s64_t mseconds;
 
@@ -73,7 +73,7 @@ u32_t criticalLoop(u32_t count)
 	while (k_uptime_get() < mseconds + NUM_MILLISECONDS) {
 		struct k_work work_item;
 
-		k_work_init(&work_item, criticalRtn);
+		k_work_init(&work_item, critical_rtn);
 		k_work_submit_to_queue(&offload_work_q, &work_item);
 		count++;
 	}
@@ -90,7 +90,7 @@ u32_t criticalLoop(u32_t count)
  * @return N/A
  */
 
-void AlternateTask(void *arg1, void *arg2, void *arg3)
+void alternate_task(void *arg1, void *arg2, void *arg3)
 {
 	ARG_UNUSED(arg1);
 	ARG_UNUSED(arg2);
@@ -98,13 +98,13 @@ void AlternateTask(void *arg1, void *arg2, void *arg3)
 
 	k_sem_take(&ALT_SEM, K_FOREVER);        /* Wait to be activated */
 
-	altTaskIterations = criticalLoop(altTaskIterations);
+	alt_task_iterations = critical_loop(alt_task_iterations);
 
 	k_sem_give(&REGRESS_SEM);
 
 	k_sem_take(&ALT_SEM, K_FOREVER);        /* Wait to be re-activated */
 
-	altTaskIterations = criticalLoop(altTaskIterations);
+	alt_task_iterations = critical_loop(alt_task_iterations);
 
 	k_sem_give(&REGRESS_SEM);
 }
@@ -120,9 +120,9 @@ void AlternateTask(void *arg1, void *arg2, void *arg3)
  * @return N/A
  */
 
-void RegressionTask(void *arg1, void *arg2, void *arg3)
+void regression_task(void *arg1, void *arg2, void *arg3)
 {
-	u32_t nCalls = 0;
+	u32_t ncalls = 0;
 
 	ARG_UNUSED(arg1);
 	ARG_UNUSED(arg2);
@@ -130,26 +130,26 @@ void RegressionTask(void *arg1, void *arg2, void *arg3)
 
 	k_sem_give(&ALT_SEM);   /* Activate AlternateTask() */
 
-	nCalls = criticalLoop(nCalls);
+	ncalls = critical_loop(ncalls);
 
 	/* Wait for AlternateTask() to complete */
 	zassert_true(k_sem_take(&REGRESS_SEM, TEST_TIMEOUT) == 0,
 		     "Timed out waiting for REGRESS_SEM");
 
-	zassert_equal(criticalVar, nCalls + altTaskIterations,
+	zassert_equal(critical_var, ncalls + alt_task_iterations,
 		      "Unexpected value for <criticalVar>");
 
 	k_sched_time_slice_set(10, 10);
 
 	k_sem_give(&ALT_SEM);   /* Re-activate AlternateTask() */
 
-	nCalls = criticalLoop(nCalls);
+	ncalls = critical_loop(ncalls);
 
 	/* Wait for AlternateTask() to finish */
 	zassert_true(k_sem_take(&REGRESS_SEM, TEST_TIMEOUT) == 0,
 		     "Timed out waiting for REGRESS_SEM");
 
-	zassert_equal(criticalVar, nCalls + altTaskIterations,
+	zassert_equal(critical_var, ncalls + alt_task_iterations,
 		      "Unexpected value for <criticalVar>");
 
 	k_sem_give(&TEST_SEM);
@@ -158,8 +158,8 @@ void RegressionTask(void *arg1, void *arg2, void *arg3)
 
 static void init_objects(void)
 {
-	criticalVar = 0;
-	altTaskIterations = 0;
+	critical_var = 0;
+	alt_task_iterations = 0;
 	k_work_q_start(&offload_work_q,
 		       offload_work_q_stack,
 		       K_THREAD_STACK_SIZEOF(offload_work_q_stack),
@@ -169,11 +169,11 @@ static void init_objects(void)
 static void start_threads(void)
 {
 	k_thread_create(&thread1, stack1, STACK_SIZE,
-			AlternateTask, NULL, NULL, NULL,
+			alternate_task, NULL, NULL, NULL,
 			K_PRIO_PREEMPT(12), 0, 0);
 
 	k_thread_create(&thread2, stack2, STACK_SIZE,
-			RegressionTask, NULL, NULL, NULL,
+			regression_task, NULL, NULL, NULL,
 			K_PRIO_PREEMPT(12), 0, 0);
 }
 
diff --git a/tests/kernel/mem_slab/mslab/src/slab.c b/tests/kernel/mem_slab/mslab/src/slab.c
index a91c3c588f3..6d7b06fa667 100644
--- a/tests/kernel/mem_slab/mslab/src/slab.c
+++ b/tests/kernel/mem_slab/mslab/src/slab.c
@@ -27,23 +27,23 @@
 #include <zephyr.h>
 
 /* size of stack area used by each thread */
-#define STACKSIZE 1024 + CONFIG_TEST_EXTRA_STACKSIZE
+#define STACKSIZE (1024 + CONFIG_TEST_EXTRA_STACKSIZE)
 
 /* Number of memory blocks. The minimum number of blocks needed to run the
  * test is 2
  */
 #define NUMBLOCKS   2
 
-static int tcRC = TC_PASS;     /* test case return code */
+static int tc_rc = TC_PASS;     /* test case return code */
 
-int testSlabGetAllBlocks(void **P);
-int testSlabFreeAllBlocks(void **P);
+int test_slab_get_all_blocks(void **P);
+int test_slab_free_all_blocks(void **P);
 
 
 K_SEM_DEFINE(SEM_HELPERDONE, 0, 1);
 K_SEM_DEFINE(SEM_REGRESSDONE, 0, 1);
 
-K_MEM_SLAB_DEFINE(MAP_LgBlks, 1024, NUMBLOCKS, 4);
+K_MEM_SLAB_DEFINE(map_lgblks, 1024, NUMBLOCKS, 4);
 
 
 /**
@@ -53,17 +53,17 @@ K_MEM_SLAB_DEFINE(MAP_LgBlks, 1024, NUMBLOCKS, 4);
  * This routine verifies current value against expected value
  * and returns true if they are the same.
  *
- * @param expectRetValue     expect value
- * @param currentRetValue    current value
+ * @param expect_ret_value     expect value
+ * @param current_ret_current    current value
  *
  * @return  true, false
  */
 
-bool verifyRetValue(int expectRetValue, int currentRetValue)
+bool verify_ret_value(int expect_ret_value, int current_ret_current)
 {
-	return (expectRetValue == currentRetValue);
+	return (expect_ret_value == current_ret_current);
 
-} /* verifyRetValue */
+} /* verify_ret_value */
 
 /**
  *
@@ -76,7 +76,7 @@ bool verifyRetValue(int expectRetValue, int currentRetValue)
  * @return  N/A
  */
 
-void HelperTask(void)
+void helper_task(void)
 {
 	void *ptr[NUMBLOCKS];           /* Pointer to memory block */
 
@@ -92,10 +92,10 @@ void HelperTask(void)
 	PRINT_LINE;
 
 	/* Test k_mem_slab_alloc */
-	tcRC = testSlabGetAllBlocks(ptr);
-	if (tcRC == TC_FAIL) {
-		TC_ERROR("Failed testSlabGetAllBlocks function\n");
-		goto exitTest1;          /* terminate test */
+	tc_rc = test_slab_get_all_blocks(ptr);
+	if (tc_rc == TC_FAIL) {
+		TC_ERROR("Failed test_slab_get_all_blocks function\n");
+		goto exittest1;          /* terminate test */
 	}
 
 	k_sem_give(&SEM_HELPERDONE);  /* Indicate part 2 is complete */
@@ -114,7 +114,7 @@ void HelperTask(void)
 	PRINT_LINE;
 
 	TC_PRINT("%s: About to free a memory block\n", __func__);
-	k_mem_slab_free(&MAP_LgBlks, &ptr[0]);
+	k_mem_slab_free(&map_lgblks, &ptr[0]);
 	k_sem_give(&SEM_HELPERDONE);
 
 	/* Part 5 of test */
@@ -123,19 +123,19 @@ void HelperTask(void)
 	TC_PRINT("(5) <%s> freeing the next block\n", __func__);
 	PRINT_LINE;
 	TC_PRINT("%s: About to free another memory block\n", __func__);
-	k_mem_slab_free(&MAP_LgBlks, &ptr[1]);
+	k_mem_slab_free(&map_lgblks, &ptr[1]);
 
 	/*
 	 * Free all the other blocks.  The first 2 blocks are freed by this task
 	 */
 	for (int i = 2; i < NUMBLOCKS; i++) {
-		k_mem_slab_free(&MAP_LgBlks, &ptr[i]);
+		k_mem_slab_free(&map_lgblks, &ptr[i]);
 	}
 	TC_PRINT("%s: freed all blocks allocated by this task\n", __func__);
 
-exitTest1:
+exittest1:
 
-	TC_END_RESULT(tcRC);
+	TC_END_RESULT(tc_rc);
 	k_sem_give(&SEM_HELPERDONE);
 }  /* HelperTask */
 
@@ -156,33 +156,33 @@ exitTest1:
  * @return  TC_PASS, TC_FAIL
  */
 
-int testSlabGetAllBlocks(void **p)
+int test_slab_get_all_blocks(void **p)
 {
-	int retValue;   /* task_mem_map_xxx interface return value */
-	void *errPtr;   /* Pointer to block */
+	int ret_value;   /* task_mem_map_xxx interface return value */
+	void *errptr;   /* Pointer to block */
 
 	TC_PRINT("Function %s\n", __func__);
 
 	for (int i = 0; i < NUMBLOCKS; i++) {
 		/* Verify number of used blocks in the map */
-		retValue = k_mem_slab_num_used_get(&MAP_LgBlks);
-		if (verifyRetValue(i, retValue)) {
-			TC_PRINT("MAP_LgBlks used %d blocks\n", retValue);
+		ret_value = k_mem_slab_num_used_get(&map_lgblks);
+		if (verify_ret_value(i, ret_value)) {
+			TC_PRINT("MAP_LgBlks used %d blocks\n", ret_value);
 		} else {
 			TC_ERROR("Failed task_mem_map_used_get for "
 				 "MAP_LgBlks, i=%d, retValue=%d\n",
-				 i, retValue);
+				 i, ret_value);
 			return TC_FAIL;
 		}
 
 		/* Get memory block */
-		retValue = k_mem_slab_alloc(&MAP_LgBlks, &p[i], K_NO_WAIT);
-		if (verifyRetValue(0, retValue)) {
+		ret_value = k_mem_slab_alloc(&map_lgblks, &p[i], K_NO_WAIT);
+		if (verify_ret_value(0, ret_value)) {
 			TC_PRINT("  k_mem_slab_alloc OK, p[%d] = %p\n",
 				 i, p[i]);
 		} else {
 			TC_ERROR("Failed k_mem_slab_alloc, i=%d, "
-				 "retValue %d\n", i, retValue);
+				 "ret_value %d\n", i, ret_value);
 			return TC_FAIL;
 		}
 
@@ -191,30 +191,30 @@ int testSlabGetAllBlocks(void **p)
 	/* Verify number of used blocks in the map - expect all blocks are
 	 * used
 	 */
-	retValue = k_mem_slab_num_used_get(&MAP_LgBlks);
-	if (verifyRetValue(NUMBLOCKS, retValue)) {
-		TC_PRINT("MAP_LgBlks used %d blocks\n", retValue);
+	ret_value = k_mem_slab_num_used_get(&map_lgblks);
+	if (verify_ret_value(NUMBLOCKS, ret_value)) {
+		TC_PRINT("MAP_LgBlks used %d blocks\n", ret_value);
 	} else {
 		TC_ERROR("Failed task_mem_map_used_get for MAP_LgBlks, "
-			 "retValue %d\n", retValue);
+			 "retValue %d\n", ret_value);
 		return TC_FAIL;
 	}
 
 	/* Try to get one more block and it should fail */
-	retValue = k_mem_slab_alloc(&MAP_LgBlks, &errPtr, K_NO_WAIT);
-	if (verifyRetValue(-ENOMEM, retValue)) {
+	ret_value = k_mem_slab_alloc(&map_lgblks, &errptr, K_NO_WAIT);
+	if (verify_ret_value(-ENOMEM, ret_value)) {
 		TC_PRINT("  k_mem_slab_alloc RC_FAIL expected as all (%d) "
 			 "blocks are used.\n", NUMBLOCKS);
 	} else {
 		TC_ERROR("Failed k_mem_slab_alloc, expect RC_FAIL, got %d\n",
-			 retValue);
+			 ret_value);
 		return TC_FAIL;
 	}
 
 	PRINT_LINE;
 
 	return TC_PASS;
-}  /* testSlabGetAllBlocks */
+}  /* test_slab_get_all_blocks */
 
 /**
  *
@@ -232,27 +232,27 @@ int testSlabGetAllBlocks(void **p)
  * @return  TC_PASS, TC_FAIL
  */
 
-int testSlabFreeAllBlocks(void **p)
+int test_slab_free_all_blocks(void **p)
 {
-	int retValue;     /* task_mem_map_xxx interface return value */
+	int ret_value;     /* task_mem_map_xxx interface return value */
 
 	TC_PRINT("Function %s\n", __func__);
 
 	for (int i = 0; i < NUMBLOCKS; i++) {
 		/* Verify number of used blocks in the map */
-		retValue = k_mem_slab_num_used_get(&MAP_LgBlks);
-		if (verifyRetValue(NUMBLOCKS - i, retValue)) {
-			TC_PRINT("MAP_LgBlks used %d blocks\n", retValue);
+		ret_value = k_mem_slab_num_used_get(&map_lgblks);
+		if (verify_ret_value(NUMBLOCKS - i, ret_value)) {
+			TC_PRINT("MAP_LgBlks used %d blocks\n", ret_value);
 		} else {
 			TC_ERROR("Failed task_mem_map_used_get for "
 				 "MAP_LgBlks, expect %d, got %d\n",
-				 NUMBLOCKS - i, retValue);
+				 NUMBLOCKS - i, ret_value);
 			return TC_FAIL;
 		}
 
 		TC_PRINT("  block ptr to free p[%d] = %p\n", i, p[i]);
 		/* Free memory block */
-		k_mem_slab_free(&MAP_LgBlks, &p[i]);
+		k_mem_slab_free(&map_lgblks, &p[i]);
 
 		TC_PRINT("MAP_LgBlks freed %d block\n", i + 1);
 
@@ -263,12 +263,12 @@ int testSlabFreeAllBlocks(void **p)
 	 *  - should be 0 as no blocks are used
 	 */
 
-	retValue = k_mem_slab_num_used_get(&MAP_LgBlks);
-	if (verifyRetValue(0, retValue)) {
-		TC_PRINT("MAP_LgBlks used %d blocks\n", retValue);
+	ret_value = k_mem_slab_num_used_get(&map_lgblks);
+	if (verify_ret_value(0, ret_value)) {
+		TC_PRINT("MAP_LgBlks used %d blocks\n", ret_value);
 	} else {
 		TC_ERROR("Failed task_mem_map_used_get for MAP_LgBlks, "
-			 "retValue %d\n", retValue);
+			 "retValue %d\n", ret_value);
 		return TC_FAIL;
 	}
 
@@ -286,7 +286,7 @@ int testSlabFreeAllBlocks(void **p)
  *
  * @return  N/A
  */
-void printPointers(void **pointer)
+void print_pointers(void **pointer)
 {
 	TC_PRINT("%s: ", __func__);
 	for (int i = 0; i < NUMBLOCKS; i++) {
@@ -296,15 +296,15 @@ void printPointers(void **pointer)
 	TC_PRINT("\n");
 	PRINT_LINE;
 
-}  /* printPointers */
+}  /* print_pointers */
 
 /**
  *
  * @brief Main task to test task_mem_map_xxx interfaces
  *
- * This routine calls testSlabGetAllBlocks() to get all memory blocks from the
- * map and calls testSlabFreeAllBlocks() to free all memory blocks.  It also
- * tries to wait (with and without timeout) for a memory block.
+ * This routine calls test_slab_get_all_blocks() to get all memory blocks from
+ * the map and calls test_slab_free_all_blocks() to free all memory blocks.
+ * It also tries to wait (with and without timeout) for a memory block.
  *
  * This routine tests the following:
  *
@@ -313,11 +313,11 @@ void printPointers(void **pointer)
  * @return  N/A
  */
 
-void RegressionTask(void)
+void regression_task(void)
 {
-	int retValue;                   /* task_mem_map_xxx interface return value */
-	void *b;                        /* Pointer to memory block */
-	void *ptr[NUMBLOCKS];           /* Pointer to memory block */
+	int ret_value;             /* task_mem_map_xxx interface return value */
+	void *b;                  /* Pointer to memory block */
+	void *ptr[NUMBLOCKS];     /* Pointer to memory block */
 
 	/* not strictly necessary, but keeps coverity checks happy */
 	memset(ptr, 0, sizeof(ptr));
@@ -332,18 +332,18 @@ void RegressionTask(void)
 	PRINT_LINE;
 
 	/* Test k_mem_slab_alloc */
-	tcRC = testSlabGetAllBlocks(ptr);
-	if (tcRC == TC_FAIL) {
-		TC_ERROR("Failed testSlabGetAllBlocks function\n");
-		goto exitTest;           /* terminate test */
+	tc_rc = test_slab_get_all_blocks(ptr);
+	if (tc_rc == TC_FAIL) {
+		TC_ERROR("Failed test_slab_get_all_blocks function\n");
+		goto exittest;           /* terminate test */
 	}
 
-	printPointers(ptr);
+	print_pointers(ptr);
 	/* Test task_mem_map_free */
-	tcRC = testSlabFreeAllBlocks(ptr);
-	if (tcRC == TC_FAIL) {
-		TC_ERROR("Failed testSlabFreeAllBlocks function\n");
-		goto exitTest;           /* terminate test */
+	tc_rc = test_slab_free_all_blocks(ptr);
+	if (tc_rc == TC_FAIL) {
+		TC_ERROR("Failed testalab_freeall_blocks function\n");
+		goto exittest;           /* terminate test */
 	}
 
 	k_sem_give(&SEM_REGRESSDONE);   /* Allow HelperTask to run */
@@ -363,26 +363,26 @@ void RegressionTask(void)
 		 "in <%s>\n", __func__);
 	PRINT_LINE;
 
-	retValue = k_mem_slab_alloc(&MAP_LgBlks, &b, 20);
-	if (verifyRetValue(-EAGAIN, retValue)) {
+	ret_value = k_mem_slab_alloc(&map_lgblks, &b, 20);
+	if (verify_ret_value(-EAGAIN, ret_value)) {
 		TC_PRINT("%s: k_mem_slab_alloc times out which is "
 			 "expected\n", __func__);
 	} else {
-		TC_ERROR("Failed k_mem_slab_alloc, retValue %d\n", retValue);
-		tcRC = TC_FAIL;
-		goto exitTest;           /* terminate test */
+		TC_ERROR("Failed k_mem_slab_alloc, retValue %d\n", ret_value);
+		tc_rc = TC_FAIL;
+		goto exittest;           /* terminate test */
 	}
 
 	TC_PRINT("%s: start to wait for block\n", __func__);
 	k_sem_give(&SEM_REGRESSDONE);    /* Allow HelperTask to run part 4 */
-	retValue = k_mem_slab_alloc(&MAP_LgBlks, &b, 50);
-	if (verifyRetValue(0, retValue)) {
+	ret_value = k_mem_slab_alloc(&map_lgblks, &b, 50);
+	if (verify_ret_value(0, ret_value)) {
 		TC_PRINT("%s: k_mem_slab_alloc OK, block allocated at %p\n",
 			 __func__, b);
 	} else {
-		TC_ERROR("Failed k_mem_slab_alloc, retValue %d\n", retValue);
-		tcRC = TC_FAIL;
-		goto exitTest;           /* terminate test */
+		TC_ERROR("Failed k_mem_slab_alloc, ret_value %d\n", ret_value);
+		tc_rc = TC_FAIL;
+		goto exittest;           /* terminate test */
 	}
 
 	/* Wait for HelperTask to complete */
@@ -390,14 +390,14 @@ void RegressionTask(void)
 
 	TC_PRINT("%s: start to wait for block\n", __func__);
 	k_sem_give(&SEM_REGRESSDONE);    /* Allow HelperTask to run part 5 */
-	retValue = k_mem_slab_alloc(&MAP_LgBlks, &b, K_FOREVER);
-	if (verifyRetValue(0, retValue)) {
+	ret_value = k_mem_slab_alloc(&map_lgblks, &b, K_FOREVER);
+	if (verify_ret_value(0, ret_value)) {
 		TC_PRINT("%s: k_mem_slab_alloc OK, block allocated at %p\n",
 			 __func__, b);
 	} else {
-		TC_ERROR("Failed k_mem_slab_alloc, retValue %d\n", retValue);
-		tcRC = TC_FAIL;
-		goto exitTest;           /* terminate test */
+		TC_ERROR("Failed k_mem_slab_alloc, ret_value %d\n", ret_value);
+		tc_rc = TC_FAIL;
+		goto exittest;           /* terminate test */
 	}
 
 	/* Wait for HelperTask to complete */
@@ -406,19 +406,19 @@ void RegressionTask(void)
 
 	/* Free memory block */
 	TC_PRINT("%s: Used %d block\n", __func__,
-		 k_mem_slab_num_used_get(&MAP_LgBlks));
-	k_mem_slab_free(&MAP_LgBlks, &b);
+		 k_mem_slab_num_used_get(&map_lgblks));
+	k_mem_slab_free(&map_lgblks, &b);
 	TC_PRINT("%s: 1 block freed, used %d block\n",
-		 __func__,  k_mem_slab_num_used_get(&MAP_LgBlks));
+		 __func__,  k_mem_slab_num_used_get(&map_lgblks));
 
-exitTest:
+exittest:
 
-	TC_END_RESULT(tcRC);
-	TC_END_REPORT(tcRC);
-}  /* RegressionTask */
+	TC_END_RESULT(tc_rc);
+	TC_END_REPORT(tc_rc);
+}  /* regression_task */
 
-K_THREAD_DEFINE(HELPERTASK, STACKSIZE, HelperTask, NULL, NULL, NULL,
+K_THREAD_DEFINE(HELPERTASK, STACKSIZE, helper_task, NULL, NULL, NULL,
 		7, 0, K_NO_WAIT);
 
-K_THREAD_DEFINE(REGRESSTASK, STACKSIZE, RegressionTask, NULL, NULL, NULL,
+K_THREAD_DEFINE(REGRESSTASK, STACKSIZE, regression_task, NULL, NULL, NULL,
 		5, 0, K_NO_WAIT);
diff --git a/tests/kernel/msgq/msgq_api/src/test_msgq_contexts.c b/tests/kernel/msgq/msgq_api/src/test_msgq_contexts.c
index 9cdce2cf195..659aee0e2af 100644
--- a/tests/kernel/msgq/msgq_api/src/test_msgq_contexts.c
+++ b/tests/kernel/msgq/msgq_api/src/test_msgq_contexts.c
@@ -31,7 +31,8 @@ static void put_msgq(struct k_msgq *pmsgq)
 		ret = k_msgq_put(pmsgq, (void *)&data[i], K_NO_WAIT);
 		zassert_false(ret, NULL);
 		/**TESTPOINT: msgq free get*/
-		zassert_equal(k_msgq_num_free_get(pmsgq), MSGQ_LEN - 1 - i, NULL);
+		zassert_equal(k_msgq_num_free_get(pmsgq),
+				MSGQ_LEN - 1 - i, NULL);
 		/**TESTPOINT: msgq used get*/
 		zassert_equal(k_msgq_num_used_get(pmsgq), i + 1, NULL);
 	}
@@ -49,7 +50,8 @@ static void get_msgq(struct k_msgq *pmsgq)
 		/**TESTPOINT: msgq free get*/
 		zassert_equal(k_msgq_num_free_get(pmsgq), i + 1, NULL);
 		/**TESTPOINT: msgq used get*/
-		zassert_equal(k_msgq_num_used_get(pmsgq), MSGQ_LEN - 1 - i, NULL);
+		zassert_equal(k_msgq_num_used_get(pmsgq),
+				MSGQ_LEN - 1 - i, NULL);
 	}
 }
 
@@ -60,12 +62,12 @@ static void purge_msgq(struct k_msgq *pmsgq)
 	zassert_equal(k_msgq_num_used_get(pmsgq), 0, NULL);
 }
 
-static void tIsr_entry(void *p)
+static void tisr_entry(void *p)
 {
 	put_msgq((struct k_msgq *)p);
 }
 
-static void tThread_entry(void *p1, void *p2, void *p3)
+static void thread_entry(void *p1, void *p2, void *p3)
 {
 	get_msgq((struct k_msgq *)p1);
 	k_sem_give(&end_sema);
@@ -76,7 +78,7 @@ static void msgq_thread(struct k_msgq *pmsgq)
 	k_sem_init(&end_sema, 0, 1);
 	/**TESTPOINT: thread-thread data passing via message queue*/
 	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
-				      tThread_entry, pmsgq, NULL, NULL,
+				      thread_entry, pmsgq, NULL, NULL,
 				      K_PRIO_PREEMPT(0), 0, 0);
 	put_msgq(pmsgq);
 	k_sem_take(&end_sema, K_FOREVER);
@@ -89,7 +91,7 @@ static void msgq_thread(struct k_msgq *pmsgq)
 static void msgq_isr(struct k_msgq *pmsgq)
 {
 	/**TESTPOINT: thread-isr data passing via message queue*/
-	irq_offload(tIsr_entry, pmsgq);
+	irq_offload(tisr_entry, pmsgq);
 	get_msgq(pmsgq);
 
 	/**TESTPOINT: msgq purge*/
diff --git a/tests/kernel/mutex/mutex/src/mutex.c b/tests/kernel/mutex/mutex/src/mutex.c
index 8c9156dfbd3..69e122dcd0e 100644
--- a/tests/kernel/mutex/mutex/src/mutex.c
+++ b/tests/kernel/mutex/mutex/src/mutex.c
@@ -51,35 +51,35 @@
 
 #define STACKSIZE 512
 
-static int tcRC = TC_PASS;         /* test case return code */
+static int tc_rc = TC_PASS;         /* test case return code */
 
 K_MUTEX_DEFINE(private_mutex);
 
 
-K_MUTEX_DEFINE(Mutex1);
-K_MUTEX_DEFINE(Mutex2);
-K_MUTEX_DEFINE(Mutex3);
-K_MUTEX_DEFINE(Mutex4);
+K_MUTEX_DEFINE(mutex1);
+K_MUTEX_DEFINE(mutex2);
+K_MUTEX_DEFINE(mutex3);
+K_MUTEX_DEFINE(mutex4);
 
 /**
  *
- * Task05 -
+ * task05 -
  *
  * @return  N/A
  */
 
-void Task05(void)
+void task05(void)
 {
 	int rv;
 
 	k_sleep(K_MSEC(3500));
 
 	/* Wait and boost owner priority to 5 */
-	rv = k_mutex_lock(&Mutex4, K_SECONDS(1));
+	rv = k_mutex_lock(&mutex4, K_SECONDS(1));
 	if (rv != -EAGAIN) {
-		tcRC = TC_FAIL;
+		tc_rc = TC_FAIL;
 		TC_ERROR("Failed to timeout on mutex 0x%x\n",
-			 (u32_t)&Mutex4);
+			 (u32_t)&mutex4);
 		return;
 	}
 }
@@ -87,12 +87,12 @@ void Task05(void)
 
 /**
  *
- * Task06 -
+ * task06 -
  *
  * @return  N/A
  */
 
-void Task06(void)
+void task06(void)
 {
 	int rv;
 
@@ -107,24 +107,24 @@ void Task06(void)
 	 * to 7, but will instead drop to 6.
 	 */
 
-	rv = k_mutex_lock(&Mutex4, K_SECONDS(2));
+	rv = k_mutex_lock(&mutex4, K_SECONDS(2));
 	if (rv != 0) {
-		tcRC = TC_FAIL;
-		TC_ERROR("Failed to take mutex 0x%x\n", (u32_t)&Mutex4);
+		tc_rc = TC_FAIL;
+		TC_ERROR("Failed to take mutex 0x%x\n", (u32_t)&mutex4);
 		return;
 	}
 
-	k_mutex_unlock(&Mutex4);
+	k_mutex_unlock(&mutex4);
 }
 
 /**
  *
- * Task07 -
+ * task07 -
  *
  * @return  N/A
  */
 
-void Task07(void)
+void task07(void)
 {
 	int rv;
 
@@ -138,11 +138,11 @@ void Task07(void)
 	 * priority of the owning task RegressionTask will drop to 8.
 	 */
 
-	rv = k_mutex_lock(&Mutex3, K_SECONDS(3));
+	rv = k_mutex_lock(&mutex3, K_SECONDS(3));
 	if (rv != -EAGAIN) {
-		tcRC = TC_FAIL;
+		tc_rc = TC_FAIL;
 		TC_ERROR("Failed to timeout on mutex 0x%x\n",
-			 (u32_t)&Mutex3);
+			 (u32_t)&mutex3);
 		return;
 	}
 
@@ -150,85 +150,85 @@ void Task07(void)
 
 /**
  *
- * Task08 -
+ * task08 -
  *
  * @return  N/A
  */
 
-void Task08(void)
+void task08(void)
 {
 	int rv;
 
 	k_sleep(K_MSEC(1500));
 
 	/* Wait and boost owner priority to 8 */
-	rv = k_mutex_lock(&Mutex2, K_FOREVER);
+	rv = k_mutex_lock(&mutex2, K_FOREVER);
 	if (rv != 0) {
-		tcRC = TC_FAIL;
-		TC_ERROR("Failed to take mutex 0x%x\n", (u32_t)&Mutex2);
+		tc_rc = TC_FAIL;
+		TC_ERROR("Failed to take mutex 0x%x\n", (u32_t)&mutex2);
 		return;
 	}
 
-	k_mutex_unlock(&Mutex2);
+	k_mutex_unlock(&mutex2);
 }
 
 /**
  *
- * Task09 -
+ * task09 -
  *
  * @return  N/A
  */
 
-void Task09(void)
+void task09(void)
 {
 	int rv;
 
-	k_sleep(K_MSEC(500));                   /* Allow lower priority task to run */
+	k_sleep(K_MSEC(500));	/* Allow lower priority task to run */
 
-	rv = k_mutex_lock(&Mutex1, K_NO_WAIT);  /*<Mutex1> is already locked. */
-	if (rv != -EBUSY) {                     /* This attempt to lock the mutex */
+	rv = k_mutex_lock(&mutex1, K_NO_WAIT);  /*<Mutex1> is already locked. */
+	if (rv != -EBUSY) {	/* This attempt to lock the mutex */
 		/* should not succeed. */
-		tcRC = TC_FAIL;
+		tc_rc = TC_FAIL;
 		TC_ERROR("Failed to NOT take locked mutex 0x%x\n",
-			 (u32_t)&Mutex1);
+			 (u32_t)&mutex1);
 		return;
 	}
 
 	/* Wait and boost owner priority to 9 */
-	rv = k_mutex_lock(&Mutex1, K_FOREVER);
+	rv = k_mutex_lock(&mutex1, K_FOREVER);
 	if (rv != 0) {
-		tcRC = TC_FAIL;
-		TC_ERROR("Failed to take mutex 0x%x\n", (u32_t)&Mutex1);
+		tc_rc = TC_FAIL;
+		TC_ERROR("Failed to take mutex 0x%x\n", (u32_t)&mutex1);
 		return;
 	}
 
-	k_mutex_unlock(&Mutex1);
+	k_mutex_unlock(&mutex1);
 }
 
 /**
  *
- * Task11 -
+ * task11 -
  *
  * @return N/A
  */
 
-void Task11(void)
+void task11(void)
 {
 	int rv;
 
 	k_sleep(K_MSEC(3500));
-	rv = k_mutex_lock(&Mutex3, K_FOREVER);
+	rv = k_mutex_lock(&mutex3, K_FOREVER);
 	if (rv != 0) {
-		tcRC = TC_FAIL;
-		TC_ERROR("Failed to take mutex 0x%x\n", (u32_t)&Mutex2);
+		tc_rc = TC_FAIL;
+		TC_ERROR("Failed to take mutex 0x%x\n", (u32_t)&mutex2);
 		return;
 	}
-	k_mutex_unlock(&Mutex3);
+	k_mutex_unlock(&mutex3);
 }
 
 K_THREAD_STACK_DEFINE(task12_stack_area, STACKSIZE);
 struct k_thread task12_thread_data;
-extern void Task12(void);
+extern void task12(void);
 
 /**
  *
@@ -240,14 +240,14 @@ extern void Task12(void);
  * @return  N/A
  */
 
-void RegressionTask(void)
+void regression_task(void)
 {
 	int rv;
 	int i;
-	struct k_mutex *mutexes[4] = { &Mutex1, &Mutex2, &Mutex3, &Mutex4 };
-	struct k_mutex *giveMutex[3] = { &Mutex3, &Mutex2, &Mutex1 };
+	struct k_mutex *mutexes[4] = { &mutex1, &mutex2, &mutex3, &mutex4 };
+	struct k_mutex *givemutex[3] = { &mutex3, &mutex2, &mutex1 };
 	int priority[4] = { 9, 8, 7, 5 };
-	int dropPri[3] = { 8, 8, 9 };
+	int droppri[3] = { 8, 8, 9 };
 
 	TC_START("Test kernel Mutex API");
 
@@ -265,8 +265,8 @@ void RegressionTask(void)
 		if (rv != 0) {
 			TC_ERROR("Failed to lock mutex 0x%x\n",
 				 (u32_t)mutexes[i]);
-			tcRC = TC_FAIL;
-			goto errorReturn;
+			tc_rc = TC_FAIL;
+			goto error_return;
 		}
 		k_sleep(K_SECONDS(1));
 
@@ -274,12 +274,12 @@ void RegressionTask(void)
 		if (rv != priority[i]) {
 			TC_ERROR("Expected priority %d, not %d\n",
 				 priority[i], rv);
-			tcRC = TC_FAIL;
-			goto errorReturn;
+			tc_rc = TC_FAIL;
+			goto error_return;
 		}
 
-		if (tcRC != TC_PASS) {  /* Catch any errors from other tasks */
-			goto errorReturn;
+		if (tc_rc != TC_PASS) {  /* Catch any errors from other tasks */
+			goto error_return;
 		}
 	}
 
@@ -297,49 +297,49 @@ void RegressionTask(void)
 		TC_ERROR("%s timed out and out priority should drop.\n",
 			 "Task05");
 		TC_ERROR("Expected priority %d, not %d\n", 6, rv);
-		tcRC = TC_FAIL;
-		goto errorReturn;
+		tc_rc = TC_FAIL;
+		goto error_return;
 	}
 
-	k_mutex_unlock(&Mutex4);
+	k_mutex_unlock(&mutex4);
 	rv = k_thread_priority_get(k_current_get());
 	if (rv != 7) {
 		TC_ERROR("Gave %s and priority should drop.\n", "Mutex4");
 		TC_ERROR("Expected priority %d, not %d\n", 7, rv);
-		tcRC = TC_FAIL;
-		goto errorReturn;
+		tc_rc = TC_FAIL;
+		goto error_return;
 	}
 
-	k_sleep(K_SECONDS(1));       /* Task07 should time out */
+	k_sleep(K_SECONDS(1));       /* task07 should time out */
 
 	/* ~ 6 seconds have passed */
 
 	for (i = 0; i < 3; i++) {
 		rv = k_thread_priority_get(k_current_get());
-		if (rv != dropPri[i]) {
+		if (rv != droppri[i]) {
 			TC_ERROR("Expected priority %d, not %d\n",
-				 dropPri[i], rv);
-			tcRC = TC_FAIL;
-			goto errorReturn;
+				 droppri[i], rv);
+			tc_rc = TC_FAIL;
+			goto error_return;
 		}
-		k_mutex_unlock(giveMutex[i]);
+		k_mutex_unlock(givemutex[i]);
 
-		if (tcRC != TC_PASS) {
-			goto errorReturn;
+		if (tc_rc != TC_PASS) {
+			goto error_return;
 		}
 	}
 
 	rv = k_thread_priority_get(k_current_get());
 	if (rv != 10) {
 		TC_ERROR("Expected priority %d, not %d\n", 10, rv);
-		tcRC = TC_FAIL;
-		goto errorReturn;
+		tc_rc = TC_FAIL;
+		goto error_return;
 	}
 
-	k_sleep(K_SECONDS(1));     /* Give Task11 time to run */
+	k_sleep(K_SECONDS(1));     /* Give task11 time to run */
 
-	if (tcRC != TC_PASS) {
-		goto errorReturn;
+	if (tc_rc != TC_PASS) {
+		goto error_return;
 	}
 
 	/* test recursive locking using a private mutex */
@@ -349,20 +349,20 @@ void RegressionTask(void)
 	rv = k_mutex_lock(&private_mutex, K_NO_WAIT);
 	if (rv != 0) {
 		TC_ERROR("Failed to lock private mutex\n");
-		tcRC = TC_FAIL;
-		goto errorReturn;
+		tc_rc = TC_FAIL;
+		goto error_return;
 	}
 
 	rv = k_mutex_lock(&private_mutex, K_NO_WAIT);
 	if (rv != 0) {
 		TC_ERROR("Failed to recursively lock private mutex\n");
-		tcRC = TC_FAIL;
-		goto errorReturn;
+		tc_rc = TC_FAIL;
+		goto error_return;
 	}
 
 	/* Start thread */
 	k_thread_create(&task12_thread_data, task12_stack_area, STACKSIZE,
-			(k_thread_entry_t)Task12, NULL, NULL, NULL,
+			(k_thread_entry_t)task12, NULL, NULL, NULL,
 			K_PRIO_PREEMPT(12), 0, K_NO_WAIT);
 	k_sleep(1);     /* Give Task12 a chance to block on the mutex */
 
@@ -372,44 +372,44 @@ void RegressionTask(void)
 	rv = k_mutex_lock(&private_mutex, K_NO_WAIT);
 	if (rv != -EBUSY) {
 		TC_ERROR("Unexpectedly got lock on private mutex\n");
-		tcRC = TC_FAIL;
-		goto errorReturn;
+		tc_rc = TC_FAIL;
+		goto error_return;
 	}
 
 	rv = k_mutex_lock(&private_mutex, K_SECONDS(1));
 	if (rv != 0) {
 		TC_ERROR("Failed to re-obtain lock on private mutex\n");
-		tcRC = TC_FAIL;
-		goto errorReturn;
+		tc_rc = TC_FAIL;
+		goto error_return;
 	}
 
 	k_mutex_unlock(&private_mutex);
 
 	TC_PRINT("Recursive locking tests successful\n");
 
-errorReturn:
-	TC_END_RESULT(tcRC);
-	TC_END_REPORT(tcRC);
+error_return:
+	TC_END_RESULT(tc_rc);
+	TC_END_REPORT(tc_rc);
 }  /* RegressionTask */
 
 
-K_THREAD_DEFINE(TASK05, STACKSIZE, Task05, NULL, NULL, NULL,
+K_THREAD_DEFINE(TASK05, STACKSIZE, task05, NULL, NULL, NULL,
 		5, 0, K_NO_WAIT);
 
-K_THREAD_DEFINE(TASK06, STACKSIZE, Task06, NULL, NULL, NULL,
+K_THREAD_DEFINE(TASK06, STACKSIZE, task06, NULL, NULL, NULL,
 		6, 0, K_NO_WAIT);
 
-K_THREAD_DEFINE(TASK07, STACKSIZE, Task07, NULL, NULL, NULL,
+K_THREAD_DEFINE(TASK07, STACKSIZE, task07, NULL, NULL, NULL,
 		7, 0, K_NO_WAIT);
 
-K_THREAD_DEFINE(TASK08, STACKSIZE, Task08, NULL, NULL, NULL,
+K_THREAD_DEFINE(TASK08, STACKSIZE, task08, NULL, NULL, NULL,
 		8, 0, K_NO_WAIT);
 
-K_THREAD_DEFINE(TASK09, STACKSIZE, Task09, NULL, NULL, NULL,
+K_THREAD_DEFINE(TASK09, STACKSIZE, task09, NULL, NULL, NULL,
 		9, 0, K_NO_WAIT);
 
-K_THREAD_DEFINE(TASK11, STACKSIZE, Task11, NULL, NULL, NULL,
+K_THREAD_DEFINE(TASK11, STACKSIZE, task11, NULL, NULL, NULL,
 		11, 0, K_NO_WAIT);
 
-K_THREAD_DEFINE(REGRESSTASK, STACKSIZE, RegressionTask, NULL, NULL, NULL,
+K_THREAD_DEFINE(REGRESSTASK, STACKSIZE, regression_task, NULL, NULL, NULL,
 		10, 0, K_NO_WAIT);
diff --git a/tests/kernel/mutex/mutex/src/task12.c b/tests/kernel/mutex/mutex/src/task12.c
index ed93859b5d2..13333e0c56b 100644
--- a/tests/kernel/mutex/mutex/src/task12.c
+++ b/tests/kernel/mutex/mutex/src/task12.c
@@ -19,7 +19,7 @@
 #include <zephyr.h>
 
 
-static int tcRC = TC_PASS;         /* test case return code */
+static int tc_rc = TC_PASS;         /* test case return code */
 
 extern struct k_mutex private_mutex;
 
@@ -30,7 +30,7 @@ extern struct k_mutex private_mutex;
  * @return  N/A
  */
 
-void Task12(void)
+void task12(void)
 {
 	int rv;
 
@@ -38,7 +38,7 @@ void Task12(void)
 
 	rv = k_mutex_lock(&private_mutex, K_FOREVER);
 	if (rv != 0) {
-		tcRC = TC_FAIL;
+		tc_rc = TC_FAIL;
 		TC_ERROR("Failed to obtain private mutex\n");
 		return;
 	}
diff --git a/tests/kernel/semaphore/sema_api/src/test_sema_contexts.c b/tests/kernel/semaphore/sema_api/src/test_sema_contexts.c
index d880c49b7d2..b991c27396c 100644
--- a/tests/kernel/semaphore/sema_api/src/test_sema_contexts.c
+++ b/tests/kernel/semaphore/sema_api/src/test_sema_contexts.c
@@ -30,12 +30,12 @@ static K_THREAD_STACK_DEFINE(tstack, STACK_SIZE);
 static struct k_thread tdata;
 
 /*entry of contexts*/
-static void tIsr_entry(void *p)
+static void tisr_entry(void *p)
 {
 	k_sem_give((struct k_sem *)p);
 }
 
-static void tThread_entry(void *p1, void *p2, void *p3)
+static void thread_entry(void *p1, void *p2, void *p3)
 {
 	k_sem_give((struct k_sem *)p1);
 }
@@ -44,7 +44,7 @@ static void tsema_thread_thread(struct k_sem *psem)
 {
 	/**TESTPOINT: thread-thread sync via sema*/
 	k_tid_t tid = k_thread_create(&tdata, tstack, STACK_SIZE,
-				      tThread_entry, psem, NULL, NULL,
+				      thread_entry, psem, NULL, NULL,
 				      K_PRIO_PREEMPT(0), 0, 0);
 
 	zassert_false(k_sem_take(psem, K_FOREVER), NULL);
@@ -55,7 +55,7 @@ static void tsema_thread_thread(struct k_sem *psem)
 static void tsema_thread_isr(struct k_sem *psem)
 {
 	/**TESTPOINT: thread-isr sync via sema*/
-	irq_offload(tIsr_entry, psem);
+	irq_offload(tisr_entry, psem);
 	zassert_false(k_sem_take(psem, K_FOREVER), NULL);
 }
 
diff --git a/tests/kernel/sprintf/src/test_sprintf.c b/tests/kernel/sprintf/src/test_sprintf.c
index 3013aaf201a..e87ddddab4a 100644
--- a/tests/kernel/sprintf/src/test_sprintf.c
+++ b/tests/kernel/sprintf/src/test_sprintf.c
@@ -7,8 +7,8 @@
  */
 
 /*
-DESCRIPTION
-This module contains the code for testing sprintf() functionality.
+ * DESCRIPTION
+ * This module contains the code for testing sprintf() functionality.
  */
 
 #include <tc_util.h>
@@ -32,22 +32,28 @@ This module contains the code for testing sprintf() functionality.
  * The underlying sprintf() architecture will truncate it.
  */
 #define REALLY_LONG_STRING \
-		"11111111111111111111111111111111111111111111111111111111111111111" \
-		"22222222222222222222222222222222222222222222222222222222222222222" \
-		"33333333333333333333333333333333333333333333333333333333333333333" \
-		"44444444444444444444444444444444444444444444444444444444444444444" \
-		"55555555555555555555555555555555555555555555555555555555555555555" \
-		"66666666666666666666666666666666666666666666666666666666666666666"
+		"1111111111111111111111111111111111" \
+		"1111111111111111111111111111111" \
+		"22222222222222222222222222222222" \
+		"222222222222222222222222222222222" \
+		"333333333333333333333333333333333" \
+		"33333333333333333333333333333333" \
+		"44444444444444444444444444444444" \
+		"444444444444444444444444444444444" \
+		"555555555555555555555555555555555" \
+		"55555555555555555555555555555555" \
+		"66666666666666666666666666666666" \
+		"666666666666666666666666666666666"
 
 #define PRINTF_MAX_STRING_LENGTH   200
 
-typedef union {
+union raw_double_u {
 	double  d;
 	struct {
 		u32_t  u1;    /* This part contains the exponent */
 		u32_t  u2;    /* This part contains the fraction */
 	};
-} raw_double_u;
+};
 
 #ifdef CONFIG_FLOAT
 /**
@@ -57,10 +63,10 @@ typedef union {
  * @return TC_PASS on success, TC_FAIL otherwise
  */
 
-int sprintfDoubleTest(void)
+int sprintf_double_test(void)
 {
 	char buffer[100];
-	raw_double_u var;
+	union raw_double_u var;
 	int  status = TC_PASS;
 
 	var.u1 = 0x00000000;
@@ -108,25 +114,29 @@ int sprintfDoubleTest(void)
 
 	sprintf(buffer, "%.*f", 11, var.d);
 	if (strcmp(buffer, "1.00000000000") != 0) {
-		TC_ERROR("sprintf(1.00000000000) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(1.00000000000) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
 	sprintf(buffer, "%12f", var.d);
 	if (strcmp(buffer, "    1.000000") != 0) {
-		TC_ERROR("sprintf(    1.000000) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(    1.000000) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
 	sprintf(buffer, "%-12f", var.d);
 	if (strcmp(buffer, "1.000000    ") != 0) {
-		TC_ERROR("sprintf(1.000000    ) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(1.000000    ) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
 	sprintf(buffer, "%012f", var.d);
 	if (strcmp(buffer, "00001.000000") != 0) {
-		TC_ERROR("sprintf(00001.000000) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(00001.000000) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
@@ -148,13 +158,15 @@ int sprintfDoubleTest(void)
 	var.d = 1234.0;
 	sprintf(buffer, "%e", var.d);
 	if (strcmp(buffer, "1.234000e+003") != 0) {
-		TC_ERROR("sprintf(1.234000e+003) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(1.234000e+003) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
 	sprintf(buffer, "%E", var.d);
 	if (strcmp(buffer, "1.234000E+003") != 0) {
-		TC_ERROR("sprintf(1.234000E+003) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(1.234000E+003) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
@@ -162,13 +174,15 @@ int sprintfDoubleTest(void)
 	var.d = 0.1234;
 	sprintf(buffer, "%e", var.d);
 	if (strcmp(buffer, "1.234000e-001") != 0) {
-		TC_ERROR("sprintf(1.234000e-001) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(1.234000e-001) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
 	sprintf(buffer, "%E", var.d);
 	if (strcmp(buffer, "1.234000E-001") != 0) {
-		TC_ERROR("sprintf(1.234000E-001) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(1.234000E-001) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
@@ -176,13 +190,15 @@ int sprintfDoubleTest(void)
 	var.d = 1234000000.0;
 	sprintf(buffer, "%g", var.d);
 	if (strcmp(buffer, "1.234e+009") != 0) {
-		TC_ERROR("sprintf(1.234e+009) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(1.234e+009) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
 	sprintf(buffer, "%G", var.d);
 	if (strcmp(buffer, "1.234E+009") != 0) {
-		TC_ERROR("sprintf(1.234E+009) - incorrect output '%s'\n", buffer);
+		TC_ERROR("sprintf(1.234E+009) - incorrect "
+			"output '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
@@ -220,7 +236,7 @@ int tvsnprintf(char *s, size_t len, const char *format, ...)
  * @return TC_PASS on success, TC_FAIL otherwise
  */
 
-int vsnprintfTest(void)
+int vsnprintf_test(void)
 {
 	int  len;
 	int  status = TC_PASS;
@@ -286,7 +302,7 @@ int tvsprintf(char *s, const char *format, ...)
  * @return TC_PASS on success, TC_FAIL otherwise
  */
 
-int vsprintfTest(void)
+int vsprintf_test(void)
 {
 	int  len;
 	int  status = TC_PASS;
@@ -320,7 +336,7 @@ int vsprintfTest(void)
  * @return TC_PASS on success, TC_FAIL otherwise
  */
 
-int snprintfTest(void)
+int snprintf_test(void)
 {
 	int  len;
 	int  status = TC_PASS;
@@ -366,7 +382,7 @@ int snprintfTest(void)
  * @return TC_PASS on success, TC_FAIL otherwise
  */
 
-int sprintfMiscTest(void)
+int sprintf_misc_test(void)
 {
 	int  status = TC_PASS;
 	int  count;
@@ -442,7 +458,7 @@ int sprintfMiscTest(void)
  * @return TC_PASS on success, TC_FAIL otherwise
  */
 
-int sprintfIntegerTest(void)
+int sprintf_integer_test(void)
 {
 	int  status = TC_PASS;
 	int  len;
@@ -453,12 +469,14 @@ int sprintfIntegerTest(void)
 	/* Note: prints hex numbers in 8 characters */
 	len = sprintf(buffer, "%x", 0x11);
 	if (len != 2) {
-		TC_ERROR("sprintf(%%x).  Expected 2 bytes written, not %d\n", len);
+		TC_ERROR("sprintf(%%x). "
+			"Expected 2 bytes written, not %d\n", len);
 		status = TC_FAIL;
 	}
 
 	if (strcmp(buffer, "11") != 0) {
-		TC_ERROR("sprintf(%%x).  Expected '%s', got '%s'\n", "11", buffer);
+		TC_ERROR("sprintf(%%x). "
+			"Expected '%s', got '%s'\n", "11", buffer);
 		status = TC_FAIL;
 	}
 
@@ -595,7 +613,7 @@ int sprintfIntegerTest(void)
  * @return TC_PASS on success, TC_FAIL otherwise
  */
 
-int sprintfStringTest(void)
+int sprintf_stringtest(void)
 {
 	int  len;
 	int  status = TC_PASS;
@@ -615,20 +633,24 @@ int sprintfStringTest(void)
 
 	sprintf(buffer, "%s", "short string");
 	if (strcmp(buffer, "short string") != 0) {
-		TC_ERROR("sprintf(%%s).  Expected 'short string', got '%s'\n", buffer);
+		TC_ERROR("sprintf(%%s). "
+			"Expected 'short string', got '%s'\n", buffer);
 		status = TC_FAIL;
 	}
 
 	len = sprintf(buffer, "%s", REALLY_LONG_STRING);
 #ifndef CONFIG_NEWLIB_LIBC
 	if (len != PRINTF_MAX_STRING_LENGTH) {
-		TC_ERROR("Internals changed.  Max string length no longer %d got %d\n",
+		TC_ERROR("Internals changed. "
+			"Max string length no longer %d got %d\n",
 				 PRINTF_MAX_STRING_LENGTH, len);
 		status = TC_FAIL;
 	}
 #endif
-	if (strncmp(buffer, REALLY_LONG_STRING, PRINTF_MAX_STRING_LENGTH) != 0) {
-		TC_ERROR("First %d characters of REALLY_LONG_STRING not printed!\n",
+	if (strncmp(buffer, REALLY_LONG_STRING,
+			PRINTF_MAX_STRING_LENGTH) != 0) {
+		TC_ERROR("First %d characters of REALLY_LONG_STRING "
+			"not printed!\n",
 				 PRINTF_MAX_STRING_LENGTH);
 		status = TC_FAIL;
 	}
@@ -652,38 +674,38 @@ void main(void)
 	PRINT_LINE;
 
 	TC_PRINT("Testing sprintf() with integers ....\n");
-	if (sprintfIntegerTest() != TC_PASS) {
+	if (sprintf_integer_test() != TC_PASS) {
 		status = TC_FAIL;
 	}
 
 	TC_PRINT("Testing snprintf() ....\n");
-	if (snprintfTest() != TC_PASS) {
+	if (snprintf_test() != TC_PASS) {
 		status = TC_FAIL;
 	}
 
 	TC_PRINT("Testing vsprintf() ....\n");
-	if (vsprintfTest() != TC_PASS) {
+	if (vsprintf_test() != TC_PASS) {
 		status = TC_FAIL;
 	}
 
 	TC_PRINT("Testing vsnprintf() ....\n");
-	if (vsnprintfTest() != TC_PASS) {
+	if (vsnprintf_test() != TC_PASS) {
 		status = TC_FAIL;
 	}
 
 	TC_PRINT("Testing sprintf() with strings ....\n");
-	if (sprintfStringTest() != TC_PASS) {
+	if (sprintf_stringtest() != TC_PASS) {
 		status = TC_FAIL;
 	}
 
 	TC_PRINT("Testing sprintf() with misc options ....\n");
-	if (sprintfMiscTest() != TC_PASS) {
+	if (sprintf_misc_test() != TC_PASS) {
 		status = TC_FAIL;
 	}
 
 #ifdef CONFIG_FLOAT
 	TC_PRINT("Testing sprintf() with doubles ....\n");
-	if (sprintfDoubleTest() != TC_PASS) {
+	if (sprintf_double_test() != TC_PASS) {
 		status = TC_FAIL;
 	}
 #endif /* CONFIG_FLOAT */
diff --git a/tests/kernel/tickless/tickless/src/timestamps.c b/tests/kernel/tickless/tickless/src/timestamps.c
index 1ede27e9341..b6958e8d05f 100644
--- a/tests/kernel/tickless/tickless/src/timestamps.c
+++ b/tests/kernel/tickless/tickless/src/timestamps.c
@@ -23,21 +23,21 @@
 
 #define _TIMESTAMP_NUM 0  /* set to timer # for use by timestamp (0-3) */
 
-#define _CLKGATECTRL *((volatile u32_t *)0x400FE104)
+#define _CLKGATECTRL (*((volatile u32_t *)0x400FE104))
 #define _CLKGATECTRL_TIMESTAMP_EN (1 << (16 + _TIMESTAMP_NUM))
 
 #define _TIMESTAMP_BASE 0x40030000
 #define _TIMESTAMP_OFFSET (0x1000 * _TIMESTAMP_NUM)
 #define _TIMESTAMP_ADDR (_TIMESTAMP_BASE + _TIMESTAMP_OFFSET)
 
-#define _TIMESTAMP_CFG *((volatile u32_t *)(_TIMESTAMP_ADDR + 0))
-#define _TIMESTAMP_CTRL *((volatile u32_t *)(_TIMESTAMP_ADDR + 0xC))
-#define _TIMESTAMP_MODE *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x4))
-#define _TIMESTAMP_LOAD *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x28))
-#define _TIMESTAMP_IMASK *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x18))
-#define _TIMESTAMP_ISTATUS *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x1C))
-#define _TIMESTAMP_ICLEAR *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x24))
-#define _TIMESTAMP_VAL *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x48))
+#define _TIMESTAMP_CFG (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0)))
+#define _TIMESTAMP_CTRL (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0xC)))
+#define _TIMESTAMP_MODE (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x4)))
+#define _TIMESTAMP_LOAD (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x28)))
+#define _TIMESTAMP_IMASK (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x18)))
+#define _TIMESTAMP_ISTATUS (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x1C)))
+#define _TIMESTAMP_ICLEAR (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x24)))
+#define _TIMESTAMP_VAL (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x48)))
 
 /*
  * Set the rollover value such that it leaves the most significant bit of
@@ -57,7 +57,7 @@
  *
  * @return N/A
  */
-void _TimestampOpen(void)
+void _timestamp_open(void)
 {
 	/* QEMU does not currently support the 32-bit timer modes of the GPTM */
 	printk("WARNING! Timestamp is not supported for this target!\n");
@@ -71,7 +71,9 @@ void _TimestampOpen(void)
 	_TIMESTAMP_CTRL = 0x0;  /* disable/reset timer */
 	_TIMESTAMP_CFG = 0x0;  /* 32-bit timer */
 	_TIMESTAMP_MODE = 0x2;  /* periodic mode */
-	_TIMESTAMP_LOAD = _TIMESTAMP_MAX; /* maximum interval to reduce rollovers */
+	_TIMESTAMP_LOAD = _TIMESTAMP_MAX; /* maximum interval
+					   * to reduce rollovers
+					   */
 	_TIMESTAMP_IMASK = 0x70F;  /* mask all timer interrupts */
 	_TIMESTAMP_ICLEAR = 0x70F;  /* clear all interrupt status */
 
@@ -86,29 +88,29 @@ void _TimestampOpen(void)
  *
  * @return timestamp value
  */
-u32_t _TimestampRead(void)
+u32_t _timestamp_read(void)
 {
-	static u32_t lastTimerVal;
+	static u32_t last_timer_val;
 	static u32_t cnt;
-	u32_t timerVal = _TIMESTAMP_VAL;
+	u32_t timer_val = _TIMESTAMP_VAL;
 
 	/* handle rollover for every other read (end of sleep) */
 
-	if ((cnt % 2) && (timerVal > lastTimerVal)) {
-		lastTimerVal = timerVal;
+	if ((cnt % 2) && (timer_val > last_timer_val)) {
+		last_timer_val = timer_val;
 
 		/* convert to extended up-counter value */
-		timerVal = _TIMESTAMP_EXT + (_TIMESTAMP_MAX - timerVal);
+		timer_val = _TIMESTAMP_EXT + (_TIMESTAMP_MAX - timer_val);
 	} else {
-		lastTimerVal = timerVal;
+		last_timer_val = timer_val;
 
 		/* convert to up-counter value */
-		timerVal = _TIMESTAMP_MAX - timerVal;
+		timer_val = _TIMESTAMP_MAX - timer_val;
 	}
 
 	cnt++;
 
-	return timerVal;
+	return timer_val;
 }
 
 /**
@@ -119,7 +121,7 @@ u32_t _TimestampRead(void)
  *
  * @return N/A
  */
-void _TimestampClose(void)
+void _timestamp_close(void)
 {
 
 	/* disable/reset timer */
@@ -135,25 +137,25 @@ void _TimestampClose(void)
 
 #define _COUNTDOWN_TIMER false
 
-#define _CLKGATECTRL *((volatile u32_t *)0x4004803C)
+#define _CLKGATECTRL (*((volatile u32_t *)0x4004803C))
 #define _CLKGATECTRL_TIMESTAMP_EN (1 << 29)
 
-#define _SYSOPTCTRL2 *((volatile u32_t *)0x40048004)
+#define _SYSOPTCTRL2 (*((volatile u32_t *)0x40048004))
 #define _SYSOPTCTRL2_32KHZRTCCLK (1 << 4)
 
 #define _TIMESTAMP_ADDR (0x4003D000)
 
-#define _TIMESTAMP_ICLEAR *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x24))
+#define _TIMESTAMP_ICLEAR (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x24)))
 
-#define _TIMESTAMP_VAL *((volatile u32_t *)(_TIMESTAMP_ADDR + 0))
-#define _TIMESTAMP_PRESCALE *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x4))
-#define _TIMESTAMP_COMP *((volatile u32_t *)(_TIMESTAMP_ADDR + 0xC))
-#define _TIMESTAMP_CTRL *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x10))
-#define _TIMESTAMP_STATUS *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x14))
-#define _TIMESTAMP_LOCK *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x18))
-#define _TIMESTAMP_IMASK *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x1C))
-#define _TIMESTAMP_RACCESS *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x800))
-#define _TIMESTAMP_WACCESS *((volatile u32_t *)(_TIMESTAMP_ADDR + 0x804))
+#define _TIMESTAMP_VAL (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0)))
+#define _TIMESTAMP_PRESCALE (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x4)))
+#define _TIMESTAMP_COMP (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0xC)))
+#define _TIMESTAMP_CTRL (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x10)))
+#define _TIMESTAMP_STATUS (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x14)))
+#define _TIMESTAMP_LOCK (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x18)))
+#define _TIMESTAMP_IMASK (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x1C)))
+#define _TIMESTAMP_RACCESS (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x800)))
+#define _TIMESTAMP_WACCESS (*((volatile u32_t *)(_TIMESTAMP_ADDR + 0x804)))
 
 /**
  *
@@ -163,7 +165,7 @@ void _TimestampClose(void)
  *
  * @return N/A
  */
-void _TimestampOpen(void)
+void _timestamp_open(void)
 {
 	/* enable timer access */
 	_CLKGATECTRL |= _CLKGATECTRL_TIMESTAMP_EN;
@@ -197,9 +199,9 @@ void _TimestampOpen(void)
  *
  * @return timestamp value
  */
-u32_t _TimestampRead(void)
+u32_t _timestamp_read(void)
 {
-	static u32_t lastPrescale;
+	static u32_t last_prescale;
 	static u32_t cnt;
 	u32_t prescale1 = _TIMESTAMP_PRESCALE;
 	u32_t prescale2 = _TIMESTAMP_PRESCALE;
@@ -211,13 +213,15 @@ u32_t _TimestampRead(void)
 		prescale2 = _TIMESTAMP_PRESCALE;
 	}
 
-	/* handle prescale rollover @ 0x8000 for every other read (end of sleep) */
+	 /* handle prescale rollover @ 0x8000
+	  * for every other read (end of sleep)
+	  */
 
-	if ((cnt % 2) && (prescale1 < lastPrescale)) {
+	if ((cnt % 2) && (prescale1 < last_prescale)) {
 		prescale1 += 0x8000;
 	}
 
-	lastPrescale = prescale2;
+	last_prescale = prescale2;
 	cnt++;
 
 	return prescale1;
@@ -231,7 +235,7 @@ u32_t _TimestampRead(void)
  *
  * @return N/A
  */
-void _TimestampClose(void)
+void _timestamp_close(void)
 {
 	_TIMESTAMP_STATUS = 0x0;  /* disable counter */
 	_TIMESTAMP_CTRL = 0x0;  /* disable oscillator */
@@ -255,7 +259,7 @@ void _TimestampClose(void)
  *
  * @return N/A
  */
-void _TimestampOpen(void)
+void _timestamp_open(void)
 {
 	/* enable RTT clock from PMC */
 	soc_pmc_peripheral_enable(ID_RTT);
@@ -272,7 +276,7 @@ void _TimestampOpen(void)
  *
  * @return timestamp value
  */
-u32_t _TimestampRead(void)
+u32_t _timestamp_read(void)
 {
 	static u32_t last_val;
 	u32_t tmr_val = _TIMESTAMP_VAL;
@@ -298,7 +302,7 @@ u32_t _TimestampRead(void)
  *
  * @return N/A
  */
-void _TimestampClose(void)
+void _timestamp_close(void)
 {
 	/* disable RTT clock from PMC */
 	soc_pmc_peripheral_disable(ID_RTT);
diff --git a/tests/net/net_pkt/src/main.c b/tests/net/net_pkt/src/main.c
index ad909d4913e..c790b45a40d 100644
--- a/tests/net/net_pkt/src/main.c
+++ b/tests/net/net_pkt/src/main.c
@@ -282,31 +282,31 @@ static const char test_data[] = { '0', '1', '2', '3', '4',
 				  '5', '6', '7' };
 
 static const char sample_data[] =
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
-	"abcdefghijklmnopqrstuvxyz"
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
+	"abcdefghijklmnopqrstuvxyz "
 	"abcdefghijklmnopqrstuvxyz";
 
 static char test_rw_short[] =
 	"abcdefghijklmnopqrstuvwxyz";
 
 static char test_rw_long[] =
-	"abcdefghijklmnopqrstuvwxyz"
-	"abcdefghijklmnopqrstuvwxyz"
-	"abcdefghijklmnopqrstuvwxyz"
-	"abcdefghijklmnopqrstuvwxyz"
-	"abcdefghijklmnopqrstuvwxyz"
-	"abcdefghijklmnopqrstuvwxyz"
-	"abcdefghijklmnopqrstuvwxyz";
+	"abcdefghijklmnopqrstuvwxyz "
+	"abcdefghijklmnopqrstuvwxyz "
+	"abcdefghijklmnopqrstuvwxyz "
+	"abcdefghijklmnopqrstuvwxyz "
+	"abcdefghijklmnopqrstuvwxyz "
+	"abcdefghijklmnopqrstuvwxyz "
+	"abcdefghijklmnopqrstuvwxyz ";
 
 static void test_pkt_read_append(void)
 {
@@ -440,7 +440,7 @@ static void test_pkt_read_append(void)
 	tfrag = net_frag_read(tfrag, off + 10, &tpos, 10, data);
 	if (!tfrag ||
 	    memcmp(sample_data + off + 10, data, 10)) {
-		printk("Failed to read from offset %d, frag length %d"
+		printk("Failed to read from offset %d, frag length %d "
 		       "read length %d\n",
 		       tfrag->len + 10, tfrag->len, 10);
 		zassert_true(false, "Fail offset read");
@@ -995,8 +995,8 @@ static void test_fragment_split(void)
 #define FRAGA (FRAG_COUNT - 2)
 #define FRAGB (FRAG_COUNT - 1)
 	struct net_pkt *pkt;
-	struct net_buf *frags[FRAG_COUNT], *frag, *fragA, *fragB;
-	int i, total, splitA, splitB;
+	struct net_buf *frags[FRAG_COUNT], *frag, *frag_a, *frag_b;
+	int i, total, split_a, split_b;
 	int ret, frag_size;
 
 	memset(frags, 0, FRAG_COUNT * sizeof(void *));
@@ -1031,45 +1031,45 @@ static void test_fragment_split(void)
 
 	net_pkt_frag_add(pkt, frags[0]);
 
-	fragA = frags[FRAGA];
-	fragB = frags[FRAGB];
+	frag_a = frags[FRAGA];
+	frag_b = frags[FRAGB];
 
-	zassert_is_null(fragA, "fragA is not NULL");
-	zassert_is_null(fragB, "fragB is not NULL");
+	zassert_is_null(frag_a, "frag_a is not NULL");
+	zassert_is_null(frag_b, "frag_b is not NULL");
 
-	splitA = frag_size * 2 / 3;
-	splitB = frag_size - splitA;
+	split_a = frag_size * 2 / 3;
+	split_b = frag_size - split_a;
 
-	zassert_true(splitA > 0, "A size is 0");
-	zassert_true(splitA > splitB, "A is smaller than B");
+	zassert_true(split_a > 0, "A size is 0");
+	zassert_true(split_a > split_b, "A is smaller than B");
 
 	/* Test some error cases first */
-	ret = net_pkt_split(NULL, NULL, 1024, &fragA, &fragB, K_NO_WAIT);
+	ret = net_pkt_split(NULL, NULL, 1024, &frag_a, &frag_b, K_NO_WAIT);
 	zassert_equal(ret, -EINVAL, "Invalid buf pointers");
 
 	ret = net_pkt_split(pkt, pkt->frags, CONFIG_NET_BUF_DATA_SIZE + 1,
-			    &fragA, &fragB, K_NO_WAIT);
+			    &frag_a, &frag_b, K_NO_WAIT);
 	zassert_equal(ret, 0, "Split failed");
 
-	ret = net_pkt_split(pkt, pkt->frags, splitA,
-			     &fragA, &fragB, K_NO_WAIT);
+	ret = net_pkt_split(pkt, pkt->frags, split_a,
+			     &frag_a, &frag_b, K_NO_WAIT);
 	zassert_equal(ret, 0, "Cannot split frag");
 
-	if (fragA->len != splitA) {
-		printk("Frag A len %d not %d\n", fragA->len, splitA);
-		zassert_equal(fragA->len, splitA, "FragA len wrong");
+	if (frag_a->len != split_a) {
+		printk("Frag_a len %d not %d\n", frag_a->len, split_a);
+		zassert_equal(frag_a->len, split_a, "Frag_a len wrong");
 	}
 
-	if (fragB->len != splitB) {
-		printk("Frag B len %d not %d\n", fragB->len, splitB);
-		zassert_true(false, "FragB len wrong");
+	if (frag_b->len != split_b) {
+		printk("Frag_b len %d not %d\n", frag_b->len, split_b);
+		zassert_true(false, "Frag_b len wrong");
 	}
 
-	zassert_false(memcmp(pkt->frags->data, fragA->data, splitA),
-		      "Frag A data mismatch");
+	zassert_false(memcmp(pkt->frags->data, frag_a->data, split_a),
+		      "Frag_a data mismatch");
 
-	zassert_false(memcmp(pkt->frags->data + splitA, fragB->data, splitB),
-		      "Frag B data mismatch");
+	zassert_false(memcmp(pkt->frags->data + split_a, frag_b->data, split_b),
+		      "Frag_b data mismatch");
 }
 
 void test_main(void)
diff --git a/tests/subsys/debug/gdb_server/src/main.c b/tests/subsys/debug/gdb_server/src/main.c
index 2b67a2651cf..f683a5384ff 100644
--- a/tests/subsys/debug/gdb_server/src/main.c
+++ b/tests/subsys/debug/gdb_server/src/main.c
@@ -32,7 +32,7 @@
  * @param my_sem       thread's own semaphore
  * @param other_sem    other thread's semaphore
  */
-void helloLoop(const char *my_name,
+void hello_loop(const char *my_name,
 	       struct k_sem *my_sem, struct k_sem *other_sem)
 {
 	while (1) {
@@ -50,32 +50,32 @@ void helloLoop(const char *my_name,
 
 /* define semaphores */
 
-K_SEM_DEFINE(threadA_sem, 1, 1);	/* starts off "available" */
-K_SEM_DEFINE(threadB_sem, 0, 1);	/* starts off "not available" */
+K_SEM_DEFINE(threada_sem, 1, 1);	/* starts off "available" */
+K_SEM_DEFINE(threadb_sem, 0, 1);	/* starts off "not available" */
 
 
-/* threadB is a dynamic thread that is spawned by threadA */
+/* threadb is a dynamic thread that is spawned by threadA */
 
-void threadB(void *dummy1, void *dummy2, void *dummy3)
+void threadb(void *dummy1, void *dummy2, void *dummy3)
 {
 	/* invoke routine to ping-pong hello messages with threadA */
-	helloLoop(__func__, &threadB_sem, &threadA_sem);
+	hello_loop(__func__, &threadb_sem, &threada_sem);
 }
 
-K_THREAD_STACK_DEFINE(threadB_stack_area, STACKSIZE);
-static struct k_thread threadB_data;
+K_THREAD_STACK_DEFINE(threadb_stack_area, STACKSIZE);
+static struct k_thread threadb_data;
 
-/* threadA is a static thread that is spawned automatically */
+/* threada is a static thread that is spawned automatically */
 
-void threadA(void *dummy1, void *dummy2, void *dummy3)
+void threada(void *dummy1, void *dummy2, void *dummy3)
 {
 	/* spawn threadB */
-	k_thread_create(&threadB_data, threadB_stack_area, STACKSIZE, threadB,
+	k_thread_create(&threadb_data, threadb_stack_area, STACKSIZE, threadb,
 			NULL, NULL, NULL, PRIORITY, 0, K_NO_WAIT);
 
 	/* invoke routine to ping-pong hello messages with threadB */
-	helloLoop(__func__, &threadA_sem, &threadB_sem);
+	hello_loop(__func__, &threada_sem, &threadb_sem);
 }
 
-K_THREAD_DEFINE(threadA_id, STACKSIZE, threadA, NULL, NULL, NULL,
+K_THREAD_DEFINE(threada_id, STACKSIZE, threada, NULL, NULL, NULL,
 		PRIORITY, 0, K_NO_WAIT);