JAL-2418 release notes
[jalview.git] / test / jalview / viewmodel / styles / ViewStyleTest.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.viewmodel.styles;
22
23 import static org.testng.AssertJUnit.assertEquals;
24 import static org.testng.AssertJUnit.assertFalse;
25 import static org.testng.AssertJUnit.assertTrue;
26
27 import jalview.gui.JvOptionPane;
28
29 import java.awt.Color;
30 import java.lang.reflect.Field;
31 import java.util.Random;
32
33 import org.testng.AssertJUnit;
34 import org.testng.annotations.BeforeClass;
35 import org.testng.annotations.Test;
36
37 public class ViewStyleTest
38 {
39
40   @BeforeClass(alwaysRun = true)
41   public void setUpJvOptionPane()
42   {
43     JvOptionPane.setInteractiveMode(false);
44     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
45   }
46
47   Random r = new Random();
48
49   /**
50    * This test uses reflection to set all fields on a ViewStyle, make a copy of
51    * it, and verify all fields match. This test should fail if a getter/setter
52    * pair are added to the class but missing in the copy constructor. Using
53    * reflection in the copy constructor itself is broken by obfuscation when the
54    * applet is built.
55    * 
56    * To prove this test works, simply comment out a line in the ViewStyle copy
57    * constructor, or add a new member field to ViewStyle.
58    * 
59    * @throws IllegalAccessException
60    * @throws IllegalArgumentException
61    */
62   @Test(groups = { "Functional" })
63   public void testCopyConstructor() throws IllegalArgumentException,
64           IllegalAccessException
65   {
66     ViewStyle vs1 = new ViewStyle();
67     Field[] fields = ViewStyle.class.getDeclaredFields();
68     for (Field field : fields)
69     {
70       field.setAccessible(true);
71       if (!copyConstructorIgnores(field.getName()))
72       {
73         changeValue(vs1, field);
74       }
75     }
76
77     ViewStyle vs2 = new ViewStyle(vs1);
78
79     for (Field field1 : fields)
80     {
81       final Object value1 = field1.get(vs1);
82       final Object value2 = field1.get(vs2);
83       String msg = "Mismatch in " + field1.getName() + "(" + value1 + "/"
84               + value2 + ") - not set in copy constructor?";
85       assertEquals(msg, value1, value2);
86     }
87     assertEquals("Hashcode not equals", vs1.hashCode(), vs2.hashCode());
88   }
89
90   /**
91    * Add any field names in here that we expect to be ignored by the copy
92    * constructor
93    * 
94    * @param name
95    * @return
96    */
97   private boolean copyConstructorIgnores(String name)
98   {
99     /*
100      * currently none!
101      */
102     return false;
103   }
104
105   /**
106    * Change the value of one field in a ViewStyle object
107    * 
108    * @param vs
109    * @param field
110    * @throws IllegalAccessException
111    */
112   protected void changeValue(ViewStyle vs, Field field)
113           throws IllegalAccessException
114   {
115     Class<?> type = field.getType();
116
117     if (type.equals(boolean.class) || type.equals(Boolean.class))
118     {
119       boolean value = (Boolean) field.get(vs);
120       // System.out.println("Setting " + field.getName() + " to " + !value);
121       field.set(vs, !value);
122     }
123     else if (type.equals(short.class) || type.equals(int.class)
124             || type.equals(long.class) || type.equals(float.class)
125             || type.equals(double.class))
126     {
127       final int value = (int) (1 + field.getDouble(vs));
128       // System.out.println("Setting " + field.getName() + " to " + value);
129       field.set(vs, value);
130     }
131     else if (type.equals(Integer.class))
132     {
133       field.set(vs, (int) (1 + getNumberValue(field, vs)));
134     }
135     else if (type.equals(Float.class))
136     {
137       field.set(vs, (float) (1f + getNumberValue(field, vs)));
138     }
139     else if (type.equals(Long.class))
140     {
141       field.set(vs, (long) (1L + getNumberValue(field, vs)));
142     }
143     else if (type.equals(Double.class))
144     {
145       field.set(vs, 1d + getNumberValue(field, vs));
146     }
147     else if (type.equals(Short.class))
148     {
149       field.set(vs, (short) (1 + getNumberValue(field, vs)));
150     }
151     else if (type.equals(Byte.class))
152     {
153       field.set(vs, (byte) (1 + getNumberValue(field, vs)));
154     }
155     else if (type.equals(Character.class))
156     {
157       field.set(vs, (char) (1 + getNumberValue(field, vs)));
158     }
159     else if (type.equals(String.class))
160     {
161       field.set(vs, "Joe" + field.get(vs));
162     }
163     else if (type.equals(Color.class))
164     {
165       field.set(vs, Color.RED.equals(field.get(vs)) ? Color.BLACK
166               : Color.RED);
167     }
168     else
169     {
170       AssertJUnit.fail("Unhandled field type (add to test): "
171               + field.getName() + ":" + type);
172     }
173   }
174
175   private double getNumberValue(Field field, ViewStyle vs)
176           throws IllegalArgumentException, IllegalAccessException
177   {
178     if (field.get(vs) == null)
179     {
180       return 0d;
181     }
182     return ((Number) field.get(vs)).doubleValue();
183   }
184
185   /**
186    * Test that the equals method compares every field by changing them one by
187    * one in a cloned ViewStyle.
188    * 
189    * This test will fail if a new field is added to ViewStyle but not to the
190    * comparisons in ViewStyle.equals().
191    * 
192    * To confirm that this test works, temporarily comment out one of the field
193    * comparisons in ViewStyle.equals()
194    * 
195    * @throws IllegalAccessException
196    * @throws IllegalArgumentException
197    */
198   @Test(groups = { "Functional" })
199   public void testEquals() throws IllegalArgumentException,
200           IllegalAccessException
201   {
202     ViewStyle vs1 = new ViewStyle();
203     ViewStyle vs2 = new ViewStyle(vs1);
204
205     assertFalse(vs1.equals(null));
206     assertFalse(vs1.equals(this));
207     assertTrue(vs1.equals(vs2));
208     assertTrue(vs2.equals(vs1));
209
210     Field[] fields = ViewStyle.class.getDeclaredFields();
211     for (Field field : fields)
212     {
213       field.setAccessible(true);
214       Object oldValue = field.get(vs2);
215       changeValue(vs2, field);
216       assertFalse("equals method ignores " + field.getName(),
217               vs1.equals(vs2));
218
219       if (vs1.hashCode() == vs2.hashCode())
220       {
221         // uncomment next line to see which fields hashCode ignores
222         // System.out.println("hashCode ignores " + field.getName());
223       }
224       // restore original value before testing the next field
225       field.set(vs2, oldValue);
226     }
227   }
228 }