teststorageimplementation.java

lucene2.2.0版本

/** 
 * Copyright 2004 The Apache Software Foundation 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */
package org.apache.lucene.gdata.storage.lucenestorage;

import java.util.concurrent.atomic.AtomicBoolean;

import junit.framework.TestCase;

import org.apache.lucene.gdata.data.ServerBaseEntry;
import org.apache.lucene.gdata.server.registry.ComponentType;
import org.apache.lucene.gdata.server.registry.GDataServerRegistry;
import org.apache.lucene.gdata.server.registry.ProvidedService;
import org.apache.lucene.gdata.storage.ModificationConflictException;
import org.apache.lucene.gdata.storage.Storage;
import org.apache.lucene.gdata.storage.StorageController;
import org.apache.lucene.gdata.storage.StorageException;
import org.apache.lucene.gdata.storage.lucenestorage.StorageEntryWrapper.StorageOperation;
import org.apache.lucene.gdata.utils.MultiThreadEntryStub;
import org.apache.lucene.gdata.utils.ProvidedServiceStub;
import org.apache.lucene.gdata.utils.Visitor;

import com.google.gdata.data.DateTime;

public class TestStorageImplementation extends TestCase {
    private static GDataServerRegistry reg = null;

    private Storage storage;

    public static boolean fail = false;

    protected void setUp() throws Exception {

        if (reg == null) {
            reg = GDataServerRegistry.getRegistry();
            if(reg.lookup(StorageController.class,ComponentType.STORAGECONTROLLER)!= null);
                reg.destroy();
            reg.registerComponent(StorageCoreControllerStub.class,null);

        }
        this.storage = reg.lookup(StorageController.class,
                ComponentType.STORAGECONTROLLER).getStorage();
    }

