Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/Java/Openjdk/test/jdk/java/util/LinkedHashMap/ (Sun/Oracle ^©) Datei vom 13.11.2022 mit Größe 12 kB

Quelle Basic.java Sprache: JAVA

/*
* Copyright (c) 2000, 2013, 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.
*/

/*
* @test
* @bug 4245809 8029795
* @summary Basic test for LinkedHashMap.  (Based on MapBash)
*/

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Random;
import java.util.Set;
import java.util.function.BiFunction;

public class Basic {
    static final Random rnd = new Random(666);
    static final Integer nil = new Integer(0);

    public static void main(String[] args)  throws Exception {
        int numItr =  500;
        int mapSize = 500;

        // Linked List testk
        for (int i=0; i<numItr; i++) {
            Map<Integer,Integer> m = new LinkedHashMap();
            Integer head = nil;

            for (int j=0; j<mapSize; j++) {
                Integer newHead;
                do {
                    newHead = new Integer(rnd.nextInt());
                } while (m.containsKey(newHead));
                m.put(newHead, head);
                head = newHead;
            }
            if (m.size() != mapSize)
                throw new Exception("Size not as expected.");

            if (new HashMap(m).hashCode() != m.hashCode())
                throw new Exception("Incorrect hashCode computation.");

            Map<Integer,Integer> m2 = new LinkedHashMap(); m2.putAll(m);
            m2.values().removeAll(m.keySet());
            if (m2.size()!= 1 || !m2.containsValue(nil))
                throw new Exception("Collection views test failed.");

            int j=0;
            while (head != nil) {
                if (!m.containsKey(head))
                    throw new Exception("Linked list doesn't contain a link.");
                Integer newHead = m.get(head);
                if (newHead == null)
                    throw new Exception("Could not retrieve a link.");
                m.remove(head);
                head = newHead;
                j++;
            }
            if (!m.isEmpty())
                throw new Exception("Map nonempty after removing all links.");
            if (j != mapSize)
                throw new Exception("Linked list size not as expected.");
        }

        Map<Integer,Integer> m = new LinkedHashMap();
        for (int i=0; i<mapSize; i++)
            if (m.put(new Integer(i), new Integer(2*i)) != null)
                throw new Exception("put returns non-null value erroneously.");
        for (int i=0; i<2*mapSize; i++)
            if (m.containsValue(new Integer(i)) != (i%2==0))
                throw new Exception("contains value "+i);
        if (m.put(nil, nil) == null)
            throw new Exception("put returns a null value erroneously.");
        Map<Integer,Integer> m2 = new LinkedHashMap(); m2.putAll(m);
        if (!m.equals(m2))
            throw new Exception("Clone not equal to original. (1)");
        if (!m2.equals(m))
            throw new Exception("Clone not equal to original. (2)");
        Set<Map.Entry<Integer,Integer>> s = m.entrySet(), s2 = m2.entrySet();
        if (!s.equals(s2))
            throw new Exception("Clone not equal to original. (3)");
        if (!s2.equals(s))
            throw new Exception("Clone not equal to original. (4)");
        if (!s.containsAll(s2))
            throw new Exception("Original doesn't contain clone!");
        if (!s2.containsAll(s))
            throw new Exception("Clone doesn't contain original!");

        m2 = serClone(m);
        if (!m.equals(m2))
            throw new Exception("Serialize Clone not equal to original. (1)");
        if (!m2.equals(m))
            throw new Exception("Serialize Clone not equal to original. (2)");
        s = m.entrySet(); s2 = m2.entrySet();
        if (!s.equals(s2))
            throw new Exception("Serialize Clone not equal to original. (3)");
        if (!s2.equals(s))
            throw new Exception("Serialize Clone not equal to original. (4)");
        if (!s.containsAll(s2))
            throw new Exception("Original doesn't contain Serialize clone!");
        if (!s2.containsAll(s))
            throw new Exception("Serialize Clone doesn't contain original!");

        s2.removeAll(s);
        if (!m2.isEmpty())
            throw new Exception("entrySet().removeAll failed.");

        m2.putAll(m);
        m2.clear();
        if (!m2.isEmpty())
            throw new Exception("clear failed.");

        Iterator it = m.entrySet().iterator();
        while (it.hasNext()) {
            it.next();
            it.remove();
        }
        if (!m.isEmpty())
            throw new Exception("Iterator.remove() failed");

        // Test ordering properties with insert order
        m = new LinkedHashMap();
        List<Integer> l = new ArrayList(mapSize);
        for (int i=0; i<mapSize; i++) {
            Integer x = new Integer(i);
            m.put(x, x);
            l.add(x);
        }
        if (!new ArrayList(m.keySet()).equals(l))
            throw new Exception("Insertion order not preserved.");
        for (int i=mapSize-1; i>=0; i--) {
            Integer x = (Integer) l.get(i);
            if (!m.get(x).equals(x))
                throw new Exception("Wrong value: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m.keySet()).equals(l))
            throw new Exception("Insertion order not preserved after read.");

        for (int i=mapSize-1; i>=0; i--) {
            Integer x = (Integer) l.get(i);
            m.put(x, x);
        }
        if (!new ArrayList(m.keySet()).equals(l))
            throw new Exception("Insert order not preserved after reinsert.");

        m2 = (Map) ((LinkedHashMap)m).clone();
        if (!m.equals(m2))
            throw new Exception("Insert-order Map != clone.");

        List<Integer> l2 = new ArrayList(l);
        Collections.shuffle(l2);
        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l2.get(i);
            if (!m2.get(x).equals(x))
              throw new Exception("Clone: Wrong val: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m2.keySet()).equals(l))
            throw new Exception("Clone: altered by read.");

        // Test ordering properties with access order
        m = new LinkedHashMap(2*mapSize, .75f, true);
        for (int i=0; i<mapSize; i++) {
            Integer x = new Integer(i);
            m.put(x, x);
        }
        if (!new ArrayList(m.keySet()).equals(l))
            throw new Exception("Insertion order not properly preserved.");

        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l2.get(i);
            if (!m.get(x).equals(x))
                throw new Exception("Wrong value: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m.keySet()).equals(l2))
            throw new Exception("Insert order not properly altered by read.");

        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l2.get(i);
            if (!m.getOrDefault(x, new Integer(i + 1000)).equals(x))
                throw new Exception("Wrong value: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m.keySet()).equals(l2))
            throw new Exception("Insert order not properly altered by read.");

        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l2.get(i);
            if (!m.replace(x, x).equals(x))
                throw new Exception("Wrong value: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m.keySet()).equals(l2))
            throw new Exception("Insert order not properly altered by replace.");

        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l2.get(i);
            if (!m.replace(x, x, x))
                throw new Exception("Wrong value: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m.keySet()).equals(l2))
            throw new Exception("Insert order not properly altered by replace.");

        BiFunction<Integer,Integer,Integer> f = (Integer y, Integer z) -> {
            if (!Objects.equals(y,z))
                throw new RuntimeException("unequal " + y + "," + z);
            return new Integer(z);
        };

        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l2.get(i);
            if (!x.equals(m.merge(x, x, f)))
                throw new Exception("Wrong value: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m.keySet()).equals(l2))
            throw new Exception("Insert order not properly altered by replace.");

        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l2.get(i);
            if (!x.equals(m.compute(x, f)))
                throw new Exception("Wrong value: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m.keySet()).equals(l2))
            throw new Exception("Insert order not properly altered by replace.");

        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l2.get(i);
            if (!x.equals(m.remove(x)))
                throw new Exception("Missing key: "+i+", "+x);
            if (!x.equals(m.computeIfAbsent(x, Integer::valueOf)))
                throw new Exception("Wrong value: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m.keySet()).equals(l2))
            throw new Exception("Insert order not properly altered by replace.");

        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l2.get(i);
            if (!x.equals(m.computeIfPresent(x, f)))
                throw new Exception("Wrong value: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m.keySet()).equals(l2))
            throw new Exception("Insert order not properly altered by replace.");

        for (int i=0; i<mapSize; i++) {
            Integer x = new Integer(i);
            m.put(x, x);
        }
        if (!new ArrayList(m.keySet()).equals(l))
            throw new Exception("Insertion order not altered by reinsert.");

        m2 = (Map) ((LinkedHashMap)m).clone();
        if (!m.equals(m2))
            throw new Exception("Access-order Map != clone.");
        for (int i=0; i<mapSize; i++) {
            Integer x = (Integer) l.get(i);
            if (!m2.get(x).equals(x))
              throw new Exception("Clone: Wrong val: "+i+", "+m.get(x)+", "+x);
        }
        if (!new ArrayList(m2.keySet()).equals(l))
            throw new Exception("Clone: order not properly altered by read.");

        System.err.println("Success.");
    }

    private static Map serClone(Map m) {
        Map result = null;
        try {
            // Serialize
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(bos);
            out.writeObject(m);
            out.flush();

            // Deserialize
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            out.close();
            ObjectInputStream in = new ObjectInputStream(bis);
            result = (Map)in.readObject();
            in.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

quality97%

¤ Dauer der Verarbeitung: 0.19 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.