#!/bin/sh

# 

# Copyright (c) 2013, 2014, 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.

# 

# 

set -x

# $1 - error code

# $2 - test name

# $3,.. - decription

test_fail() {

    error=$1

    shift

    name=$1

    shift

    echo "TEST [$name] FAILED:"

    echo "$@"

    exit $error

}

# $@ - additional vm opts

start_test() {

    # disable core dump on *nix

    ulimit -S -c 0

    # disable core dump on windows

    VMOPTS="$@ -XX:-CreateMinidumpOnCrash"

    cmd="${JAVA} ${VMOPTS} -XX:+ReplayCompiles -XX:ReplayDataFile=${replay_data}"

    echo $cmd

    $cmd

    return $?

}

# $1 - error_code

# $2 - test name

# $3,.. - additional vm opts

positive_test() {

    error=$1

    shift

    name=$1

    shift

    VMOPTS="${TESTOPTS} $@"

    echo "POSITIVE TEST [$name]"

    start_test ${VMOPTS}

    exit_code=$?

    if [ ${exit_code} -ne 0 ]

    then

        test_fail $error "$name" "exit_code[${exit_code}] != 0 during replay "\

                "w/ vmopts: ${VMOPTS}"

    fi

}

# $1 - error_code

# $2 - test name

# $2,.. - additional vm opts

negative_test() {

    error=$1

    shift

    name=$1

    shift

    VMOPTS="${TESTOPTS} $@"

    echo "NEGATIVE TEST [$name]"

    start_test ${VMOPTS}

    exit_code=$?

    if [ ${exit_code} -eq 0 ]

    then

        test_fail $error "$name" "exit_code[${exit_code}] == 0 during replay "\

                "w/ vmopts: ${VMOPTS}"

    fi

}

# $1 - initial error_code

common_tests() {

    positive_test $1 "COMMON :: THE SAME FLAGS"

    if [ $tiered_available -eq 1 ]

    then

        positive_test `expr $1 + 1` "COMMON :: TIERED" -XX:+TieredCompilation

    fi

}

# $1 - initial error_code

# $2 - non-tiered comp_level 

nontiered_tests() {

    level=`grep "^compile " $replay_data | awk '{print $6}'`

    # is level available in non-tiered

    if [ "$level" -eq $2 ]

    then

        positive_test $1 "NON-TIERED :: AVAILABLE COMP_LEVEL" \

                -XX:-TieredCompilation

    else

        negative_test `expr $1 + 1` "NON-TIERED :: UNAVAILABLE COMP_LEVEL" \

                -XX:-TieredCompilation

    fi

}

# $1 - initial error_code

client_tests() {

    # testing in opposite VM

    if [ $server_available -eq 1 ]

    then

        negative_test $1 "SERVER :: NON-TIERED" -XX:-TieredCompilation \

                -server

        if [ $tiered_available -eq 1 ]

        then

            positive_test `expr $1 + 1` "SERVER :: TIERED" -XX:+TieredCompilation \

                    -server

        fi

    fi

    nontiered_tests `expr $1 + 2` $client_level 

}

# $1 - initial error_code

server_tests() {

    # testing in opposite VM

    if [ $client_available -eq 1 ]

    then

        # tiered is unavailable in client vm, so results w/ flags will be the same as w/o flags

        negative_test $1 "CLIENT" -client

    fi

    nontiered_tests `expr $1 + 2` $server_level

}

cleanup() {

    ${RM} -f core*

    ${RM} -f replay*.txt

    ${RM} -f hs_err_pid*.log

    ${RM} -f test_core

    ${RM} -f test_replay.txt

}

JAVA=${TESTJAVA}${FS}bin${FS}java

replay_data=test_replay.txt

${JAVA} ${TESTOPTS} -Xinternalversion 2>&1 | grep debug

# Only test fastdebug 

if [ $? -ne 0 ]

then

    echo TEST SKIPPED: product build

    exit 0

fi

is_int=`${JAVA} ${TESTOPTS} -version 2>&1 | grep -c "interpreted mode"`

# Not applicable for Xint

if [ $is_int -ne 0 ]

then

    echo TEST SKIPPED: interpreted mode

    exit 0

fi

cleanup

