bundles/org.eclipse.osgi.tests/src/org/eclipse/osgi/tests/container/NamespaceListTest.java - equinox/rt.equinox.framework - Git at Google

 /*******************************************************************************
  * Copyright (c) 2021 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
  *     Hannes Wellmann - Bug 573025: introduce and apply NamespaceList.Builder
  *******************************************************************************/
 package org.eclipse.osgi.tests.container;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;

 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Objects;
 import java.util.Random;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import org.junit.Test;
 import org.osgi.framework.Bundle;

 /**
  * Using reflection because to avoid exporting internals.
  */
 public class NamespaceListTest extends AbstractTest {
 	static final Method NAMESPACELIST_GET_LIST;
 	static final Method NAMESPACELIST_IS_EMPTY;
 	static final Method NAMESPACELIST_EMPTY;
 	static final Method NAMESPACELIST_CREATE_BUILDER;

 	// only access fields reflectively that are not part of the Collection-API
 	static final Method BUILDER_CREATE;
 	static final Method BUILDER_ADD_ALL;
 	static final Method BUILDER_ADD_AFTER_LAST_MATCH;
 	static final Method BUILDER_REMOVE_NAMESPACE_IF;
 	static final Method BUILDER_REMOVE_ELEMENTS_OF_NAMESPACE_IF;
 	static final Method BUILDER_BUILD;

 	static {
 		try {
 			ClassLoader classLoader = Bundle.class.getClassLoader();
 			Class<?> namespaceList = classLoader.loadClass("org.eclipse.osgi.internal.container.NamespaceList");
 			Class<?> namespaceListBuilder = classLoader
 					.loadClass("org.eclipse.osgi.internal.container.NamespaceList$Builder");

 			NAMESPACELIST_GET_LIST = namespaceList.getMethod("getList", String.class);
 			NAMESPACELIST_IS_EMPTY = namespaceList.getMethod("isEmpty");
 			NAMESPACELIST_EMPTY = namespaceList.getMethod("empty", Function.class);
 			NAMESPACELIST_CREATE_BUILDER = namespaceList.getMethod("createBuilder");

 			BUILDER_CREATE = namespaceListBuilder.getMethod("create", Function.class);
 			BUILDER_ADD_ALL = namespaceListBuilder.getMethod("addAll", namespaceList);
 			BUILDER_ADD_AFTER_LAST_MATCH = namespaceListBuilder.getMethod("addAfterLastMatch", Object.class,
 					Predicate.class);
 			BUILDER_REMOVE_NAMESPACE_IF = namespaceListBuilder.getMethod("removeNamespaceIf", Predicate.class);
 			BUILDER_REMOVE_ELEMENTS_OF_NAMESPACE_IF = namespaceListBuilder.getMethod("removeElementsOfNamespaceIf",
 					String.class, Predicate.class);
 			BUILDER_BUILD = namespaceListBuilder.getMethod("build");
 		} catch (Throwable t) {
 			throw new RuntimeException(t);
 		}
 	}

 	static Object newNamespace(List<NamespaceElement> elements) throws Exception {
 		Collection<NamespaceElement> builder = builderCreate();
 		builder.addAll(elements);
 		return build(builder);
 	}

 	// --- reflectively invoked methods of NamespaceList ---

 	static <E> Object createEmptyNamespaceList(Function<E, String> getNamespace) throws Exception {
 		return NAMESPACELIST_EMPTY.invoke(null, getNamespace);
 	}

 	static boolean isEmpty(Object namespaceList) throws Exception {
 		return (boolean) NAMESPACELIST_IS_EMPTY.invoke(namespaceList);
 	}

 	static List<NamespaceElement> getList(Object namespaceList, String namespace) throws Exception {
 		return (List<NamespaceElement>) NAMESPACELIST_GET_LIST.invoke(namespaceList, namespace);
 	}

 	static Collection<NamespaceElement> createBuilder(Object namespaceList) throws Exception {
 		return (Collection<NamespaceElement>) NAMESPACELIST_CREATE_BUILDER.invoke(namespaceList);
 	}

 	// --- reflectively invoked non-Collection methods of NamespaceList$Builder ---

 	static Collection<NamespaceElement> builderCreate() throws Exception {
 		Function<NamespaceElement, String> getNamespace = NamespaceElement::getNamespace;
 		return (Collection<NamespaceElement>) BUILDER_CREATE.invoke(null, getNamespace);
 	}

 	static <E> void builderAddAll(Collection<E> builder, Object namespaceList) throws Exception {
 		BUILDER_ADD_ALL.invoke(builder, namespaceList);
 	}

 	static <E> void builderAddAfterLastMatch(Collection<E> builder, E e, Predicate<E> matcher) throws Exception {
 		BUILDER_ADD_AFTER_LAST_MATCH.invoke(builder, e, matcher);
 	}

 	static <E> void builderRemoveNamespaceIf(Collection<E> builder, Predicate<String> filter) throws Exception {
 		BUILDER_REMOVE_NAMESPACE_IF.invoke(builder, filter);
 	}

 	static <E> void builderRemoveElementsOfNamespaceIf(Collection<E> builder, String namespace, Predicate<E> filter)
 			throws Exception {
 		BUILDER_REMOVE_ELEMENTS_OF_NAMESPACE_IF.invoke(builder, namespace, filter);
 	}

 	static <E> Object build(Collection<E> builder) throws Exception {
 		return BUILDER_BUILD.invoke(builder);
 	}

 	static class NamespaceElement {
 		final int id;
 		final String namespace;

 		public NamespaceElement(int id, String namespace) {
 			super();
 			this.id = id;
 			this.namespace = namespace;
 		}

 		public int getId() {
 			return id;
 		}

 		public String getNamespace() {
 			return namespace;
 		}

 		@Override
 		public boolean equals(Object o) {
 			if (o instanceof NamespaceElement) {
 				NamespaceElement other = (NamespaceElement) o;
 				return this.id == other.id && this.namespace.equals(other.namespace);
 			}
 			return false;
 		}

 		@Override
 		public int hashCode() {
 			return Objects.hash(namespace, id);
 		}

 		@Override
 		public String toString() {
 			return namespace + ':' + id;
 		}
 	}

 	// --- tests ---

 	@Test
 	public void testCreateEmptyList() throws Exception {
 		Object namespaceList = createEmptyNamespaceList(NamespaceElement::getNamespace);
 		assertTrue("List is not empty.", isEmpty(namespaceList));
 	}

 	@Test
 	public void testIsEmpty() throws Exception {
 		Object namespaceList = newNamespace(Collections.emptyList());
 		assertTrue("List is not empty.", isEmpty(namespaceList));

 		List<NamespaceElement> elements = new ArrayList<>();
 		elements.add(new NamespaceElement(0, "ns1"));
 		namespaceList = newNamespace(elements);
 		assertFalse("List is empty.", isEmpty(namespaceList));

 		elements.add(new NamespaceElement(1, "ns2"));
 		namespaceList = newNamespace(elements);
 		assertFalse("List is empty.", isEmpty(namespaceList));
 	}

 	@Test
 	public void testGetList() throws Exception {
 		Object namespaceList = newNamespace(Collections.emptyList());

 		List<NamespaceElement> list = getList(namespaceList, null);
 		assertTrue("List is not empty.", list.isEmpty());
 		failAdd(list);

 		list = getList(namespaceList, "ns-1");
 		assertTrue("List is not empty.", list.isEmpty());
 		failAdd(list);

 		List<NamespaceElement> elements = populate(5, 10);

 		namespaceList = newNamespace(elements);

 		for (int i = 0; i < 10; i++) {
 			list = getList(namespaceList, "ns-" + i);
 			failAdd(list);
 			assertEquals("Wrong list.", populate(5, "ns-" + i), list);
 		}

 		list = getList(namespaceList, null);
 		failAdd(list);
 		assertEquals("Wrong list.", populate(5, 10), list);
 	}

 	@Test
 	public void testOutOfOrderNamespace() throws Exception {
 		List<NamespaceElement> elements = populate(4, 4);
 		randomListSort(elements);
 		Object namespaceList = newNamespace(elements);
 		for (int i = 0; i < 4; i++) {
 			List<NamespaceElement> list = getList(namespaceList, "ns-" + i);
 			failAdd(list);
 			// list is random order now, but should all have the same namespace
 			assertEquals("Wrong number of elements", 4, list.size());
 			for (NamespaceElement e : list) {
 				assertEquals("Wrong namespace", "ns-" + i, e.getNamespace());
 			}
 		}
 	}

 	@Test
 	public void testCreateBuilder() throws Exception {

 		List<NamespaceElement> elements = populate(5, 10);
 		Object namespaceList = newNamespace(elements);
 		Collection<NamespaceElement> builder = createBuilder(namespaceList);

 		Object buildNamespaceList = build(builder);

 		// The order of all elements should be maintained

 		assertEquals("Builder not populated correctly", getList(buildNamespaceList, null),
 				getList(namespaceList, null));
 	}

 	// --- uility methods ---

 	private void failAdd(List<NamespaceElement> list) {
 		NamespaceElement e = new NamespaceElement(0, "ns");
 		assertThrows(UnsupportedOperationException.class, () -> list.add(e));
 	}

 	static List<NamespaceElement> populate(int numElementsPerNS, int numNS) {
 		List<NamespaceElement> elements = new ArrayList<>(numElementsPerNS * numNS);
 		for (int namespace = 0; namespace < numNS; namespace++) {
 			for (int element = 0; element < numElementsPerNS; element++) {
 				elements.add(new NamespaceElement(element, "ns-" + namespace));
 			}
 		}
 		return elements;
 	}

 	static List<NamespaceElement> populate(int numElements, String namespace) {
 		List<NamespaceElement> elements = new ArrayList<>(numElements);
 		for (int element = 0; element < numElements; element++) {
 			elements.add(new NamespaceElement(element, namespace));
 		}
 		return elements;
 	}

 	static void randomListSort(List<NamespaceElement> elements) {
 		// random sort in reproducible order
 		Collections.shuffle(elements, new Random(43L));
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2021 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
	* Hannes Wellmann - Bug 573025: introduce and apply NamespaceList.Builder
	*******************************************************************************/
	package org.eclipse.osgi.tests.container;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertThrows;
	import static org.junit.Assert.assertTrue;

	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;
	import java.util.Objects;
	import java.util.Random;
	import java.util.function.Function;
	import java.util.function.Predicate;
	import org.junit.Test;
	import org.osgi.framework.Bundle;

	/**
	* Using reflection because to avoid exporting internals.
	*/
	public class NamespaceListTest extends AbstractTest {
	static final Method NAMESPACELIST_GET_LIST;
	static final Method NAMESPACELIST_IS_EMPTY;
	static final Method NAMESPACELIST_EMPTY;
	static final Method NAMESPACELIST_CREATE_BUILDER;

	// only access fields reflectively that are not part of the Collection-API
	static final Method BUILDER_CREATE;
	static final Method BUILDER_ADD_ALL;
	static final Method BUILDER_ADD_AFTER_LAST_MATCH;
	static final Method BUILDER_REMOVE_NAMESPACE_IF;
	static final Method BUILDER_REMOVE_ELEMENTS_OF_NAMESPACE_IF;
	static final Method BUILDER_BUILD;

	static {
	try {
	ClassLoader classLoader = Bundle.class.getClassLoader();
	Class<?> namespaceList = classLoader.loadClass("org.eclipse.osgi.internal.container.NamespaceList");
	Class<?> namespaceListBuilder = classLoader
	.loadClass("org.eclipse.osgi.internal.container.NamespaceList$Builder");

	NAMESPACELIST_GET_LIST = namespaceList.getMethod("getList", String.class);
	NAMESPACELIST_IS_EMPTY = namespaceList.getMethod("isEmpty");
	NAMESPACELIST_EMPTY = namespaceList.getMethod("empty", Function.class);
	NAMESPACELIST_CREATE_BUILDER = namespaceList.getMethod("createBuilder");

	BUILDER_CREATE = namespaceListBuilder.getMethod("create", Function.class);
	BUILDER_ADD_ALL = namespaceListBuilder.getMethod("addAll", namespaceList);
	BUILDER_ADD_AFTER_LAST_MATCH = namespaceListBuilder.getMethod("addAfterLastMatch", Object.class,
	Predicate.class);
	BUILDER_REMOVE_NAMESPACE_IF = namespaceListBuilder.getMethod("removeNamespaceIf", Predicate.class);
	BUILDER_REMOVE_ELEMENTS_OF_NAMESPACE_IF = namespaceListBuilder.getMethod("removeElementsOfNamespaceIf",
	String.class, Predicate.class);
	BUILDER_BUILD = namespaceListBuilder.getMethod("build");
	} catch (Throwable t) {
	throw new RuntimeException(t);
	}
	}

	static Object newNamespace(List<NamespaceElement> elements) throws Exception {
	Collection<NamespaceElement> builder = builderCreate();
	builder.addAll(elements);
	return build(builder);
	}

	// --- reflectively invoked methods of NamespaceList ---

	static <E> Object createEmptyNamespaceList(Function<E, String> getNamespace) throws Exception {
	return NAMESPACELIST_EMPTY.invoke(null, getNamespace);
	}

	static boolean isEmpty(Object namespaceList) throws Exception {
	return (boolean) NAMESPACELIST_IS_EMPTY.invoke(namespaceList);
	}

	static List<NamespaceElement> getList(Object namespaceList, String namespace) throws Exception {
	return (List<NamespaceElement>) NAMESPACELIST_GET_LIST.invoke(namespaceList, namespace);
	}

	static Collection<NamespaceElement> createBuilder(Object namespaceList) throws Exception {
	return (Collection<NamespaceElement>) NAMESPACELIST_CREATE_BUILDER.invoke(namespaceList);
	}

	// --- reflectively invoked non-Collection methods of NamespaceList$Builder ---

	static Collection<NamespaceElement> builderCreate() throws Exception {
	Function<NamespaceElement, String> getNamespace = NamespaceElement::getNamespace;
	return (Collection<NamespaceElement>) BUILDER_CREATE.invoke(null, getNamespace);
	}

	static <E> void builderAddAll(Collection<E> builder, Object namespaceList) throws Exception {
	BUILDER_ADD_ALL.invoke(builder, namespaceList);
	}

	static <E> void builderAddAfterLastMatch(Collection<E> builder, E e, Predicate<E> matcher) throws Exception {
	BUILDER_ADD_AFTER_LAST_MATCH.invoke(builder, e, matcher);
	}

	static <E> void builderRemoveNamespaceIf(Collection<E> builder, Predicate<String> filter) throws Exception {
	BUILDER_REMOVE_NAMESPACE_IF.invoke(builder, filter);
	}

	static <E> void builderRemoveElementsOfNamespaceIf(Collection<E> builder, String namespace, Predicate<E> filter)
	throws Exception {
	BUILDER_REMOVE_ELEMENTS_OF_NAMESPACE_IF.invoke(builder, namespace, filter);
	}

	static <E> Object build(Collection<E> builder) throws Exception {
	return BUILDER_BUILD.invoke(builder);
	}

	static class NamespaceElement {
	final int id;
	final String namespace;

	public NamespaceElement(int id, String namespace) {
	super();
	this.id = id;
	this.namespace = namespace;
	}

	public int getId() {
	return id;
	}

	public String getNamespace() {
	return namespace;
	}

	@Override
	public boolean equals(Object o) {
	if (o instanceof NamespaceElement) {
	NamespaceElement other = (NamespaceElement) o;
	return this.id == other.id && this.namespace.equals(other.namespace);
	}
	return false;
	}

	@Override
	public int hashCode() {
	return Objects.hash(namespace, id);
	}

	@Override
	public String toString() {
	return namespace + ':' + id;
	}
	}

	// --- tests ---

	@Test
	public void testCreateEmptyList() throws Exception {
	Object namespaceList = createEmptyNamespaceList(NamespaceElement::getNamespace);
	assertTrue("List is not empty.", isEmpty(namespaceList));
	}

	@Test
	public void testIsEmpty() throws Exception {
	Object namespaceList = newNamespace(Collections.emptyList());
	assertTrue("List is not empty.", isEmpty(namespaceList));

	List<NamespaceElement> elements = new ArrayList<>();
	elements.add(new NamespaceElement(0, "ns1"));
	namespaceList = newNamespace(elements);
	assertFalse("List is empty.", isEmpty(namespaceList));

	elements.add(new NamespaceElement(1, "ns2"));
	namespaceList = newNamespace(elements);
	assertFalse("List is empty.", isEmpty(namespaceList));
	}

	@Test
	public void testGetList() throws Exception {
	Object namespaceList = newNamespace(Collections.emptyList());

	List<NamespaceElement> list = getList(namespaceList, null);
	assertTrue("List is not empty.", list.isEmpty());
	failAdd(list);

	list = getList(namespaceList, "ns-1");
	assertTrue("List is not empty.", list.isEmpty());
	failAdd(list);

	List<NamespaceElement> elements = populate(5, 10);

	namespaceList = newNamespace(elements);

	for (int i = 0; i < 10; i++) {
	list = getList(namespaceList, "ns-" + i);
	failAdd(list);
	assertEquals("Wrong list.", populate(5, "ns-" + i), list);
	}

	list = getList(namespaceList, null);
	failAdd(list);
	assertEquals("Wrong list.", populate(5, 10), list);
	}

	@Test
	public void testOutOfOrderNamespace() throws Exception {
	List<NamespaceElement> elements = populate(4, 4);
	randomListSort(elements);
	Object namespaceList = newNamespace(elements);
	for (int i = 0; i < 4; i++) {
	List<NamespaceElement> list = getList(namespaceList, "ns-" + i);
	failAdd(list);
	// list is random order now, but should all have the same namespace
	assertEquals("Wrong number of elements", 4, list.size());
	for (NamespaceElement e : list) {
	assertEquals("Wrong namespace", "ns-" + i, e.getNamespace());
	}
	}
	}

	@Test
	public void testCreateBuilder() throws Exception {

	List<NamespaceElement> elements = populate(5, 10);
	Object namespaceList = newNamespace(elements);
	Collection<NamespaceElement> builder = createBuilder(namespaceList);

	Object buildNamespaceList = build(builder);

	// The order of all elements should be maintained

	assertEquals("Builder not populated correctly", getList(buildNamespaceList, null),
	getList(namespaceList, null));
	}

	// --- uility methods ---

	private void failAdd(List<NamespaceElement> list) {
	NamespaceElement e = new NamespaceElement(0, "ns");
	assertThrows(UnsupportedOperationException.class, () -> list.add(e));
	}

	static List<NamespaceElement> populate(int numElementsPerNS, int numNS) {
	List<NamespaceElement> elements = new ArrayList<>(numElementsPerNS * numNS);
	for (int namespace = 0; namespace < numNS; namespace++) {
	for (int element = 0; element < numElementsPerNS; element++) {
	elements.add(new NamespaceElement(element, "ns-" + namespace));
	}
	}
	return elements;
	}

	static List<NamespaceElement> populate(int numElements, String namespace) {
	List<NamespaceElement> elements = new ArrayList<>(numElements);
	for (int element = 0; element < numElements; element++) {
	elements.add(new NamespaceElement(element, namespace));
	}
	return elements;
	}

	static void randomListSort(List<NamespaceElement> elements) {
	// random sort in reproducible order
	Collections.shuffle(elements, new Random(43L));
	}
	}