/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.core;

import org.apache.harmony.dalvik.NativeTestTarget;

import android.test.PerformanceTestBase;
import android.test.PerformanceTestCase;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

import junit.framework.Assert;

public class PerformanceTests {
    public static String[] children() {
        return new String[] {
                //StringEquals2.class.getName(),
                //StringEquals10.class.getName(),
                //StringEquals20.class.getName(),
                //StringEquals200.class.getName(),
                //StringEquals200U.class.getName(),
                //StringCompareTo10.class.getName(),
                //StringCompareTo200.class.getName(),
                StringLength.class.getName(),
                StringCrawl.class.getName(),
                Ackermann.class.getName(),
                AddTest.class.getName(),
//                AddMemberVariableTest.class.getName(),
                ArrayListIterator.class.getName(),
                BoundsCheckTest.class.getName(),
//                EmptyClassBaseTest.class.getName(),
                EmptyJniStaticMethod0.class.getName(),
                EmptyJniStaticMethod6.class.getName(),
                EmptyJniStaticMethod6L.class.getName(),
                FibonacciFast.class.getName(),
                FibonacciSlow.class.getName(),
//                LoopTests.class.getName(),
//                HashMapTest.class.getName(),
//                InterfaceTests.class.getName(),
                LocalVariableAccess.class.getName(),
                MemeberVariableAccess.class.getName(),
                NestedLoop.class.getName(),
//                StringConcatenationTests.class.getName(),
//                ArrayListBase.class.getName(),
                SynchronizedGetAndSetInt.class.getName(),

                /* this will not work on JamVM -- lacks atomic ops */
                AtomicGetAndSetInt.class.getName(),
        };
    }

    public static class SizeTest {
        private int mSize;

        public SizeTest(int size) {
            mSize = size;
        }

        public int size() {
            return mSize;
        }
    }

