| /* |
| * Copyright (c) 2016, 2017, 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 "prims/jvm.h" |
| #include "runtime/arguments.hpp" |
| #include "unittest.hpp" |
| #include "utilities/align.hpp" |
| #include "utilities/globalDefinitions.hpp" |
| |
| class ArgumentsTest : public ::testing::Test { |
| public: |
| static intx parse_xss_inner_annotated(const char* str, jint expected_err, const char* file, int line_number); |
| |
| // Expose the private Arguments functions. |
| |
| static Arguments::ArgsRange check_memory_size(julong size, julong min_size, julong max_size) { |
| return Arguments::check_memory_size(size, min_size, max_size); |
| } |
| |
| static jint parse_xss(const JavaVMOption* option, const char* tail, intx* out_ThreadStackSize) { |
| return Arguments::parse_xss(option, tail, out_ThreadStackSize); |
| } |
| }; |
| |
| TEST_F(ArgumentsTest, atojulong) { |
| char ullong_max[32]; |
| int ret = jio_snprintf(ullong_max, sizeof(ullong_max), JULONG_FORMAT, ULLONG_MAX); |
| ASSERT_NE(-1, ret); |
| |
| julong value; |
| const char* invalid_strings[] = { |
| "", "-1", "-100", " 1", "2 ", "3 2", "1.0", |
| "0x4.5", "0x", "0x0x1" "0.001", "4e10", "e" |
| "K", "M", "G", "1MB", "1KM", "AA", "0B", |
| "18446744073709551615K", "17179869184G", |
| "999999999999999999999999999999" |
| }; |
| for (uint i = 0; i < ARRAY_SIZE(invalid_strings); i++) { |
| ASSERT_FALSE(Arguments::atojulong(invalid_strings[i], &value)) |
| << "Invalid string '" << invalid_strings[i] << "' parsed without error."; |
| } |
| |
| struct { |
| const char* str; |
| julong expected_value; |
| } valid_strings[] = { |
| { "0", 0 }, |
| { "4711", 4711 }, |
| { "1K", 1ULL * K }, |
| { "1k", 1ULL * K }, |
| { "2M", 2ULL * M }, |
| { "2m", 2ULL * M }, |
| { "4G", 4ULL * G }, |
| { "4g", 4ULL * G }, |
| { "0K", 0 }, |
| { ullong_max, ULLONG_MAX }, |
| { "0xcafebabe", 0xcafebabe }, |
| { "0XCAFEBABE", 0xcafebabe }, |
| { "0XCAFEbabe", 0xcafebabe }, |
| { "0x10K", 0x10 * K } |
| }; |
| for (uint i = 0; i < ARRAY_SIZE(valid_strings); i++) { |
| ASSERT_TRUE(Arguments::atojulong(valid_strings[i].str, &value)) |
| << "Valid string '" << valid_strings[i].str << "' did not parse."; |
| ASSERT_EQ(valid_strings[i].expected_value, value); |
| } |
| } |
| |
| TEST_F(ArgumentsTest, check_memory_size__min) { |
| EXPECT_EQ(check_memory_size(999, 1000, max_uintx), Arguments::arg_too_small); |
| EXPECT_EQ(check_memory_size(1000, 1000, max_uintx), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size(1001, 1000, max_uintx), Arguments::arg_in_range); |
| |
| EXPECT_EQ(check_memory_size(max_intx - 2, max_intx - 1, max_uintx), Arguments::arg_too_small); |
| EXPECT_EQ(check_memory_size(max_intx - 1, max_intx - 1, max_uintx), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size(max_intx - 0, max_intx - 1, max_uintx), Arguments::arg_in_range); |
| |
| EXPECT_EQ(check_memory_size(max_intx - 1, max_intx, max_uintx), Arguments::arg_too_small); |
| EXPECT_EQ(check_memory_size(max_intx , max_intx, max_uintx), Arguments::arg_in_range); |
| |
| NOT_LP64( |
| EXPECT_EQ(check_memory_size((julong)max_intx + 1, max_intx, max_uintx), Arguments::arg_in_range); |
| |
| EXPECT_EQ(check_memory_size( max_intx - 1, (julong)max_intx + 1, max_uintx), Arguments::arg_too_small); |
| EXPECT_EQ(check_memory_size( max_intx , (julong)max_intx + 1, max_uintx), Arguments::arg_too_small); |
| EXPECT_EQ(check_memory_size((julong)max_intx + 1, (julong)max_intx + 1, max_uintx), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size((julong)max_intx + 2, (julong)max_intx + 1, max_uintx), Arguments::arg_in_range); |
| ); |
| |
| EXPECT_EQ(check_memory_size(max_uintx - 2, max_uintx - 1, max_uintx), Arguments::arg_too_small); |
| EXPECT_EQ(check_memory_size(max_uintx - 1, max_uintx - 1, max_uintx), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size(max_uintx , max_uintx - 1, max_uintx), Arguments::arg_in_range); |
| |
| EXPECT_EQ(check_memory_size(max_uintx - 1, max_uintx, max_uintx), Arguments::arg_too_small); |
| EXPECT_EQ(check_memory_size(max_uintx , max_uintx, max_uintx), Arguments::arg_in_range); |
| } |
| |
| TEST_F(ArgumentsTest, check_memory_size__max) { |
| EXPECT_EQ(check_memory_size(max_uintx - 1, 1000, max_uintx), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size(max_uintx , 1000, max_uintx), Arguments::arg_in_range); |
| |
| EXPECT_EQ(check_memory_size(max_intx - 2 , 1000, max_intx - 1), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size(max_intx - 1 , 1000, max_intx - 1), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size(max_intx , 1000, max_intx - 1), Arguments::arg_too_big); |
| |
| EXPECT_EQ(check_memory_size(max_intx - 1 , 1000, max_intx), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size(max_intx , 1000, max_intx), Arguments::arg_in_range); |
| |
| NOT_LP64( |
| EXPECT_EQ(check_memory_size((julong)max_intx + 1 , 1000, max_intx), Arguments::arg_too_big); |
| |
| EXPECT_EQ(check_memory_size( max_intx , 1000, (julong)max_intx + 1), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size((julong)max_intx + 1 , 1000, (julong)max_intx + 1), Arguments::arg_in_range); |
| EXPECT_EQ(check_memory_size((julong)max_intx + 2 , 1000, (julong)max_intx + 1), Arguments::arg_too_big); |
| ); |
| } |
| |
| // A random value - used to verify the output when parsing is expected to fail. |
| static const intx no_value = 4711; |
| |
| inline intx ArgumentsTest::parse_xss_inner_annotated(const char* str, jint expected_err, const char* file, int line_number) { |
| intx value = no_value; |
| jint err = parse_xss(NULL /* Silence error messages */, str, &value); |
| EXPECT_EQ(err, expected_err) << "Failure from: " << file << ":" << line_number; |
| return value; |
| } |
| |
| // Wrapper around the help function - gives file and line number when a test failure occurs. |
| #define parse_xss_inner(str, expected_err) ArgumentsTest::parse_xss_inner_annotated(str, expected_err, __FILE__, __LINE__) |
| |
| static intx calc_expected(julong small_xss_input) { |
| assert(small_xss_input <= max_julong / 2, "Sanity"); |
| |
| // Match code in arguments.cpp |
| julong julong_ret = align_up_(small_xss_input, K) / K; |
| assert(julong_ret <= (julong)max_intx, "Overflow: " JULONG_FORMAT, julong_ret); |
| return (intx)julong_ret; |
| } |
| |
| static char buff[100]; |
| static char* to_string(julong value) { |
| jio_snprintf(buff, sizeof(buff), JULONG_FORMAT, value); |
| return buff; |
| } |
| |
| TEST_VM_F(ArgumentsTest, parse_xss) { |
| // Test the maximum input value - should fail. |
| { |
| EXPECT_EQ(parse_xss_inner(to_string(max_julong), JNI_EINVAL), no_value); |
| NOT_LP64(EXPECT_EQ(parse_xss_inner(to_string(max_uintx), JNI_EINVAL), no_value)); |
| } |
| |
| // Test values "far" away from the uintx boundary, |
| // but still beyond the max limit. |
| { |
| LP64_ONLY(EXPECT_EQ(parse_xss_inner(to_string(max_julong / 2), JNI_EINVAL), no_value)); |
| EXPECT_EQ(parse_xss_inner(to_string(INT_MAX), JNI_EINVAL), no_value); |
| } |
| |
| // Test at and around the max limit. |
| { |
| EXPECT_EQ(parse_xss_inner(to_string(1 * M * K - 1), JNI_OK), calc_expected(1 * M * K - 1)); |
| EXPECT_EQ(parse_xss_inner(to_string(1 * M * K), JNI_OK), calc_expected(1 * M * K)); |
| EXPECT_EQ(parse_xss_inner(to_string(1 * M * K + 1), JNI_EINVAL), no_value); |
| } |
| |
| // Test value aligned both to K and vm_page_size. |
| { |
| EXPECT_TRUE(is_aligned(32 * M, K)); |
| EXPECT_TRUE(is_aligned(32 * M, (size_t)os::vm_page_size())); |
| EXPECT_EQ(parse_xss_inner(to_string(32 * M), JNI_OK), (intx)(32 * M / K)); |
| } |
| |
| // Test around the min limit. |
| { |
| EXPECT_EQ(parse_xss_inner(to_string(0), JNI_OK), calc_expected(0)); |
| EXPECT_EQ(parse_xss_inner(to_string(1), JNI_OK), calc_expected(1)); |
| EXPECT_EQ(parse_xss_inner(to_string(K - 1), JNI_OK), calc_expected(K - 1)); |
| EXPECT_EQ(parse_xss_inner(to_string(K), JNI_OK), calc_expected(K)); |
| EXPECT_EQ(parse_xss_inner(to_string(K + 1), JNI_OK), calc_expected(K + 1)); |
| } |
| } |