277 lines
9.8 KiB
Java
Executable File
277 lines
9.8 KiB
Java
Executable File
/*
|
|
* Copyright (C) 2001-2004 Red Hat Inc. All Rights Reserved.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public License
|
|
* as published by the Free Software Foundation; either version 2.1 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
package com.arsdigita.london.terms;
|
|
|
|
import java.net.MalformedURLException;
|
|
import java.net.URL;
|
|
import java.util.Date;
|
|
|
|
import org.apache.log4j.Logger;
|
|
|
|
import com.arsdigita.domain.DomainCollection;
|
|
import com.arsdigita.persistence.SessionManager;
|
|
import com.arsdigita.tools.junit.framework.BaseTestCase;
|
|
import com.arsdigita.util.UncheckedWrapperException;
|
|
|
|
|
|
/**
|
|
* Test all aspects of the Term class.
|
|
*/
|
|
public class TermsTest extends BaseTestCase {
|
|
|
|
private final static Logger s_log = Logger.getLogger(TermsTest.class);
|
|
|
|
private final static int NONPREFERRED_COUNT = 5;
|
|
private final static int PREFERRED_COUNT = 10;
|
|
private final static int NARROWER_COUNT = 5;
|
|
|
|
private Domain m_domain1;
|
|
|
|
private Term[] m_terms1;
|
|
private Term[] m_p_terms1;
|
|
private Term[] m_np_terms1;
|
|
private Term[] m_na_terms1;
|
|
|
|
private Domain m_domain2;
|
|
|
|
private Term[] m_terms2;
|
|
private Term[] m_p_terms2;
|
|
private Term[] m_np_terms2;
|
|
private Term[] m_na_terms2;
|
|
|
|
private Domain m_domain3;
|
|
|
|
private Term[] m_terms3;
|
|
private Term[] m_p_terms3;
|
|
private Term[] m_np_terms3;
|
|
private Term[] m_na_terms3;
|
|
|
|
/**
|
|
* Constructs a TermTest with the specified name.
|
|
*
|
|
* @param name Test case name.
|
|
**/
|
|
public TermsTest( String name ) {
|
|
super( name );
|
|
}
|
|
|
|
public void setUp() {
|
|
try {
|
|
m_domain1 = Domain.create("eg-terms1",
|
|
new URL("http://www.example.com/terms-1"),
|
|
"Terms 1",
|
|
"Terms in set 1",
|
|
"1.01",
|
|
new Date());
|
|
|
|
m_p_terms1 = setUpTerms(m_domain1, PREFERRED_COUNT, new Term[] {}, 0);
|
|
m_np_terms1 = setUpTerms(m_domain1, NONPREFERRED_COUNT,
|
|
m_p_terms1, PREFERRED_COUNT);
|
|
m_na_terms1 = setUpTerms(m_domain1, NARROWER_COUNT, new Term[] {},
|
|
PREFERRED_COUNT + NONPREFERRED_COUNT);
|
|
m_terms1 = unifyTerms(m_p_terms1, m_np_terms1, m_na_terms1);
|
|
|
|
|
|
|
|
m_domain2 = Domain.create("eg-terms2",
|
|
new URL("http://www.example.com/terms-2"),
|
|
"Terms 2",
|
|
"Terms in set 2",
|
|
"2.02",
|
|
new Date());
|
|
m_p_terms2 = setUpTerms(m_domain2, PREFERRED_COUNT, new Term[] {}, 0);
|
|
m_np_terms2 = setUpTerms(m_domain2, NONPREFERRED_COUNT,
|
|
m_p_terms2, PREFERRED_COUNT);
|
|
m_na_terms2 = setUpTerms(m_domain2, NARROWER_COUNT, new Term[] {},
|
|
PREFERRED_COUNT + NONPREFERRED_COUNT);
|
|
m_terms2 = unifyTerms(m_p_terms2, m_np_terms2, m_na_terms2);
|
|
|
|
|
|
|
|
m_domain3 = Domain.create("eg-terms3",
|
|
new URL("http://www.example.com/terms-3"),
|
|
"Terms 3",
|
|
"Terms in set 3",
|
|
"3.03",
|
|
new Date());
|
|
m_p_terms3 = setUpTerms(m_domain3, PREFERRED_COUNT, new Term[] {}, 0);
|
|
m_np_terms3 = setUpTerms(m_domain3, NONPREFERRED_COUNT,
|
|
m_p_terms3, PREFERRED_COUNT);
|
|
m_na_terms3 = setUpTerms(m_domain3, NARROWER_COUNT, new Term[] {},
|
|
PREFERRED_COUNT + NONPREFERRED_COUNT);
|
|
m_terms3 = unifyTerms(m_p_terms3, m_np_terms3, m_na_terms3);
|
|
|
|
|
|
} catch (MalformedURLException ex) {
|
|
throw new UncheckedWrapperException("Cannot parse url", ex);
|
|
}
|
|
}
|
|
|
|
public void tearDown() {
|
|
// You never know with new persistence if there is an
|
|
// error lurking that won't appear until the session
|
|
// is flushed. So just to be sure...
|
|
SessionManager.getSession().flushAll();
|
|
}
|
|
|
|
public Term[] setUpTerms(Domain domain,
|
|
int count,
|
|
Term[] preferred,
|
|
int offset) {
|
|
Term[] terms = new Term[count];
|
|
|
|
for (int i = 0 ; i < count ; i++) {
|
|
terms[i] = Term.create(new Integer(i+offset),
|
|
domain.getKey() + "Term0" + i,
|
|
false,
|
|
domain.getKey() + "term0" + i,
|
|
domain);
|
|
}
|
|
|
|
return terms;
|
|
}
|
|
|
|
public Term[] unifyTerms(Term[] preferred,
|
|
Term[] nonpreferred,
|
|
Term[] narrower) {
|
|
Term[] terms = new Term[preferred.length +
|
|
nonpreferred.length +
|
|
narrower.length];
|
|
|
|
for (int i = 0 ; i < preferred.length ; i++) {
|
|
terms[i] = preferred[i];
|
|
}
|
|
for (int i = 0 ; i < nonpreferred.length ; i++) {
|
|
terms[preferred.length + i] = nonpreferred[i];
|
|
}
|
|
for (int i = 0 ; i < narrower.length ; i++) {
|
|
terms[preferred.length + nonpreferred.length + i] = narrower[i];
|
|
}
|
|
|
|
return terms;
|
|
}
|
|
|
|
public void testDomainTerms() {
|
|
_testDomainTerms(m_domain1, m_terms1);
|
|
_testDomainTerms(m_domain2, m_terms2);
|
|
_testDomainTerms(m_domain3, m_terms3);
|
|
}
|
|
|
|
private void _testDomainTerms(Domain domain,
|
|
Term[] expected) {
|
|
DomainCollection actual = domain.getTerms();
|
|
actual.addOrder(Term.UNIQUE_ID);
|
|
|
|
int i = 0;
|
|
while (actual.next()) {
|
|
Term term = (Term)actual.getDomainObject();
|
|
assertEquals(term, expected[i]);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
public void testNarrowerTerms() {
|
|
_testNarrowerTerms(m_p_terms1, m_np_terms1, m_na_terms1);
|
|
_testNarrowerTerms(m_p_terms2, m_np_terms2, m_na_terms2);
|
|
_testNarrowerTerms(m_p_terms3, m_np_terms3, m_na_terms3);
|
|
}
|
|
|
|
private void _testNarrowerTerms(Term[] preferred,
|
|
Term[] nonpreferred,
|
|
Term[] narrower) {
|
|
for (int i = 0 ; i < preferred.length ; i++) {
|
|
int n = i % narrower.length;
|
|
boolean def = i < narrower.length;
|
|
preferred[i].addNarrowerTerm(narrower[n],
|
|
def,
|
|
true);
|
|
}
|
|
|
|
for (int i = 0 ; i < preferred.length ; i++) {
|
|
int n = i % nonpreferred.length;
|
|
preferred[i].addNarrowerTerm(nonpreferred[n],
|
|
false,
|
|
true);
|
|
}
|
|
|
|
for (int i = 0 ; i < preferred.length ; i++) {
|
|
DomainCollection terms = preferred[i].getNarrowerTerms();
|
|
if (s_log.isDebugEnabled()) {
|
|
s_log.debug("Testing narrower terms of " + preferred[i]);
|
|
}
|
|
|
|
while (terms.next()) {
|
|
Term actual = (Term)terms.getDomainObject();
|
|
|
|
int n1 = i % narrower.length;
|
|
int n2 = i % nonpreferred.length;
|
|
|
|
Term expectedNarrow = narrower[n1];
|
|
Term expectedNon = nonpreferred[n2];
|
|
|
|
if (s_log.isDebugEnabled()) {
|
|
s_log.debug("Got " + actual + " was expecting " +
|
|
expectedNarrow + " or " + expectedNon);
|
|
}
|
|
|
|
assertTrue(actual.equals(expectedNon) ||
|
|
actual.equals(expectedNarrow));
|
|
}
|
|
}
|
|
|
|
for (int i = 0 ; i < narrower.length ; i++) {
|
|
if (s_log.isDebugEnabled()) {
|
|
s_log.debug("Testing broader terms of " + narrower[i]);
|
|
}
|
|
|
|
DomainCollection terms = narrower[i].getBroaderTerms();
|
|
while (terms.next()) {
|
|
Term actual = (Term)terms.getDomainObject();
|
|
boolean found = false;
|
|
for (int j = 0 ; j < preferred.length && !found ; j++) {
|
|
found = preferred[j].equals(actual);
|
|
}
|
|
|
|
if (s_log.isDebugEnabled()) {
|
|
s_log.debug("Got " + actual);
|
|
}
|
|
|
|
assertTrue(found);
|
|
}
|
|
}
|
|
|
|
for (int i = 0 ; i < narrower.length ; i++) {
|
|
if (s_log.isDebugEnabled()) {
|
|
s_log.debug("Testing default broader term of " + narrower[i]);
|
|
}
|
|
|
|
Term actual = narrower[i].getBroaderTerm();
|
|
Term expected = preferred[i];
|
|
|
|
if (s_log.isDebugEnabled()) {
|
|
s_log.debug("Got " + actual + " was expecting " + expected);
|
|
}
|
|
|
|
assertEquals(actual, expected);
|
|
}
|
|
}
|
|
|
|
|
|
}
|