/*
 * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Oracle - initial API and implementation from Oracle TopLink
package org.eclipse.persistence.testing.tests.identitymaps;

import java.util.Vector;
import java.util.Enumeration;
import java.util.Hashtable;
import org.eclipse.persistence.testing.framework.*;
import org.eclipse.persistence.internal.identitymaps.*;

/**
 * Register multiple objects in an identity map.
 * <p>
 * FullIdentityMap should store and correctly maintain identity for all objects.
 * NoIdentityMap should not store or maintain identity for any objects.
 * Fixed size identity maps should correctly store all objects,
 * but only retain their specified fixed size number of objects.
*/
public class MultipleRegisterTest extends TestCase {
    IdentityMap map;
    Vector primaryKeys;
    Vector originalObjects;
    Vector retrievedObjects;

    public MultipleRegisterTest(IdentityMap map, Vector keys, Vector testObjects) {
        this.map = map;
        primaryKeys = keys;
        originalObjects = testObjects;
    }

    @Override
    public void test() {
        for (int index = 0; index < primaryKeys.size(); index++) {
            Vector key = (Vector)primaryKeys.elementAt(index);
            Object value = originalObjects.elementAt(index);
            map.put(key, value, null, 0);
        }

        retrievedObjects = new Vector();
        for (int index = 0; index < primaryKeys.size(); index++) {
            Vector key = (Vector)primaryKeys.elementAt(index);
            Object value = map.get(key);
            retrievedObjects.addElement(value);
        }
    }

    @Override
    public void verify() {
        if (map instanceof NoIdentityMap) {
            verify((NoIdentityMap)map);
        } else if (map instanceof CacheIdentityMap) {
            verifyFixedSize();
        } else {
            if (originalObjects.size() != retrievedObjects.size()) {
                throw new TestErrorException(originalObjects.size() + " objects were registered " + "in the identity map but only " + retrievedObjects.size() + " were retrieved.");
            }

            Hashtable mismatches = verifyObjectIdentity();
            if (mismatches.size() != 0) {
                throw new TestErrorException(mismatches.size() + " mismatches occurred while" + " retrieving objects from a full identity map. The mismatches are " + mismatches + ".");
            }
        }
    }

    public void verify(NoIdentityMap map) {
        if (map.getSize() != 0) {
            throw new TestErrorException("Objects were registered in a NoIdentityMap " + "but there are " + map.getSize() + " objects in the map.");
        }

        Enumeration values = retrievedObjects.elements();
        while (values.hasMoreElements()) {
            if (values.nextElement() != null) {
                throw new TestErrorException("A non-null value was retrieved from a no identity map.");
            }
        }
    }

    public void verifyFixedSize() {
        if (!(map.getSize() <= map.getMaxSize())) {
            throw new TestErrorException("Fixed size identity map " + map + " contains " + map.getSize() + " objects. " + "The specified maximum size for this map is " + map.getMaxSize() + ".");
        }

        Hashtable mismatches = verifyObjectIdentity();
        int expectedMismatches = originalObjects.size() - map.getMaxSize();
        if (mismatches.size() != expectedMismatches) {
            throw new TestErrorException(mismatches.size() + "mismatches occurred while" + "retrieving objects from the identity map. " + expectedMismatches + "were expected. The mismatches were " + mismatches + ".");
        }
    }

    public Hashtable verifyObjectIdentity() {
        Hashtable mismatches = new Hashtable();

        for (int index = 0; index < originalObjects.size(); index++) {
            Object original = originalObjects.elementAt(index);
            Object retrieved = retrievedObjects.elementAt(index);
            if (original != retrieved) {
                mismatches.put(original, retrieved);
            }
        }

        return mismatches;
    }
}