org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/contentassist/ContentAssistHistoryTest.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2020 IBM Corporation and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.text.tests.contentassist;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 import org.junit.Rule;
 import org.junit.Test;

 import org.eclipse.core.runtime.Preferences;

 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IType;

 import org.eclipse.jdt.ui.tests.core.rules.ProjectTestSetup;

 import org.eclipse.jdt.internal.ui.text.java.ContentAssistHistory;
 import org.eclipse.jdt.internal.ui.text.java.ContentAssistHistory.RHSHistory;

 /**
  * @since 3.2
  */
 public class ContentAssistHistoryTest {
 	private static final String LINKED_LIST= "java.util.LinkedList";
 	private static final String ARRAY_LIST= "java.util.ArrayList";
 	private static final String ITERABLE= "java.lang.Iterable";
 	private static final String LIST= "java.util.List";
 	private static final String COLLECTION= "java.util.Collection";
 	private static final String STRING_BUFFER= "java.lang.StringBuffer";
 	private static final String CHAR_SEQUENCE= "java.lang.CharSequence";
 	private static final String STRING= "java.lang.String";

 	private static IType fgStringT;
 	private static IType fgCharSequenceT;
 	private static IType fgStringBufferT;
 	private static IType fgCollectionT;
 	private static IType fgListT;
 	private static IType fgArrayListT;
 	private static IType fgLinkedListT;

 	@Rule
 	public ProjectTestSetup pts= new ProjectTestSetup() {
 			/*
 			 * @see org.eclipse.jdt.ui.tests.core.ProjectTestSetup#setUp()
 			 */
 			@Override
 			protected void before() throws Throwable {
 				super.before();

 				IJavaProject project= getProject();
 				fgStringT= project.findType(STRING);
 				fgCharSequenceT= project.findType(CHAR_SEQUENCE);
 				fgStringBufferT= project.findType(STRING_BUFFER);
 				fgCollectionT= project.findType(COLLECTION);
 				fgListT= project.findType(LIST);
 				fgArrayListT= project.findType(ARRAY_LIST);
 				fgLinkedListT= project.findType(LINKED_LIST);
 			}
 		};

 	@Test
 	public void testContentAssistHistoryIntInt() {
 		try {
 			new ContentAssistHistory(-1, 1);
 			fail();
 		} catch (IllegalArgumentException e) {
 		}
 		try {
 			new ContentAssistHistory(1, 0);
 			fail();
 		} catch (IllegalArgumentException e) {
 		}
 		try {
 			new ContentAssistHistory(1, 1);
 		} catch (IllegalArgumentException e) {
 			fail();
 		}
 	}

 	@Test
 	public void testContentAssistHistory() {
 		try {
 			new ContentAssistHistory();
 		} catch (IllegalArgumentException e) {
 			fail();
 		}
 	}

 	@Test
 	public void testRememberArgumentChecking() throws Exception {
 		ContentAssistHistory history= new ContentAssistHistory();
 		try {
 			history.remember(null, null);
 			fail();
 		} catch (IllegalArgumentException e) {
 		}
 		try {
 			history.remember(null, fgStringT);
 			fail();
 		} catch (IllegalArgumentException e) {
 		}
 		try {
 			history.remember(fgStringT, null);
 			fail();
 		} catch (IllegalArgumentException e) {
 		}
 		try {
 			history.remember(fgStringT, fgStringT);
 		} catch (IllegalArgumentException e) {
 			fail();
 		}
 	}

 	@Test
 	public void testGetHistory() {
 		ContentAssistHistory history= new ContentAssistHistory();
 		assertTrue(history.getHistory(STRING).getTypes().isEmpty());

 		history.remember(fgCharSequenceT, fgStringT);
 		assertTrue(history.getHistory(STRING).getTypes().isEmpty());
 		assertEquals(list(STRING), history.getHistory(CHAR_SEQUENCE).getTypes());

 		history.remember(fgStringT, fgStringT);
 		assertTrue("history must not remember final left hand sides", history.getHistory(STRING).getTypes().isEmpty());

 		history.remember(fgCharSequenceT, fgStringBufferT);
 		assertTrue(history.getHistory(STRING).getTypes().isEmpty());
 		assertEquals(list(STRING, STRING_BUFFER), history.getHistory(CHAR_SEQUENCE).getTypes());

 		history.remember(fgStringT, fgStringT);
 		assertTrue(history.getHistory(STRING).getTypes().isEmpty());
 		assertEquals("order not correct", list(STRING_BUFFER, STRING), history.getHistory(CHAR_SEQUENCE).getTypes());
 	}

 	@Test
 	public void testHistoryCapSize() {
 		ContentAssistHistory history= new ContentAssistHistory(1, 1);

 		history.remember(fgCharSequenceT, fgStringT);
 		assertEqualMap(map(CHAR_SEQUENCE, list(STRING)), history.getEntireHistory());

 		history.remember(fgStringT, fgStringT);
 		assertEqualMap("adding final types must not modify the history", map(CHAR_SEQUENCE, list(STRING)), history.getEntireHistory());

 		history.remember(fgCharSequenceT, fgStringBufferT);
 		assertEqualMap(map(CHAR_SEQUENCE, list(STRING_BUFFER)), history.getEntireHistory());

 		history.remember(fgCharSequenceT, fgArrayListT);
 		assertEqualMap("adding types that are not related must not modify the history", map(CHAR_SEQUENCE, list(STRING_BUFFER)), history.getEntireHistory());

 		history.remember(fgListT, fgStringT);
 		assertEqualMap("adding types that are not related must not modify the history", map(CHAR_SEQUENCE, list(STRING_BUFFER)), history.getEntireHistory());

 		history.remember(fgCollectionT, fgArrayListT);
 		assertEqualMap(map(COLLECTION, list(ARRAY_LIST)), history.getEntireHistory());
 	}

 	@Test
 	public void testGetHistoryForHierarchy() {
 		ContentAssistHistory history= new ContentAssistHistory();

 		history.remember(fgListT, fgArrayListT);
 		assertEqualMap(map(LIST, list(ARRAY_LIST), COLLECTION, list(ARRAY_LIST), ITERABLE, list(ARRAY_LIST)), history.getEntireHistory());
 	}

 	@Test
 	public void testGetEntireHistory() {
 		ContentAssistHistory history= new ContentAssistHistory();

 		history.remember(fgListT, fgArrayListT);
 		history.remember(fgCollectionT, fgLinkedListT);

 		assertEqualMap(map(LIST, list(ARRAY_LIST), COLLECTION, list(ARRAY_LIST, LINKED_LIST), ITERABLE, list(ARRAY_LIST, LINKED_LIST)), history.getEntireHistory());
 	}

 	@Test
 	public void testReadOnlyEntireHistory() {
 		ContentAssistHistory history= new ContentAssistHistory();

 		history.remember(fgListT, fgArrayListT);
 		history.remember(fgCollectionT, fgLinkedListT);

 		Map<String, RHSHistory> map= history.getEntireHistory();
 		try {
 			map.clear();
 			fail();
 		} catch (UnsupportedOperationException x) {
 		}

 		try {
 			map.get(LIST).getTypes().clear();
 			fail();
 		} catch (UnsupportedOperationException x) {
 		}
 	}

 	@Test
 	public void testReadOnlyHistory() {
 		ContentAssistHistory history= new ContentAssistHistory();

 		history.remember(fgListT, fgArrayListT);
 		history.remember(fgCollectionT, fgLinkedListT);

 		List<String> set= history.getHistory(LIST).getTypes();
 		try {
 			set.clear();
 			fail();
 		} catch (UnsupportedOperationException x) {
 		}
 	}

 	@Test
 	public void testLoadStore() throws Exception {
 		ContentAssistHistory history= new ContentAssistHistory();

 		history.remember(fgListT, fgArrayListT);
 		history.remember(fgCharSequenceT, fgStringT);


 		Preferences prefs= new Preferences();
 		String key= "myKey";
 		ContentAssistHistory.store(history, prefs, key);
 		ContentAssistHistory loaded= ContentAssistHistory.load(prefs, key);

 		assertEqualMap(map(LIST, list(ARRAY_LIST), COLLECTION, list(ARRAY_LIST), ITERABLE, list(ARRAY_LIST), CHAR_SEQUENCE, list(STRING)), loaded.getEntireHistory());
 	}

 	private static void assertEqualMap(Map<String, List<String>> expected, Map<String, RHSHistory> actual) {
 		assertEqualMap("", expected, actual);
 	}

 	private static void assertEqualMap(String message, Map<String, List<String>> expected, Map<String, RHSHistory> actual) {
 		assertEquals(message, expected.size(), actual.size());
 		for (Map.Entry<String, List<String>> entry : expected.entrySet()) {
 			String type = entry.getKey();
 			assertEquals(message, entry.getValue(), actual.get(type).getTypes());
 		}
 	}

 	private Map<String, List<String>> map(String type, List<String> set) {
 		Map<String, List<String>> map= new HashMap<>();
 		map.put(type, set);
 		return map;
 	}

 	private Map<String, List<String>> map(String t1, List<String> s1, String t2, List<String> s2) {
 		Map<String, List<String>> map= map(t1, s1);
 		map.put(t2, s2);
 		return map;
 	}

 	private Map<String, List<String>> map(String t1, List<String> s1, String t2, List<String> s2, String t3, List<String> s3) {
 		Map<String, List<String>> map= map(t1, s1, t2, s2);
 		map.put(t3, s3);
 		return map;
 	}

 	private Map<String, List<String>> map(String t1, List<String> s1, String t2, List<String> s2, String t3, List<String> s3, String t4, List<String> s4) {
 		Map<String, List<String>> map= map(t1, s1, t2, s2, t3, s3);
 		map.put(t4, s4);
 		return map;
 	}

 	List<String> list(String param) {
 		List<String> list= new ArrayList<>();
 		list.add(param);
 		return list;
 	}

 	List<String> list(String p1, String p2) {
 		List<String> list= list(p1);
 		list.add(p2);
 		return list;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2005, 2020 IBM Corporation and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.text.tests.contentassist;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assert.fail;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	import org.junit.Rule;
	import org.junit.Test;

	import org.eclipse.core.runtime.Preferences;

	import org.eclipse.jdt.core.IJavaProject;
	import org.eclipse.jdt.core.IType;

	import org.eclipse.jdt.ui.tests.core.rules.ProjectTestSetup;

	import org.eclipse.jdt.internal.ui.text.java.ContentAssistHistory;
	import org.eclipse.jdt.internal.ui.text.java.ContentAssistHistory.RHSHistory;

	/**
	* @since 3.2
	*/
	public class ContentAssistHistoryTest {
	private static final String LINKED_LIST= "java.util.LinkedList";
	private static final String ARRAY_LIST= "java.util.ArrayList";
	private static final String ITERABLE= "java.lang.Iterable";
	private static final String LIST= "java.util.List";
	private static final String COLLECTION= "java.util.Collection";
	private static final String STRING_BUFFER= "java.lang.StringBuffer";
	private static final String CHAR_SEQUENCE= "java.lang.CharSequence";
	private static final String STRING= "java.lang.String";

	private static IType fgStringT;
	private static IType fgCharSequenceT;
	private static IType fgStringBufferT;
	private static IType fgCollectionT;
	private static IType fgListT;
	private static IType fgArrayListT;
	private static IType fgLinkedListT;

	@Rule
	public ProjectTestSetup pts= new ProjectTestSetup() {
	/*
	* @see org.eclipse.jdt.ui.tests.core.ProjectTestSetup#setUp()
	*/
	@Override
	protected void before() throws Throwable {
	super.before();

	IJavaProject project= getProject();
	fgStringT= project.findType(STRING);
	fgCharSequenceT= project.findType(CHAR_SEQUENCE);
	fgStringBufferT= project.findType(STRING_BUFFER);
	fgCollectionT= project.findType(COLLECTION);
	fgListT= project.findType(LIST);
	fgArrayListT= project.findType(ARRAY_LIST);
	fgLinkedListT= project.findType(LINKED_LIST);
	}
	};

	@Test
	public void testContentAssistHistoryIntInt() {
	try {
	new ContentAssistHistory(-1, 1);
	fail();
	} catch (IllegalArgumentException e) {
	}
	try {
	new ContentAssistHistory(1, 0);
	fail();
	} catch (IllegalArgumentException e) {
	}
	try {
	new ContentAssistHistory(1, 1);
	} catch (IllegalArgumentException e) {
	fail();
	}
	}

	@Test
	public void testContentAssistHistory() {
	try {
	new ContentAssistHistory();
	} catch (IllegalArgumentException e) {
	fail();
	}
	}

	@Test
	public void testRememberArgumentChecking() throws Exception {
	ContentAssistHistory history= new ContentAssistHistory();
	try {
	history.remember(null, null);
	fail();
	} catch (IllegalArgumentException e) {
	}
	try {
	history.remember(null, fgStringT);
	fail();
	} catch (IllegalArgumentException e) {
	}
	try {
	history.remember(fgStringT, null);
	fail();
	} catch (IllegalArgumentException e) {
	}
	try {
	history.remember(fgStringT, fgStringT);
	} catch (IllegalArgumentException e) {
	fail();
	}
	}

	@Test
	public void testGetHistory() {
	ContentAssistHistory history= new ContentAssistHistory();
	assertTrue(history.getHistory(STRING).getTypes().isEmpty());

	history.remember(fgCharSequenceT, fgStringT);
	assertTrue(history.getHistory(STRING).getTypes().isEmpty());
	assertEquals(list(STRING), history.getHistory(CHAR_SEQUENCE).getTypes());

	history.remember(fgStringT, fgStringT);
	assertTrue("history must not remember final left hand sides", history.getHistory(STRING).getTypes().isEmpty());

	history.remember(fgCharSequenceT, fgStringBufferT);
	assertTrue(history.getHistory(STRING).getTypes().isEmpty());
	assertEquals(list(STRING, STRING_BUFFER), history.getHistory(CHAR_SEQUENCE).getTypes());

	history.remember(fgStringT, fgStringT);
	assertTrue(history.getHistory(STRING).getTypes().isEmpty());
	assertEquals("order not correct", list(STRING_BUFFER, STRING), history.getHistory(CHAR_SEQUENCE).getTypes());
	}

	@Test
	public void testHistoryCapSize() {
	ContentAssistHistory history= new ContentAssistHistory(1, 1);

	history.remember(fgCharSequenceT, fgStringT);
	assertEqualMap(map(CHAR_SEQUENCE, list(STRING)), history.getEntireHistory());

	history.remember(fgStringT, fgStringT);
	assertEqualMap("adding final types must not modify the history", map(CHAR_SEQUENCE, list(STRING)), history.getEntireHistory());

	history.remember(fgCharSequenceT, fgStringBufferT);
	assertEqualMap(map(CHAR_SEQUENCE, list(STRING_BUFFER)), history.getEntireHistory());

	history.remember(fgCharSequenceT, fgArrayListT);
	assertEqualMap("adding types that are not related must not modify the history", map(CHAR_SEQUENCE, list(STRING_BUFFER)), history.getEntireHistory());

	history.remember(fgListT, fgStringT);
	assertEqualMap("adding types that are not related must not modify the history", map(CHAR_SEQUENCE, list(STRING_BUFFER)), history.getEntireHistory());

	history.remember(fgCollectionT, fgArrayListT);
	assertEqualMap(map(COLLECTION, list(ARRAY_LIST)), history.getEntireHistory());
	}

	@Test
	public void testGetHistoryForHierarchy() {
	ContentAssistHistory history= new ContentAssistHistory();

	history.remember(fgListT, fgArrayListT);
	assertEqualMap(map(LIST, list(ARRAY_LIST), COLLECTION, list(ARRAY_LIST), ITERABLE, list(ARRAY_LIST)), history.getEntireHistory());
	}

	@Test
	public void testGetEntireHistory() {
	ContentAssistHistory history= new ContentAssistHistory();

	history.remember(fgListT, fgArrayListT);
	history.remember(fgCollectionT, fgLinkedListT);

	assertEqualMap(map(LIST, list(ARRAY_LIST), COLLECTION, list(ARRAY_LIST, LINKED_LIST), ITERABLE, list(ARRAY_LIST, LINKED_LIST)), history.getEntireHistory());
	}

	@Test
	public void testReadOnlyEntireHistory() {
	ContentAssistHistory history= new ContentAssistHistory();

	history.remember(fgListT, fgArrayListT);
	history.remember(fgCollectionT, fgLinkedListT);

	Map<String, RHSHistory> map= history.getEntireHistory();
	try {
	map.clear();
	fail();
	} catch (UnsupportedOperationException x) {
	}

	try {
	map.get(LIST).getTypes().clear();
	fail();
	} catch (UnsupportedOperationException x) {
	}
	}

	@Test
	public void testReadOnlyHistory() {
	ContentAssistHistory history= new ContentAssistHistory();

	history.remember(fgListT, fgArrayListT);
	history.remember(fgCollectionT, fgLinkedListT);

	List<String> set= history.getHistory(LIST).getTypes();
	try {
	set.clear();
	fail();
	} catch (UnsupportedOperationException x) {
	}
	}

	@Test
	public void testLoadStore() throws Exception {
	ContentAssistHistory history= new ContentAssistHistory();

	history.remember(fgListT, fgArrayListT);
	history.remember(fgCharSequenceT, fgStringT);


	Preferences prefs= new Preferences();
	String key= "myKey";
	ContentAssistHistory.store(history, prefs, key);
	ContentAssistHistory loaded= ContentAssistHistory.load(prefs, key);

	assertEqualMap(map(LIST, list(ARRAY_LIST), COLLECTION, list(ARRAY_LIST), ITERABLE, list(ARRAY_LIST), CHAR_SEQUENCE, list(STRING)), loaded.getEntireHistory());
	}

	private static void assertEqualMap(Map<String, List<String>> expected, Map<String, RHSHistory> actual) {
	assertEqualMap("", expected, actual);
	}

	private static void assertEqualMap(String message, Map<String, List<String>> expected, Map<String, RHSHistory> actual) {
	assertEquals(message, expected.size(), actual.size());
	for (Map.Entry<String, List<String>> entry : expected.entrySet()) {
	String type = entry.getKey();
	assertEquals(message, entry.getValue(), actual.get(type).getTypes());
	}
	}

	private Map<String, List<String>> map(String type, List<String> set) {
	Map<String, List<String>> map= new HashMap<>();
	map.put(type, set);
	return map;
	}

	private Map<String, List<String>> map(String t1, List<String> s1, String t2, List<String> s2) {
	Map<String, List<String>> map= map(t1, s1);
	map.put(t2, s2);
	return map;
	}

	private Map<String, List<String>> map(String t1, List<String> s1, String t2, List<String> s2, String t3, List<String> s3) {
	Map<String, List<String>> map= map(t1, s1, t2, s2);
	map.put(t3, s3);
	return map;
	}

	private Map<String, List<String>> map(String t1, List<String> s1, String t2, List<String> s2, String t3, List<String> s3, String t4, List<String> s4) {
	Map<String, List<String>> map= map(t1, s1, t2, s2, t3, s3);
	map.put(t4, s4);
	return map;
	}

	List<String> list(String param) {
	List<String> list= new ArrayList<>();
	list.add(param);
	return list;
	}

	List<String> list(String p1, String p2) {
	List<String> list= list(p1);
	list.add(p2);
	return list;
	}
	}