/*

 * Copyright (c) 2011, 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 7047069

 * @summary Array can dynamically change size when assigned to an object field

 *

 * @run main/othervm -Xbatch Test7047069

 */

import java.util.*;

import java.awt.geom.*;

public class Test7047069 {

    static boolean verbose;

    static final int GROW_SIZE = 24;    // Multiple of cubic & quad curve size

    float squareflat;           // Square of the flatness parameter

                    // for testing against squared lengths

    int limit;              // Maximum number of recursion levels

    float hold[] = new float[14];   // The cache of interpolated coords

                    // Note that this must be long enough

                    // to store a full cubic segment and

                    // a relative cubic segment to avoid

                    // aliasing when copying the coords

                    // of a curve to the end of the array.

                    // This is also serendipitously equal

                    // to the size of a full quad segment

                    // and 2 relative quad segments.

    int holdEnd;            // The index of the last curve segment

                    // being held for interpolation

    int holdIndex;          // The index of the curve segment

                    // that was last interpolated.  This

                    // is the curve segment ready to be

                    // returned in the next call to

                    // currentSegment().

    int levels[];           // The recursion level at which

                    // each curve being held in storage

                    // was generated.

    int levelIndex;         // The index of the entry in the

                    // levels array of the curve segment

                    // at the holdIndex

    public static void subdivide(float src[], int srcoff,

                                 float left[], int leftoff,

                                 float right[], int rightoff)

    {

        float x1 = src[srcoff + 0];

        float y1 = src[srcoff + 1];

        float ctrlx = src[srcoff + 2];

        float ctrly = src[srcoff + 3];

        float x2 = src[srcoff + 4];

        float y2 = src[srcoff + 5];

        if (left != null) {

            left[leftoff + 0] = x1;

            left[leftoff + 1] = y1;

        }

        if (right != null) {

            right[rightoff + 4] = x2;

            right[rightoff + 5] = y2;

        }

        x1 = (x1 + ctrlx) / 2f;

        y1 = (y1 + ctrly) / 2f;

        x2 = (x2 + ctrlx) / 2f;

        y2 = (y2 + ctrly) / 2f;

        ctrlx = (x1 + x2) / 2f;

        ctrly = (y1 + y2) / 2f;

        if (left != null) {

            left[leftoff + 2] = x1;

            left[leftoff + 3] = y1;

            left[leftoff + 4] = ctrlx;

            left[leftoff + 5] = ctrly;

        }

        if (right != null) {

            right[rightoff + 0] = ctrlx;

            right[rightoff + 1] = ctrly;

            right[rightoff + 2] = x2;

            right[rightoff + 3] = y2;

        }

    }

    public static double getFlatnessSq(float coords[], int offset) {

        return Line2D.ptSegDistSq(coords[offset + 0], coords[offset + 1],

                                  coords[offset + 4], coords[offset + 5],

                                  coords[offset + 2], coords[offset + 3]);

    }

    public Test7047069() {

        this.squareflat = .0001f * .0001f;

        holdIndex = hold.length - 6;

        holdEnd = hold.length - 2;

        hold[holdIndex + 0] = (float) (Math.random() * 100);

        hold[holdIndex + 1] = (float) (Math.random() * 100);

        hold[holdIndex + 2] = (float) (Math.random() * 100);

        hold[holdIndex + 3] = (float) (Math.random() * 100);

        hold[holdIndex + 4] = (float) (Math.random() * 100);

        hold[holdIndex + 5] = (float) (Math.random() * 100);

        levelIndex = 0;

        this.limit = 10;

        this.levels = new int[limit + 1];

    }

    /*

     * Ensures that the hold array can hold up to (want) more values.

     * It is currently holding (hold.length - holdIndex) values.

     */

    void ensureHoldCapacity(int want) {

        if (holdIndex - want < 0) {

            int have = hold.length - holdIndex;

            int newsize = hold.length + GROW_SIZE;

            float newhold[] = new float[newsize];

            System.arraycopy(hold, holdIndex,

                     newhold, holdIndex + GROW_SIZE,

                     have);

            if (verbose) System.err.println("old hold = "+hold+"["+hold.length+"]");

            if (verbose) System.err.println("replacement hold = "+newhold+"["+newhold.length+"]");

            hold = newhold;

            if (verbose) System.err.println("new hold = "+hold+"["+hold.length+"]");

            if (verbose) System.err.println("replacement hold still = "+newhold+"["+newhold.length+"]");

            holdIndex += GROW_SIZE;

            holdEnd += GROW_SIZE;

        }

    }

    private boolean next() {

        if (holdIndex >= holdEnd) {

            return false;

        }

        int level = levels[levelIndex];

        while (level < limit) {

            if (getFlatnessSq(hold, holdIndex) < squareflat) {

                break;

            }

            ensureHoldCapacity(4);

            subdivide(hold, holdIndex,

                      hold, holdIndex - 4,

                      hold, holdIndex);

            holdIndex -= 4;

            // Now that we have subdivided, we have constructed

            // two curves of one depth lower than the original

            // curve.  One of those curves is in the place of

            // the former curve and one of them is in the next

            // set of held coordinate slots.  We now set both

            // curves level values to the next higher level.

            level++;

            levels[levelIndex] = level;

            levelIndex++;

            levels[levelIndex] = level;

        }

        // This curve segment is flat enough, or it is too deep

        // in recursion levels to try to flatten any more.  The

        // two coordinates at holdIndex+4 and holdIndex+5 now

        // contain the endpoint of the curve which can be the

        // endpoint of an approximating line segment.

        holdIndex += 4;

        levelIndex--;

        return true;

    }

    public static void main(String argv[]) {

        verbose = (argv.length > 0);

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

            Test7047069 st = new Test7047069();

            while (st.next()) {}

        }

    }

}