/*

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

 */

//package nsk.jvmti.RedefineClasses.StressRedefine;

package nsk.jvmti.RedefineClasses;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Random;

import nsk.share.TestFailure;

import nsk.share.gc.GCTestBase;

import nsk.share.test.ExecutionController;

import nsk.share.test.Stresser;

import nsk.share.test.Tests;

import vm.share.InMemoryJavaCompiler;

/**

 * There is a data structure named "dictionary" in class BlockFreelist. It stores

 * information about free memory blocks for further reusing. Allocation of new block goes

 * from dictionary only if dictionary is fat enough. (At the moment of test creation this limit is 64K.)

 *

 * This tests stresses dictionary as other test metaspace/StressDictionary does, but instead of

 * failing classloading this test leverages redefineClass method from jvmti.

 */

public class StressRedefine extends GCTestBase {

    private static int staticMethodCallersNumber = 10;

    private static int nonstaticMethodCallersNumber = 10;

    private static int redefiningThreadsNumber = 40;

    private static double corruptingBytecodeProbability = .75;

    private static volatile Class<?> myClass;

    private static ExecutionController stresser;

    private static String[] args;

    static Random seedGenerator;

    static {

        try {

            System.loadLibrary("stressRedefine");

        } catch (UnsatisfiedLinkError e) {

            System.err.println("Could not load stressRedefine library");

            System.err.println("java.library.path:" +

                System.getProperty("java.library.path"));

            throw e;

        }

    }

    native static int makeRedefinition(int verbose, Class<?> redefClass, byte[] classBytes);

    public static void main(String[] args) {

        StressRedefine.args = args;

        Tests.runTest(new StressRedefine(), args);

    }

        stresser = new Stresser(args);

        for (int i = 0; i < args.length; i++ ) {

        }

        //Dynamic attach if required

        nsk.share.jvmti.JVMTITest.commonInit(args);

        new StressRedefine().runIt();

        }

    private static class StaticMethodCaller implements Runnable {

        private Random random;

        public StaticMethodCaller() {random = new Random(seedGenerator.nextLong());}

    }

    private static class NonstaticMethodCaller implements Runnable {

        private Random random;

        public NonstaticMethodCaller() {random = new Random(seedGenerator.nextLong());}

        @Override

    }

    private static class Worker implements Runnable {

        private Random random;

        public Worker() {random = new Random(seedGenerator.nextLong());}

                }

    }

    private void runIt() {

        myClass = new DefiningClassLoader().defineClass(generateAndCompile());

        stresser.start(0);

        List<Thread> threads = new LinkedList<Thread>();

        for (int i = 0; i < staticMethodCallersNumber; i++) {

        }

        for (int i = 0; i < nonstaticMethodCallersNumber; i++) {

        }

        for (int i = 0; i < redefiningThreadsNumber; i++) {

        }

        for (Thread thread : threads) {

        }

        for (Thread thread : threads) {

        }

    }

    private static byte[] generateAndCompile() {

        Map<String, CharSequence> sources = new HashMap<String, CharSequence>();

        sources.put(GenerateSourceHelper.CLASS_NAME, GenerateSourceHelper.generateSource());

        return InMemoryJavaCompiler.compile(sources).values().iterator().next();

    }

        }

}