client_available=`${JAVA} ${TESTOPTS} -client -Xinternalversion 2>&1 | \

        grep -c Client`

server_available=`${JAVA} ${TESTOPTS} -server -Xinternalversion 2>&1 | \

        grep -c Server`

tiered_available=`${JAVA} ${TESTOPTS} -XX:+TieredCompilation -XX:+PrintFlagsFinal -version | \

        grep TieredCompilation | \

        grep -c true`

is_tiered=`${JAVA} ${TESTOPTS} -XX:+PrintFlagsFinal -version | \

        grep TieredCompilation | \

        grep -c true`

# CompLevel_simple -- C1

client_level=1

# CompLevel_full_optimization -- C2 or Shark 

server_level=4

echo "client_available=$client_available"

echo "server_available=$server_available"

echo "tiered_available=$tiered_available"

echo "is_tiered=$is_tiered"

# crash vm in compiler thread with generation replay data and 'small' dump-file

# $@ - additional vm opts

generate_replay() {

    if [ $VM_OS != "windows" ]

    then

        # enable core dump

        ulimit -c unlimited

        new_ulimit=`ulimit -c`

        if [ $new_ulimit != "unlimited" -a $new_ulimit != "-1" ]

        then

            test_fail 2 "CHECK :: ULIMIT" "Could not set 'ulimit -c unlimited'. 'ulimit -c' returns : $new_ulimit"

        fi

        if [ $VM_OS = "solaris" ]

        then

            coreadm -p core $$

        fi

    fi

    cmd="${JAVA} ${TESTOPTS} $@ \

            -Xms8m \

            -Xmx32m \

            -XX:MetaspaceSize=4m \

            -XX:MaxMetaspaceSize=16m \

            -XX:InitialCodeCacheSize=512k \

            -XX:ReservedCodeCacheSize=4m \

            -XX:ThreadStackSize=512 \

            -XX:VMThreadStackSize=512 \

            -XX:CompilerThreadStackSize=512 \

            -XX:ParallelGCThreads=1 \

            -XX:CICompilerCount=2 \

            -Xcomp \

            -XX:CICrashAt=1 \

            -XX:+CreateMinidumpOnCrash \

            -XX:+DumpReplayDataOnError \

            -XX:-TransmitErrorReport \

            -XX:+PreferInterpreterNativeStubs \

            -XX:+PrintCompilation \

            -XX:ReplayDataFile=${replay_data} \

            -version"

    echo GENERATION OF REPLAY.TXT:

    echo $cmd

    ${cmd} > crash.out 2>&1

    exit_code=$?

    if [ ${exit_code} -eq 0 ]

    then

        cat crash.out

        test_fail 3 "CHECK :: CRASH" "JVM exits gracefully"

    fi

    core_locations=`grep -i core crash.out | grep "location:" | \

            sed -e 's/.*location: //'`

    if [ -z "${core_locations}" ]

    then

        test_fail 4 "CHECK :: CORE_LOCATION" "output doesn't contain the location of core file, see crash.out"

    fi

    rm crash.out 

    # processing core locations for *nix

    if [ $VM_OS != "windows" ]

    then

        # remove 'or' between '<core_path>/core.<pid>' and 'core'

        # and the rest of line -- ' (max size ...) . To ensure a full core ...'

        core_locations=`echo $core_locations | \

                sed -e 's/\([^ ]*\) or \([^ ]*\).*/\1 \2/'`

        core_with_dir=`echo $core_locations | awk '{print $1}'`

        core_with_pid=`echo $core_locations | awk '{print $2}'`

        dir=`dirname $core_with_dir`

        file=`basename $core_with_dir`

        # add <core_path>/core.<pid> core

        core_locations='$core_with_dir' '$file'

        if [ -n "${core_with_pid}" ]

        then

            core_locations=$core_locations '$core_with_pid' '$dir${FS}$core_with_pid'

        fi

    fi

    echo "LOOKING FOR CORE IN ${core_locations}"

    for core in $core_locations

    do

        if [ -r "$core" ]

        then

            core_file=$core

        fi

    done

    # core-file was found

    if [ -n "$core_file" ]

    then

        ${MV} "${core_file}" test_core

        core_file=test_core

    fi

    ${RM} -f hs_err_pid*.log

}