spec: Fix formatting

17 files changed, 67 insertions, 67 deletions

diff --git a/spec/rtems/barrier/req/perf-release-auto-other-cpu.yml b/spec/rtems/barrier/req/perf-release-auto-other-cpu.yml
index 183ce067..dc309345 100644
--- a/spec/rtems/barrier/req/perf-release-auto-other-cpu.yml
+++ b/spec/rtems/barrier/req/perf-release-auto-other-cpu.yml
@@ -152,10 +152,10 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with distinct home schedulers.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to ${../if/wait:/name}
+  Let U and V be two tasks with distinct home schedulers.  Let :math:`B`
+  be a time point measured by U right before a call to ${../if/wait:/name}
   which automaticall releases the barrier.  Let :math:`E` be a time point
-  measured by ``V`` right after a call to ${../if/wait:/name} returns
+  measured by V right after a call to ${../if/wait:/name} returns
   successfully due to the ${../if/wait:/name} call associated with :math:`B`.
   While the execution environment is ${.:/environment}, while the barrier is an
   automatic release barrier, while the measurement sample is :math:`E - B`,
diff --git a/spec/rtems/barrier/req/perf-release-manual-preempt.yml b/spec/rtems/barrier/req/perf-release-manual-preempt.yml
index 9c256659..a728828a 100644
--- a/spec/rtems/barrier/req/perf-release-manual-preempt.yml
+++ b/spec/rtems/barrier/req/perf-release-manual-preempt.yml
@@ -195,10 +195,10 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to
   ${../if/release:/name} which preempts the caller.  Let :math:`E` be a time
-  point measured by ``V`` right after a call to ${../if/wait:/name} returns
+  point measured by V right after a call to ${../if/wait:/name} returns
   successfully due to the ${../if/release:/name} call associated with
   :math:`B`.
 
diff --git a/spec/rtems/event/req/perf-isr-preempt.yml b/spec/rtems/event/req/perf-isr-preempt.yml
index e1beb42a..d85a66fe 100644
--- a/spec/rtems/event/req/perf-isr-preempt.yml
+++ b/spec/rtems/event/req/perf-isr-preempt.yml
@@ -163,13 +163,13 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` be an interrupt service and `V`` be a task which both execute on the
-  same processor.  Let :math:`B` be a time point measured by ``U`` right before
-  a call to ${../if/send:/name} which unblocks task ``V`` which preempts the
-  executing task.  Let :math:`E` be a time point measured by ``V`` right after
+  Let U be an interrupt service and V be a task which both execute on the
+  same processor.  Let :math:`B` be a time point measured by U right before
+  a call to ${../if/send:/name} which unblocks task V which preempts the
+  executing task.  Let :math:`E` be a time point measured by V right after
   the first context switch after :math:`B`.
 
-  While the execution environment is ${.:/environment}, while task ``V`` waits
+  While the execution environment is ${.:/environment}, while task V waits
   for events, while the measurement sample is :math:`E - B`, when exactly
   ${../val/perf:/params/sample-count} samples are collected, the
   ${.:/limit-kind} shall be ${.:/limit-condition}.
diff --git a/spec/rtems/event/req/perf-other-cpu.yml b/spec/rtems/event/req/perf-other-cpu.yml
index d6915c47..31c2b329 100644
--- a/spec/rtems/event/req/perf-other-cpu.yml
+++ b/spec/rtems/event/req/perf-other-cpu.yml
@@ -134,13 +134,13 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with distinct home schedulers.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to ${../if/send:/name}
-  which does satisfy the event condition of the waiting task ``V`` which is
+  Let U and V be two tasks with distinct home schedulers.  Let :math:`B`
+  be a time point measured by U right before a call to ${../if/send:/name}
+  which does satisfy the event condition of the waiting task V which is
   scheduled on another processor.  Let :math:`E` be a time point measured by
-  ``V`` right after the first context switch after :math:`B`.
+  V right after the first context switch after :math:`B`.
 