    public static class LocalVariableAccess extends PerformanceTestBase {
        private static final int ITERATIONS = 100000;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 20);
            return 0;
        }

        public void testRun() {
            boolean variable = false;
            boolean local = true;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                local = variable;
                local = variable;
                local = variable;
                local = variable;
                local = variable; // 5
                local = variable;
                local = variable;
                local = variable;
                local = variable;
                local = variable; // 10
                local = variable;
                local = variable;
                local = variable;
                local = variable;
                local = variable; // 15
                local = variable;
                local = variable;
                local = variable;
                local = variable;
                local = variable; // 20
            }
        }
    }

    /* This test is intentionally misspelled. Please do not rename it. Thanks! */
    public static class MemeberVariableAccess extends PerformanceTestBase {
        private static final int ITERATIONS = 100000;

        public volatile boolean mMember = false;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 20);
            return 0;
        }

        public void testRun() {
            boolean local = true;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                local = mMember;
                local = mMember;
                local = mMember;
                local = mMember;
                local = mMember; // 5
                local = mMember;
                local = mMember;
                local = mMember;
                local = mMember;
                local = mMember; // 10
                local = mMember;
                local = mMember;
                local = mMember;
                local = mMember;
                local = mMember; // 15
                local = mMember;
                local = mMember;
                local = mMember;
                local = mMember;
                local = mMember; // 20
            }
        }
    }

    public static class ArrayListIterator extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;
        private ArrayList mList;
        private String[] mKeys;
        private Iterator mIterator;

        public void setUp() throws Exception {
            super.setUp();
            mList = new ArrayList();
            mKeys = new String[ITERATIONS];

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                mKeys[i] = Integer.toString(i, 16);
                mList.add(mKeys[i]);
            }
        }

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS);
            return 0;
        }

        public void testRun() {
            mIterator = mList.iterator();
            while (mIterator.hasNext()) {
                mIterator.next();
            }
        }
    }

    public static class Ackermann extends PerformanceTestBase {
        public static final int ITERATIONS = 100;
        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS);
            return 0;
        }

        public void testRun() {
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                ackermann(3, 13);
            }
        }

        private int ackermann(int m, int n) {
            if (m == 0)
                return n + 1;
            if (n == 0)
                return ackermann(m - 1, 1);
            return ackermann(m, n - 1);
        }
    }

    public static class FibonacciSlow extends PerformanceTestBase {
        public void setUp() throws Exception {
            super.setUp();
            Assert.assertEquals(0, fibonacci(0));
            Assert.assertEquals(1, fibonacci(1));
            Assert.assertEquals(1, fibonacci(2));
            Assert.assertEquals(2, fibonacci(3));
            Assert.assertEquals(6765, fibonacci(20));
        }

        public void tearDown() {
        }

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            return 0;
        }

        public void testRun() {
            fibonacci(20);
        }

        private long fibonacci(long n) {
            if (n == 0)
                return 0;
            if (n == 1)
                return 1;
            return fibonacci(n - 2) + fibonacci(n - 1);
        }
    }

    public static class FibonacciFast extends PerformanceTestBase {
        public void setUp() throws Exception {
            super.setUp();
            Assert.assertEquals(0, fibonacci(0));
            Assert.assertEquals(1, fibonacci(1));
            Assert.assertEquals(1, fibonacci(2));
            Assert.assertEquals(2, fibonacci(3));
            Assert.assertEquals(6765, fibonacci(20));
        }

        public void tearDown() {
        }

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            return 0;
        }

        public void testRun() {
            fibonacci(5000);
        }

        private long fibonacci(long n) {
            if (n == 0)
                return 0;
            if (n == 1)
                return 1;

            int x = 0;
            int y = 1;
            for (int i = 0; i < n - 1; i++) {
                y = y + x;
                x = y - x;
            }

            return y;
        }
    }

    public static class HashMapTest extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;
        private HashMap mMap;
        private String[] mKeys;

        public void setUp() throws Exception {
            super.setUp();
            mMap = new HashMap();
            mKeys = new String[ITERATIONS];

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                mKeys[i] = Integer.toString(i, 16);
                mMap.put(mKeys[i], i);
            }
        }

        public void tearDown() {
        }

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS);
            return 0;
        }

        public void testHashMapContainsKey() {
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                mMap.containsKey(mKeys[i]);
            }
        }

        public void testHashMapIterator() {
            Iterator iterator;

            iterator = mMap.entrySet().iterator();
            while (iterator.hasNext()) {
                iterator.next();
            }
        }

        public void testHashMapPut() {
            HashMap map = new HashMap();
            String[] keys = mKeys;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                map.put(keys[i], i);
            }
        }
    }

    interface IA {
        void funcA0();
        void funcA1();
        void funcA2();
        void funcA3();
    }
    interface IAB extends IA {
        void funcAB0();
        void funcAB1();
        void funcAB2();
        void funcAB3();
    }
    interface IABC extends IAB {
        void funcABC0();
        void funcABC1();
        void funcABC2();
        void funcABC3();
    }
    interface IB {
        void funcB0();
        void funcB1();
        void funcB2();
        void funcB3();
    }
    interface IC {
        void funcC0();
        void funcC1();
        void funcC2();
        void funcC3();
    }

    static class Alphabet implements Cloneable, IB, IABC, IC, Runnable {
        public void funcA0() {
        }
        public void funcA1() {
        }
        public void funcA2() {
        }
        public void funcA3() {
        }
        public void funcAB0() {
        }
        public void funcAB1() {
        }
        public void funcAB2() {
        }
        public void funcAB3() {
        }
        public void funcABC0() {
        }
        public void funcABC1() {
        }
        public void funcABC2() {
        }
        public void funcABC3() {
        }
        public void funcB0() {
        }
        public void funcB1() {
        }
        public void funcB2() {
        }
        public void funcB3() {
        }
        public void funcC0() {
        }
        public void funcC1() {
        }
        public void funcC2() {
        }
        public void funcC3() {
        }
        public void run() {
        }
    };

    public static class InterfaceTests extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        /* call method directly */
        public void testInterfaceCalls0() {
            Alphabet alpha = new Alphabet();

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                alpha.funcABC1();
                alpha.funcABC1();
                alpha.funcABC1();
                alpha.funcABC1();
                alpha.funcABC1();
                alpha.funcABC1();
                alpha.funcABC1();
                alpha.funcABC1();
                alpha.funcABC1();
                alpha.funcABC1();
            }
        }

       /* call method through interface reference */
        public void testInterfaceCalls1() {
            Alphabet alpha = new Alphabet();
            IABC iabc = alpha;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                iabc.funcABC1();
                iabc.funcABC1();
                iabc.funcABC1();
                iabc.funcABC1();
                iabc.funcABC1();
                iabc.funcABC1();
                iabc.funcABC1();
                iabc.funcABC1();
                iabc.funcABC1();
                iabc.funcABC1();
            }
        }

        public void testInstanceOfTrivial() {
            Alphabet alpha = new Alphabet();
            IABC iabc = alpha;
            boolean val;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                val = iabc instanceof Alphabet;
                val = iabc instanceof Alphabet;
                val = iabc instanceof Alphabet;
                val = iabc instanceof Alphabet;
                val = iabc instanceof Alphabet;
                val = iabc instanceof Alphabet;
                val = iabc instanceof Alphabet;
                val = iabc instanceof Alphabet;
                val = iabc instanceof Alphabet;
                val = iabc instanceof Alphabet;
            }
        }

        public void testInstanceOfInterface() {
            Alphabet alpha = new Alphabet();
            IABC iabc = alpha;
            boolean val;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                val = iabc instanceof IA;
                val = iabc instanceof IA;
                val = iabc instanceof IA;
                val = iabc instanceof IA;
                val = iabc instanceof IA;
                val = iabc instanceof IA;
                val = iabc instanceof IA;
                val = iabc instanceof IA;
                val = iabc instanceof IA;
                val = iabc instanceof IA;
            }
        }

        public void testInstanceOfNot() {
            Alphabet alpha = new Alphabet();
            IABC iabc = alpha;
            boolean val;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                val = iabc instanceof EmptyInterface;
                val = iabc instanceof EmptyInterface;
                val = iabc instanceof EmptyInterface;
                val = iabc instanceof EmptyInterface;
                val = iabc instanceof EmptyInterface;
                val = iabc instanceof EmptyInterface;
                val = iabc instanceof EmptyInterface;
                val = iabc instanceof EmptyInterface;
                val = iabc instanceof EmptyInterface;
                val = iabc instanceof EmptyInterface;
            }
        }
    }

    public static class NestedLoop extends PerformanceTestBase {
        private static final int ITERATIONS = 10;
        private static final int LOOPS = 5;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * LOOPS);
            return 0;
        }

        public void testRun() {
            int x = 0;
            for (int a = 0; a < ITERATIONS; a++) {
                for (int b = 0; b < ITERATIONS; b++) {
                    for (int c = 0; c < ITERATIONS; c++) {
                        for (int d = 0; d < ITERATIONS; d++) {
                            for (int e = 0; e < ITERATIONS; e++) {
                                x++;
                            }
                        }
                    }
                }
            }
        }
    }

    public static class StringConcatenationTests extends PerformanceTestBase {
        private static final int ITERATIONS = 1000;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS);
            return 0;
        }

        public void testStringConcatenation1() {
            StringBuffer buffer = new StringBuffer();
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                buffer.append("Hello World!\n");
            }
            buffer = null;
        }

        public void testStringConcatenation2() {
            String string = "";
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                string += "Hello World!\n";
            }
            string = null;
        }
    }

    public static class StringLength extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;
        private static final String TEST_STRING = "This is the string we use for testing..."; // 40 chars

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        public void testRun() {
            String testStr = TEST_STRING;
            int length;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                length = testStr.length();
                length = testStr.length();
                length = testStr.length();
                length = testStr.length();
                length = testStr.length();
                length = testStr.length();
                length = testStr.length();
                length = testStr.length();
                length = testStr.length();
                length = testStr.length();
            }
        }
    }

    public static class EmptyJniStaticMethod0 extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        public void testRun() {
            int a, b, c, d, e, f;

            a = b = c = d = e = f = 0;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
            }
        }
    }
    public static class EmptyJniStaticMethod6 extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        public void testRun() {
            int a, b, c, d, e, f;

            a = b = c = d = e = f = 0;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
            }
        }
    }
    public static class EmptyJniStaticMethod6L extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        public void testRun() {
            String a = null;
            String[] b = null;
            int[][] c = null;
            Object d = null;
            Object[] e = null;
            Object[][][][] f = null;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6L(a, b, c, d, e, f);
            }
        }
    }

    public static class StringCrawl extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;
        private static final String TEST_STRING = "This is the string we use for testing..."; // 40 chars

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * TEST_STRING.length());
            return 0;
        }

        public void testRun() {
            String testStr = TEST_STRING;
            char ch;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                /* this is the wrong way to walk through a string */
                for (int j = 0; j < testStr.length(); j++) {
                    ch = testStr.charAt(j);
                }
            }
        }
    }

    public static class AddTest extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 20);
            return 0;
        }

        public void testRun() {
            int j = 0;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
            }
        }
    }

    public static class AddMemberVariableTest extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;
        private int j;

        public void setUp() throws Exception {
           super.setUp();
           j = 0;
        }

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        public void testAddMemberVariableTest() {
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
                j++;
            }
        }

        public void testAddMemberVariableInMethodTest() {
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                add();
                add();
                add();
                add();
                add();
                add();
                add();
                add();
                add();
                add();
            }
        }

        public void add() {
            j++;
        }
    }

    private interface EmptyInterface {
        public void emptyVirtual();

    }

    private static class EmptyClass implements EmptyInterface {
        public void emptyVirtual() {
        }

        public static void emptyStatic() {
        }
    }

    public static class EmptyClassBaseTest extends PerformanceTestBase {
        protected EmptyInterface mEmptyInterface;
        protected EmptyClass mEmptyClass;

        public void setUp() throws Exception {
            super.setUp();
            mEmptyClass = new EmptyClass();
            mEmptyInterface = mEmptyClass;
        }
        private static final int ITERATIONS = 10000;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        public void testEmptyVirtualMethod() {
            //EmptyClass emtpyClass = mEmptyClass;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                mEmptyClass.emptyVirtual();
                mEmptyClass.emptyVirtual();
                mEmptyClass.emptyVirtual();
                mEmptyClass.emptyVirtual();
                mEmptyClass.emptyVirtual();
                mEmptyClass.emptyVirtual();
                mEmptyClass.emptyVirtual();
                mEmptyClass.emptyVirtual();
                mEmptyClass.emptyVirtual();
                mEmptyClass.emptyVirtual();
            }
        }

        public void testEmptyVirtualMethodTestInLocal() {
            EmptyClass empty = mEmptyClass;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                empty.emptyVirtual();
                empty.emptyVirtual();
                empty.emptyVirtual();
                empty.emptyVirtual();
                empty.emptyVirtual();
                empty.emptyVirtual();
                empty.emptyVirtual();
                empty.emptyVirtual();
                empty.emptyVirtual();
                empty.emptyVirtual();
            }
        }

    public void testEmptyStaticMethod () {
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                EmptyClass.emptyStatic();
                EmptyClass.emptyStatic();
                EmptyClass.emptyStatic();
                EmptyClass.emptyStatic();
                EmptyClass.emptyStatic();
                EmptyClass.emptyStatic();
                EmptyClass.emptyStatic();
                EmptyClass.emptyStatic();
                EmptyClass.emptyStatic();
                EmptyClass.emptyStatic();
            }
        }

    public void testEmptyJniStaticMethod0() {

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
                NativeTestTarget.emptyJniStaticMethod0();
            }
        }

    public void testEmptyJniStaticMethod6() {
            int a, b, c, d, e, f;

            a = b = c = d = e = f = 0;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
                NativeTestTarget.emptyJniStaticMethod6(a, b, c, d, e, f);
            }
        }

    public void testEmptyInternalStaticMethod() {
            /*
             * The method called is a VM-internal method with no extra
             * wrapping.
             */
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                NativeTestTarget.emptyInternalStaticMethod();
                NativeTestTarget.emptyInternalStaticMethod();
                NativeTestTarget.emptyInternalStaticMethod();
                NativeTestTarget.emptyInternalStaticMethod();
                NativeTestTarget.emptyInternalStaticMethod();
                NativeTestTarget.emptyInternalStaticMethod();
                NativeTestTarget.emptyInternalStaticMethod();
                NativeTestTarget.emptyInternalStaticMethod();
                NativeTestTarget.emptyInternalStaticMethod();
                NativeTestTarget.emptyInternalStaticMethod();
            }
        }

    public void testEmptyInlineStaticMethod() {
            /*
             * The method called is a VM-internal method that gets
             * specially "inlined" in a bytecode transformation.
             */
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                NativeTestTarget.emptyInlineMethod();
                NativeTestTarget.emptyInlineMethod();
                NativeTestTarget.emptyInlineMethod();
                NativeTestTarget.emptyInlineMethod();
                NativeTestTarget.emptyInlineMethod();
                NativeTestTarget.emptyInlineMethod();
                NativeTestTarget.emptyInlineMethod();
                NativeTestTarget.emptyInlineMethod();
                NativeTestTarget.emptyInlineMethod();
                NativeTestTarget.emptyInlineMethod();
            }
        }

    public void testEmptyInterfaceMethodTest() {
            EmptyInterface emptyInterface = mEmptyInterface;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                emptyInterface.emptyVirtual();
                emptyInterface.emptyVirtual();
                emptyInterface.emptyVirtual();
                emptyInterface.emptyVirtual();
                emptyInterface.emptyVirtual();
                emptyInterface.emptyVirtual();
                emptyInterface.emptyVirtual();
                emptyInterface.emptyVirtual();
                emptyInterface.emptyVirtual();
                emptyInterface.emptyVirtual();
            }
        }
    }

    public static class LoopTests extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;
        private SizeTest mSizeTest = new SizeTest(ITERATIONS);

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS);
            return 0;
        }

        public void testForLoopTest() {
            int i = 0;
            for (; i < 10000; i++) {
            }
        }

        public void testWhileLoopTest() {
            int i = 0;

            while (i < 10000) {
                i++;
            }
        }

        public void testForLoopSizeCalledInside() {
            for (int i = 0; i < mSizeTest.size(); i++) {
            }
        }

        public void testForLoopSizeCalledOutside() {
            final int size = mSizeTest.size();
            for (int i = 0; i < size; i++) {
            }
        }
    }

    public static class BoundsCheckTest extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;
        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        public void testRun() {
            int[] data = new int[1];

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                data[0] = i;
                data[0] = i;
                data[0] = i;
                data[0] = i;
                data[0] = i;
                data[0] = i;
                data[0] = i;
                data[0] = i;
                data[0] = i;
                data[0] = i;
            }
        }
    }

    public static class ArrayListBase extends PerformanceTestBase {
        public void setUp() throws Exception {
            super.setUp();
            mList = new ArrayList();
            mList.add(0);
            mList.add(1);
            mList.add(2);
            mList.add(3);
            mList.add(4);
            mList.add(5);
            mList.add(6);
            mList.add(7);
            mList.add(8);
            mList.add(9);
        }

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(100);
            return 0;
        }

        ArrayList<Integer> mList;

        public void testForArrayList() {
            int i = 0;
            int res = 0;
            for (; i < 100; i++) {
                for (int j = 0; j < mList.size(); j++) {
                    res += mList.get(j);
                }
            }
        }

        public void testForLocalArrayList() {
            int i = 0;
            int res = 0;
            for (; i < 100; i++) {
                final List<Integer> list = mList;
                final int N = list.size();
                for (int j = 0; j < N; j++) {
                    res += list.get(j);
                }
            }
        }

        public void testForEachArrayList() {
            int i = 0;
            int res = 0;
            for (; i < 100; i++) {
                for (Integer v : mList) {
                    res += v;
                }
            }
        }
    }

    public static class SynchronizedGetAndSetInt extends PerformanceTestBase {
        private static final int ITERATIONS = 100000;

        public int mMember = 0;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS);
            return 0;
        }

        public void testRun() {
            int result = 0;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                synchronized (this) {
                    result = mMember;
                    mMember = i;
                }
            }
        }
    }

    public static class AtomicGetAndSetInt extends PerformanceTestBase {
        private static final int ITERATIONS = 100000;

        public AtomicInteger mMember = new AtomicInteger(0);

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS);
            return 0;
        }

        public void testRun() {
            int result = 0;
            for (int i = ITERATIONS - 1; i >= 0; i--) {
                result = mMember.getAndSet(i);
            }
        }
    }

    public static abstract class StringEquals extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;

        protected String mString1, mString2;
        public void setUp() throws Exception {
          super.setUp();
        }

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        public void testRun() {
            String string1 = mString1;
            String string2 = mString2;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                string1.equals(string2);
                string1.equals(string2);
                string1.equals(string2);
                string1.equals(string2);
                string1.equals(string2);
                string1.equals(string2);
                string1.equals(string2);
                string1.equals(string2);
                string1.equals(string2);
                string1.equals(string2);
            }
        }
    }

    public static class StringEquals2 extends StringEquals {
        public void setUp() throws Exception {
            mString1 = "01";
            mString2 = "0x";
        }
    }
    public static class StringEquals10 extends StringEquals {
        public void setUp() throws Exception {
            mString1 = "0123456789";
            mString2 = "012345678x";
        }
    }
    public static class StringEquals20 extends StringEquals {
        public void setUp() throws Exception {
            mString1 = "01234567890123456789";
            mString2 = "0123456789012345678x";
        }
    }

    public static class StringEquals200 extends StringEquals {
        public void setUp() throws Exception {
            mString1 = "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789";
            mString2 = "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "012345678901234567890123456789012345678x";
        }
    }
    public static class StringEquals200U extends StringEquals {
        /* make one of the strings non-word aligned (bad memcmp case) */
        public void setUp() throws Exception {
            String tmpStr;
            mString1 = "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789";
            tmpStr = "z0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "012345678901234567890123456789012345678x";
            mString2 = tmpStr.substring(1);
        }
    }

    public static abstract class StringCompareTo extends PerformanceTestBase {
        private static final int ITERATIONS = 10000;

        protected String mString1, mString2;

        public int startPerformance(PerformanceTestCase.Intermediates intermediates) {
            intermediates.setInternalIterations(ITERATIONS * 10);
            return 0;
        }

        public void testRun() {
            String string1 = mString1;
            String string2 = mString2;

            for (int i = ITERATIONS - 1; i >= 0; i--) {
                string1.compareTo(string2);
                string1.compareTo(string2);
                string1.compareTo(string2);
                string1.compareTo(string2);
                string1.compareTo(string2);
                string1.compareTo(string2);
                string1.compareTo(string2);
                string1.compareTo(string2);
                string1.compareTo(string2);
                string1.compareTo(string2);
            }
        }
    }
    public static class StringCompareTo10 extends StringCompareTo {
        public void setUp() throws Exception {
            mString1 = "0123456789";
            mString2 = "012345678x";
        }
    }
    public static class StringCompareTo200 extends StringCompareTo {
        public void setUp() throws Exception {
            mString1 = "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789";
            mString2 = "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "0123456789012345678901234567890123456789"
                    + "012345678901234567890123456789012345678x";
        }
    }
}