/*
 * Copyright (c) 2003, 2012, 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.io.*;
import java.lang.instrument.*;

import java.security.ProtectionDomain;
import java.util.*;


/**
 * Simple tests for the TransformerManager
 *
 */
public abstract class
ATransformerManagementTestCase
    extends AInstrumentationTestCase
{
    private static final String redefinedClassName = "DummyClass";

    protected int   kModSamples = 2;
    public final    ClassFileTransformer[] kTransformerSamples = new ClassFileTransformer[]
        {
            new MyClassFileTransformer(         Integer.toString(0)),
            new MyClassFileTransformer( Integer.toString(1)),
            new MyClassFileTransformer(         Integer.toString(2)),
            new MyClassFileTransformer( Integer.toString(3)),
            new MyClassFileTransformer(         Integer.toString(4)),
            new MyClassFileTransformer( Integer.toString(5)),
            new MyClassFileTransformer(         Integer.toString(6)),
            new MyClassFileTransformer( Integer.toString(7)),
            new MyClassFileTransformer(         Integer.toString(8)),
            new MyClassFileTransformer( Integer.toString(9)),
            new MyClassFileTransformer(         Integer.toString(10)),
            new MyClassFileTransformer( Integer.toString(11)),
            new MyClassFileTransformer( Integer.toString(12)),
            new MyClassFileTransformer( Integer.toString(13)),
            new MyClassFileTransformer(         Integer.toString(14)),
            new MyClassFileTransformer( Integer.toString(15)),
            new MyClassFileTransformer(         Integer.toString(16)),
            new MyClassFileTransformer(         Integer.toString(17)),
            new MyClassFileTransformer( Integer.toString(18)),
        };

    private ArrayList           fTransformers;       // The list of transformers
    private int                 fTransformerIndex;   // The number of transformers encountered
    private String              fDelayedFailure;     // Set non-null if failed in transformer


    /**
     * Constructor for ATransformerManagementTestCase.
     */
    public ATransformerManagementTestCase(String name)
    {
        super(name);
    }


    /**
     * Returns one of the sample transformers
     * @return a random transformer
     */
    protected ClassFileTransformer
    getRandomTransformer()
    {
        int randIndex = (int)Math.floor(Math.random() * kTransformerSamples.length);
        verbosePrint("Choosing random transformer #" + randIndex);
        return kTransformerSamples[randIndex];
    }

    /**
     * Method addTransformerToManager.
     * @param manager
     * @param transformer
     */
    protected void
    addTransformerToManager(
        Instrumentation         manager,
        ClassFileTransformer    transformer)
    {
        addTransformerToManager(manager, transformer, false);
    }

    /**
     * Method addTransformerToManager.
     * @param manager
     * @param transformer
     * @param canRetransform
     */
    protected void
    addTransformerToManager(
        Instrumentation         manager,
        ClassFileTransformer    transformer,
        boolean                 canRetransform)
    {
        if (transformer != null)
        {
            fTransformers.add(transformer);
        }
        manager.addTransformer(transformer, canRetransform);
        verbosePrint("Added transformer " + transformer
            + " with canRetransform=" + canRetransform);
    }

    /**
     * Remove transformer from manager and list
     * @param manager
     * @param transformer
     */
    protected void
    removeTransformerFromManager(
        Instrumentation manager,
        ClassFileTransformer transformer)
    {
        assertTrue("Transformer not found in manager ("+transformer+")", manager.removeTransformer(transformer));

        if (transformer != null)
        {
            fTransformers.remove(transformer);
        }
        verbosePrint("Removed transformer " + transformer);
    }

    /**
     * Decrements the transformer index as well as removes transformer
     * @param fInst         manager
     * @param transformer       transformer to remove
     * @param decrementIndex    the tranformer index gets out of sync with transformers
     *                          that are removed from the manager
     */
    protected void
    removeTransformerFromManager(   Instrumentation manager,
                                    ClassFileTransformer transformer,
                                    boolean decrementIndex)
    {
        removeTransformerFromManager(manager, transformer);
        if (decrementIndex)
        {
            fTransformerIndex--;
            verbosePrint("removeTransformerFromManager fTransformerIndex decremented to: " +
                         fTransformerIndex);
        }
    }

    /**
     * verify transformer by asserting that the number of transforms that occured
     * is the same as the number of valid transformers added to the list.
     * @param manager
     */
    protected void
    verifyTransformers(Instrumentation manager)
    {
        File f = new File(System.getProperty("test.classes", "."), redefinedClassName + ".class");
        System.out.println("Reading test class from " + f);
        try
        {
            InputStream redefineStream = new FileInputStream(f);
            byte[] bytes = NamedBuffer.loadBufferFromStream(redefineStream);
            ClassDefinition cd = new ClassDefinition(DummyClass.class, bytes);
            fInst.redefineClasses(new ClassDefinition[]{ cd });
            verbosePrint("verifyTransformers redefined " + redefinedClassName);
        }
        catch (IOException e)
        {
            fail("Could not load the class: " + redefinedClassName);
        }
        catch (ClassNotFoundException e)
        {
            fail("Could not find the class: " + redefinedClassName);
        }
        catch (UnmodifiableClassException e)
        {
            fail("Could not modify the class: " + redefinedClassName);
        }

        // Report any delayed failures
        assertTrue(fDelayedFailure, fDelayedFailure == null);

        assertEquals("The number of transformers that were run does not match the expected number added to manager",
                        fTransformers.size(), fTransformerIndex);
    }


    /**
     * Asserts that the transformer being checked by the manager is the correct
     * one (as far as order goes) and updates the number of transformers that have
     * been called.  Note that since this is being called inside of a transformer,
     * a standard assert (which throws an exception) cannot be used since it would
     * simply cancel the transformation and otherwise be ignored.  Instead, note
     * the failure for delayed processing.
     * @param ClassFileTransformer
     */
    private void
    checkInTransformer(ClassFileTransformer transformer)
    {
        verbosePrint("checkInTransformer: " + transformer);
        if (fDelayedFailure == null)
        {
            if (fTransformers.size() <= fTransformerIndex)
            {
                String msg = "The number of transformers that have checked in (" +(fTransformerIndex+1) +
                    ") is greater number of tranformers created ("+fTransformers.size()+")";
                fDelayedFailure = msg;
                System.err.println("Delayed failure: " + msg);
                verbosePrint("Delayed failure: " + msg);
            }
            if (!fTransformers.get(fTransformerIndex).equals(transformer))
            {
                String msg = "Transformer " + fTransformers.get(fTransformerIndex) +
                    " should be the same as " + transformer;
                fDelayedFailure = msg;
                System.err.println("Delayed failure: " + msg);
                verbosePrint("Delayed failure: " + msg);
            }
            fTransformerIndex++;
            verbosePrint("fTransformerIndex incremented to: " + fTransformerIndex);
        }
    }

    /**
     * Create a new manager, a new transformer list, and initializes the number of transformers
     * indexed to zero.
     */
    protected void
    setUp()
        throws Exception
    {
        super.setUp();
        fTransformers = new ArrayList();
        fTransformerIndex = 0;
        fDelayedFailure = null;
        verbosePrint("setUp completed");
    }

    /**
     * Sets the manager and transformers to null so that setUp needs to update.
     */
    protected void
    tearDown()
        throws Exception
    {
        verbosePrint("tearDown beginning");
        fTransformers = null;
        super.tearDown();
    }

    /*
     *  Simple transformer that registers when it transforms
     */
    public class MyClassFileTransformer extends SimpleIdentityTransformer {
        private final String fID;

        public MyClassFileTransformer(String id) {
            super();
            fID = id;
        }

        public String toString() {
            return MyClassFileTransformer.this.getClass().getName() + fID;
        }

        public byte[]
        transform(
            ClassLoader loader,
            String className,
            Class<?> classBeingRedefined,
            ProtectionDomain    protectionDomain,
            byte[] classfileBuffer) {

            // The transform testing is triggered by redefine, ignore others
            if (classBeingRedefined != null) checkInTransformer(MyClassFileTransformer.this);

            return super.transform(    loader,
                                        className,
                                        classBeingRedefined,
                                        protectionDomain,
                                        classfileBuffer);
        }
    }


    /**
     * Class loader that does nothing
     */
    public class MyClassLoader extends ClassLoader
    {
        /**
         * Constructor for MyClassLoader.
         */
        public MyClassLoader()
        {
            super();
        }

    }

    public String debug_byteArrayToString(byte[] b) {
        if (b == null) return "null";

        StringBuffer buf = new StringBuffer();
        buf.append("byte[");
        buf.append(b.length);
        buf.append("] (");
        for (int i = 0; i < b.length; i++)
        {
            buf.append(b[i]);
            buf.append(",");
        }
        buf.deleteCharAt(buf.length()-1);
        buf.append(")");

        return buf.toString();
    }
}