jdk/test/java/net/httpclient/TestKit.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * 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.
  */

 import java.util.AbstractMap;
 import java.util.Collection;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.function.Supplier;
 import java.util.regex.Pattern;

 import static java.util.Collections.emptyList;
 import static java.util.Collections.singleton;
 import static java.util.Objects.requireNonNull;

 //
 // A set of testing utility functions
 //
 public final class TestKit {

     private TestKit() { }

     public static void assertNotThrows(ThrowingProcedure code) {
         requireNonNull(code, "code");
         assertNotThrows(() -> {
             code.run();
             return null;
         });
     }

     public static <V> V assertNotThrows(ThrowingFunction<V> code) {
         requireNonNull(code, "code");
         try {
             return code.run();
         } catch (Throwable t) {
             throw new RuntimeException("Expected to run normally, but threw "
                     + t.getClass().getCanonicalName(), t);
         }
     }

     public static <T extends Throwable> T assertThrows(Class<T> clazz,
                                                        ThrowingProcedure code) {
         requireNonNull(clazz, "clazz");
         requireNonNull(code, "code");
         try {
             code.run();
         } catch (Throwable t) {
             if (clazz.isInstance(t)) {
                 return clazz.cast(t);
             }
             throw new RuntimeException("Expected to catch an exception of type "
                     + clazz.getCanonicalName() + ", but caught "
                     + t.getClass().getCanonicalName(), t);

         }
         throw new RuntimeException("Expected to catch an exception of type "
                 + clazz.getCanonicalName() + ", but caught nothing");
     }

     public interface ThrowingProcedure {
         void run() throws Throwable;
     }

     public interface ThrowingFunction<V> {
         V run() throws Throwable;
     }

     // The rationale behind asking for a regex is to not pollute variable names
     // space in the scope of assertion: if it's something as simple as checking
     // a message, we can do it inside
     public static <T extends Throwable> T assertThrows(Class<T> clazz,
                                                        String messageRegex,
                                                        ThrowingProcedure code) {
         requireNonNull(messageRegex, "messagePattern");
         T t = assertThrows(clazz, code);
         String m = t.getMessage();
         if (m == null) {
             throw new RuntimeException(String.format(
                     "Expected exception message to match the regex '%s', " +
                             "but the message was null", messageRegex), t);
         }
         if (!Pattern.matches(messageRegex, m)) {
             throw new RuntimeException(String.format(
                     "Expected exception message to match the regex '%s', " +
                             "actual message: %s", messageRegex, m), t);
         }
         return t;
     }

     /*
      * Asserts that the given Collection is unmodifiable: any mutator method
      * throw an UnsupportedOperationException unconditionally.
      */
     public static void assertUnmodifiableCollection(Collection<?> collection) {
         assertUnmodifiableCollection(collection, () -> null);
     }

     public static <E> void assertUnmodifiableCollection(Collection<E> collection,
                                                         Supplier<? extends E> elementsFactory) {
         requireNonNull(collection, "collection");
         requireNonNull(elementsFactory, "elementsFactory");

         E e = elementsFactory.get();

         assertUOE(() -> collection.add(e));
         assertUOE(() -> collection.addAll(singleton(e)));
         Iterator<?> i = collection.iterator();
         if (i.hasNext()) {
             i.next();
             assertUOE(i::remove);
         }
         assertUOE(collection::clear);
         assertUOE(() -> collection.remove(e));
         assertUOE(() -> collection.removeAll(singleton(e)));
         assertUOE(() -> collection.removeIf(x -> true));
         assertUOE(() -> collection.retainAll(emptyList()));
         // No need to check toArray methods, since API guarantees arrays
         // returned by them are "safe"
     }

     public static void assertUnmodifiableSet(Set<?> set) {
         assertUnmodifiableCollection(set, () -> null);
     }

     public static <E> void assertUnmodifiableSet(Set<E> set,
                                                  Supplier<? extends E> elementsFactory) {
         assertUnmodifiableCollection(set, elementsFactory);
     }

     public static void assertUnmodifiableList(List<?> list) {
         assertUnmodifiableList(list, () -> null);
     }

     public static <E> void assertUnmodifiableList(List<E> list,
                                                   Supplier<? extends E> elementsFactory) {
         assertUnmodifiableList(list, elementsFactory, 3); // This list, its sublist and its sublist's sublist
     }

     private static <E> void assertUnmodifiableList(List<E> list,
                                                    Supplier<? extends E> elementsFactory,
                                                    int depth) {
         requireNonNull(list, "list");
         requireNonNull(elementsFactory, "elementsFactory");
         if (depth < 0) {
             throw new IllegalArgumentException("depth: " + depth);
         }
         if (depth == 0) {
             return;
         }

         E e = elementsFactory.get();

         assertUnmodifiableCollection(list, elementsFactory);
         assertUOE(() -> list.add(0, e));
         assertUOE(() -> list.addAll(0, singleton(e)));

         ListIterator<E> i = list.listIterator();
         if (i.hasNext()) {
             i.next();
             assertUOE(i::remove);
             assertUOE(() -> i.set(e));
             assertUOE(() -> i.add(e));
         }
         assertUOE(() -> list.remove((int) 0));
         assertUOE(() -> list.replaceAll(x -> e));
         assertUOE(() -> list.set(0, e));

         // Any non-null general-purpose Comparator would do
         Comparator<Object> comparator = (a, b) -> Objects.hash(a, b);
         assertUOE(() -> list.sort(comparator));

         assertUnmodifiableList(list.subList(0, list.size()), elementsFactory, depth - 1);
     }

     public static void assertUnmodifiableMap(Map<?, ?> map) {
         assertUnmodifiableMap(map, () -> new AbstractMap.SimpleImmutableEntry<>(null, null));
     }

     public static <K, V> void assertUnmodifiableMap(Map<K, V> map,
                                                     Supplier<? extends Map.Entry<? extends K, ? extends V>> entriesFactory) {
         requireNonNull(map, "map");
         requireNonNull(entriesFactory, "entriesFactory");
         assertUOE(map::clear);

         Map.Entry<? extends K, ? extends V> e1 = entriesFactory.get();
         K k = e1.getKey();
         V v = e1.getValue();

         assertUOE(() -> map.compute(k, (k1, v1) -> v));
         assertUOE(() -> map.computeIfAbsent(k, (k1) -> v));
         assertUOE(() -> map.computeIfPresent(k, (k1, v1) -> v));

         Set<Map.Entry<K, V>> entrySet = map.entrySet();
         assertUnmodifiableSet(entrySet);
         for (Map.Entry<K, V> e : entrySet) {
             assertUOE(() -> e.setValue(null));
         }

         assertUnmodifiableSet(map.keySet());
         assertUOE(() -> map.merge(k, v, (k1, v1) -> v));
         assertUOE(() -> map.put(k, v));
         // Map.of(k, v) wouldn't do, as it doesn't permit nulls
         Map<K, V> m = new HashMap<>();
         m.put(k, v);
         assertUOE(() -> map.putAll(m));
         assertUOE(() -> map.putIfAbsent(k, v));
         assertUOE(() -> map.remove(k));
         assertUOE(() -> map.remove(k, v));
         assertUOE(() -> map.replace(k, v));
         assertUOE(() -> map.replace(k, v, v));
         assertUOE(() -> map.replaceAll((k1, v1) -> v));
         assertUnmodifiableCollection(map.values());
     }

     public static void assertUOE(ThrowingProcedure code) {
         assertThrows(UnsupportedOperationException.class, code);
     }
 }
	/*
	* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* 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.
	*/

	import java.util.AbstractMap;
	import java.util.Collection;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.ListIterator;
	import java.util.Map;
	import java.util.Objects;
	import java.util.Set;
	import java.util.function.Supplier;
	import java.util.regex.Pattern;

	import static java.util.Collections.emptyList;
	import static java.util.Collections.singleton;
	import static java.util.Objects.requireNonNull;

	//
	// A set of testing utility functions
	//
	public final class TestKit {

	private TestKit() { }

	public static void assertNotThrows(ThrowingProcedure code) {
	requireNonNull(code, "code");
	assertNotThrows(() -> {
	code.run();
	return null;
	});
	}

	public static <V> V assertNotThrows(ThrowingFunction<V> code) {
	requireNonNull(code, "code");
	try {
	return code.run();
	} catch (Throwable t) {
	throw new RuntimeException("Expected to run normally, but threw "
	+ t.getClass().getCanonicalName(), t);
	}
	}

	public static <T extends Throwable> T assertThrows(Class<T> clazz,
	ThrowingProcedure code) {
	requireNonNull(clazz, "clazz");
	requireNonNull(code, "code");
	try {
	code.run();
	} catch (Throwable t) {
	if (clazz.isInstance(t)) {
	return clazz.cast(t);
	}
	throw new RuntimeException("Expected to catch an exception of type "
	+ clazz.getCanonicalName() + ", but caught "
	+ t.getClass().getCanonicalName(), t);

	}
	throw new RuntimeException("Expected to catch an exception of type "
	+ clazz.getCanonicalName() + ", but caught nothing");
	}

	public interface ThrowingProcedure {
	void run() throws Throwable;
	}

	public interface ThrowingFunction<V> {
	V run() throws Throwable;
	}

	// The rationale behind asking for a regex is to not pollute variable names
	// space in the scope of assertion: if it's something as simple as checking
	// a message, we can do it inside
	public static <T extends Throwable> T assertThrows(Class<T> clazz,
	String messageRegex,
	ThrowingProcedure code) {
	requireNonNull(messageRegex, "messagePattern");
	T t = assertThrows(clazz, code);
	String m = t.getMessage();
	if (m == null) {
	throw new RuntimeException(String.format(
	"Expected exception message to match the regex '%s', " +
	"but the message was null", messageRegex), t);
	}
	if (!Pattern.matches(messageRegex, m)) {
	throw new RuntimeException(String.format(
	"Expected exception message to match the regex '%s', " +
	"actual message: %s", messageRegex, m), t);
	}
	return t;
	}

	/*
	* Asserts that the given Collection is unmodifiable: any mutator method
	* throw an UnsupportedOperationException unconditionally.
	*/
	public static void assertUnmodifiableCollection(Collection<?> collection) {
	assertUnmodifiableCollection(collection, () -> null);
	}

	public static <E> void assertUnmodifiableCollection(Collection<E> collection,
	Supplier<? extends E> elementsFactory) {
	requireNonNull(collection, "collection");
	requireNonNull(elementsFactory, "elementsFactory");

	E e = elementsFactory.get();

	assertUOE(() -> collection.add(e));
	assertUOE(() -> collection.addAll(singleton(e)));
	Iterator<?> i = collection.iterator();
	if (i.hasNext()) {
	i.next();
	assertUOE(i::remove);
	}
	assertUOE(collection::clear);
	assertUOE(() -> collection.remove(e));
	assertUOE(() -> collection.removeAll(singleton(e)));
	assertUOE(() -> collection.removeIf(x -> true));
	assertUOE(() -> collection.retainAll(emptyList()));
	// No need to check toArray methods, since API guarantees arrays
	// returned by them are "safe"
	}

	public static void assertUnmodifiableSet(Set<?> set) {
	assertUnmodifiableCollection(set, () -> null);
	}

	public static <E> void assertUnmodifiableSet(Set<E> set,
	Supplier<? extends E> elementsFactory) {
	assertUnmodifiableCollection(set, elementsFactory);
	}

	public static void assertUnmodifiableList(List<?> list) {
	assertUnmodifiableList(list, () -> null);
	}

	public static <E> void assertUnmodifiableList(List<E> list,
	Supplier<? extends E> elementsFactory) {
	assertUnmodifiableList(list, elementsFactory, 3); // This list, its sublist and its sublist's sublist
	}

	private static <E> void assertUnmodifiableList(List<E> list,
	Supplier<? extends E> elementsFactory,
	int depth) {
	requireNonNull(list, "list");
	requireNonNull(elementsFactory, "elementsFactory");
	if (depth < 0) {
	throw new IllegalArgumentException("depth: " + depth);
	}
	if (depth == 0) {
	return;
	}

	E e = elementsFactory.get();

	assertUnmodifiableCollection(list, elementsFactory);
	assertUOE(() -> list.add(0, e));
	assertUOE(() -> list.addAll(0, singleton(e)));

	ListIterator<E> i = list.listIterator();
	if (i.hasNext()) {
	i.next();
	assertUOE(i::remove);
	assertUOE(() -> i.set(e));
	assertUOE(() -> i.add(e));
	}
	assertUOE(() -> list.remove((int) 0));
	assertUOE(() -> list.replaceAll(x -> e));
	assertUOE(() -> list.set(0, e));

	// Any non-null general-purpose Comparator would do
	Comparator<Object> comparator = (a, b) -> Objects.hash(a, b);
	assertUOE(() -> list.sort(comparator));

	assertUnmodifiableList(list.subList(0, list.size()), elementsFactory, depth - 1);
	}

	public static void assertUnmodifiableMap(Map<?, ?> map) {
	assertUnmodifiableMap(map, () -> new AbstractMap.SimpleImmutableEntry<>(null, null));
	}

	public static <K, V> void assertUnmodifiableMap(Map<K, V> map,
	Supplier<? extends Map.Entry<? extends K, ? extends V>> entriesFactory) {
	requireNonNull(map, "map");
	requireNonNull(entriesFactory, "entriesFactory");
	assertUOE(map::clear);

	Map.Entry<? extends K, ? extends V> e1 = entriesFactory.get();
	K k = e1.getKey();
	V v = e1.getValue();

	assertUOE(() -> map.compute(k, (k1, v1) -> v));
	assertUOE(() -> map.computeIfAbsent(k, (k1) -> v));
	assertUOE(() -> map.computeIfPresent(k, (k1, v1) -> v));

	Set<Map.Entry<K, V>> entrySet = map.entrySet();
	assertUnmodifiableSet(entrySet);
	for (Map.Entry<K, V> e : entrySet) {
	assertUOE(() -> e.setValue(null));
	}

	assertUnmodifiableSet(map.keySet());
	assertUOE(() -> map.merge(k, v, (k1, v1) -> v));
	assertUOE(() -> map.put(k, v));
	// Map.of(k, v) wouldn't do, as it doesn't permit nulls
	Map<K, V> m = new HashMap<>();
	m.put(k, v);
	assertUOE(() -> map.putAll(m));
	assertUOE(() -> map.putIfAbsent(k, v));
	assertUOE(() -> map.remove(k));
	assertUOE(() -> map.remove(k, v));
	assertUOE(() -> map.replace(k, v));
	assertUOE(() -> map.replace(k, v, v));
	assertUOE(() -> map.replaceAll((k1, v1) -> v));
	assertUnmodifiableCollection(map.values());
	}

	public static void assertUOE(ThrowingProcedure code) {
	assertThrows(UnsupportedOperationException.class, code);
	}
	}