**   Copyright notice                                                       **

**                                                                          **

**   (c) 2005-2006 RSSOwl Development Team                                  **

**   http://www.rssowl.org/                                                 **

**                                                                          **

**   All rights reserved                                                    **

**                                                                          **

**   This program and the accompanying materials are made available under   **

**   the terms of the Eclipse Public License v1.0 which accompanies this    **

**   distribution, and is available at:                                     **

**   http://www.rssowl.org/legal/epl-v10.html                               **

**                                                                          **

**   A copy is found in the file epl-v10.html and important notices to the  **

**   license from the team is found in the textfile LICENSE.txt distributed **

**   in this package.                                                       **

**                                                                          **

**   This copyright notice MUST APPEAR in all copies of the file!           **

**                                                                          **

**   Contributors:                                                          **

**     RSSOwl Development Team - initial API and implementation             **

**                                                                          **

**  **********************************************************************  */

* @author Ismael Juma (ismael@juma.me.uk)

*/

  private static final String NOT_IDENTICAL_MESSAGE = "Item in the database is not identical to initial item.";

  private IModelTypesFactory fTypesFactory;

  private IModelDAO fModelDAO;

  private IApplicationLayer fAppLayer;

  /**

   * @throws Exception

   */

  @Before

  public void setUp() throws Exception {

    NewsModel.getDefault().getPersistenceLayer().getModelSearch().stopIndexer();

    NewsModel.getDefault().getPersistenceLayer().recreateSchema();

    fTypesFactory = NewsModel.getDefault().getTypesFactory();

    fModelDAO = NewsModel.getDefault().getPersistenceLayer().getModelDAO();

    fAppLayer = NewsModel.getDefault().getPersistenceLayer().getApplicationLayer();

  }

  private ICategory createFeedCategory() throws PersistenceException {

    IFeed feed = fModelDAO.saveFeed(createFeed());

    ICategory category = fTypesFactory.createCategory(null, feed);

    category.setName("categoryName");

    category.setDomain("some/domain");

    category.setProperty("one_property", "value");

    return category;

  }

  private ICategory createNewsCategory() throws PersistenceException {

    IFeed feed = fModelDAO.saveFeed(createFeed());

    INews news = fModelDAO.saveNews(createNews(feed));

    ICategory category = fTypesFactory.createCategory(null, news);

    category.setName("categoryName");

    category.setDomain("some/domain");

    category.setProperty("one_property", "value");

    return category;

  }

 

  private IBookMark createBookMark() throws PersistenceException   {

    IFolder folder = fModelDAO.saveFolder(createFolder());

    return createBookMark(folder);

  }

 

  private ISearchMark createSearchMark() throws PersistenceException   {

    IFolder folder = fModelDAO.saveFolder(createFolder());

    return createSearchMark(folder);

  }

  private IBookMark createBookMark(IFolder folder) throws PersistenceException {

    IFeed feed = createFeed();

    IFeed savedFeed = fAppLayer.loadFeed(feed.getLink());

    if (savedFeed == null)

      savedFeed = fModelDAO.saveFeed(feed);

   

    IBookMark bookMark = fTypesFactory.createBookMark(null, folder, savedFeed.getLink(),

        new FeedReference(savedFeed.getId()), "Default bookmark");

    bookMark.setLastVisitDate(createDate());

    bookMark.setPopularity(50);

    bookMark.setErrorLoading(false);

    return bookMark;

  }

 

  private IFolder createFolder() {

    return createFolder(null);

  }

  private IFolder createFolder(IFolder parent) {

    IFolder folder = fTypesFactory.createFolder(null, parent, "SomeFolder");

    folder.setBlogrollUrl(createURI("http://someuri.com"));

    folder.setProperty("somekey", "somevalue");

    return folder;

  }

 

  /**

   * Checks:

   * - Addition of person

   * - That ADD event is issued

   * - Updating of person

   * - That UPDATE event is issued

   * - Getting of person

   */

  @Test

  public void testAddUpdateAndGetPerson() {

    IFeed feed = createFeed();

    final Person initialJohn = (Person) createPersonJohn(feed);

    final Person[] updatedJohn = new Person[1];

    final boolean[] personAddedCalled = new boolean[] { false };

    final boolean[] personUpdatedCalled = new boolean[] { false };

    PersonListener personListener = null;

    try {

      personListener = new PersonAdapter() {

        @Override

        public void personAdded(Set<PersonEvent> events) {

          for (PersonEvent event : events) {

            personAddedCalled[0] = true;

            Person dbPerson = (Person) event.getEntity();

            initialJohn.setId(dbPerson.getId());

            assertTrue(initialJohn.isIdentical(dbPerson));

          }

        }

        @Override

        public void personUpdated(Set<PersonEvent> events) {

          PersonEvent event = events.iterator().next();

          personUpdatedCalled[0] = true;

          Person dbPerson = (Person) event.getEntity();

          assertTrue(updatedJohn[0].isIdentical(dbPerson));

        }

      };

      NewsModel.getDefault().addPersonListener(personListener);

      long savedJohnId = fModelDAO.savePerson(initialJohn).getId().longValue();

      System.gc();

      IPerson savedJohn = fModelDAO.loadPerson(savedJohnId);

      initialJohn.setId(savedJohn.getId());

      assertTrue(initialJohn.isIdentical(savedJohn));

      URI oldJohnEmail = savedJohn.getEmail();

      IPerson dan = createPersonDan(feed);

      dan.setEmail(oldJohnEmail);

      NewsModel.getDefault().removePersonListener(personListener);

      fModelDAO.savePerson(dan);

      savedJohn.setEmail(createURI("anewemailaddress@gmail.com"));

      updatedJohn[0] = (Person) savedJohn;

      NewsModel.getDefault().addPersonListener(personListener);

      fModelDAO.savePerson(savedJohn);

      assertTrue(personAddedCalled[0]);

      assertTrue(personUpdatedCalled[0]);

      fModelDAO.deletePerson(new PersonReference(updatedJohn[0].getId()));

     

    } catch (PersistenceException e) {

      fail(e.getMessage());

    } finally {

      if (personListener != null) {

        NewsModel.getDefault().removePersonListener(personListener);

      }

    }

  }

 

  /**

   * Tests that {@link News#merge(INews)} copies the link property correctly.

   * @throws Exception

   */

  @Test

  public void testNewsMergeLink() throws Exception  {

    IFeed feed = fModelDAO.saveFeed(createFeed());

    INews news = fTypesFactory.createNews(null, feed, new Date());

    news.setLink(createURI("http://www.uri.com"));

    INews anotherNews = fTypesFactory.createNews(null, feed, new Date());

    URI uri = createURI("http://www.anotheruri.com");

    anotherNews.setLink(uri);

   

    news.merge(anotherNews);

   

    assertEquals(uri, news.getLink());

    Field linkField = News.class.getDeclaredField("fLink");

    linkField.setAccessible(true);

    URI link = (URI) linkField.get(news);

    assertEquals(uri, link);

  }

 

  /**

   * Tests INews#setLink.

   * @throws Exception

   */

  @Test

  public void testNewsSetLink() throws Exception {

    IFeed feed = fModelDAO.saveFeed(createFeed());

    INews news = fTypesFactory.createNews(null, feed, new Date());

    URI uri = createURI("http://uri.com");

    news.setLink(uri);

    assertEquals(uri, news.getLink());

    news.setLink(null);

    assertNull(news.getLink());

    news.setLink(uri);

    assertEquals(uri, news.getLink());

    URI anotherUri = createURI("http://anotheruri.com");

    news.setLink(anotherUri);

   

    assertSame("URI is not being cached", anotherUri, news.getLink());

    assertEquals(anotherUri, news.getLink());

  }

  /**

   * Tests that no event is sent when NewsManager#setState() is called and

   * the new state is the same as the old state.

   * @throws Exception

   */

  @Test

  public void testNewsManagerSetSameState() throws Exception {

    final IFeed feed;

    try {

      feed = fModelDAO.saveFeed(createFeed());

    } catch (PersistenceException e) {

      fail(e.getMessage());

      return;

    }

    final News initialNews = (News) createNews(feed);

    initialNews.setState(State.NEW);

    INews news = null;

    try {

      news = fModelDAO.saveNews(initialNews);

    } catch (PersistenceException e) {

      fail(e.getMessage());

      return;

    }

    NewsListener newsListener = null;

    try {

      newsListener = new NewsListener() {

        public void newsAdded(Set<NewsEvent> events) {

          fail("No events should have been fired, but NewsListener#newsAdded() was called");

        }

        public void newsDeleted(Set<NewsEvent> events) {

          fail("No events should have been fired, but NewsListener#newsDeleted() was called.");

        }

        public void newsUpdated(Set<NewsEvent> events) {

          fail("No events should have been fired, but NewsListener#newsUpdated() was called.");

        }

      };

      NewsModel.getDefault().addNewsListener(newsListener);

     

      news.setState(State.NEW);

      fModelDAO.saveNews(news);

     

      NewsModel.getDefault().removeNewsListener(newsListener);

      fModelDAO.deleteNews(new NewsReference(news.getId()));

      fModelDAO.deleteFeed(new FeedReference(feed.getId()));

    } finally {

      if (newsListener != null) {

        NewsModel.getDefault().removeNewsListener(newsListener);

      }

    }

  }

 

  /**

   * Tests deleting a INews and checking that the parent feed doesn't have it

   * anymore.

   * @throws PersistenceException

   */

  @Test

  public void testDeleteNews() throws PersistenceException {

    IFeed feed = createFeed();

    feed = fModelDAO.saveFeed(feed);

    INews news = createNews(feed);

    news = fModelDAO.saveNews(news);

    Long newsId = news.getId();

    fModelDAO.deleteNews(new NewsReference(newsId));

    feed = fModelDAO.loadFeed(feed.getId());

    assertEquals(0, feed.getNews().size());

    assertNull(fModelDAO.loadNews(newsId));

  }

  /**

   * Tests loading the root folders.

   */

  @Test

  public void testLoadRootFolders() {

    try {

      // Save root folders

      IFolder folder1 = createFolder();

      folder1 = fModelDAO.saveFolder(folder1);

      IFolder folder2 = fTypesFactory.createFolder(null, null, "AnotherFolder");

      folder2 = fModelDAO.saveFolder(folder2);

      // Save non-root folder

      IFolder nonRootFolder = createFolderWithParent();

      fModelDAO.saveFolder(nonRootFolder);

      List<IFolder> rootFolderRefs = fAppLayer.loadRootFolders();

      assertEquals(3, rootFolderRefs.size());

      for (IFolder rootFolder : rootFolderRefs) {

        assertTrue(rootFolder.equals(folder1) || rootFolder.equals(folder2) || rootFolder.equals(nonRootFolder.getParent()));

      }

    } catch (PersistenceException e) {

      fail(e.getMessage());

    }

  }

  /**

   * Simply adds and deletes a IBookMark and fails if an exceptions is thrown.

   */

  @Test

  public void testAddAndDeleteBookMark() {

    try {

      IBookMark bookMark = createBookMark();

      bookMark = fModelDAO.saveBookMark(bookMark);

      fModelDAO.deleteBookMark(new BookMarkReference(bookMark.getId()));

    } catch (PersistenceException e) {

      fail(e.getMessage());

    }

  }

  /**

   * Simply adds and deletes a ICategory with a feed as parent

   * and fails if an exception is thrown.

   */

  @Test

  public void testAddAndDeleteFeedCategory() {

    try {

      ICategory category = createFeedCategory();

      ICategory savedCategory = fModelDAO.saveCategory(category);

      fModelDAO.deleteCategory(new CategoryReference(savedCategory.getId()));

    } catch (PersistenceException e) {

      fail(e.getMessage());

    }

  }

  /**

   * Simply adds and deletes a ICategory with a news as parent

   * and fails if an exception is thrown.

   */

  @Test

  public void testAddAndDeleteNewsCategory() {

    try {

      ICategory category = createNewsCategory();

      ICategory savedCategory = fModelDAO.saveCategory(category);

      fModelDAO.deleteCategory(new CategoryReference(savedCategory.getId()));

    } catch (PersistenceException e) {

      fail(e.getMessage());

    }

  }

  /**

   * Adds, retrieves and checks if the added object matches the retrieved one.

   */

  //FIXME Need the method loadCategories in a public interface

