@Test public void testNewInstance() { final Results results = new DefaultResultsImpl(); assertTrue(results.getMessages().isEmpty()); assertTrue(results.getMessages(ResultType.ERROR).isEmpty()); assertTrue(results.getMessages(ResultType.WARNING).isEmpty()); }
@Test public void testNewInstance() { final Results results = new DefaultResultsImpl(); assertTrue(results.getMessages().isEmpty()); assertTrue(results.getMessages(ResultType.ERROR).isEmpty()); assertTrue(results.getMessages(ResultType.WARNING).isEmpty()); }
@Test public void thereIsNoPartsTest() { singlePartHelper = new SinglePartPanelHelper(new ArrayList<>(), placeManager); assertTrue(singlePartHelper.hasNoParts()); }
@Test public void thereIsNoPartsTest() { singlePartHelper = new SinglePartPanelHelper(new ArrayList<>(), placeManager); assertTrue(singlePartHelper.hasNoParts()); }
@Test public void getPlaceFromFirstPartTest() { PlaceRequest place = mock(PlaceRequest.class); PartDefinition part = mock(PartDefinition.class); when(part.getPlace()).thenReturn(place); Collection<PartDefinition> parts = Arrays.asList(part); singlePartHelper = new SinglePartPanelHelper(parts, placeManager); assertTrue(!singlePartHelper.hasNoParts()); assertEquals(place, singlePartHelper.getPlaceFromFirstPart()); }
@Test public void getPlaceFromFirstPartTest() { PlaceRequest place = mock(PlaceRequest.class); PartDefinition part = mock(PartDefinition.class); when(part.getPlace()).thenReturn(place); Collection<PartDefinition> parts = Arrays.asList(part); singlePartHelper = new SinglePartPanelHelper(parts, placeManager); assertTrue(!singlePartHelper.hasNoParts()); assertEquals(place, singlePartHelper.getPlaceFromFirstPart()); }
@Test public void testChangeDataModelerContextSameContextSourceMode() { testSetDataModelerFocusEventWithPlanner(); originalContext.setEditionMode(DataModelerContext.EditionMode.SOURCE_MODE); handler.onContextChange(new DataModelerWorkbenchContextChangeEvent()); assertTrue(handler.shouldRefreshDocks()); assertTrue(handler.shouldDisableDocks()); verify(command, times(2)).execute(); }
public void testEntrySetAfterClearInBranchedTransaction() throws Exception { cache.put(1, "v1"); tm().begin(); try { assertEquals("v1", cache.get(1)); //clear is non transactional cache.clear(); Set<Map.Entry<Object, Object>> entrySet = cache.entrySet(); assertEquals(1, entrySet.size()); Map.Entry<Object, Object> entry = entrySet.iterator().next(); assertEquals(1, entry.getKey()); assertEquals("v1", entry.getValue()); assertTrue(entrySet.contains(TestingUtil.<Object, Object>createMapEntry(1, "v1"))); } finally { safeCommit(false); } }
public void testEntrySetAfterClearInBranchedTransactionOnWrite() throws Exception { cache.put(1, "v1"); tm().begin(); try { assertEquals("v1", cache.put(1, "v2")); //clear is non transactional cache.clear(); Set<Map.Entry<Object, Object>> entrySet = cache.entrySet(); assertEquals(1, entrySet.size()); Map.Entry<Object, Object> entry = entrySet.iterator().next(); assertEquals(1, entry.getKey()); assertEquals("v2", entry.getValue()); assertTrue(entrySet.contains(TestingUtil.<Object, Object>createMapEntry(1, "v2"))); } finally { safeCommit(true); } }
public void testValuesAfterClearInBranchedTransaction() throws Exception { cache.put(1, "v1"); tm().begin(); try { assertEquals("v1", cache.get(1)); //clear is non transactional cache.clear(); Collection<Object> values = cache.values(); assertEquals(1, values.size()); assertTrue(values.contains("v1")); } finally { safeCommit(false); } }
public void testKeySetAfterClearInBranchedTransactionOnWrite() throws Exception { cache.put(1, "v1"); tm().begin(); try { assertEquals("v1", cache.put(1, "v2")); //clear is non transactional cache.clear(); Set<Object> keySet = cache.keySet(); assertEquals(1, keySet.size()); assertTrue(keySet.contains(1)); } finally { safeCommit(true); } }
public void testKeySetAfterClearInBranchedTransaction() throws Exception { cache.put(1, "v1"); tm().begin(); try { assertEquals("v1", cache.get(1)); //clear is non transactional cache.clear(); Set<Object> keySet = cache.keySet(); assertEquals(1, keySet.size()); assertTrue(keySet.contains(1)); } finally { safeCommit(false); } }
public void testValuesAfterClearInBranchedTransactionOnWrite() throws Exception { cache.put(1, "v1"); tm().begin(); try { assertEquals("v1", cache.put(1, "v2")); //clear is non transactional cache.clear(); Collection<Object> values = cache.values(); assertEquals(1, values.size()); assertTrue(values.contains("v2")); } finally { safeCommit(true); } }
public void testKeySetAfterRemoveInBranchedTransaction() throws Exception { cache.put(1, "v1"); cache.put(2, "v2"); tm().begin(); try { assertEquals("v1", cache.get(1)); Transaction suspended = tm().suspend(); cache.remove(1); tm().resume(suspended); Set<Object> keySet = cache.keySet(); assertEquals(2, keySet.size()); assertTrue(keySet.contains(1)); assertTrue(keySet.contains(2)); } finally { safeCommit(false); } }
public void testValuesAfterRemoveInBranchedTransaction() throws Exception { cache.put(1, "v1"); cache.put(2, "v2"); tm().begin(); try { assertEquals("v1", cache.get(1)); Transaction suspended = tm().suspend(); cache.remove(1); tm().resume(suspended); Collection<Object> values = cache.values(); assertEquals(2, values.size()); assertTrue(values.contains("v1")); assertTrue(values.contains("v2")); } finally { safeCommit(false); } }
public void testEntrySetAfterDoubleRemoveInBranchedTransaction() throws Exception { cache.put(1, "v1"); cache.put(2, "v2"); tm().begin(); try { assertEquals("v1", cache.remove(1)); Transaction suspended = tm().suspend(); assertEquals("v1", cache.remove(1)); tm().resume(suspended); Set<Map.Entry<Object, Object>> entrySet = cache.entrySet(); assertEquals(1, entrySet.size()); Map.Entry<Object, Object> entry = entrySet.iterator().next(); assertEquals(2, entry.getKey()); assertEquals("v2", entry.getValue()); assertTrue(entrySet.contains(TestingUtil.<Object, Object>createMapEntry(2, "v2"))); } finally { safeCommit(true); } }
public void testKeySetAfterDoubleRemoveInBranchedTransaction() throws Exception { cache.put(1, "v1"); cache.put(2, "v2"); tm().begin(); try { assertEquals("v1", cache.remove(1)); Transaction suspended = tm().suspend(); assertEquals("v1", cache.remove(1)); tm().resume(suspended); Set<Object> keySet = cache.keySet(); assertEquals(1, keySet.size()); assertTrue(keySet.contains(2)); } finally { safeCommit(true); } }
@Test public void testContains() { final Results results = new DefaultResultsImpl(); results.addMessage(new DefaultResultImpl(ResultType.ERROR, "An error")); assertTrue(results.contains(ResultType.ERROR)); assertFalse(results.contains(ResultType.WARNING)); } }
public void testValuesAfterDoubleRemoveInBranchedTransaction() throws Exception { cache.put(1, "v1"); cache.put(2, "v2"); tm().begin(); try { assertEquals("v1", cache.remove(1)); Transaction suspended = tm().suspend(); assertEquals("v1", cache.remove(1)); tm().resume(suspended); Collection<Object> values = cache.values(); assertEquals(1, values.size()); assertTrue(values.contains("v2")); } finally { safeCommit(true); } }
@Test public void testContains() { final Results results = new DefaultResultsImpl(); results.addMessage(new DefaultResultImpl(ResultType.ERROR, "An error")); assertTrue(results.contains(ResultType.ERROR)); assertFalse(results.contains(ResultType.WARNING)); } }