/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */

package org.apache.tools.ant;

import java.io.File;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import org.apache.tools.ant.taskdefs.condition.Os;
import org.junit.Before;
import org.junit.ComparisonFailure;
import org.junit.Ignore;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;

import static org.hamcrest.Matchers.hasProperty;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;

/**
 * JUnit testcases for org.apache.tools.ant.IntrospectionHelper.
 *
 */

public class IntrospectionHelperTest {

    @Rule
    public ExpectedException thrown = ExpectedException.none();

    private Project p;
    private IntrospectionHelper ih;
    private static final String projectBasedir = File.separator;

    @Before
    public void setUp() {
        p = new Project();
        p.setBasedir(projectBasedir);
        ih = IntrospectionHelper.getHelper(getClass());
    }

    @Test
    public void testIsDynamic() {
        assertFalse("Not dynamic", ih.isDynamic());
    }

    @Test
    public void testIsContainer() {
        assertFalse("Not a container", ih.isContainer());
    }

    @Test
    public void testAddText() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(ComparisonFailure.class)));
        ih.addText(p, this, "test");
        ih.addText(p, this, "test2");
    }

    @Test(expected = BuildException.class)
    public void testAddTextToString() throws BuildException {
        ih = IntrospectionHelper.getHelper(String.class);
        ih.addText(p, "", "test");
    }

    @Ignore("This silently ignores a build exception")
    @Test(expected = BuildException.class)
    public void testGetAddTextMethod() {
        Method m = ih.getAddTextMethod();
        assertMethod(m, "addText", String.class, "test", "bing!");
        IntrospectionHelper.getHelper(String.class).getAddTextMethod();
    }

    @Test
    public void testSupportsCharacters() {
        assertTrue("IntrospectionHelperTest supports addText", ih.supportsCharacters());
        ih = IntrospectionHelper.getHelper(String.class);
        assertFalse("String doesn\'t support addText", ih.supportsCharacters());
    }

    public void addText(String text) {
        assertEquals("test", text);
    }

    /**
     * Fail: don't have element type one
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorOne() {
        ih.getElementType("one");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: createTwo takes arguments
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorTwo() {
        ih.getElementType("two");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: createThree returns void
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorThree() {
        ih.getElementType("three");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: createFour returns array
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorFour() {
        ih.getElementType("four");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: createFive returns primitive type
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorFive() {
        ih.getElementType("five");
        // TODO we should be asserting a value in here
    }

    @Test
    public void testElementCreatorSix() throws BuildException {
        assertEquals(String.class, ih.getElementType("six"));
        assertEquals("test", ih.createElement(p, this, "six"));
    }

    /**
     * Fail: addSeven takes two arguments
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorSeven() {
        ih.getElementType("seven");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: addEight takes no arguments
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorEight() {
        ih.getElementType("eight");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: addNine returns non void
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorNine() {
        ih.getElementType("nine");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: addTen takes array argument
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorTen() {
        ih.getElementType("ten");
        // TODO we should be asserting a value in here
    }

    /**
     * addEleven takes primitive argument
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorEleven() {
        ih.getElementType("eleven");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: no primitive constructor for java.lang.Class
     */
    @Test(expected = BuildException.class)
    public void testElementCreatorTwelve() throws BuildException {
        ih.getElementType("twelve");
        // TODO we should be asserting a value in here
    }

    @Test
    public void testElementCreatorThirteen() throws BuildException {
        assertEquals(StringBuffer.class, ih.getElementType("thirteen"));
        assertEquals("test", ih.createElement(p, this, "thirteen").toString());
    }

    /**
     * Fail: fourteen throws NullPointerException
     */
    @Test
    public void testElementCreatorFourteen() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(NullPointerException.class)));
        ih.createElement(p, this, "fourteen");
    }

    /**
     * Fail: fifteen throws NullPointerException
     */
    @Test
    public void testElementCreatorFifteen() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(NullPointerException.class)));
        ih.createElement(p, this, "fifteen");
    }

    private Map<String, Class<?>> getExpectedNestedElements() {
        Map<String, Class<?>> elemMap = new Hashtable<>();
        elemMap.put("six", String.class);
        elemMap.put("thirteen", StringBuffer.class);
        elemMap.put("fourteen", StringBuffer.class);
        elemMap.put("fifteen", StringBuffer.class);
        return elemMap;
    }

    @Test
    public void testGetNestedElements() {
        Map<String, Class<?>> elemMap = getExpectedNestedElements();
        for (String name : Collections.list(ih.getNestedElements())) {
            Class<?> expect = elemMap.get(name);
            assertNotNull("Support for " + name + " in IntrospectionHelperTest?",
                          expect);
            assertEquals("Return type of " + name, expect, ih.getElementType(name));
            elemMap.remove(name);
        }
        assertTrue("Found all", elemMap.isEmpty());
    }

    @Test(expected = UnsupportedOperationException.class)
    public void testGetNestedElementMap() {
        Map<String, Class<?>> elemMap = getExpectedNestedElements();
        Map<String, Class<?>> actualMap = ih.getNestedElementMap();
        actualMap.forEach((elemName, value) -> {
            Class<?> elemClass = elemMap.get(elemName);
            assertNotNull("Support for " + elemName + " in IntrospectionHelperTest?", elemClass);
            assertEquals("Type of " + elemName, elemClass, value);
            elemMap.remove(elemName);
        });
        assertTrue("Found all", elemMap.isEmpty());

        // Check it's a read-only map.
        actualMap.clear();
        // TODO we should be asserting a value somewhere in here
    }

    @Test
    public void testGetElementMethod() {
        assertElemMethod("six", "createSix", String.class, null);
        assertElemMethod("thirteen", "addThirteen", null, StringBuffer.class);
        assertElemMethod("fourteen", "addFourteen", null, StringBuffer.class);
        assertElemMethod("fifteen", "createFifteen", StringBuffer.class, null);
    }

    private void assertElemMethod(String elemName, String methodName,
                                  Class<?> returnType, Class<?> methodArg) {
        Method m = ih.getElementMethod(elemName);
        assertEquals("Method name", methodName, m.getName());
        Class<?> expectedReturnType = (returnType == null) ? Void.TYPE : returnType;
        assertEquals("Return type", expectedReturnType, m.getReturnType());
        Class<?>[] args = m.getParameterTypes();
        if (methodArg != null) {
            assertEquals("Arg Count", 1, args.length);
            assertEquals("Arg Type", methodArg, args[0]);
        } else {
            assertEquals("Arg Count", 0, args.length);
        }
    }

    public Object createTwo(String s) {
        return null;
    }

    public void createThree() {
    }

    public Object[] createFour() {
        return null;
    }

    public int createFive() {
        return 0;
    }

    public String createSix() {
        return "test";
    }

    public StringBuffer createFifteen() {
        throw new NullPointerException();
    }

    public void addSeven(String s, String s2) {
    }

    public void addEight() {
    }

    public String addNine(String s) {
        return null;
    }

    public void addTen(String[] s) {
    }

    public void addEleven(int i) {
    }

    public void addTwelve(Class<?> c) {
    }

    public void addThirteen(StringBuffer sb) {
        sb.append("test");
    }

    public void addFourteen(StringBuffer s) {
        throw new NullPointerException();
    }

    /**
     * Fail: setOne doesn't exist
     */
    @Test(expected = BuildException.class)
    public void testAttributeSetterOne() {
        ih.setAttribute(p, this, "one", "test");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: setTwo returns non void
     */
    @Test(expected = BuildException.class)
    public void testAttributeSetterTwo() {
        ih.setAttribute(p, this, "two", "test");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: setThree takes no args
     */
    @Test(expected = BuildException.class)
    public void testAttributeSetterThree() {
        ih.setAttribute(p, this, "three", "test");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: setFour takes two args
     */
    @Test(expected = BuildException.class)
    public void testAttributeSetterFour() {
        ih.setAttribute(p, this, "four", "test");
        //TODO we should be asserting a value in here
    }

    /**
     * Fail: setFive takes array arg
     */
    @Test(expected = BuildException.class)
    public void testAttributeSetterFive() {
        ih.setAttribute(p, this, "five", "test");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: Project doesn't have a String constructor
     */
    @Test(expected = BuildException.class)
    public void testAttributeSetterSix() {
        ih.setAttribute(p, this, "six", "test");
        // TODO we should be asserting a value in here
    }

    /**
     * Fail: 2 shouldn't be equal to three
     */
    @Test
    public void testAttributeSetterSeven() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(ComparisonFailure.class)));
        ih.setAttribute(p, this, "seven", "2");
        ih.setAttribute(p, this, "seven", "3");
    }

    /**
     * Fail: 2 shouldn't be equal to three as int
     */
    @Test
    public void testAttributeSetterEight() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "eight", "2");
        ih.setAttribute(p, this, "eight", "3");
    }

    /**
     * Fail: 2 shouldn't be equal to three as Integer
     */
    @Test
    public void testAttributeSetterNine() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "nine", "2");
        ih.setAttribute(p, this, "nine", "3");
    }

    /**
     * Fail: string + 2 shouldn't be equal to string + 3
     */
    @Test
    public void testAttributeSetterTen() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "ten", "2");
        ih.setAttribute(p, this, "ten", "3");
    }

    /**
     * Fail: on shouldn't be false
     */
    @Test
    public void testAttributeSetterEleven() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "eleven", "2");
        ih.setAttribute(p, this, "eleven", "on");
    }

    /**
     * Fail: on shouldn't be false
     */
    @Test
    public void testAttributeSetterTwelve() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "twelve", "2");
        ih.setAttribute(p, this, "twelve", "on");
    }

    /**
     * Fail: org.apache.tools.ant.Project shouldn't be equal to org.apache.tools.ant.ProjectHelper
     */
    @Test
    public void testAttributeSetterThirteen() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "thirteen", "org.apache.tools.ant.Project");
        ih.setAttribute(p, this, "thirteen", "org.apache.tools.ant.ProjectHelper");
    }

    /**
     * Fail: org.apache.tools.ant.Project2 doesn't exist
     */
    @Test
    public void testAttributeSetterThirteenNonExistentClass() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(ClassNotFoundException.class)));
        ih.setAttribute(p, this, "thirteen", "org.apache.tools.ant.Project2");
    }

    /**
     * Fail: 2 shouldn't be equal to three as StringBuffer
     */
    @Test
    public void testAttributeSetterFourteen() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(ComparisonFailure.class)));
        ih.setAttribute(p, this, "fourteen", "2");
            ih.setAttribute(p, this, "fourteen", "on");
    }

    /**
     * Fail: o shouldn't be equal to a
     */
    @Test
    public void testAttributeSetterFifteen() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "fifteen", "abcd");
        ih.setAttribute(p, this, "fifteen", "on");
    }

    /**
     * Fail: o shouldn't be equal to a
     */
    @Test
    public void testAttributeSetterSixteen() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "sixteen", "abcd");
        ih.setAttribute(p, this, "sixteen", "on");
    }

    /**
     * Fail: 17 shouldn't be equals to three
     */
    @Test
    public void testAttributeSetterSeventeen() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "seventeen", "17");
        ih.setAttribute(p, this, "seventeen", "3");
    }

    /**
     * Fail: 18 shouldn't be equals to three
     */
    @Test
    public void testAttributeSetterEighteen() {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "eightteen", "18");
        ih.setAttribute(p, this, "eightteen", "3");
    }

    /**
     * Fail: 19 shouldn't be equals to three
     */
    @Test
    public void testAttributeSetterNineteen() throws BuildException {
        thrown.expect(BuildException.class);
        thrown.expect(hasProperty("cause", instanceOf(AssertionError.class)));
        ih.setAttribute(p, this, "nineteen", "19");
        ih.setAttribute(p, this, "nineteen", "3");
    }

    private Map<String, Class<?>> getExpectedAttributes() {
        Map<String, Class<?>> attrMap = new Hashtable<>();
        attrMap.put("seven", String.class);
        attrMap.put("eight", Integer.TYPE);
        attrMap.put("nine", Integer.class);
        attrMap.put("ten", File.class);
        attrMap.put("eleven", Boolean.TYPE);
        attrMap.put("twelve", Boolean.class);
        attrMap.put("thirteen", Class.class);
        attrMap.put("fourteen", StringBuffer.class);
        attrMap.put("fifteen", Character.TYPE);
        attrMap.put("sixteen", Character.class);
        attrMap.put("seventeen", Byte.TYPE);
        attrMap.put("eightteen", Short.TYPE);
        attrMap.put("nineteen", Double.TYPE);
        attrMap.put("twenty", Path.class);

        /*
         * JUnit 3.7 adds a getName method to TestCase - so we now
         * have a name attribute in IntrospectionHelperTest.
         *
         * Simply add it here and remove it after the tests.
         */
        attrMap.put("name", String.class);

        return attrMap;
    }

    @Test
    public void testGetAttributes() {
        Map<String, Class<?>> attrMap = getExpectedAttributes();
        for (String name : Collections.list(ih.getAttributes())) {
            Class<?> expect = attrMap.get(name);
            assertNotNull("Support for " + name + " in IntrospectionHelperTest?",
                          expect);
            assertEquals("Type of " + name, expect, ih.getAttributeType(name));
            attrMap.remove(name);
        }
        attrMap.remove("name");
        assertTrue("Found all", attrMap.isEmpty());
    }

    @Test
    public void testGetAttributeMap() {
        Map<String, Class<?>> attrMap = getExpectedAttributes();
        ih.getAttributeMap().forEach((attrName, value) -> {
            Class<?> attrClass = attrMap.get(attrName);
            assertNotNull("Support for " + attrName + " in IntrospectionHelperTest?", attrClass);
            assertEquals("Type of " + attrName, attrClass, value);
            attrMap.remove(attrName);
        });
        attrMap.remove("name");
        assertTrue("Found all", attrMap.isEmpty());
    }

    @Test
    public void testClearGetAttributeMap() {
        thrown.expect(UnsupportedOperationException.class);
        // TODO we should be asserting a value somewhere in here
        // Check it's a read-only map.
        ih.getAttributeMap().clear();
    }

    @Test
    public void testGetAttributeMethod() {
        assertAttrMethod("seven", "setSeven", String.class,
                "2", "3");
        assertAttrMethod("eight", "setEight", Integer.TYPE,
                2, 3);
        assertAttrMethod("nine", "setNine", Integer.class,
                2, 3);
        assertAttrMethod("ten", "setTen", File.class,
                new File(projectBasedir + 2), new File("toto"));
        assertAttrMethod("eleven", "setEleven", Boolean.TYPE,
                Boolean.FALSE, Boolean.TRUE);
        assertAttrMethod("twelve", "setTwelve", Boolean.class,
                Boolean.FALSE, Boolean.TRUE);
        assertAttrMethod("thirteen", "setThirteen", Class.class,
                Project.class, Map.class);
        assertAttrMethod("fourteen", "setFourteen", StringBuffer.class,
                new StringBuffer("2"), new StringBuffer("3"));
        assertAttrMethod("fifteen", "setFifteen", Character.TYPE,
                'a', 'b');
        assertAttrMethod("sixteen", "setSixteen", Character.class,
                'a', 'b');
        assertAttrMethod("seventeen", "setSeventeen", Byte.TYPE,
                (byte) 17, (byte) 10);
        assertAttrMethod("eightteen", "setEightteen", Short.TYPE,
                (short) 18, (short) 10);
        assertAttrMethod("nineteen", "setNineteen", Double.TYPE,
                19d, (double) (short) 10);
        assertAttrMethod("twenty", "setTwenty", Path.class,
                new File(projectBasedir + 20).toPath(), Paths.get("toto"));

        thrown.expect(BuildException.class);
        thrown.expectMessage("doesn't support the \"onehundred\" attribute.");
        assertAttrMethod("onehundred", null, null, null, null);
    }

    private void assertAttrMethod(String attrName, String methodName,
                                  Class<?> methodArg, Object arg, Object badArg) {
        assertMethod(ih.getAttributeMethod(attrName), methodName, methodArg, arg, badArg);
    }

    public int setTwo(String s) {
        return 0;
    }

    public void setThree() {
    }

    public void setFour(String s1, String s2) {
    }

    public void setFive(String[] s) {
    }

    public void setSix(Project p) {
    }

    public void setSeven(String s) {
        assertEquals("2", s);
    }

    public void setEight(int i) {
        assertEquals(2, i);
    }

    public void setNine(Integer i) {
        assertEquals(2, i.intValue());
    }

    public void setTen(File f) {
        String path = f.getAbsolutePath();
        if (Os.isFamily("unix") || Os.isFamily("openvms")) {
            assertEquals(projectBasedir + "2", path);
        } else if (Os.isFamily("netware")) {
            assertEquals(projectBasedir + "2", path.toLowerCase(Locale.US));
        } else {
            assertEquals(":" + projectBasedir + "2",
                         path.toLowerCase(Locale.US).substring(1));
        }
    }

    public void setEleven(boolean b) {
        assertFalse(b);
    }

    public void setTwelve(Boolean b) {
        assertFalse(b);
    }

    public void setThirteen(Class<?> c) {
        assertEquals(Project.class, c);
    }

    public void setFourteen(StringBuffer sb) {
        assertEquals("2", sb.toString());
    }

    public void setFifteen(char c) {
        assertEquals(c, 'a');
    }

    public void setSixteen(Character c) {
        assertEquals(c.charValue(), 'a');
    }

    public void setSeventeen(byte b) {
        assertEquals(17, b);
    }

    public void setEightteen(short s) {
        assertEquals(18, s);
    }

    public void setNineteen(double d) {
        double diff = d - 19;
        assertTrue("Expected 19, received " + d, diff > -1e-6 && diff < 1e-6);
    }

    public void setTwenty(Path p) {
        String path = p.toAbsolutePath().toString();
        if (Os.isFamily("unix") || Os.isFamily("openvms")) {
            assertEquals(projectBasedir + "20", path);
        } else if (Os.isFamily("netware")) {
            assertEquals(projectBasedir + "20", path.toLowerCase(Locale.US));
        } else {
            assertEquals(":" + projectBasedir + "20",
                         path.toLowerCase(Locale.US).substring(1));
        }
    }

    @Test
    public void testGetExtensionPoints() {
        List<Method> extensions = ih.getExtensionPoints();
        final int adders = 2;
        assertEquals("extension count", adders, extensions.size());

        // this original test assumed something about the order of
        // add(Number) and addConfigured(Map) returned by reflection.
        // Unfortunately the assumption doesn't hold for all VMs
        // (failed on MacOS X using JDK 1.4.2_05) and the possible
        // combinatorics are too hard to check.  We really only want
        // to ensure that the more derived Hashtable can be found
        // before Map.
        // assertMethod(extensions.get(0), "add", Number.class, new Integer(2), new Integer(3));

        // addConfigured(Hashtable) should come before addConfigured(Map)
        assertMethod(extensions.get(adders - 2),
                        "addConfigured", Hashtable.class,
                        makeTable("key", "value"), makeTable("1", "2"));

        assertMethod(extensions.get(adders - 1), "addConfigured", Map.class,
                        new HashMap<String, String>(), makeTable("1", "2"));
    }

    private void assertMethod(Method m, String methodName, Class<?> methodArg,
                              Object arg, Object badArg) {
        assertEquals("Method name", methodName, m.getName());
        assertEquals("Return type", Void.TYPE, m.getReturnType());
        Class<?>[] args = m.getParameterTypes();
        assertEquals("Arg Count", 1, args.length);
        assertEquals("Arg Type", methodArg, args[0]);

        try {
            m.invoke(this, arg);
        } catch (IllegalAccessException | InvocationTargetException e) {
            throw new BuildException(e);
        }

        try {
            m.invoke(this, badArg);
        } catch (IllegalAccessException e) {
            throw new BuildException(e);
        } catch (InvocationTargetException e) {
            assertThat(e, hasProperty("cause", instanceOf(AssertionError.class)));
        }
    }

    public List<Object> add(List<Object> l) {
        // INVALID extension point
        return null;
    }

    // see comments in testGetExtensionPoints
//    public void add(Number n) {
//        // Valid extension point
//        assertEquals(2, n.intValue());
//    }

    public void add(List<Object> l, int i) {
        // INVALID extension point
    }

    public void addConfigured(Map<Object, Object> m) {
        // Valid extension point
        assertTrue(m.isEmpty());
    }

    public void addConfigured(Hashtable<String, String> h) {
        // Valid extension point, more derived than Map above, but *after* it!
        assertEquals(makeTable("key", "value"), h);
    }

    private Hashtable<String, String> makeTable(String key, String value) {
        Hashtable<String, String> table = new Hashtable<>();
        table.put(key, value);
        return table;
    }

}
