--- jsr166/src/test/loops/SCollection.java	2009/10/29 23:09:08	1.2
+++ jsr166/src/test/loops/SCollection.java	2010/10/16 16:22:57	1.3
@@ -13,7 +13,6 @@ import java.util.concurrent.locks.*;
  * that places read-write locks around unsynchronized Collections.
  * Exists as a sample input for CollectionLoops test.
  */
-
 public final class SCollection<E> implements Collection<E> {
     private final Collection c;
     private final ReentrantLock l = new ReentrantLock();
@@ -29,58 +28,99 @@ public final class SCollection<E> implem
     }
 
     public final int size() {
-        l.lock(); try {return c.size();} finally { l.unlock(); }
+        l.lock();
+        try { return c.size(); }
+        finally { l.unlock(); }
     }
-    public final boolean isEmpty(){
-        l.lock(); try {return c.isEmpty();} finally { l.unlock(); }
+
+    public final boolean isEmpty() {
+        l.lock();
+        try { return c.isEmpty(); }
+        finally { l.unlock(); }
     }
 
     public final boolean contains(Object o) {
-        l.lock(); try {return c.contains(o);} finally { l.unlock(); }
+        l.lock();
+        try { return c.contains(o); }
+        finally { l.unlock(); }
     }
 
     public final boolean equals(Object o) {
-        l.lock(); try {return c.equals(o);} finally { l.unlock(); }
+        l.lock();
+        try { return c.equals(o); }
+        finally { l.unlock(); }
     }
+
     public final int hashCode() {
-        l.lock(); try {return c.hashCode();} finally { l.unlock(); }
+        l.lock();
+        try { return c.hashCode(); }
+        finally { l.unlock(); }
     }
+
     public final String toString() {
-        l.lock(); try {return c.toString();} finally { l.unlock(); }
+        l.lock();
+        try { return c.toString(); }
+        finally { l.unlock(); }
     }
 
     public final Iterator<E> iterator() {
-        l.lock(); try {return c.iterator();} finally { l.unlock(); }
+        l.lock();
+        try { return c.iterator(); }
+        finally { l.unlock(); }
     }
 
     public final Object[] toArray() {
-        l.lock(); try  {return c.toArray();} finally { l.unlock(); }
+        l.lock();
+        try { return c.toArray(); }
+        finally { l.unlock(); }
     }
+
     public final <T> T[] toArray(T[] a) {
-        l.lock(); try  {return (T[])c.toArray(a);} finally { l.unlock(); }
+        l.lock();
+        try { return (T[])c.toArray(a); }
+        finally { l.unlock(); }
     }
 
     public final boolean add(E e) {
-        l.lock(); try  {return c.add(e);} finally { l.unlock(); }
+        l.lock();
+        try { return c.add(e); }
+        finally { l.unlock(); }
     }
+
     public final boolean remove(Object o) {
-        l.lock(); try  {return c.remove(o);} finally { l.unlock(); }
+        l.lock();
+        try { return c.remove(o); }
+        finally { l.unlock(); }
     }
 
     public final boolean containsAll(Collection<?> coll) {
-        l.lock(); try  {return c.containsAll(coll);} finally { l.unlock(); }
+        l.lock();
+        try { return c.containsAll(coll); }
+        finally { l.unlock(); }
     }
+
     public final boolean addAll(Collection<? extends E> coll) {
-        l.lock(); try  {return c.addAll(coll);} finally { l.unlock(); }
+        l.lock();
+        try { return c.addAll(coll); }
+        finally { l.unlock(); }
     }
+
     public final boolean removeAll(Collection<?> coll) {
-        l.lock(); try  {return c.removeAll(coll);} finally { l.unlock(); }
+        l.lock();
+        try { return c.removeAll(coll); }
+        finally { l.unlock(); }
     }
+
     public final boolean retainAll(Collection<?> coll) {
-        l.lock(); try  {return c.retainAll(coll);} finally { l.unlock(); }
+        l.lock();
+        try { return c.retainAll(coll); }
+        finally { l.unlock(); }
     }
+
     public final void clear() {
-        l.lock(); try  {c.clear();} finally { l.unlock(); }
+        l.lock();
+        try { c.clear(); }
+        finally { l.unlock(); }
     }
 
 }