-  While the execution environment is ${.:/environment}, while the task ``V``
+  While the execution environment is ${.:/environment}, while the task V
   waits for events, while the measurement sample is :math:`E - B`, when exactly
   ${../val/perf:/params/sample-count} samples are collected, the
   ${.:/limit-kind} shall be ${.:/limit-condition}.
diff --git a/spec/rtems/event/req/perf-other-preempt.yml b/spec/rtems/event/req/perf-other-preempt.yml
index 45e492ba..5410d441 100644
--- a/spec/rtems/event/req/perf-other-preempt.yml
+++ b/spec/rtems/event/req/perf-other-preempt.yml
@@ -164,13 +164,13 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to ${../if/send:/name}
-  which does satisfy the event condition of the waiting task ``V`` which does
-  preempt the caller.  Let :math:`E` be a time point measured by ``V`` right
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to ${../if/send:/name}
+  which does satisfy the event condition of the waiting task V which does
+  preempt the caller.  Let :math:`E` be a time point measured by V right
   after the first context switch after :math:`B`.
 
-  While the execution environment is ${.:/environment}, while the task ``V``
+  While the execution environment is ${.:/environment}, while the task V
   waits for events, while the measurement sample is :math:`E - B`, when exactly
   ${../val/perf:/params/sample-count} samples are collected, the
   ${.:/limit-kind} shall be ${.:/limit-condition}.
diff --git a/spec/rtems/message/req/perf-receive-wait-forever.yml b/spec/rtems/message/req/perf-receive-wait-forever.yml
index 7933ed57..2dfa99ef 100644
--- a/spec/rtems/message/req/perf-receive-wait-forever.yml
+++ b/spec/rtems/message/req/perf-receive-wait-forever.yml
@@ -181,10 +181,10 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to
   ${../if/receive:/name} which blocks on the message queue with no timeout.
-  Let :math:`E` be a time point measured by ``V`` right after the first context
+  Let :math:`E` be a time point measured by V right after the first context
   switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while a message queue
diff --git a/spec/rtems/message/req/perf-receive-wait-timed.yml b/spec/rtems/message/req/perf-receive-wait-timed.yml
index d72386d1..d58bfcd0 100644
--- a/spec/rtems/message/req/perf-receive-wait-timed.yml
+++ b/spec/rtems/message/req/perf-receive-wait-timed.yml
@@ -181,10 +181,10 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to
   ${../if/receive:/name} which blocks on the message queue with a timeout.  Let
-  :math:`E` be a time point measured by ``V`` right after the first context
+  :math:`E` be a time point measured by V right after the first context
   switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while a message queue
diff --git a/spec/rtems/message/req/perf-send-other-cpu.yml b/spec/rtems/message/req/perf-send-other-cpu.yml
index 735b7826..dc3e8171 100644
--- a/spec/rtems/message/req/perf-send-other-cpu.yml
+++ b/spec/rtems/message/req/perf-send-other-cpu.yml
@@ -146,14 +146,14 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with distinct home schedulers.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to ${../if/send:/name}
-  which unblocks the waiting task ``V`` which is scheduled on another
-  processor.  Let :math:`E` be a time point measured by ``V`` right after the
+  Let U and V be two tasks with distinct home schedulers.  Let :math:`B`
+  be a time point measured by U right before a call to ${../if/send:/name}
+  which unblocks the waiting task V which is scheduled on another
+  processor.  Let :math:`E` be a time point measured by V right after the
   first context switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while a message queue
-  is empty, while only task ``V`` waits on the message queue, while the
+  is empty, while only task V waits on the message queue, while the
   measurement sample is :math:`E - B`, when exactly
   ${../val/perf:/params/sample-count} samples are collected, the
   ${.:/limit-kind} shall be ${.:/limit-condition}.
