Mailing-List: contact java-commits-help@lucene.apache.org; run by ezmlm
Precedence: bulk
Reply-To: java-dev@lucene.apache.org
Received-SPF: pass (asf.osuosl.org: local policy)
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: svn commit: r425563 [2/2] - in
 /lucene/java/trunk/contrib/gdata-server/src:
 java/org/apache/lucene/gdata/server/registry/configuration/
 java/org/apache/lucene/gdata/storage/db4o/
 test/org/apache/lucene/gdata/server/registry/configuration/ test/org/apac...
Date: Wed, 26 Jul 2006 00:20:01 -0000
To: java-commits@lucene.apache.org
From: yonik@apache.org
Message-Id: <20060726002003.A477A1A981D@eris.apache.org>

Added: lucene/java/trunk/contrib/gdata-server/src/test/org/apache/lucene/gdata/storage/db4o/TestDb4oStorage.java
URL: http://svn.apache.org/viewvc/lucene/java/trunk/contrib/gdata-server/src/test/org/apache/lucene/gdata/storage/db4o/TestDb4oStorage.java?rev=425563&view=auto
==============================================================================
--- lucene/java/trunk/contrib/gdata-server/src/test/org/apache/lucene/gdata/storage/db4o/TestDb4oStorage.java (added)
+++ lucene/java/trunk/contrib/gdata-server/src/test/org/apache/lucene/gdata/storage/db4o/TestDb4oStorage.java Tue Jul 25 17:20:00 2006
@@ -0,0 +1,877 @@
+package org.apache.lucene.gdata.storage.db4o;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import junit.framework.TestCase;
+
+import org.apache.lucene.gdata.data.GDataAccount;
+import org.apache.lucene.gdata.data.ServerBaseEntry;
+import org.apache.lucene.gdata.data.ServerBaseFeed;
+import org.apache.lucene.gdata.server.registry.ProvidedServiceConfig;
+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.Visitor;
+
+import com.db4o.ObjectContainer;
+import com.db4o.ObjectSet;
+import com.db4o.query.Query;
+import com.google.gdata.data.BaseEntry;
+import com.google.gdata.data.BaseFeed;
+import com.google.gdata.data.DateTime;
+import com.google.gdata.data.ExtensionProfile;
+import com.google.gdata.data.PlainTextConstruct;
+import com.google.gdata.util.common.xml.XmlWriter;
+
+public class TestDb4oStorage extends TestCase {
+    private static final String FEEDID = "myFeed";
+
+    private static final String ACCOUNTNAME = "myAccount";
+
+    private static final String SERVICENAME = "myService";
+
+    DB4oController controller;
+
+    static volatile boolean fail = false;
+
+    protected void setUp() throws Exception {
+        this.controller = new DB4oController();
+        this.controller.setContainerPoolSize(2);
+        this.controller.setFilePath("test.yap");
+        this.controller.setRunAsServer(true);
+        this.controller.setPassword("");
+        this.controller.setUser("");
+        this.controller.setUseWeakReferences(true);
+        this.controller.setPort(0);
+        this.controller.initialize();
+        this.controller.visiteInitialize();
+        clearDB();
+    }
+
+    protected void tearDown() throws Exception {
+        clearDB();
+        fail = false;
+        this.controller.getStorage().close();
+        this.controller.visiteDestroy();
+        this.controller.destroy();
+    }
+
+    private void clearDB() {
+        ObjectContainer container = this.controller.releaseContainer();
+        ObjectSet set = container.get(new Object());
+
+        for (Object object : set) {
+            container.delete(object);
+        }
+        container.ext().purge();
+        container.close();
+    }
+
+    ObjectContainer getContainer() {
+        return this.controller.releaseContainer();
+    }
+
+
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.storeEntry(ServerBaseEntry)'
+     */
+    @SuppressWarnings("unchecked")
+    public void testStoreEntry() throws StorageException {
+        Storage storage = this.controller.getStorage();
+        try {
+            ServerBaseEntry e = createServerBaseEntry();
+            storage.storeEntry(e);
+            fail("excption exp. for feed for the entry");
+        } catch (StorageException e) {
+            //
+        }
+        storeServerBaseFeed();
+        ServerBaseEntry e = createServerBaseEntry();
+        storage.storeEntry(e);
+        ServerBaseEntry e1 = createServerBaseEntry();
+        storage.storeEntry(e1);
+
+        storage = this.controller.getStorage();
+        Query query = getContainer().query();
+        query.constrain(BaseEntry.class);
+        query.descend("id").constrain(e.getId());
+        ObjectSet resultSet = query.execute();
+        assertEquals(1, resultSet.size());
+        BaseEntry storedEntry = (BaseEntry)resultSet.next();
+        assertEquals("1",storedEntry.getVersionId());
+
+        ServerBaseFeed bFeed = new ServerBaseFeed();
+        bFeed.setItemsPerPage(25);
+        bFeed.setId(FEEDID);
+        bFeed.setStartIndex(1);
+        BaseFeed<BaseFeed, BaseEntry> feed = storage.getFeed(bFeed);
+        assertEquals(2, feed.getEntries().size());
+        assertEquals(e.getId(), feed.getEntries().get(1).getId()); // last post
+        // ->
+        // previously
+        // created
+        assertEquals(e1.getId(), feed.getEntries().get(0).getId()); // first pos
+        // -> last
+        // created
+        assertEquals(feed.getUpdated(), feed.getEntries().get(0).getUpdated());
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.deleteEntry(ServerBaseEntry)'
+     */
+    public void testDeleteEntry() throws StorageException, InterruptedException {
+        ObjectContainer container = getContainer();
+        storeServerBaseFeed();
+        Storage storage = this.controller.getStorage();
+        ServerBaseEntry e = createServerBaseEntry();
+        storage.storeEntry(e);
+        ServerBaseEntry e1 = createServerBaseEntry();
+        storage.storeEntry(e1);
+
+        storage.deleteEntry(e);
+        
+        container.close();
+        container = getContainer();
+        Query query = container.query();
+        query.constrain(BaseEntry.class);
+        query.descend("id").constrain(e.getId());
+        ObjectSet resultSet = query.execute();
+        assertEquals(0, resultSet.size());
+
+        // #### test version matching
+        ServerBaseEntry eVersion = createServerBaseEntry();
+        storage.storeEntry(eVersion);
+        eVersion.setVersion(33);
+        try {
+            storage.deleteEntry(eVersion);
+            fail("version does not match");
+        } catch (Exception ex) {
+            // TODO: handle exception
+        }
+
+        storage = this.controller.getStorage();
+        storage.deleteEntry(e1);
+        container.close();
+        container = getContainer();
+        query = container.query();
+        query.constrain(BaseEntry.class);
+        query.descend("id").constrain(e1.getId());
+        resultSet = query.execute();
+        assertEquals(0, resultSet.size());
+
+        // ############ test concurrency
+
+        // ############ test concurrency
+        Object monitor = new Object();
+        AtomicBoolean reached = new AtomicBoolean(false);
+        MultiThreadEntryStub concuEntry = new MultiThreadEntryStub();
+        concuEntry.setId(System.currentTimeMillis() + "");
+        ProvidedServiceConfig conf = new ProvidedServiceConfig();
+        conf.setName(SERVICENAME);
+        concuEntry.setServiceConfig(conf);
+        concuEntry.setUpdated(DateTime.now());
+        concuEntry.setFeedId(FEEDID);
+
+        storage = this.controller.getStorage();
+
+        storage.storeEntry(concuEntry);
+        storage.close();
+        concuEntry.acceptGetVersionVisitor(getMonitorVisitor(monitor,reached));
+
+
+        Thread t1 = getDelThread(controller, concuEntry, false);
+
+        Thread t2 = getDelThread(controller, 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");
+        
+        container.close();
+
+    }
+    
+    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(StorageController c, ServerBaseEntry e,
+            boolean conflictExpected) {
+        Thread t1 = new Thread(new Runner(c, e, conflictExpected,
+                StorageOperation.DELETE));
+        t1.setPriority(Thread.MAX_PRIORITY);
+        return t1;
+    }
+
+    private Thread getUpdThread(StorageController c, ServerBaseEntry e,
+            boolean conflictExpected) {
+        Thread t1 = new Thread(new Runner(c, e, conflictExpected,
+                StorageOperation.UPDATE));
+        t1.setPriority(Thread.MAX_PRIORITY);
+        return t1;
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.updateEntry(ServerBaseEntry)'
+     */
+    public void testUpdateEntry() throws StorageException, InterruptedException {
+        storeServerBaseFeed();
+        Storage storage = this.controller.getStorage();
+        ServerBaseEntry e = createServerBaseEntry();
+        ServerBaseEntry e1 = createServerBaseEntry();
+        try {
+            storage.updateEntry(e);
+            fail("entry does not exist");
+        } catch (StorageException ex) {
+            ex.printStackTrace();
+        }
+        storage.storeEntry(e);
+
+        storage = this.controller.getStorage();
+
+        storage.storeEntry(e1);
+        ServerBaseEntry e2 = createServerBaseEntry();
+        e2.setId(e.getId());
+        e2.setTitle(new PlainTextConstruct("new"));
+        e2.setUpdated(DateTime.now());
+        storage.updateEntry(e2);
+        ObjectContainer container = getContainer();
+        Query query = container.query();
+        query.constrain(BaseEntry.class);
+        query.descend("id").constrain(e.getId());
+        ObjectSet resultSet = query.execute();
+        assertEquals(1, resultSet.size());
+        BaseEntry result = (BaseEntry) resultSet.next();
+        assertEquals("new", result.getTitle().getPlainText());
+        assertEquals("2", result.getVersionId());
+        
+        
+        ServerBaseFeed bFeed = new ServerBaseFeed();
+        bFeed.setItemsPerPage(25);
+        bFeed.setId(FEEDID);
+        bFeed.setStartIndex(1);
+        storage = this.controller.getStorage();
+        BaseFeed<BaseFeed, BaseEntry> feed = storage.getFeed(bFeed);
+
+        assertEquals(2, feed.getEntries().size());
+        assertEquals(e.getId(), feed.getEntries().get(0).getId());
+        assertEquals(feed.getUpdated(), feed.getEntries().get(0).getUpdated());
+
+        storage = this.controller.getStorage();
+        storage.storeEntry(e);
+
+        e2.setVersion(5);
+        try {
+            storage.updateEntry(e2);
+            fail("version does not match");
+        } catch (Exception ex) {
+            // TODO: handle exception
+        }
+
+        // ############ test concurrency
+        Object monitor = new Object();
+        AtomicBoolean reached = new AtomicBoolean(false);
+
+        MultiThreadEntryStub concuEntry = new MultiThreadEntryStub();
+        concuEntry.setId(System.currentTimeMillis() + "");
+        ProvidedServiceConfig conf = new ProvidedServiceConfig();
+        conf.setName(SERVICENAME);
+        concuEntry.setServiceConfig(conf);
+        concuEntry.setUpdated(DateTime.now());
+        concuEntry.setFeedId(FEEDID);
+
+        storage = this.controller.getStorage();
+
+        storage.storeEntry(concuEntry);
+        storage.close();
+        concuEntry.acceptGetEntryVisitor(getMonitorVisitor(monitor,reached));
+
+
+        Thread t1 = getUpdThread(controller, concuEntry, false);
+
+        Thread t2 = getUpdThread(controller, 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");
+        container.close();
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.getFeed(ServerBaseFeed)'
+     */
+    public void testGetFeed() throws StorageException {
+        storeServerBaseFeed();
+        Storage storage = this.controller.getStorage();
+        ServerBaseFeed feed = new ServerBaseFeed();
+        feed.setItemsPerPage(25);
+        feed.setStartIndex(1);
+        feed.setId(FEEDID);
+        BaseFeed result = storage.getFeed(feed);
+        assertNotNull(result);
+        assertEquals(0, result.getEntries().size());
+        List<String> idlist = new ArrayList<String>(30);
+        ServerBaseEntry e1 = null;
+        for (int i = 0; i < 30; i++) {
+            e1 = createServerBaseEntry();
+            storage.storeEntry(e1);
+            idlist.add(0, e1.getId());
+        }
+        String firstId = e1.getId();
+
+        storage = this.controller.getStorage();
+        result = storage.getFeed(feed);
+        assertNotNull(result);
+        assertEquals(25, result.getEntries().size());
+        for (int i = 0; i < 25; i++) {
+            assertEquals(idlist.get(i),
+                    ((BaseEntry) result.getEntries().get(i)).getId());
+        }
+
+        storage = this.controller.getStorage();
+        feed.setItemsPerPage(5);
+        result = storage.getFeed(feed);
+        assertNotNull(result);
+        assertEquals(5, result.getEntries().size());
+        for (int i = 0; i < 5; i++) {
+            assertEquals(idlist.get(i),
+                    ((BaseEntry) result.getEntries().get(i)).getId());
+        }
+
+        storage = this.controller.getStorage();
+        feed.setItemsPerPage(1);
+        feed.setStartIndex(1);
+        result = storage.getFeed(feed);
+        assertNotNull(result);
+        assertEquals(1, result.getEntries().size());
+
+        assertEquals(idlist.get(0), ((BaseEntry) result.getEntries().get(0))
+                .getId());
+
+        storage = this.controller.getStorage();
+        feed.setItemsPerPage(50);
+        feed.setStartIndex(28);
+        result = storage.getFeed(feed);
+        assertNotNull(result);
+        assertEquals(3, result.getEntries().size());
+
+        assertEquals(idlist.get(27), ((BaseEntry) result.getEntries().get(0))
+                .getId());
+        assertEquals(idlist.get(28), ((BaseEntry) result.getEntries().get(1))
+                .getId());
+        assertEquals(idlist.get(29), ((BaseEntry) result.getEntries().get(2))
+                .getId());
+
+        storage = this.controller.getStorage();
+        feed.setItemsPerPage(50);
+        feed.setStartIndex(30);
+        result = storage.getFeed(feed);
+        assertNotNull(result);
+        assertEquals(1, result.getEntries().size());
+
+        assertEquals(idlist.get(29), ((BaseEntry) result.getEntries().get(0))
+                .getId());
+
+        // assertNotSame(firstId,((BaseEntry)result.getEntries().get(0)).getId());
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.getEntry(ServerBaseEntry)'
+     */
+    public void testGetEntry() throws StorageException {
+        storeServerBaseFeed();
+        Storage storage = this.controller.getStorage();
+        ServerBaseEntry e = createServerBaseEntry();
+        storage.storeEntry(e);
+        ServerBaseEntry e1 = createServerBaseEntry();
+        storage.storeEntry(e1);
+
+        storage = this.controller.getStorage();
+        BaseEntry result = storage.getEntry(e);
+        assertNotNull(result);
+        assertEquals(e.getId(), result.getId());
+        try {
+            e1.setId("hello");
+            result = storage.getEntry(e1);
+            fail("no such entry");
+        } catch (StorageException ex) {
+            ex.printStackTrace();
+        }
+
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.storeAccount(GDataAccount)'
+     */
+    public void testStoreAccount() throws StorageException {
+        GDataAccount account = new GDataAccount();
+        account.setName("simon");
+        account.setPassword("somepass");
+        Storage storage = this.controller.getStorage();
+        storage.storeAccount(account);
+        ObjectContainer container = getContainer();
+        Query q = container.query();
+        q.constrain(GDataAccount.class);
+        q.descend("name").constrain(account.getName());
+        ObjectSet set = q.execute();
+        assertEquals(1, set.size());
+        assertEquals(account.getPassword(), ((GDataAccount) set.next())
+                .getPassword());
+        try {
+            storage.storeAccount(account);
+            fail("Account already stored");
+        } catch (Exception e) {
+
+        }
+        container.close();
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.updateAccount(GDataAccount)'
+     */
+    public void testUpdateAccount() throws StorageException {
+        GDataAccount account = new GDataAccount();
+        account.setName("simon");
+        account.setPassword("somepass");
+
+        Storage storage = this.controller.getStorage();
+        try {
+            storage.updateAccount(account);
+            fail("Account does not exist");
+        } catch (Exception e) {
+            //
+        }
+        try {
+            storage.updateAccount(null);
+            fail("Account is null");
+        } catch (Exception e) {
+            //
+        }
+        storage.storeAccount(account);
+        ObjectContainer container = getContainer();
+        Query q = container.query();
+        q.constrain(GDataAccount.class);
+        q.descend("name").constrain(account.getName());
+        ObjectSet set = q.execute();
+        assertEquals(1, set.size());
+        assertEquals(account.getPassword(), ((GDataAccount) set.next())
+                .getPassword());
+        account = new GDataAccount();
+        account.setName("simon");
+        account.setPassword("newPass");
+        storage.updateAccount(account);
+
+        q = container.query();
+        q.constrain(GDataAccount.class);
+        q.descend("name").constrain(account.getName());
+        set = q.execute();
+        assertEquals(1, set.size());
+        assertEquals(account.getPassword(), ((GDataAccount) set.next())
+                .getPassword());
+        container.close();
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.deleteAccount(String)'
+     */
+    public void testDeleteAccount() throws StorageException {
+        GDataAccount account = new GDataAccount();
+        account.setName("simon");
+        account.setPassword("somepass");
+        Storage storage = this.controller.getStorage();
+        storage.storeAccount(account);
+        ObjectContainer container = getContainer();
+        Query q = container.query();
+        q.constrain(GDataAccount.class);
+        q.descend("name").constrain(account.getName());
+        ObjectSet set = q.execute();
+        assertEquals(1, set.size());
+
+        storage.deleteAccount(account.getName());
+
+        q = container.query();
+        q.constrain(GDataAccount.class);
+        q.descend("name").constrain(account.getName());
+        set = q.execute();
+        assertEquals(0, set.size());
+        try {
+            storage.deleteAccount("notstored");
+            fail("account not stored");
+        } catch (Exception e) {
+            // 
+        }
+        try {
+            storage.deleteAccount(null);
+            fail("name is null");
+        } catch (Exception e) {
+            // 
+        }
+        container.close();
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.storeFeed(ServerBaseFeed,
+     * String)'
+     */
+    public void testStoreFeed() throws StorageException {
+        ObjectContainer container = getContainer();
+        ServerBaseFeed feed = new ServerBaseFeed();
+        feed.setId(FEEDID);
+        ProvidedServiceConfig conf = new ProvidedServiceConfig();
+        conf.setName(SERVICENAME);
+        feed.setServiceConfig(conf);
+
+        Storage storage = this.controller.getStorage();
+        try {
+            storage.storeFeed(feed, ACCOUNTNAME);
+            fail("no accoutn stored");
+        } catch (Exception e) {
+            // 
+        }
+        GDataAccount account = new GDataAccount();
+        account.setName(ACCOUNTNAME);
+        account.setPassword("somePass");
+        container.set(account);
+        container.commit();
+        container.close();
+        storage.storeFeed(feed, ACCOUNTNAME);
+
+        container = getContainer();
+        Query query = container.query();
+        query.constrain(ServerBaseFeed.class);
+        query.descend("feed").descend("id").constrain(FEEDID);
+        ObjectSet set = query.execute();
+        assertEquals(1, set.size());
+
+        assertEquals(feed.getId(), ((ServerBaseFeed) set.next()).getId());
+        container.close();
+
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.deleteFeed(String)'
+     */
+    public void testDeleteFeed() throws StorageException {
+    
+
+    
+        ServerBaseFeed feed = new ServerBaseFeed();
+        feed.setId(FEEDID);
+        GDataAccount account = new GDataAccount();
+        account.setName(ACCOUNTNAME);
+        account.setPassword("somePass");
+        ObjectContainer container = getContainer();
+        container.set(account);
+        container.commit();
+        container.close();
+        Storage storage = this.controller.getStorage();
+        ProvidedServiceConfig conf = new ProvidedServiceConfig();
+        conf.setName(SERVICENAME);
+        feed.setServiceConfig(conf);
+        storage.storeFeed(feed, ACCOUNTNAME);
+    
+        storage.deleteFeed(FEEDID);
+        container = getContainer();
+        Query query = container.query();
+        query.constrain(ServerBaseFeed.class);
+        query.descend("feed").descend("id").constrain(FEEDID);
+        ObjectSet set = query.execute();
+        assertEquals(0, set.size());
+
+        query = getContainer().query();
+        query.constrain(BaseFeed.class);
+        query.descend("id").constrain(FEEDID);
+        set = query.execute();
+        assertEquals(0, set.size());
+        container.close();
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.getServiceForFeed(String)'
+     */
+    public void testGetServiceForFeed() throws StorageException {
+        ServerBaseFeed feed = new ServerBaseFeed();
+        ProvidedServiceConfig conf = new ProvidedServiceConfig();
+        conf.setName(SERVICENAME);
+        feed.setServiceConfig(conf);
+        feed.setId(FEEDID);
+        GDataAccount account = new GDataAccount();
+        account.setName(ACCOUNTNAME);
+        account.setPassword("somePass");
+        ObjectContainer container = getContainer();
+        container.set(account);
+        container.commit();
+        container.close();
+        Storage storage = this.controller.getStorage();
+        storage.storeFeed(feed, ACCOUNTNAME);
+
+        assertEquals(SERVICENAME, storage.getServiceForFeed(FEEDID));
+        try {
+            storage.getServiceForFeed(null);
+            fail("ID is null");
+        } catch (Exception e) {
+            // 
+        }
+
+        try {
+            storage.getServiceForFeed("someOtherId");
+            fail("feed for id is not stored");
+        } catch (Exception e) {
+            // 
+        }
+
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.getAccount(String)'
+     */
+    public void testGetAccount() throws StorageException {
+        GDataAccount account = new GDataAccount();
+        account.setName(ACCOUNTNAME);
+        account.setPassword("somePass");
+        ObjectContainer container = getContainer();
+        container.set(account);
+        container.commit();
+        container.close();
+       
+        Storage storage = this.controller.getStorage();
+        assertNotNull(storage.getAccount(ACCOUNTNAME));
+        assertEquals(account.getPassword(), storage.getAccount(ACCOUNTNAME)
+                .getPassword());
+        try {
+            storage.getAccount(null);
+            fail("accountname is null");
+        } catch (Exception e) {
+            // 
+        }
+        try {
+            storage.getAccount("someOtherAccount");
+            fail("accountname is not stored");
+        } catch (Exception e) {
+            // 
+        }
+    }
+
+    /*
+     * Test method for
+     * 'org.apache.lucene.gdata.storage.db4o.DB4oStorage.updateFeed(ServerBaseFeed,
+     * String)'
+     */
+    public void testUpdateFeed() throws StorageException {
+        ObjectContainer container = getContainer();
+        ServerBaseFeed feed = new ServerBaseFeed();
+        ProvidedServiceConfig conf = new ProvidedServiceConfig();
+        conf.setName(SERVICENAME);
+        feed.setId(FEEDID);
+        feed.setServiceConfig(conf);
+        Storage storage = this.controller.getStorage();
+        GDataAccount account = new GDataAccount();
+        account.setName(ACCOUNTNAME);
+        account.setPassword("somePass");
+        container.set(account);
+        container.commit();
+        container.close();
+        storage.storeFeed(feed, ACCOUNTNAME);
+        assertNull(feed.getTitle());
+        ServerBaseFeed feedU = new ServerBaseFeed();
+        feedU.setServiceConfig(conf);
+        feedU.setId(FEEDID);
+        feedU.setTitle(new PlainTextConstruct("someText"));
+        storage.updateFeed(feedU, ACCOUNTNAME);
+        ServerBaseFeed requestFeed = new ServerBaseFeed();
+        requestFeed.setId(FEEDID);
+        assertNotNull(storage.getFeed(requestFeed));
+        assertEquals(feedU.getTitle(), storage.getFeed(requestFeed).getTitle());
+        try {
+            storage.updateFeed(null, ACCOUNTNAME);
+            fail("feed is null");
+        } catch (Exception e) {
+            // 
+        }
+        try {
+            storage.updateFeed(feedU, null);
+            fail("accountname is null");
+        } catch (Exception e) {
+            // 
+        }
+        try {
+            feedU.setServiceType(null);
+            storage.updateFeed(feedU, ACCOUNTNAME);
+            fail("servicetype is null");
+        } catch (Exception e) {
+            // 
+        }
+
+    }
+
+    private static ServerBaseEntry createServerBaseEntry() {
+        ServerBaseEntry e = new ServerBaseEntry();
+        e.setId(System.currentTimeMillis() + "");
+        ProvidedServiceConfig conf = new ProvidedServiceConfig();
+        conf.setName(SERVICENAME);
+        e.setServiceConfig(conf);
+        e.setUpdated(DateTime.now());
+        e.setFeedId(FEEDID);
+        try {
+            Thread.sleep(2);
+        } catch (InterruptedException e1) {
+
+            e1.printStackTrace();
+        }
+        return e;
+    }
+
+    private void storeServerBaseFeed() {
+        ServerBaseFeed f = new ServerBaseFeed();
+        ProvidedServiceConfig conf = new ProvidedServiceConfig();
+        conf.setName(SERVICENAME);
+        f.setServiceConfig(conf);
+        f.setId(System.currentTimeMillis() + "");
+        f.setId(FEEDID);
+        f.setUpdated(DateTime.now());
+        ObjectContainer con = this.controller.releaseContainer();
+        con.set(f);
+        con.commit();
+
+        con.close();
+
+    }
+
+    static class Runner implements Runnable {
+        Storage s;
+
+        StorageController c;
+
+        ServerBaseEntry e;
+
+        boolean expConf;
+
+        StorageOperation op;
+
+        public Runner(StorageController c, ServerBaseEntry e,
+                boolean expectConflict, StorageOperation op) {
+
+            this.c = c;
+
+            this.e = e;
+            this.expConf = expectConflict;
+            this.op = op;
+
+        }
+
+        public void run() {
+            try {
+                ((DB4oController) this.c).visiteInitialize();
+                this.s = this.c.getStorage();
+            } catch (StorageException e1) {
+
+                e1.printStackTrace();
+            }
+            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;
+            } finally {
+                ((DB4oController) this.c).visiteDestroy();
+            }
+
+        }
+    }
+}

Propchange: lucene/java/trunk/contrib/gdata-server/src/test/org/apache/lucene/gdata/storage/db4o/TestDb4oStorage.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: lucene/java/trunk/contrib/gdata-server/src/test/org/apache/lucene/gdata/storage/db4o/TestDb4oStorage.java
------------------------------------------------------------------------------
    svn:executable = *

Propchange: lucene/java/trunk/contrib/gdata-server/src/test/org/apache/lucene/gdata/storage/db4o/TestDb4oStorage.java
------------------------------------------------------------------------------
    svn:keywords = Date Author Id Revision HeadURL