/*

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

 */

#include "precompiled.hpp"

#include <locale.h>

#include "compiler/directivesParser.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/thread.hpp"

#include "unittest.hpp"

class DirectivesParserTest : public ::testing::Test{

 protected:

  const char* const _locale;

  ResourceMark rm;

  stringStream stream;

  // These tests require the "C" locale to correctly parse decimal values

  DirectivesParserTest() : _locale(setlocale(LC_NUMERIC, NULL)) {

    setlocale(LC_NUMERIC, "C");

  }

  ~DirectivesParserTest() {

    setlocale(LC_NUMERIC, _locale);

  }

  void test_negative(const char* text) {

    JavaThread* THREAD = JavaThread::current();

    ThreadInVMfromNative ThreadInVMfromNative(THREAD);

    DirectivesParser cd(text, &stream, false);

    cd.clean_tmp();

    EXPECT_FALSE(cd.valid()) << "text: " << std::endl << text << std::endl << stream.as_string();

  }

  void test_positive(const char* text) {

    JavaThread* THREAD = JavaThread::current();

    ThreadInVMfromNative ThreadInVMfromNative(THREAD);

    DirectivesParser cd(text, &stream, false);

    cd.clean_tmp();

    EXPECT_TRUE(cd.valid()) << "text: " << std::endl << text << std::endl << stream.as_string();

  }

};

TEST_VM_F(DirectivesParserTest, empty_object) {

  test_negative("{}");

}

TEST_VM_F(DirectivesParserTest, empty_array) {

  test_positive("[]");

}

TEST_VM_F(DirectivesParserTest, empty_object_in_array) {

  test_negative("[{}]");

}

TEST_VM_F(DirectivesParserTest, empty_objects_in_array) {

  test_negative("[{},{}]");

}

TEST_VM_F(DirectivesParserTest, empty_objects) {

  test_negative("{},{}");

}

TEST_VM_F(DirectivesParserTest, simple_match) {

  test_positive(

      "[" "\n"

      "  {" "\n"

      "    match: \"foo/bar.*\"," "\n"

      "    inline : \"+java/util.*\"," "\n"

      "    PrintAssembly: true," "\n"

      "    BreakAtExecute: true," "\n"

      "  }" "\n"

      "]" "\n");

}

TEST_VM_F(DirectivesParserTest, nesting_arrays) {

  test_negative(

      "[" "\n"

      "  [" "\n"

      "    {" "\n"

      "      match: \"foo/bar.*\"," "\n"

      "      inline : \"+java/util.*\"," "\n"

      "      PrintAssembly: true," "\n"

      "      BreakAtExecute: true," "\n"

      "    }" "\n"

      "  ]" "\n"

      "]" "\n");

}

TEST_VM_F(DirectivesParserTest, c1_block) {

  test_positive(

    "[" "\n"

    "  {" "\n"

    "    match: \"foo/bar.*\"," "\n"

    "    c1: {"

    "      PrintInlining: false," "\n"

    "    }" "\n"

    "  }" "\n"

    "]" "\n");

}

TEST_VM_F(DirectivesParserTest, c2_block) {

  test_positive(

      "[" "\n"

      "  {" "\n"

      "    match: \"foo/bar.*\"," "\n"

      "    c2: {" "\n"

      "      PrintInlining: false," "\n"

      "    }" "\n"

      "  }" "\n"

      "]" "\n");

}

TEST_VM_F(DirectivesParserTest, boolean_array) {

  test_negative(

      "[" "\n"

      "  {" "\n"

      "    match: \"foo/bar.*\"," "\n"

      "    PrintInlining: [" "\n"

      "      true," "\n"

      "      false" "\n"

      "    ]," "\n"

      "  }" "\n"

      "]" "\n");

}

TEST_VM_F(DirectivesParserTest, multiple_objects) {

  test_positive(

      "[" "\n"

      "  {"

      "    // pattern to match against class+method+signature" "\n"

      "    // leading and trailing wildcard (*) allowed" "\n"

      "    match: \"foo/bar.*\"," "\n"

      "" "\n"

      "    // override defaults for specified compiler" "\n"

      "    // we may differentiate between levels too. TBD." "\n"

      "    c1:  {" "\n"

      "      //override c1 presets " "\n"

      "      DumpReplay: false," "\n"

      "      BreakAtCompile: true," "\n"

      "    }," "\n"

      "" "\n"

      "    c2: {" "\n"

      "        // control inlining of method" "\n"

      "        // + force inline, - dont inline" "\n"

      "        inline : \"+java/util.*\"," "\n"

      "        PrintInlining: true," "\n"

      "    }," "\n"

      "" "\n"

      "    // directives outside a specific preset applies to all compilers" "\n"

      "    inline : [ \"+java/util.*\", \"-com/sun.*\"]," "\n"

      "    BreakAtExecute: true," "\n"

      "    Log: true," "\n"

      "  }," "\n"

      "  {" "\n"

      "    // matching several patterns require an array" "\n"

      "    match: [\"baz.*\",\"frob.*\"]," "\n"

      "" "\n"

      "    // applies to all compilers" "\n"

      "    // + force inline, - dont inline" "\n"

      "    inline : [ \"+java/util.*\", \"-com/sun.*\" ]," "\n"

      "    PrintInlining: true," "\n"

      "" "\n"

      "    // force matching compiles to be blocking/syncronous" "\n"

      "    PrintNMethods: true" "\n"

      "  }," "\n"

      "]" "\n");

}

// Test max stack depth

TEST_VM_F(DirectivesParserTest, correct_max_stack_depth) {

  test_positive(

      "[" "\n"              // depth 1: type_dir_array

      "  {" "\n"            // depth 2: type_directives

      "    match: \"*.*\"," // match required

      "    c1:" "\n"        // depth 3: type_c1

      "    {" "\n"

      "      inline:" "\n"  // depth 4: type_inline

      "      [" "\n"        // depth 5: type_value_array

      "        \"foo\"," "\n"

      "        \"bar\"," "\n"

      "      ]" "\n"        // depth 3: pop type_value_array and type_inline keys

      "    }" "\n"          // depth 2: pop type_c1 key

      "  }" "\n"            // depth 1: pop type_directives key

      "]" "\n");            // depth 0: pop type_dir_array key

}

// Test max stack depth

TEST_VM_F(DirectivesParserTest, incorrect_max_stack_depth) {

  test_negative("[{c1:{c1:{c1:{c1:{c1:{c1:{c1:{}}}}}}}}]");

}