Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.uberfire.io.lock.impl;
  
  import java.io.File;
  import java.net.URI;
  import java.util.Date;
  import java.util.HashMap;
  
 import org.junit.Test;
 import  org.uberfire.java.nio.file.FileSystem;
 import  org.uberfire.java.nio.file.Path;
 import  org.uberfire.java.nio.file.api.FileSystemProviders;
 import  org.uberfire.java.nio.fs.jgit.JGitFileSystemProvider;
 
 import static java.lang.Thread.*;
 import static org.junit.Assert.*;
 
 public class FSLockServiceImplTest {
 
     final static IOService ioService = new IOServiceDotFileImpl();
     static FileSystem fs1;
     static FileSystem fs2;
     private static File path = null;
 
     @BeforeClass
     public static void setup() throws IOException {
          = CommonIOServiceDotFileTest.createTempDirectory();
         System.setProperty"org.uberfire.nio.git.dir".getAbsolutePath() );
         ..println".niogit: " + .getAbsolutePath() );
 
         final URI newRepo = URI.create"git://fs-lock-repo" );
 
          = .newFileSystemnewReponew HashMap<StringObject>() );
         Path init = .get( URI.create"git://fs-lock-repo/init.file" ) );
         .writeinit"setupFS!" );
 
         final URI newRepo2 = URI.create"git://fs-lock-repo-another-test" );
 
          = .newFileSystemnewRepo2new HashMap<StringObject>() {{
             put"init""true" );
         }} );
         init = .get( URI.create"git://fs-lock-repo/init.file" ) );
         .writeinit"setupFS!" );
     }
 
     @AfterClass
     @BeforeClass
     public static void cleanup() {
         if (  != null ) {
             FileUtils.deleteQuietly );
         }
     }
 
     @Test
     public void acquireLock() throws Exception {
         assertFalse.isLocked ) );
         .lock );
         assertTrue.isLocked ) );
         .unlock );
         assertFalse.isLocked ) );
     }
 
     @Test
     public void acquireTwoLock() throws Exception {
         assertFalse.isLocked ) );
         assertFalse.isLocked ) );
         .lock );
         assertTrue.isLocked ) );
         assertFalse.isLocked ) );
         .lock );
         assertTrue.isLocked ) );
         assertTrue.isLocked ) );
         .unlock );
         assertFalse.isLocked ) );
         assertTrue.isLocked ) );
         .unlock );
         assertFalse.isLocked ) );
         assertFalse.isLocked ) );
     }
 
     @Ignore //Race Condition
     @Test
     public void threeThreadsTryingToAcquireLockForTheSameFS() throws Exception {
         FSThread fsThread1 = new FSThread );
         Thread t1 = new ThreadfsThread1 );
         FSThread fsThread2 = new FSThread );
         Thread t2 = new ThreadfsThread2 );
        FSThread fsThread3 = new FSThread );
        Thread t3 = new ThreadfsThread3 );
        t1.start();
        t2.start();
        t3.start();
        t1.join();
        t2.join();
        t3.join();
        assertTruefsThread1.whenITookLock() < fsThread2.whenITookLock() );
        assertTrue(fsThread2.whenITookLock() < fsThread3.whenITookLock());
        assertMinDeltasfsThread1fsThread2fsThread3 );
    }
    @Test
    public void sameThreadShouldNotWaitForLock(){
        .lock );
        .waitForUnlock );
    }
    private void assertMinDeltasFSThread fsThread1,
                                  FSThread fsThread2,
                                  FSThread fsThread3 ) {
        assertTrue(fsThread2.whenITookLock()-fsThread1.whenITookLock() >= fsThread1.waitTime());
        assertTrue(fsThread3.whenITookLock()-fsThread2.whenITookLock() >= fsThread1.waitTime());
    }
    class FSThread implements Runnable {
        private final FileSystem fs;
        private final FSLockService lockService;
        private Date timestampThatITakeTheLock;
        public FSThread( FileSystem fs,
                         FSLockService lockService ) {
            this. = fs;
            this. = lockService;
        }
        public void run() {
            try {
                .lock );
                 = new Date();
                sleepwaitTime() );
                .unlock );
            } catch ( InterruptedException e ) {
                e.printStackTrace();
            }
        }
        int waitTime() {
            return 100;
        }
        long whenITookLock() {
            return .getTime();
        }
    }
New to GrepCode? Check out our FAQ X