/*
* BioJava development code
*
* This code may be freely distributed and modified under the
* terms of the GNU Lesser General Public Licence. This should
* be distributed with the code. If you do not have a copy,
* see:
*
* http://www.gnu.org/copyleft/lesser.html
*
* Copyright for this code is held jointly by the individual
* authors. These should be listed in @author doc comments.
*
* For more information on the BioJava project and its aims,
* or to join the biojava-l mailing list, visit the home page
* at:
*
* http://www.biojava.org/
*
*/
package org.biojava.nbio.structure.symmetry.internal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import junit.framework.TestCase;
import org.biojava.nbio.structure.StructureException;
import org.biojava.nbio.structure.align.util.AlignmentTools;
import org.biojava.nbio.structure.symmetry.internal.SequenceFunctionRefiner;
/**
* @author blivens
*
*/
public class TestSingleRefiner extends TestCase {
List<Map<Integer, Integer>> alignments;
List<Integer> orders;
List<Map<Integer, Integer>> expecteds;
@Override
protected void setUp() throws Exception {
super.setUp();
Map<Integer,Integer> align;
Map<Integer,Integer> expect;
// Note that all the expecteds rely on scoreAbsError being used internally
// by refineSymmetry
alignments = new ArrayList<Map<Integer,Integer>>();
orders = new ArrayList<Integer>();
expecteds = new ArrayList<Map<Integer,Integer>>();
/* 0. Chained alignment
* 1\
* 2>6>10<--
* 3>7>11</
* 4>8>12</
* 5>9>13<--
*/
align = new HashMap<Integer,Integer>();
align.put( 1, 6);
align.put( 2, 6);
align.put( 3, 7);
align.put( 4, 8);
align.put( 5, 9);
align.put( 6, 10);
align.put( 7, 11);
align.put( 8, 12);
align.put( 9, 13);
align.put( 10, 2);
align.put( 11, 4);
align.put( 12, 5);
align.put( 13, 5);
alignments.add(align);
orders.add(3);
/* 0. Expect
* 2>6>10<--
* 3>7>11<--
* 4>8>12<--
* 5>9>13<--
*/
expect = new HashMap<Integer,Integer>();
expect.put( 2, 6);
expect.put( 3, 7);
expect.put( 4, 8);
expect.put( 5, 9);
expect.put( 6, 10);
expect.put( 7, 11);
expect.put( 8, 12);
expect.put( 9, 13);
expect.put( 10, 2);
expect.put( 11, 3);
expect.put( 12, 4);
expect.put( 13, 5);
expecteds.add( expect);
/* 1. Entering ring
* 1->5->9<--
* 4->8<\
*/
align = new HashMap<Integer,Integer>();
align.put( 1, 5);
align.put( 5, 9);
align.put( 9, 1);
align.put( 4, 8);
align.put( 8, 1);
alignments.add(align);
orders.add(3);
/* 1. Expect
* 1->5->9<--
*/
expect = new HashMap<Integer,Integer>();
expect.put( 1, 5);
expect.put( 5, 9);
expect.put( 9, 1);
expecteds.add(expect);
/* 2. independent chain, lowest res
* 1->5->9<--
* 2->6->10<\
*/
align = new HashMap<Integer,Integer>();
align.put( 1, 5);
align.put( 5, 9);
align.put( 9, 1);
align.put( 2, 6);
align.put( 6, 10);
align.put( 10, 1);
alignments.add(align);
orders.add(3);
/* 2. Expect
* 1->5->9<--
* 2->6->10<--
*/
expect = new HashMap<Integer,Integer>();
expect.put( 1, 5);
expect.put( 5, 9);
expect.put( 9, 1);
expect.put( 2, 6);
expect.put( 6, 10);
expect.put( 10, 2);
expecteds.add(expect);
/* 3. independent chain, not lowest res
* 1->5->9<--
* 2/^6->10<--
*/
align = new HashMap<Integer,Integer>();
align.put( 1, 5);
align.put( 5, 9);
align.put( 9, 1);
align.put( 2, 5);
align.put( 6, 10);
align.put( 10, 2);
alignments.add(align);
orders.add(3);
/* 3. Expect
* 1->5->9<--
* 2->6->10<--
*/
expect = new HashMap<Integer,Integer>();
expect.put( 1, 5);
expect.put( 5, 9);
expect.put( 9, 1);
expect.put( 2, 6);
expect.put( 6, 10);
expect.put( 10, 2);
expecteds.add(expect);
/* 4. Wrong order
* 3->7<--
*/
align = new HashMap<Integer,Integer>();
align.put( 3, 7);
align.put( 7, 3);
alignments.add(align);
orders.add(3);
/*
* 4. Expect empty
*/
expect = new HashMap<Integer,Integer>();
expecteds.add(expect);
/* 5. Prioritize score over chain length
* 1->5->9</
* 3->6->10
*/
align = new HashMap<Integer,Integer>();
align.put( 1, 5);
align.put( 5, 9);
align.put( 9, 3);
align.put( 3, 6);
align.put( 6, 10);
alignments.add(align);
orders.add(3);
/* 5. Expect
* 3->5->9<--
*/
expect = new HashMap<Integer,Integer>();
expect.put( 3, 5);
expect.put( 5, 9);
expect.put( 9, 3);
expecteds.add(expect);
assertEquals("Error with setup", alignments.size(), expecteds.size());
/*
* 6. Small cycles can be repaired. 3>5>7>5
*/
align = new HashMap<Integer, Integer>();
align.put(3, 5);
align.put(5, 7);
align.put(7, 5);
alignments.add(align);
orders.add(3);
/*
* 6. Expect 3>5>7<--
*/
expect = new HashMap<Integer, Integer>();
expect.put(3, 5);
expect.put(5, 7);
expect.put(7, 3);
expecteds.add(expect);
/*
* 7. It might be a good idea to allow cycles if their length divides the order. However, this isn't allowed
* yet. 3>5<
*/
align = new HashMap<Integer, Integer>();
align.put(3, 5);
align.put(5, 3);
alignments.add(align);
orders.add(4);
/*
* 7. Expect empty, but could argue for 3>5<--
*/
expect = new HashMap<Integer, Integer>();
expecteds.add(expect);
}
public void testExpected() throws StructureException {
for(int i=0;i<alignments.size(); i++) {
Map<Integer,Integer> align = alignments.get(i);
Map<Integer,Integer> expect = expecteds.get(i);
Map<Integer, Integer> refined = SequenceFunctionRefiner.refineSymmetry(align, 3);
if (!expect.equals(refined)) {
System.out.println("Actual: " + AlignmentTools.toConciseAlignmentString(align));
System.out.println("Expect: " + AlignmentTools.toConciseAlignmentString(expect));
}
assertEquals("Alignment " + i + " refinement wrong", expect, refined);
}
}
/**
* Refined alignments should be automorphic (one-to-one)
* @param align
*/
private void testAutomorphism(Map<Integer,Integer> align) {
for(Integer pre:align.keySet()) {
Integer post = align.get(pre);
assertNotNull("Not automorphic: f("+pre+") not defined",post);
assertTrue("not automorphic: f("+pre+") = "+post+" but f("+post+") undefined", align.containsKey(post));
}
}
public void testAutomorphism() throws StructureException {
for(int i=0;i<alignments.size(); i++) {
Map<Integer,Integer> align = alignments.get(i);
Map<Integer,Integer> refined = SequenceFunctionRefiner.refineSymmetry(align,orders.get(i));
testAutomorphism(refined);
}
}
private void testSymmetric(Map<Integer,Integer> align, int k) {
Map<Integer,Integer> alignK = AlignmentTools.applyAlignment(align, k);
assertEquals(align.size(), alignK.size()); // Assumption; Should be tested by AlignmentToolsTest
int refinementNum = 0;
for(Integer res : alignK.keySet()) {
Integer resK = alignK.get(res);
assertEquals(String.format("Asymmetric alignment in #%d. f^%d(%d)=%d", refinementNum++, k, res, resK), res,
resK);
}
}
public void testSymmetric() throws StructureException {
for(int i=0;i<alignments.size(); i++) {
Map<Integer,Integer> align = alignments.get(i);
int order = orders.get(i);
Map<Integer, Integer> refined = SequenceFunctionRefiner.refineSymmetry(align, order);
testSymmetric(refined, order);
}
}
/* Didn't end up being a useful function, so never implemented.
public void testPartitionAlignment() throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
// test private partitionAlignment method
Method partitionAlignment = SymmRefiner.class.getDeclaredMethod("partitionAlignment", new Class[] {Map.class});
partitionAlignment.setAccessible(true);
Map<Integer,Integer> alignment = new HashMap<Integer, Integer>();
alignment.put(2, 11);
alignment.put(3, 12);
alignment.put(4, 13);
alignment.put(6, 14);
alignment.put(7, 15);
alignment.put(8, 16);
alignment.put(10, 18);
alignment.put(12, 20);
alignment.put(13, 21);
alignment.put(15, 22);
alignment.put(16, 23);
alignment.put(17, 24);
alignment.put(18, 2);
alignment.put(20, 3);
alignment.put(21, 4);
alignment.put(22, 6);
alignment.put(23, 8);
alignment.put(24, 10);
List<Map<Integer,Integer>> expected = new ArrayList<Map<Integer,Integer>>();
//Note: should be insensitive to order (like a set), but that's harder to compare
Map<Integer,Integer> expectedAlign = new HashMap<Integer, Integer>();
expectedAlign.put(2, 11);
expectedAlign.put(10, 18);
expectedAlign.put(17, 24);
expectedAlign.put(18, 2);
expectedAlign.put(24, 10);
expected.add(expectedAlign);
expectedAlign = new HashMap<Integer, Integer>();
expectedAlign.put(6, 14);
expectedAlign.put(7, 15);
expectedAlign.put(15, 22);
expectedAlign.put(22, 6);
expected.add(expectedAlign);
List<Map<Integer,Integer>> result;
result = (List<Map<Integer, Integer>>) partitionAlignment.invoke(null, expectedAlign);
assertEquals("Expected number of partitions differs.",expected.size(), result.size());
Iterator<Map<Integer, Integer>> expIt = expected.iterator();
Iterator<Map<Integer, Integer>> resultIt = result.iterator();
while(expIt.hasNext()) {
Map<Integer, Integer> exp = expIt.next();
Map<Integer, Integer> res = resultIt.next();
assertEquals("Mapping differs.",exp,res);
}
}
*/
}