    protected void tearDown() throws Exception {
        this.storage.close();
        fail = false;
    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.storeEntry(ServerBaseEntry)'
     */
    public void testStoreEntry() {

        try {
            this.storage.storeEntry(null);
            fail("entry is null");
        } catch (StorageException e) {
            //
        }
        ServerBaseEntry entry = new ServerBaseEntry();
        entry.setServiceConfig(new ProvidedServiceStub());

        try {
            this.storage.storeEntry(entry);
            fail("feed is null");
        } catch (StorageException e) {
            //
        }

        entry.setFeedId("someID");
        try {
            this.storage.storeEntry(entry);

        } catch (StorageException e1) {
            fail("unexpected exception");

        }
        entry.setServiceConfig(null);
        try {
            this.storage.storeEntry(entry);
            fail("no service config");
        } catch (StorageException e) {

        }
        entry.setVersion(5);
        try {
            this.storage.storeEntry(entry);
            fail("version is greater than 1");
        } catch (StorageException e) {

        }

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.deleteEntry(ServerBaseEntry)'
     */
    public void testDeleteEntry() throws InterruptedException {
        try {
            this.storage.storeEntry(null);
            fail("entry is null");
        } catch (StorageException e) {
            //
        }
        ServerBaseEntry entry = new ServerBaseEntry();
        entry.setServiceConfig(new ProvidedServiceStub());
        entry.setId("someID");
        entry.setFeedId("someID");
        try {
            this.storage.storeEntry(entry);

        } catch (StorageException e) {
            fail("unexpected exception");
            //
        }
        entry.setFeedId(null);
        try {
            this.storage.deleteEntry(entry);
            fail("feed is null");
        } catch (StorageException e) {
            //
        }

        entry.setFeedId("someID");
        try {
            this.storage.deleteEntry(entry);

        } catch (StorageException e1) {
            e1.printStackTrace();
            fail("unexpected exception");

        }
        entry.setFeedId("someID");
        
        try {
            this.storage.deleteEntry(entry);

        } catch (StorageException e1) {
            e1.printStackTrace();
            fail("unexpected exception");

        }
        
        
        
        Object monitor = new Object();
        AtomicBoolean reached = new AtomicBoolean(false);

        MultiThreadEntryStub concuEntry = new MultiThreadEntryStub();
        concuEntry.setId(System.currentTimeMillis() + "");
        ProvidedService conf = new ProvidedServiceStub();
        
        concuEntry.setServiceConfig(conf);
        concuEntry.setUpdated(DateTime.now());
        concuEntry.setFeedId("feed");
        this.storage.storeEntry(concuEntry);
        storage.close();
        concuEntry.acceptGetVersionVisitor(getMonitorVisitor(monitor,reached));


        Thread t1 = getDelThread(storage, concuEntry, false);

        Thread t2 = getDelThread(storage, concuEntry, true);
        t1.start();
        /*
         * Wait active -- not nice but works fine here
         * wait until thread parked
         */

        while (true) {
            synchronized (monitor) {
                if (reached.get())
                    break;
                monitor.wait(10);
            }
        }
        t2.start();
        t2.join(800);
        /*
         * Wait active -- not nice but works fine here
         * wake up the waiting thread
         */
        while (true) {
            synchronized (monitor) {
                if (!reached.get())
                    break;
                monitor.notifyAll();
            }
        }
        t1.join(300);
        if (fail)
            fail("thread failed -- see stacktrace");
       
       
    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.updateEntry(ServerBaseEntry)'
     */
    public void testUpdateEntry() throws InterruptedException {
        Object monitor = new Object();
        AtomicBoolean reached = new AtomicBoolean(false);

        MultiThreadEntryStub concuEntry = new MultiThreadEntryStub();
        concuEntry.setId(System.currentTimeMillis() + "");
        ProvidedService conf = new ProvidedServiceStub();
        
        concuEntry.setServiceConfig(conf);
        concuEntry.setUpdated(DateTime.now());
        concuEntry.setFeedId("feed");
        this.storage.storeEntry(concuEntry);
        storage.close();
        concuEntry.acceptGetEntryVisitor(getMonitorVisitor(monitor,reached));


        Thread t1 = getUpdThread(storage, concuEntry, false);

        Thread t2 = getUpdThread(storage, concuEntry, true);
        t1.start();
        /*
         * Wait active -- not nice but works fine here
         * wait until thread parked
         */

        while (true) {
            synchronized (monitor) {
                if (reached.get())
                    break;
                monitor.wait(10);
            }
        }
        t2.start();
        t2.join(800);
        /*
         * Wait active -- not nice but works fine here
         * wake up the waiting thread
         */
        while (true) {
            synchronized (monitor) {
                if (!reached.get())
                    break;
                monitor.notifyAll();
            }
        }
        t1.join(300);
        if (fail)
            fail("thread failed -- see stacktrace");

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.getFeed(ServerBaseFeed)'
     */
    public void testGetFeed() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.getEntry(ServerBaseEntry)'
     */
    public void testGetEntry() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.close()'
     */
    public void testClose() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.storeAccount(GDataAccount)'
     */
    public void testStoreAccount() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.updateAccount(GDataAccount)'
     */
    public void testUpdateAccount() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.deleteAccount(String)'
     */
    public void testDeleteAccount() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.storeFeed(ServerBaseFeed,
     * String)'
     */
    public void testStoreFeed() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.deleteFeed(String)'
     */
    public void testDeleteFeed() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.updateFeed(ServerBaseFeed,
     * String)'
     */
    public void testUpdateFeed() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.getServiceForFeed(String)'
     */
    public void testGetServiceForFeed() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.getAccount(String)'
     */
    public void testGetAccount() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.getAccountNameForFeedId(String)'
     */
    public void testGetAccountNameForFeedId() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.getEntryLastModified(String,
     * String)'
     */
    public void testGetEntryLastModified() {

    }

    /*
     * Test method for
     * 'org.apache.lucene.gdata.storage.lucenestorage.StorageImplementation.getFeedLastModified(String)'
     */
    public void testGetFeedLastModified() {

    }
    static class Runner implements Runnable {
        Storage s;

        StorageController c;

        ServerBaseEntry e;

        boolean expConf;

        StorageOperation op;

        public Runner(Storage s, ServerBaseEntry e,
                boolean expectConflict, StorageOperation op) {
            this.s = s;
            this.e = e;
            this.expConf = expectConflict;
            this.op = op;
        }

        public void run() {
           
            try {
                if (this.op == StorageOperation.DELETE)
                    this.s.deleteEntry(e);
                if (this.op == StorageOperation.UPDATE)
                    this.s.updateEntry(e);
                if (expConf)
                    fail = true;
            } catch (ModificationConflictException ex) {
                if (!expConf)
                    fail = true;
                ex.printStackTrace();

            } catch (StorageException ex) {
                ex.printStackTrace();
                fail = true;
            }

        }
    }
    
    private Visitor getMonitorVisitor(final Object monitor, final AtomicBoolean reached){
        /*
         * The executing thread stops at a defined position while holding the semaphore inside the storageImpl
         */
        return new Visitor(){
          public void execute(Object[] o){
            synchronized (monitor) {
            try {
                reached.set(true);
                monitor.wait();
                reached.set(false);
              
            } catch (InterruptedException e) {
                //                   
            }
            }
          }
        };
    }

    private Thread getDelThread(Storage s, ServerBaseEntry e,
            boolean conflictExpected) {
        Thread t1 = new Thread(new Runner(s, e, conflictExpected,
                StorageOperation.DELETE));
        t1.setPriority(Thread.MAX_PRIORITY);
        return t1;
    }

    private Thread getUpdThread(Storage s, ServerBaseEntry e,
            boolean conflictExpected) {
        Thread t1 = new Thread(new Runner(s, e, conflictExpected,
                StorageOperation.UPDATE));
        t1.setPriority(Thread.MAX_PRIORITY);
        return t1;
    }

}