modules/graphics/src/test/java/test/com/sun/javafx/css/PseudoClassTest.java
Print this page
rev 9250 : 8134762: Refactor Javafx graphics module tests for clear separation of tests
Reviewed-by:
*** 21,38 ****
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
! package com.sun.javafx.css;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
- import javafx.beans.value.ChangeListener;
import javafx.collections.ObservableSet;
import javafx.collections.SetChangeListener;
import javafx.css.PseudoClass;
import static org.junit.Assert.*;
import org.junit.Before;
--- 21,40 ----
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
! package test.com.sun.javafx.css;
+ import com.sun.javafx.css.BitSetShim;
+ import com.sun.javafx.css.PseudoClassState;
+ import com.sun.javafx.css.PseudoClassStateShim;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javafx.collections.ObservableSet;
import javafx.collections.SetChangeListener;
import javafx.css.PseudoClass;
import static org.junit.Assert.*;
import org.junit.Before;
*** 47,58 ****
public PseudoClassTest() {
}
@Before
public void before() {
! PseudoClassState.pseudoClassMap.clear();
! PseudoClassState.pseudoClasses.clear();
}
@Test
public void testGetState() {
String pseudoClass = "xyzzy";
--- 49,60 ----
public PseudoClassTest() {
}
@Before
public void before() {
! PseudoClassStateShim.pseudoClassMap.clear();
! PseudoClassStateShim.pseudoClasses.clear();
}
@Test
public void testGetState() {
String pseudoClass = "xyzzy";
*** 102,115 ****
@Test
public void testPseudoClassState_add() {
String pseudoClass = "xyzzy";
PseudoClass state = PseudoClass.getPseudoClass(pseudoClass);
PseudoClassState states = new PseudoClassState();
! states.add(state);
List<PseudoClass> stateList = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = states.iterator();
while (iter.hasNext()) {
stateList.add(iter.next());
}
assertTrue(stateList.contains(state));
--- 104,117 ----
@Test
public void testPseudoClassState_add() {
String pseudoClass = "xyzzy";
PseudoClass state = PseudoClass.getPseudoClass(pseudoClass);
PseudoClassState states = new PseudoClassState();
! BitSetShim.add(states, state);
List<PseudoClass> stateList = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(states);
while (iter.hasNext()) {
stateList.add(iter.next());
}
assertTrue(stateList.contains(state));
*** 123,137 ****
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
}
List<PseudoClass> stateList = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = states.iterator();
while (iter.hasNext()) {
stateList.add(iter.next());
}
for (int n=0; n<pseudoClasses.length; n++) {
--- 125,139 ----
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
}
List<PseudoClass> stateList = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(states);
while (iter.hasNext()) {
stateList.add(iter.next());
}
for (int n=0; n<pseudoClasses.length; n++) {
*** 149,164 ****
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
}
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! assertTrue(states.contains(state));
}
}
@Test
--- 151,166 ----
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
}
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! assertTrue( BitSetShim.contains(states, state));
}
}
@Test
*** 173,188 ****
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
}
for (int n=0; n<notExpected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(notExpected[n]);
! assertTrue(states.contains(state) == false);
}
}
@Test
--- 175,190 ----
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
}
for (int n=0; n<notExpected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(notExpected[n]);
! assertTrue( BitSetShim.contains(states, state) == false);
}
}
@Test
*** 193,206 ****
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
}
! assertTrue(states.contains(null) == false);
}
@Test
public void testPseudoClassState_removeState() {
--- 195,208 ----
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
}
! assertTrue( BitSetShim.contains(states, null) == false);
}
@Test
public void testPseudoClassState_removeState() {
*** 214,234 ****
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
}
! states.remove(PseudoClass.getPseudoClass("three"));
! assertTrue(states.contains(PseudoClass.getPseudoClass("three"))==false);
// should still have the others.
for (int n=1; n<expected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(expected[n]);
! assertTrue(states.contains(state));
}
}
@Test
--- 216,236 ----
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
}
! BitSetShim.remove(states, PseudoClass.getPseudoClass("three"));
! assertTrue( BitSetShim.contains(states, PseudoClass.getPseudoClass("three"))==false);
// should still have the others.
for (int n=1; n<expected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(expected[n]);
! assertTrue( BitSetShim.contains(states, state));
}
}
@Test
*** 238,259 ****
"zero", "one"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one", "two", "three"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! bStates.add(PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(bStates.containsAll(aStates));
}
@Test
public void testPseudoClassState_containsAll_negativeTest() {
--- 240,261 ----
"zero", "one"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one", "two", "three"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! BitSetShim.add(bStates, PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(BitSetShim.containsAll(bStates, aStates));
}
@Test
public void testPseudoClassState_containsAll_negativeTest() {
*** 261,282 ****
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! bStates.add(PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(bStates.containsAll(aStates) == false);
}
@Test
public void testPseudoClassState_containsAll_whenSetsAreEqual() {
--- 263,284 ----
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! BitSetShim.add(bStates, PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(BitSetShim.containsAll(bStates, aStates) == false);
}
@Test
public void testPseudoClassState_containsAll_whenSetsAreEqual() {
*** 284,305 ****
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one", "two", "three"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! bStates.add(PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(bStates.containsAll(aStates));
}
@Test
public void testPseudoClassState_containsAll_whenSetsDisjoint() {
--- 286,307 ----
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one", "two", "three"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! BitSetShim.add(bStates, PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(BitSetShim.containsAll(bStates, aStates));
}
@Test
public void testPseudoClassState_containsAll_whenSetsDisjoint() {
*** 307,328 ****
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"four", "five", "six", "seven"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! bStates.add(PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(bStates.containsAll(aStates) == false);
}
@Test
public void testPseudoClassState_containsAll_whenOneSetEmpty() {
--- 309,330 ----
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"four", "five", "six", "seven"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! BitSetShim.add(bStates, PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(BitSetShim.containsAll(bStates, aStates) == false);
}
@Test
public void testPseudoClassState_containsAll_whenOneSetEmpty() {
*** 330,357 ****
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
PseudoClassState bStates = new PseudoClassState();
! assertTrue(bStates.containsAll(aStates) == false);
! assertTrue(aStates.containsAll(bStates));
}
@Test
public void testPseudoClassState_containsAll_whenBothSetsEmpty() {
PseudoClassState aStates = new PseudoClassState();
PseudoClassState bStates = new PseudoClassState();
! assertTrue(bStates.containsAll(aStates));
! assertTrue(aStates.containsAll(bStates));
}
@Test
public void testPseudoClassState_size() {
--- 332,359 ----
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
PseudoClassState bStates = new PseudoClassState();
! assertTrue(BitSetShim.containsAll(bStates, aStates) == false);
! assertTrue(BitSetShim.containsAll(aStates, bStates));
}
@Test
public void testPseudoClassState_containsAll_whenBothSetsEmpty() {
PseudoClassState aStates = new PseudoClassState();
PseudoClassState bStates = new PseudoClassState();
! assertTrue(BitSetShim.containsAll(bStates, aStates));
! assertTrue(BitSetShim.containsAll(aStates, bStates));
}
@Test
public void testPseudoClassState_size() {
*** 364,377 ****
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
}
! assertEquals(expected, states.size());
}
@Test
public void testPseudoClassState_size_afterRemove() {
--- 366,379 ----
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
}
! assertEquals(expected, BitSetShim.size(states));
}
@Test
public void testPseudoClassState_size_afterRemove() {
*** 383,398 ****
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
}
! states.remove(PseudoClass.getPseudoClass("three"));
! assertEquals(expected, states.size());
}
@Test
public void testPseudoClassState_size_afterRemoveOnEmpty() {
--- 385,400 ----
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
}
! BitSetShim.remove(states, PseudoClass.getPseudoClass("three"));
! assertEquals(expected, BitSetShim.size(states));
}
@Test
public void testPseudoClassState_size_afterRemoveOnEmpty() {
*** 404,422 ****
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
}
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.remove(state);
}
! assertEquals(expected, states.size());
}
@Test
public void testPseudoClassState_size_afterAddWhenAlreadyContains() {
--- 406,424 ----
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
}
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.remove(states, state);
}
! assertEquals(expected, BitSetShim.size(states));
}
@Test
public void testPseudoClassState_size_afterAddWhenAlreadyContains() {
*** 428,457 ****
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
}
PseudoClass state = PseudoClass.getPseudoClass("three");
! states.add(state);
! assertEquals(expected, states.size());
}
@Test
public void testPseudoClassState_isEmpty() {
PseudoClassState states = new PseudoClassState();
! assertTrue(states.isEmpty());
}
@Test
public void testPseudoClassState_isEmpty_negativeTest() {
PseudoClassState states = new PseudoClassState();
! states.add(PseudoClass.getPseudoClass("pseudo-class"));
! assertTrue(states.isEmpty() == false);
}
@Test
public void testPseudoClassState_isEmpty_whenBitMaskLengthGreaterThanOne() {
PseudoClassState states = new PseudoClassState();
--- 430,459 ----
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
}
PseudoClass state = PseudoClass.getPseudoClass("three");
! BitSetShim.add(states, state);
! assertEquals(expected, BitSetShim.size(states));
}
@Test
public void testPseudoClassState_isEmpty() {
PseudoClassState states = new PseudoClassState();
! assertTrue(BitSetShim.isEmpty(states));
}
@Test
public void testPseudoClassState_isEmpty_negativeTest() {
PseudoClassState states = new PseudoClassState();
! BitSetShim.add(states, PseudoClass.getPseudoClass("pseudo-class"));
! assertTrue(BitSetShim.isEmpty(states) == false);
}
@Test
public void testPseudoClassState_isEmpty_whenBitMaskLengthGreaterThanOne() {
PseudoClassState states = new PseudoClassState();
*** 462,473 ****
}
} catch (IndexOutOfBoundsException exception) {
fail();
}
! states.add(state);
! assertTrue(states.isEmpty() == false);
}
@Test
public void testPseudoClassState_equals() {
--- 464,475 ----
}
} catch (IndexOutOfBoundsException exception) {
fail();
}
! BitSetShim.add(states, state);
! assertTrue(BitSetShim.isEmpty(states) == false);
}
@Test
public void testPseudoClassState_equals() {
*** 475,496 ****
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one", "two", "three"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! bStates.add(PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(aStates.equals(bStates));
}
@Test
public void testPseudoClassState_equals_negativeTest() {
--- 477,498 ----
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one", "two", "three"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! BitSetShim.add(bStates, PseudoClass.getPseudoClass(setB[n]));
}
! assertTrue(BitSetShim.equals(aStates, bStates));
}
@Test
public void testPseudoClassState_equals_negativeTest() {
*** 498,519 ****
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one", "two", "four"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! bStates.add(PseudoClass.getPseudoClass(setB[n]));
}
! assertFalse(aStates.equals(bStates));
}
@Test
public void testPseudoClassState_retainAll() {
--- 500,521 ----
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"zero", "one", "two", "four"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! BitSetShim.add(bStates, PseudoClass.getPseudoClass(setB[n]));
}
! assertFalse(BitSetShim.equals(aStates, bStates));
}
@Test
public void testPseudoClassState_retainAll() {
*** 521,568 ****
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"four", "five", "one", "two", "three"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! bStates.add(PseudoClass.getPseudoClass(setB[n]));
}
String[] expected = new String[] {
"one", "two", "three"
};
! aStates.retainAll(bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = aStates.iterator();
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(expected.length, states.size(), 0.000001);
for (int n=0; n<expected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(expected[n]);
! assertTrue(aStates.contains(state));
}
}
@Test
public void testPseudoClassState_retainAll_withEmptyStates() {
PseudoClassState bStates = new PseudoClassState();
PseudoClassState aStates = new PseudoClassState();
! aStates.retainAll(bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = aStates.iterator();
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(0, states.size(), 0.000001);
}
--- 523,570 ----
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"four", "five", "one", "two", "three"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! BitSetShim.add(bStates, PseudoClass.getPseudoClass(setB[n]));
}
String[] expected = new String[] {
"one", "two", "three"
};
! BitSetShim.retainAll(aStates, bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(aStates);
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(expected.length, states.size(), 0.000001);
for (int n=0; n<expected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(expected[n]);
! assertTrue( BitSetShim.contains(aStates, state));
}
}
@Test
public void testPseudoClassState_retainAll_withEmptyStates() {
PseudoClassState bStates = new PseudoClassState();
PseudoClassState aStates = new PseudoClassState();
! BitSetShim.retainAll(aStates, bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(aStates);
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(0, states.size(), 0.000001);
}
*** 570,582 ****
@Test
public void testPseudoClassState_retainAll_withNullArg() {
PseudoClassState aStates = new PseudoClassState();
PseudoClassState bStates = null;
! aStates.retainAll(bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = aStates.iterator();
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(0, states.size(), 0.000001);
--- 572,584 ----
@Test
public void testPseudoClassState_retainAll_withNullArg() {
PseudoClassState aStates = new PseudoClassState();
PseudoClassState bStates = null;
! BitSetShim.retainAll(aStates, bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(aStates);
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(0, states.size(), 0.000001);
*** 589,623 ****
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"four", "five"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! bStates.add(PseudoClass.getPseudoClass(setB[n]));
}
String[] expected = new String[0];
! aStates.retainAll(bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = aStates.iterator();
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(expected.length, states.size(), 0.000001);
for (int n=0; n<expected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(expected[n]);
! assertTrue(aStates.contains(state));
}
}
@Test
public void testPseudoClassState_addAll() {
--- 591,625 ----
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"four", "five"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! BitSetShim.add(bStates, PseudoClass.getPseudoClass(setB[n]));
}
String[] expected = new String[0];
! BitSetShim.retainAll(aStates, bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(aStates);
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(expected.length, states.size(), 0.000001);
for (int n=0; n<expected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(expected[n]);
! assertTrue( BitSetShim.contains(aStates, state));
}
}
@Test
public void testPseudoClassState_addAll() {
*** 626,674 ****
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! aStates.add(PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"four", "five"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! bStates.add(PseudoClass.getPseudoClass(setB[n]));
}
String[] expected = new String[] {
"zero", "one", "two", "three",
"four", "five"
};
! aStates.addAll(bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = aStates.iterator();
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(expected.length, states.size(), 0.000001);
for (int n=0; n<expected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(expected[n]);
! assertTrue(aStates.contains(state));
}
}
@Test
public void testPseudoClassState_addAll_withEmptyStates() {
PseudoClassState bStates = new PseudoClassState();
PseudoClassState aStates = new PseudoClassState();
! aStates.addAll(bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = aStates.iterator();
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(0, states.size(), 0.000001);
}
--- 628,676 ----
"zero", "one", "two", "three"
};
PseudoClassState aStates = new PseudoClassState();
for(int n=0; n<setA.length; n++) {
! BitSetShim.add(aStates, PseudoClass.getPseudoClass(setA[n]));
}
String[] setB = new String[] {
"four", "five"
};
PseudoClassState bStates = new PseudoClassState();
for(int n=0; n<setB.length; n++) {
! BitSetShim.add(bStates, PseudoClass.getPseudoClass(setB[n]));
}
String[] expected = new String[] {
"zero", "one", "two", "three",
"four", "five"
};
! BitSetShim.addAll(aStates, bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(aStates);
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(expected.length, states.size(), 0.000001);
for (int n=0; n<expected.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(expected[n]);
! assertTrue( BitSetShim.contains(aStates, state));
}
}
@Test
public void testPseudoClassState_addAll_withEmptyStates() {
PseudoClassState bStates = new PseudoClassState();
PseudoClassState aStates = new PseudoClassState();
! BitSetShim.addAll(aStates, bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(aStates);
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(0, states.size(), 0.000001);
}
*** 676,688 ****
@Test
public void testPseudoClassState_addAll_withNullArgs() {
PseudoClassState aStates = new PseudoClassState();
PseudoClassState bStates = null;
! aStates.addAll(bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = aStates.iterator();
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(0, states.size(), 0.000001);
--- 678,690 ----
@Test
public void testPseudoClassState_addAll_withNullArgs() {
PseudoClassState aStates = new PseudoClassState();
PseudoClassState bStates = null;
! BitSetShim.addAll(aStates, bStates);
List<PseudoClass> states = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(aStates);
while (iter.hasNext()) {
states.add(iter.next());
}
assertEquals(0, states.size(), 0.000001);
*** 696,711 ****
};
List<PseudoClass> expected = new ArrayList<PseudoClass>();
PseudoClassState states = new PseudoClassState();
for(int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! states.add(state);
expected.add(state);
}
List<PseudoClass> stateList = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = states.iterator();
while (iter.hasNext()) {
stateList.add(iter.next());
}
assertTrue(expected.containsAll(stateList));
--- 698,713 ----
};
List<PseudoClass> expected = new ArrayList<PseudoClass>();
PseudoClassState states = new PseudoClassState();
for(int n=0; n<pseudoClasses.length; n++) {
PseudoClass state = PseudoClass.getPseudoClass(pseudoClasses[n]);
! BitSetShim.add(states, state);
expected.add(state);
}
List<PseudoClass> stateList = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(states);
while (iter.hasNext()) {
stateList.add(iter.next());
}
assertTrue(expected.containsAll(stateList));
*** 718,732 ****
"zero", "one", "two", "three"
};
PseudoClassState states = new PseudoClassState();
for(int n=0; n<pseudoClasses.length; n++) {
! states.add(PseudoClass.getPseudoClass(pseudoClasses[n]));
}
List<PseudoClass> stateList = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = states.iterator();
while (iter.hasNext()) {
stateList.add(iter.next());
}
String expected = stateList.toString();
--- 720,734 ----
"zero", "one", "two", "three"
};
PseudoClassState states = new PseudoClassState();
for(int n=0; n<pseudoClasses.length; n++) {
! BitSetShim.add(states, PseudoClass.getPseudoClass(pseudoClasses[n]));
}
List<PseudoClass> stateList = new ArrayList<PseudoClass>();
! Iterator<PseudoClass> iter = BitSetShim.iterator(states);
while (iter.hasNext()) {
stateList.add(iter.next());
}
String expected = stateList.toString();
*** 740,754 ****
PseudoClass[] pseudoClasses = new PseudoClass[4];
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
pseudoClasses[n] = PseudoClass.getPseudoClass(Integer.toString(n));
! states.add(pseudoClasses[n]);
};
int iterations = 0;
! Iterator<PseudoClass> iter = states.iterator();
while(iter.hasNext()) {
iterations += 1;
assertTrue (iterations+">"+pseudoClasses.length, iterations <= pseudoClasses.length);
--- 742,756 ----
PseudoClass[] pseudoClasses = new PseudoClass[4];
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
pseudoClasses[n] = PseudoClass.getPseudoClass(Integer.toString(n));
! BitSetShim.add(states, pseudoClasses[n]);
};
int iterations = 0;
! Iterator<PseudoClass> iter = BitSetShim.iterator(states);
while(iter.hasNext()) {
iterations += 1;
assertTrue (iterations+">"+pseudoClasses.length, iterations <= pseudoClasses.length);
*** 765,779 ****
PseudoClass[] pseudoClasses = new PseudoClass[Long.SIZE*3];
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
pseudoClasses[n] = PseudoClass.getPseudoClass(Integer.toString(n));
! states.add(pseudoClasses[n]);
};
int iterations = 0;
! Iterator<PseudoClass> iter = states.iterator();
while(iter.hasNext()) {
iterations += 1;
assertTrue (iterations+">"+pseudoClasses.length, iterations <= pseudoClasses.length);
--- 767,781 ----
PseudoClass[] pseudoClasses = new PseudoClass[Long.SIZE*3];
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
pseudoClasses[n] = PseudoClass.getPseudoClass(Integer.toString(n));
! BitSetShim.add(states, pseudoClasses[n]);
};
int iterations = 0;
! Iterator<PseudoClass> iter = BitSetShim.iterator(states);
while(iter.hasNext()) {
iterations += 1;
assertTrue (iterations+">"+pseudoClasses.length, iterations <= pseudoClasses.length);
*** 790,845 ****
PseudoClass[] pseudoClasses = new PseudoClass[4];
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
pseudoClasses[n] = PseudoClass.getPseudoClass(Integer.toString(n));
! states.add(pseudoClasses[n]);
};
int iterations = 0;
int nPseudoClasses = pseudoClasses.length;
! Iterator<PseudoClass> iter = states.iterator();
while(iter.hasNext()) {
++iterations;
if ((iterations % 2) == 0) {
iter.remove();
--nPseudoClasses;
! assertFalse(states.contains(pseudoClasses[iterations-1]));
}
}
! assertTrue (nPseudoClasses+"!="+states.size(), nPseudoClasses == states.size());
}
@Test public void testPseudoClassState_iterator_remove_withLargeNumberOfPseudoClasses() {
PseudoClass[] pseudoClasses = new PseudoClass[Long.SIZE*3];
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
pseudoClasses[n] = PseudoClass.getPseudoClass(Integer.toString(n));
! states.add(pseudoClasses[n]);
};
int iterations = 0;
int nPseudoClasses = pseudoClasses.length;
! Iterator<PseudoClass> iter = states.iterator();
while(iter.hasNext()) {
++iterations;
if ((iterations % 2) == 0) {
iter.remove();
--nPseudoClasses;
! assertFalse(states.contains(pseudoClasses[iterations-1]));
}
}
! assertTrue (nPseudoClasses+"!="+states.size(), nPseudoClasses == states.size());
}
int nObservations = 0;
--- 792,847 ----
PseudoClass[] pseudoClasses = new PseudoClass[4];
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
pseudoClasses[n] = PseudoClass.getPseudoClass(Integer.toString(n));
! BitSetShim.add(states, pseudoClasses[n]);
};
int iterations = 0;
int nPseudoClasses = pseudoClasses.length;
! Iterator<PseudoClass> iter = BitSetShim.iterator(states);
while(iter.hasNext()) {
++iterations;
if ((iterations % 2) == 0) {
iter.remove();
--nPseudoClasses;
! assertFalse( BitSetShim.contains(states, pseudoClasses[iterations-1]));
}
}
! assertTrue (nPseudoClasses+"!="+BitSetShim.size(states), nPseudoClasses == BitSetShim.size(states));
}
@Test public void testPseudoClassState_iterator_remove_withLargeNumberOfPseudoClasses() {
PseudoClass[] pseudoClasses = new PseudoClass[Long.SIZE*3];
PseudoClassState states = new PseudoClassState();
for (int n=0; n<pseudoClasses.length; n++) {
pseudoClasses[n] = PseudoClass.getPseudoClass(Integer.toString(n));
! BitSetShim.add(states, pseudoClasses[n]);
};
int iterations = 0;
int nPseudoClasses = pseudoClasses.length;
! Iterator<PseudoClass> iter = BitSetShim.iterator(states);
while(iter.hasNext()) {
++iterations;
if ((iterations % 2) == 0) {
iter.remove();
--nPseudoClasses;
! assertFalse( BitSetShim.contains(states, pseudoClasses[iterations-1]));
}
}
! assertTrue (nPseudoClasses+"!="+BitSetShim.size(states), nPseudoClasses == BitSetShim.size(states));
}
int nObservations = 0;
*** 1163,1174 ****
Set<PseudoClass> setB = new PseudoClassState();
assertTrue(setA.retainAll(setB));
! assertArrayEquals(new long[0], ((PseudoClassState)setA).getBits());
!
}
@Test public void testRemoveAllOfSameSetResultsInEmptySet() {
final PseudoClass[] pseudoClasses = new PseudoClass[] {
--- 1165,1175 ----
Set<PseudoClass> setB = new PseudoClassState();
assertTrue(setA.retainAll(setB));
! assertArrayEquals(new long[0], BitSetShim.getBits((PseudoClassState)setA));
}
@Test public void testRemoveAllOfSameSetResultsInEmptySet() {
final PseudoClass[] pseudoClasses = new PseudoClass[] {
*** 1184,1194 ****
setA.add(pseudoClasses[n]);
};
assertTrue(setA.removeAll(setA));
! assertArrayEquals(new long[0], ((PseudoClassState)setA).getBits());
}
@Test public void testRemoveLastBitResultsInEmptySet() {
--- 1185,1195 ----
setA.add(pseudoClasses[n]);
};
assertTrue(setA.removeAll(setA));
! assertArrayEquals(new long[0], BitSetShim.getBits((PseudoClassState)setA));
}
@Test public void testRemoveLastBitResultsInEmptySet() {
*** 1207,1217 ****
for (int n=0; n<pseudoClasses.length; n++) {
assertTrue(setA.remove(pseudoClasses[n]));
};
! assertArrayEquals(new long[0], ((PseudoClassState)setA).getBits());
}
@Test public void testRemoveLastBitByIteratorResultsInEmptySet() {
--- 1208,1218 ----
for (int n=0; n<pseudoClasses.length; n++) {
assertTrue(setA.remove(pseudoClasses[n]));
};
! assertArrayEquals(new long[0], BitSetShim.getBits((PseudoClassState)setA));
}
@Test public void testRemoveLastBitByIteratorResultsInEmptySet() {
*** 1231,1249 ****
Iterator<PseudoClass> iterator = setA.iterator();
while (iterator.hasNext()) {
iterator.remove();
}
! assertArrayEquals(new long[0], ((PseudoClassState)setA).getBits());
}
@Test public void testAddEmptyToEmptyResultsInEmptySet() {
Set<PseudoClass> setA = new PseudoClassState();
Set<PseudoClass> setB = new PseudoClassState();
assertFalse(setA.addAll(setB));
! assertArrayEquals(new long[0], ((PseudoClassState)setA).getBits());
}
}
--- 1232,1250 ----
Iterator<PseudoClass> iterator = setA.iterator();
while (iterator.hasNext()) {
iterator.remove();
}
! assertArrayEquals(new long[0], BitSetShim.getBits((PseudoClassState)setA));
}
@Test public void testAddEmptyToEmptyResultsInEmptySet() {
Set<PseudoClass> setA = new PseudoClassState();
Set<PseudoClass> setB = new PseudoClassState();
assertFalse(setA.addAll(setB));
! assertArrayEquals(new long[0], BitSetShim.getBits((PseudoClassState)setA));
}
}