diff --git a/spec/rtems/message/req/perf-send-preempt.yml b/spec/rtems/message/req/perf-send-preempt.yml
index 6b297e03..6015f7ff 100644
--- a/spec/rtems/message/req/perf-send-preempt.yml
+++ b/spec/rtems/message/req/perf-send-preempt.yml
@@ -175,14 +175,14 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to ${../if/send:/name}
-  which unblocks the waiting task ``V`` which does preempt the caller.  Let
-  :math:`E` be a time point measured by ``V`` right after the first context
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to ${../if/send:/name}
+  which unblocks the waiting task V which does preempt the caller.  Let
+  :math:`E` be a time point measured by V right after the first context
   switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while a message queue
-  is empty, while only task ``V`` waits on the message queue, while the
+  is empty, while only task V waits on the message queue, while the
   measurement sample is :math:`E - B`, when exactly
   ${../val/perf:/params/sample-count} samples are collected, the
   ${.:/limit-kind} shall be ${.:/limit-condition}.
diff --git a/spec/rtems/sem/req/perf-mtx-pi-release-other-cpu.yml b/spec/rtems/sem/req/perf-mtx-pi-release-other-cpu.yml
index ce22c77f..bf6d2a0e 100644
--- a/spec/rtems/sem/req/perf-mtx-pi-release-other-cpu.yml
+++ b/spec/rtems/sem/req/perf-mtx-pi-release-other-cpu.yml
@@ -141,14 +141,14 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with distinct home schedulers.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to
-  ${../if/release:/name} which unblocks task ``V`` which is scheduled on
-  another processor.  Let :math:`E` be a time point measured by ``V`` right
+  Let U and V be two tasks with distinct home schedulers.  Let :math:`B`
+  be a time point measured by U right before a call to
+  ${../if/release:/name} which unblocks task V which is scheduled on
+  another processor.  Let :math:`E` be a time point measured by V right
   after the first context switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while the semaphore is
-  a priority inheritance mutex, while exactly task ``V`` waits on the mutex,
+  a priority inheritance mutex, while exactly task V waits on the mutex,
   while the measurement sample is :math:`E - B`, when exactly
   ${../val/perf:/params/sample-count} samples are collected, the
   ${.:/limit-kind} shall be ${.:/limit-condition}.
diff --git a/spec/rtems/sem/req/perf-mtx-pi-release-preempt.yml b/spec/rtems/sem/req/perf-mtx-pi-release-preempt.yml
index 2d1e2fc1..8db88f20 100644
--- a/spec/rtems/sem/req/perf-mtx-pi-release-preempt.yml
+++ b/spec/rtems/sem/req/perf-mtx-pi-release-preempt.yml
@@ -170,14 +170,14 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to
-  ${../if/release:/name} which unblocks task ``V`` which does preempt the
-  caller.  Let :math:`E` be a time point measured by ``V`` right after the
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to
+  ${../if/release:/name} which unblocks task V which does preempt the
+  caller.  Let :math:`E` be a time point measured by V right after the
   first context switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while the semaphore is
-  a priority inheritance mutex, while exactly task ``V`` waits for the mutex,
+  a priority inheritance mutex, while exactly task V waits for the mutex,
   while the measurement sample is :math:`E - B`, when exactly
   ${../val/perf:/params/sample-count} samples are collected, the
   ${.:/limit-kind} shall be ${.:/limit-condition}.
diff --git a/spec/rtems/sem/req/perf-mtx-pi-wait-forever.yml b/spec/rtems/sem/req/perf-mtx-pi-wait-forever.yml
index 8af87a8e..986f840c 100644
--- a/spec/rtems/sem/req/perf-mtx-pi-wait-forever.yml
+++ b/spec/rtems/sem/req/perf-mtx-pi-wait-forever.yml
@@ -178,10 +178,10 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to
   ${../if/obtain:/name} which blocks on the mutex with no timeout.  Let
-  :math:`E` be a time point measured by ``V`` right after the first context
+  :math:`E` be a time point measured by V right after the first context
   switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while the semaphore is
diff --git a/spec/rtems/sem/req/perf-mtx-pi-wait-timed.yml b/spec/rtems/sem/req/perf-mtx-pi-wait-timed.yml
index b7bc0db3..18926e17 100644
--- a/spec/rtems/sem/req/perf-mtx-pi-wait-timed.yml
+++ b/spec/rtems/sem/req/perf-mtx-pi-wait-timed.yml
@@ -178,10 +178,10 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to
   ${../if/obtain:/name} which blocks on the mutex with a timeout.  Let
