Incorporated the review comments

Author: rajkan01

TESTS/mbedmicro-rtos-mbed/semaphore/main.cpp

@@ -64,9 +64,9 @@ void test_thread(int const *delay)
 
 /* Test multiple threads
 
-    Given 3 threads started with different delays and a semaphore with 2 tokens
-    when each thread runs it tries to acquire a token
-    then no more than two threads should be able to access protected region
+    Given 3 child threads started with different delays and a semaphore with 2 tokens available
+    when each child thread calls @a acquire
+    then no more than two child threads should be able to access protected region
 */
 void test_multi()
 {
@@ -100,13 +100,11 @@ void single_thread(struct test_data *data)
 
 /** Test single thread
 
-    Given a two threads A & B and a semaphore (with count of 0) and a counter (equals to 0)
-    when thread B calls @a wait
-    then thread B waits for a token to become available
-    then the counter is equal to 0
-    when thread A calls @a release on the semaphore
-    then thread B acquires a token and increments the counter
-    then the counter equals to 1
+    Given a 2(main and child) threads and a semaphore with no tokens available
+    when the child thread calls @a acquire
+    then the child thread is blocked
+    when main thread calls @a release on the semaphore
+    then the child thread is unblocked.
  */
 void test_single_thread()
 {
@@ -143,9 +141,9 @@ void timeout_thread(Semaphore *sem)
 
 /** Test timeout
 
-    Given thread and a semaphore with no tokens available
-    when thread calls @a wait on the semaphore with timeout of 10ms
-    then the thread waits for 10ms and timeouts after
+    Given a 2(main and child) threads and a semaphore with no tokens available
+    when a child thread calls @a try_acquire_for with 30ms timeout
+    then the child thread is blocked for 30ms and timeouts after
  */
 void test_timeout()
 {
@@ -177,8 +175,10 @@ void test_ticker_release(struct test_data *data)
 /** Test semaphore acquire
 
     Given a semaphore with no tokens available and ticker with the callback registered
-    when callbacks update the test data and release semaphore
-    which will unblock the main thread which is blocked on semaphore acquire.
+    when the main thread calls @a acquire
+    then the main thread is blocked
+    when callback calls @a release on the semaphore
+    then the main thread is unblocked
  */
 void test_semaphore_acquire()
 {
@@ -205,29 +205,29 @@ void test_ticker_try_acquire(Semaphore *sem)
 /** Test semaphore try acquire
 
     Given a semaphore with no tokens available and ticker with the callback registered
-    when callbacks try to acquire the semaphore will fail.
+    when callback tries to acquire the semaphore, it fails.
  */
 void test_semaphore_try_acquire()
 {
     Semaphore sem(0);
     Ticker t1;
     t1.attach_us(callback(test_ticker_try_acquire, &sem), 3000);
-    ThisThread::sleep_for(3);
+    ThisThread::sleep_for(4);
     t1.detach();
 }
 
 
 /** Test semaphore try timeout
 
     Given a semaphore with no tokens available
-    when the main thread calls @a wait on the semaphore with try timeout of 5ms
-    then the main thread waits for 5ms and timeouts after
+    when the main thread calls @a try_acquire_for with 3ms timeout
+    then the main thread is blocked for 3ms and timeouts after
  */
 void test_semaphore_try_timeout()
 {
     Semaphore sem(0);
     bool res;
-    res = sem.try_acquire_for(5);
+    res = sem.try_acquire_for(3);
     TEST_ASSERT_FALSE(res);
 }
 
@@ -242,16 +242,18 @@ void test_ticker_semaphore_release(struct Semaphore *sem)
 /** Test semaphore try acquire timeout
 
     Given a semaphore with no tokens available and ticker with the callback registered
-    when callbacks release the semaphore will unblock the main thread
-    which is waiting for semaphore with a timeout.
+    when the main thread calls @a try_acquire_for with 10ms timeout
+    then the main thread is blocked for 10ms
+    when callbacks calls @a release on the semaphore 
+    then the main thread is unblocked.
  */
 void test_semaphore_try_acquire_timeout()
 {
     Semaphore sem(0);
     bool res;
     Ticker t1;
     t1.attach_us(callback(test_ticker_semaphore_release, &sem), 3000);
-    res = sem.try_acquire_for(30);
+    res = sem.try_acquire_for(10);
     t1.detach();
     TEST_ASSERT_TRUE(res);
 }
@@ -260,12 +262,12 @@ void test_semaphore_try_acquire_timeout()
 
 Test 1 token no timeout
 Given thread and a semaphore with one token available
-when thread calls @a wait on the semaphore with timeout of 0ms
+when thread calls @a try_acquire with timeout of 0ms
 then the thread acquires the token immediately
 
 Test 0 tokens no timeout
 Given thread and a semaphore with no tokens available
-when thread calls @a wait on the semaphore with timeout of 0ms
+when thread calls @a try_acquire with timeout of 0ms
 then the thread returns immediately without acquiring a token
  */
 template<int T>
@@ -285,7 +287,7 @@ void test_no_timeout()
 /** Test multiple tokens wait
 
     Given a thread and a semaphore initialized with 5 tokens
-    when thread calls @a wait 6 times on the semaphore
+    when thread calls @a try_acquire 6 times in a loop
     then the token counts goes to zero
  */
 void test_multiple_tokens_wait()