//  @Test

//  public void testAddAndGetFeedCategory() {

//    try {

//      Category category = (Category) createFeedCategory();

//      CategoryReference ref = fModelDAO.saveCategory(category);

//      List<ICategory> categories = fModelDAO.loadCategories();

//      assertEquals(1, categories.size());

//      category.setId(categories.get(0).getId());

//      assertTrue(category.isIdentical(categories.get(0)));

//      manager.deleteCategory(ref);

//    } catch (PersistenceLayerException e) {

//      fail(e.getMessage());

//    }

//  }

  /**

   * Adds, retrieves and checks if the added object matches the retrieved one.

   */

//  @Test

//  public void testAddAndGetNewsCategory() {

//    try {

//      Category category = (Category) createNewsCategory();

//      CategoryManager manager = fManagers.getCategoryManager();

//      CategoryReference ref = manager.saveCategory(category);

//      List<ICategory> categories = manager.loadCategories();

//      assertEquals(1, categories.size());

//      category.setId(categories.get(0).getId());

//      assertTrue(category.isIdentical(categories.get(0)));

//      manager.deleteCategory(ref);

//    } catch (PersistenceLayerException e) {

//      fail(e.getMessage());

//    }

//  }

  private ILabel createLabel() {

    ILabel label = fTypesFactory.createLabel(null, "someLabel");

    label.setColor("200,100,009");

    return label;

  }

  /**

   * Checks:

   * - Addition of label

   * - That ADD event is issued

   * - Updating of label

   * - That UPDATE event is issued

   * - Getting of label

   */

  @Test

  public void testAddUpdateAndGetLabel() {

    final Label initialLabel = (Label) createLabel();

    final Label[] updatedLabel = new Label[1];

    final boolean[] labelAddedCalled = new boolean[] { false };

    final boolean[] labelUpdatedCalled = new boolean[] { false };

    LabelListener labelListener = null;

    try {

      labelListener = new LabelAdapter() {

        @Override

        public void labelAdded(Set<LabelEvent> events) {

          for (LabelEvent event : events) {

            labelAddedCalled[0] = true;

            Label dbLabel = (Label) event.getEntity();

            initialLabel.setId(dbLabel.getId());

            assertTrue(initialLabel.isIdentical(dbLabel));

          }

        }

        @Override

        public void labelUpdated(Set<LabelEvent> events) {

          LabelEvent event = events.iterator().next();

          labelUpdatedCalled[0] = true;

          Label dbLabel = (Label) event.getEntity();

          assertTrue(updatedLabel[0].isIdentical(dbLabel));

        }

      };

      NewsModel.getDefault().addLabelListener(labelListener);

      long savedLabelId = fModelDAO.saveLabel(initialLabel).getId().longValue();

      System.gc();

      ILabel dbLabel = fModelDAO.loadLabel(savedLabelId);

      initialLabel.setId(dbLabel.getId());

      assertTrue(initialLabel.isIdentical(dbLabel));

      dbLabel.setColor("255,255,137");

      updatedLabel[0] = (Label) dbLabel;

      fModelDAO.saveLabel(dbLabel);

      assertTrue(labelAddedCalled[0]);

      assertTrue(labelUpdatedCalled[0]);

      fModelDAO.deleteLabel(new LabelReference(updatedLabel[0].getId()));

    } catch (PersistenceException e) {

      fail(e.getMessage());

    } finally {

      if (labelListener != null) {

        NewsModel.getDefault().removeLabelListener(labelListener);

      }

    }

  }

  /**

   * Checks:

   * - Addition of category

   * - That ADD event is issued

   * - Updating of category

   * - That UPDATE event is issued

   * - Getting of category

   */

  @Test

  public void testAddUpdateAndGetCategory() {

    final Category[] initialCategory = new Category[1];

    try {

      initialCategory[0] = (Category) createNewsCategory();

    } catch (PersistenceException e) {

      fail(e.getMessage());

    }

    final Category[] updatedCategory = new Category[1];

    final boolean[] categoryAddedCalled = new boolean[] { false };

    final boolean[] categoryUpdatedCalled = new boolean[] { false };

    CategoryListener categoryListener = null;

    try {

      categoryListener = new CategoryAdapter() {

        @Override

        public void categoryAdded(Set<CategoryEvent> events) {

          CategoryEvent event = events.iterator().next();

          try {

            categoryAddedCalled[0] = true;

            Category dbCategory = (Category) event.getEntity();

            initialCategory[0].setId(dbCategory.getId());

            assertTrue(initialCategory[0].isIdentical(dbCategory));

            dbCategory.setDomain("newDomain/newDomain");

            updatedCategory[0] = dbCategory;

            fModelDAO.saveCategory(dbCategory);

          } catch (PersistenceException e) {

            fail(e.getMessage());

          }

        }

        @Override

        public void categoryUpdated(Set<CategoryEvent> events) {

          CategoryEvent event = events.iterator().next();

          categoryUpdatedCalled[0] = true;

          Category dbCategory = (Category) event.getEntity();

          assertTrue(updatedCategory[0].isIdentical(dbCategory));

        }

      };

      NewsModel.getDefault().addCategoryListener(categoryListener);

      fModelDAO.saveCategory(initialCategory[0]);

      assertTrue(categoryAddedCalled[0]);

      assertTrue(categoryUpdatedCalled[0]);

      fModelDAO.deleteCategory(new CategoryReference(updatedCategory[0].getId()));

    } catch (PersistenceException e) {

      fail(e.getMessage());

    } finally {

      if (categoryListener != null) {

        NewsModel.getDefault().removeCategoryListener(categoryListener);

      }

    }

  }

  /**

   * Tests adding, updating and getting a folder with no parent.

   */

  @Test

  public void testAddUpdateAndGetFolder() {

    final Folder initialFolder = (Folder) createFolder();

    final Folder[] updatedFolder = new Folder[1];

    final boolean[] folderAddedCalled = new boolean[] { false };

    final boolean[] folderUpdatedCalled = new boolean[] { false };

    FolderListener folderListener = null;

    try {

      folderListener = new FolderAdapter() {

        @Override

        public void folderAdded(Set<FolderEvent> events) {

          for (FolderEvent event : events) {

            try {

              folderAddedCalled[0] = true;

              Folder dbFolder = (Folder) event.getEntity();

              initialFolder.setId(dbFolder.getId());

              assertTrue(NOT_IDENTICAL_MESSAGE, initialFolder.isIdentical(dbFolder));

              dbFolder.setBlogrollUrl(createURI("http://www.newuri.com"));

              dbFolder.setName("New name");

              updatedFolder[0] = dbFolder;

              fModelDAO.saveFolder(dbFolder);

            } catch (PersistenceException e) {

              fail(e.getMessage());

            }

          }

        }

        @Override

        public void folderUpdated(Set<FolderEvent> events) {

          for (FolderEvent event : events) {

            folderUpdatedCalled[0] = true;

            Folder dbFolder = (Folder) event.getEntity();

            assertTrue(updatedFolder[0].isIdentical(dbFolder));

          }

        }

      };

      NewsModel.getDefault().addFolderListener(folderListener);

      fModelDAO.saveFolder(initialFolder);

      assertTrue(folderAddedCalled[0]);

      assertTrue(folderUpdatedCalled[0]);

      fModelDAO.deleteFolder(new FolderReference(updatedFolder[0].getId()));

    } catch (PersistenceException e) {

      fail(e.getMessage());

    } finally {

      if (folderListener != null) {

        NewsModel.getDefault().removeFolderListener(folderListener);

      }

    }

  }

  private IFolder createFolderWithParent() throws PersistenceException {

    IFolder parentFolder = createFolder();

    parentFolder = fModelDAO.saveFolder(parentFolder);

    IFolder folder = fTypesFactory.createFolder(null, parentFolder, "MainFolder");

    folder.setBlogrollUrl(createURI("http://www.rssowl.com"));

    folder.setProperty("skey", "svalue");

    return folder;

  }

  /**

   * Tests adding, updating and getting a folder that has a parent.

   */

  @Test

  public void testAddUpdateAndGetFolderWithParent() {

    final Folder[] initialFolder = new Folder[1];

    final String[] folderName = new String[1];

    try {

      initialFolder[0] = (Folder) createFolderWithParent();

      folderName[0] = initialFolder[0].getName();

    } catch (PersistenceException e) {

      fail(e.getMessage());

    }

    final Folder[] updatedFolder = new Folder[1];

    final boolean[] folderAddedCalled = new boolean[] { false };

    final boolean[] folderUpdatedCalled = new boolean[] { false };

    FolderListener folderListener = null;

    try {

      folderListener = new FolderAdapter() {

        @Override

        public void folderAdded(Set<FolderEvent> events) {

          for (FolderEvent event : events) {

            try {

              folderAddedCalled[0] = true;

              Folder dbFolder = (Folder) event.getEntity();

              initialFolder[0].setId(dbFolder.getId());

              assertTrue(initialFolder[0].isIdentical(dbFolder));

              dbFolder.setBlogrollUrl(createURI("http://www.newuri.com"));

              updatedFolder[0] = dbFolder;

              fModelDAO.saveFolder(dbFolder);

            } catch (PersistenceException e) {

              fail(e.getMessage());

            }

          }

        }

        @Override

        public void folderUpdated(Set<FolderEvent> events) {

          for (FolderEvent event : events) {

            /* Ignore event from parent */

            if (!folderName[0].equals(event.getEntity().getName())) {

              return;

            }

            folderUpdatedCalled[0] = true;

            Folder dbFolder = (Folder) event.getEntity();

            assertTrue(updatedFolder[0].isIdentical(dbFolder));

          }

        }

      };

      NewsModel.getDefault().addFolderListener(folderListener);

      fModelDAO.saveFolder(initialFolder[0]);

      assertTrue(folderAddedCalled[0]);

      assertTrue(folderUpdatedCalled[0]);

      fModelDAO.deleteFolder(new FolderReference(updatedFolder[0].getId()));

    } catch (PersistenceException e) {

      fail(e.getMessage());

    } finally {

      if (folderListener != null) {

        NewsModel.getDefault().removeFolderListener(folderListener);

      }

    }

  }

 

  /**

   * When updating a child folder, the root event should be on the folder

   * where save is called.

   */

  @Test

  public void testRootFolderWhenFolderChildIsUpdated() {

    final Folder[] initialFolder = new Folder[1];

    final String[] folderName = new String[1];

    try {

      initialFolder[0] = (Folder) createFolderWithParent();

      folderName[0] = initialFolder[0].getName();

    } catch (PersistenceException e) {

      fail(e.getMessage());

    }

    FolderListener folderListener = null;

    try {

      folderListener = new FolderAdapter() {

        @Override

        public void folderAdded(Set<FolderEvent> events) {

          for (FolderEvent event : events) {

            if (folderName[0].equals(event.getEntity().getName())) {

              assertEquals(true, event.isRoot());

            } else {

              assertEquals(false, event.isRoot());

            }

          }

        }

      };

      NewsModel.getDefault().addFolderListener(folderListener);

      fModelDAO.saveFolder(initialFolder[0]);

    } catch (PersistenceException e) {

      fail(e.getMessage());

    } finally {

      if (folderListener != null) {

        NewsModel.getDefault().removeFolderListener(folderListener);

      }

    }

  }

  private IPerson createPersonJohn(IExtendableType type) {

    IPerson person = fTypesFactory.createPerson(null, type);

    person.setName("John");

    person.setEmail(createURI("john@hotmail.com"));

    person.setUri(createURI("http://mysite.hotmail.com"));

    person.setProperty("property", "property_value");

    return person;

  }

  URI createURI(String uri) {

    try {

      return new URI(uri);

    } catch (URISyntaxException e) {

      //should not happen;

      return null;

    }

  }

  private IPerson createPersonMary(IExtendableType type) {

    IPerson person = fTypesFactory.createPerson(null, type);

    person.setName("Mary");

    person.setEmail(createURI("mary@hotmail.com"));

    person.setUri(createURI("http://mary.hotmail.com"));

    person.setProperty("test", "property");

    return person;

  }

  @SuppressWarnings("unused")

  private IPerson createPersonDan(IExtendableType type) {

    IPerson person = fTypesFactory.createPerson(null, type);

    person.setName("Dan");

    person.setEmail(createURI("dan@yahoo.com"));

    return person;

  }

  /**

   * Saves the same feed twice without merging. Should throw an

   * IllegalArgumentException.

   * @throws PersistenceException

   */

  @Test(expected = IllegalArgumentException.class)

  public void testSaveFeedTwice() throws PersistenceException {

    fModelDAO.saveFeed(createFeed());

    fModelDAO.saveFeed(createFeed());

  }

 

  /**

   * Saves the same feed twice, but merge it before saving it a second

   * time. No exception should be thrown.

   */

  @Test

  public void testSaveFeedTwiceAfterMerging() {

    try {

      IFeed savedFeed = fModelDAO.saveFeed(createFeed());

      savedFeed = savedFeed.merge(createFeed());

      fModelDAO.saveFeed(savedFeed);

    } catch (PersistenceException e) {

      TestUtils.fail(e);

    }

  }

  /**

   * Tests adding, updating and getting a bookmark.

   */

  @Test

  public void testAddUpdateAndGetBookMark() {

    BookMarkListener bookMarkListener = null;

    try {

      final BookMark initialBookMark = (BookMark) createBookMark();

      final BookMark[] updatedBookMark = new BookMark[1];

      final boolean[] bookMarkAddedCalled = new boolean[] { false };

      final boolean[] bookMarkUpdatedCalled = new boolean[] { false };

      bookMarkListener = new BookMarkAdapter() {

        @Override

        public void bookMarkAdded(Set<BookMarkEvent> events) {

          BookMarkEvent event = events.iterator().next();

          try {

            bookMarkAddedCalled[0] = true;

            BookMark dbBookMark = (BookMark) event.getEntity();

            initialBookMark.setId(dbBookMark.getId());

            assertTrue(initialBookMark.isIdentical(dbBookMark));

            dbBookMark.setName("Another name");

            updatedBookMark[0] = dbBookMark;

            fModelDAO.saveBookMark(dbBookMark);

          } catch (PersistenceException e) {

            fail(e.getMessage());

          }

        }

        @Override

        public void bookMarkUpdated(Set<BookMarkEvent> events) {

          BookMarkEvent event = events.iterator().next();

          bookMarkUpdatedCalled[0] = true;

          BookMark dbBookMark = (BookMark) event.getEntity();

          assertTrue(updatedBookMark[0].isIdentical(dbBookMark));

        }

      };

      NewsModel.getDefault().addBookMarkListener(bookMarkListener);

      fModelDAO.saveBookMark(initialBookMark);

      assertTrue(bookMarkAddedCalled[0]);

      assertTrue(bookMarkUpdatedCalled[0]);

    } catch (PersistenceException e) {

      fail(e.getMessage());

    }

    finally {

      if (bookMarkListener != null) {

        NewsModel.getDefault().removeBookMarkListener(bookMarkListener);

      }

    }

  }

 

  /**

   * Tests adding, updating and getting a ISearchMark.

   */

  @Test

  public void testAddUpdateAndGetSearchMark() {

    SearchMarkListener searchMarkListener = null;

    try {

      final SearchMark initialSearchMark = (SearchMark) createSearchMark();

      final SearchMark[] updatedSearchMark = new SearchMark[1];

      final boolean[] searchMarkAddedCalled = new boolean[] { false };

      final boolean[] searchMarkUpdatedCalled = new boolean[] { false };

      searchMarkListener = new SearchMarkAdapter() {

        @Override

        public void searchMarkAdded(Set<SearchMarkEvent> events) {

          SearchMarkEvent event = events.iterator().next();

          try {

            searchMarkAddedCalled[0] = true;

            SearchMark dbSearchMark = (SearchMark) event.getEntity();

            initialSearchMark.setId(dbSearchMark.getId());

            assertTrue(initialSearchMark.isIdentical(dbSearchMark));

            dbSearchMark.setName("Another name");

            updatedSearchMark[0] = dbSearchMark;

            fModelDAO.saveSearchMark(dbSearchMark);

          } catch (PersistenceException e) {

            fail(e.getMessage());

          }

        }

        @Override

        public void searchMarkUpdated(Set<SearchMarkEvent> events) {

          SearchMarkEvent event = events.iterator().next();

          searchMarkUpdatedCalled[0] = true;

          SearchMark dbSearchMark = (SearchMark) event.getEntity();

          assertTrue(updatedSearchMark[0].isIdentical(dbSearchMark));

        }

      };

      NewsModel.getDefault().addSearchMarkListener(searchMarkListener);

      fModelDAO.saveSearchMark(initialSearchMark);

      assertTrue(searchMarkAddedCalled[0]);

      assertTrue(searchMarkUpdatedCalled[0]);

    } catch (PersistenceException e) {

      fail(e.getMessage());

    }

    finally {

      if (searchMarkListener != null) {

        NewsModel.getDefault().removeSearchMarkListener(searchMarkListener);

      }

    }

  }

  private URL createURL(String url) {

    try {

      return new URL(url);

    } catch (MalformedURLException e) {

      //should not happen;

      return null;

    }

  }

  private Date createDate() {

    return new Date();

  }

  private IImage createImage(IFeed feed) {

    IImage image = fTypesFactory.createImage(feed);

    image.setLink(createURI("http://www.rssowl.org/image.png"));

    return image;

  }

  /**

   * Tests adding, updating and getting a news.

   */

  @Test

  public void testAddUpdateAndGetNews() {

    final IFeed feed;

    try {

      feed = fModelDAO.saveFeed(createFeed());

    } catch (PersistenceException e) {

      fail(e.getMessage());

      return;

    }

    final News initialNews = (News) createNews(feed);

    final Feed[] initialFeed = new Feed[1];

    final Person[] initialAuthor = new Person[1];

    final Source[] initialSource = new Source[1];

    final Guid[] initialGuid = new Guid[1];

    final News[] updatedNews = new News[1];

    final boolean[] NewsAddedCalled = new boolean[] { false };

    final boolean[] NewsUpdatedCalled = new boolean[] { false };

    NewsListener newsListener = null;

    try {

      newsListener = new NewsAdapter() {

        @Override

        public void newsAdded(Set<NewsEvent> events) {

          NewsEvent event = events.iterator().next();

          try {

            NewsAddedCalled[0] = true;

            initialFeed[0] = (Feed) initialNews.getFeedReference().resolve();

            initialAuthor[0] = (Person) initialNews.getAuthor();

            initialSource[0] = (Source) initialNews.getSource();

            initialGuid[0] = (Guid) initialNews.getGuid();

            News dbNews = (News) event.getEntity();

            initialAuthor[0].setId(dbNews.getAuthor().getId());

            initialAuthor[0].isIdentical(dbNews.getAuthor());

            initialNews.setId(dbNews.getId());

            assertTrue(initialNews.isIdentical(dbNews));

            dbNews.setDescription("The description has been changed in the news");

            dbNews.setState(State.UNREAD);

            updatedNews[0] = dbNews;

            fModelDAO.saveNews(dbNews);

          } catch (PersistenceException e) {

            fail(e.getMessage());

          }

        }

        @Override

        public void newsUpdated(Set<NewsEvent> events) {

          NewsEvent event = events.iterator().next();

          NewsUpdatedCalled[0] = true;

          News dbNews = (News) event.getEntity();

          assertTrue(updatedNews[0].isIdentical(dbNews));

        }

      };

      NewsModel.getDefault().addNewsListener(newsListener);

      fModelDAO.saveNews(initialNews);

      assertTrue(NewsAddedCalled[0]);

      assertTrue(NewsUpdatedCalled[0]);

      fModelDAO.deleteNews(new NewsReference(updatedNews[0].getId()));

    } catch (PersistenceException e) {

      fail(e.getMessage());

    } finally {

      if (newsListener != null) {

        NewsModel.getDefault().removeNewsListener(newsListener);

      }

    }

  }

  private INews createNews(IFeed feed) {

    INews news = fTypesFactory.createNews(null, feed, createDate());