-  :math:`E` be a time point measured by ``V`` right after the first context
+  :math:`E` be a time point measured by V right after the first context
   switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while the semaphore is
diff --git a/spec/rtems/task/req/perf-restart-preempt.yml b/spec/rtems/task/req/perf-restart-preempt.yml
index 9b2b14c6..13a59cd2 100644
--- a/spec/rtems/task/req/perf-restart-preempt.yml
+++ b/spec/rtems/task/req/perf-restart-preempt.yml
@@ -178,10 +178,10 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to
-  ${../if/restart:/name} which starts task ``V`` which preempts the caller.
-  Let :math:`E` be a time point measured by ``V`` right after the first context
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to
+  ${../if/restart:/name} which starts task V which preempts the caller.
+  Let :math:`E` be a time point measured by V right after the first context
   switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while the measurement
diff --git a/spec/rtems/task/req/perf-restart-self.yml b/spec/rtems/task/req/perf-restart-self.yml
index 00a03774..8b9c6b13 100644
--- a/spec/rtems/task/req/perf-restart-self.yml
+++ b/spec/rtems/task/req/perf-restart-self.yml
@@ -176,7 +176,7 @@ test-teardown:
 text: |
   Let :math:`B` be a time point measured by a task right before a call to
   ${../if/restart:/name} which restarts the caller.  Let :math:`E` be a time
-  point measured by ``V`` right after the first context switch after :math:`B`.
+  point measured by V right after the first context switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while the measurement
   sample is :math:`E - B`, the ${.:/limit-kind} shall be ${.:/limit-condition}.
diff --git a/spec/rtems/task/req/perf-set-scheduler-preempt.yml b/spec/rtems/task/req/perf-set-scheduler-preempt.yml
index c1545a1b..0537965f 100644
--- a/spec/rtems/task/req/perf-set-scheduler-preempt.yml
+++ b/spec/rtems/task/req/perf-set-scheduler-preempt.yml
@@ -157,11 +157,11 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the distinct home schedulers.  Let
-  :math:`B` be a time point measured by ``U`` right before a call to
-  ${../if/set-scheduler:/name} which moves task ``V`` to the home scheduler of
-  ``U`` which preempts the caller.  Let :math:`E` be a time point measured by
-  ``V`` right after the first context switch after :math:`B`.
+  Let U and V be two tasks with the distinct home schedulers.  Let
+  :math:`B` be a time point measured by U right before a call to
+  ${../if/set-scheduler:/name} which moves task V to the home scheduler of
+  U which preempts the caller.  Let :math:`E` be a time point measured by
+  V right after the first context switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while the measurement
   sample is :math:`E - B`, when exactly ${../val/perf:/params/sample-count}
diff --git a/spec/rtems/task/req/perf-start-preempt.yml b/spec/rtems/task/req/perf-start-preempt.yml
index e8c188b5..aad6027b 100644
--- a/spec/rtems/task/req/perf-start-preempt.yml
+++ b/spec/rtems/task/req/perf-start-preempt.yml
@@ -175,10 +175,10 @@ test-teardown:
     return tic == toc;
   description: null
 text: |
-  Let ``U` and `V`` be two tasks with the same home scheduler.  Let :math:`B`
-  be a time point measured by ``U`` right before a call to ${../if/start:/name}
-  which starts task ``V`` which preempts the caller.  Let :math:`E` be a time
-  point measured by ``V`` right after the first context switch after :math:`B`.
+  Let U and V be two tasks with the same home scheduler.  Let :math:`B`
+  be a time point measured by U right before a call to ${../if/start:/name}
+  which starts task V which preempts the caller.  Let :math:`E` be a time
+  point measured by V right after the first context switch after :math:`B`.
 
   While the execution environment is ${.:/environment}, while the measurement
   sample is :math:`E - B`, when exactly ${../val/perf:/params/sample-count}