This is an archive of the discontinued LLVM Phabricator instance.

Differential D140076

[libc] Templatize ato* tests
ClosedPublic

Authored by abrachet on Dec 14 2022, 5:32 PM.

Details

Reviewers
michaelrj
sivachandra
lntue
Commits
rGd07c54c2a5d6: [libc] Templatize ato* tests

Diff Detail

Event Timeline

abrachet created this revision.Dec 14 2022, 5:32 PM
Herald added a project: Restricted Project. · View Herald TranscriptDec 14 2022, 5:32 PM
Herald added subscribers: ecnelises, tschuett. · View Herald Transcript
abrachet requested review of this revision.Dec 14 2022, 5:32 PM
Harbormaster completed remote builds in B203255: Diff 483050.Dec 14 2022, 6:05 PM
sivachandra accepted this revision.Dec 14 2022, 10:45 PM
sivachandra added inline comments.
libc/test/src/stdlib/CMakeLists.txt
25

I think a more appropriate way would be to add a header library and list it under DEPENDS of these test targets. Same for the Bazel build - the header library can be listed as a cc_library with only hdrs.

This revision is now accepted and ready to land.Dec 14 2022, 10:45 PM
Closed by commit rGd07c54c2a5d6: [libc] Templatize ato* tests (authored by abrachet). · Explain WhyDec 15 2022, 9:31 AM
This revision was automatically updated to reflect the committed changes.
abrachet added a commit: rGd07c54c2a5d6: [libc] Templatize ato* tests.
Herald added a project: Restricted Project. · View Herald TranscriptDec 15 2022, 9:31 AM
Herald added a subscriber: libc-commits. · View Herald Transcript

Revision Contents

PathSize
libc/
test/
src/
stdlib/
89 lines
9 lines
59 lines
53 lines
59 lines
utils/
bazel/
llvm-project-overlay/
libc/
test/
src/
stdlib/
8 lines

Diff 483216

libc/test/src/stdlib/AtoiTest.h

  • This file was added.
//===-- A template class for testing ato* functions -------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "utils/UnitTest/Test.h"
#include <limits.h>
template <typename ReturnT> struct AtoTest : public __llvm_libc::testing::Test {
using FunctionT = ReturnT (*)(const char *);
void validNumbers(FunctionT func) {
const char *zero = "0";
ASSERT_EQ(func(zero), static_cast<ReturnT>(0));
const char *ten = "10";
ASSERT_EQ(func(ten), static_cast<ReturnT>(10));
const char *negative_hundred = "-100";
ASSERT_EQ(func(negative_hundred), static_cast<ReturnT>(-100));
const char *positive_thousand = "+1000";
ASSERT_EQ(func(positive_thousand), static_cast<ReturnT>(1000));
const char *spaces_before = " 12345";
ASSERT_EQ(func(spaces_before), static_cast<ReturnT>(12345));
const char *tabs_before = "\t\t\t\t67890";
ASSERT_EQ(func(tabs_before), static_cast<ReturnT>(67890));
const char *letters_after = "123abc";
ASSERT_EQ(func(letters_after), static_cast<ReturnT>(123));
const char *letters_between = "456def789";
ASSERT_EQ(func(letters_between), static_cast<ReturnT>(456));
const char *all_together = "\t 110 times 5 = 550";
ASSERT_EQ(func(all_together), static_cast<ReturnT>(110));
const char *biggest_int = "2147483647";
ASSERT_EQ(func(biggest_int), static_cast<ReturnT>(INT_MAX));
const char *smallest_int = "-2147483648";
ASSERT_EQ(func(smallest_int), static_cast<ReturnT>(INT_MIN));
if constexpr (sizeof(ReturnT) >= 8) {
const char *biggest_long_long = "9223372036854775807";
ASSERT_EQ(func(biggest_long_long), static_cast<ReturnT>(LLONG_MAX));
const char *smallest_long_long = "-9223372036854775808";
ASSERT_EQ(func(smallest_long_long), static_cast<ReturnT>(LLONG_MIN));
}
}
void nonBaseTenWholeNumbers(FunctionT func) {
const char *hexadecimal = "0x10";
ASSERT_EQ(func(hexadecimal), static_cast<ReturnT>(0));
const char *octal = "010";
ASSERT_EQ(func(octal), static_cast<ReturnT>(10));
const char *decimal_point = "5.9";
ASSERT_EQ(func(decimal_point), static_cast<ReturnT>(5));
}
void notNumbers(FunctionT func) {
const char *ten_as_word = "ten";
ASSERT_EQ(func(ten_as_word), static_cast<ReturnT>(0));
const char *lots_of_letters =
"wtragsdhfgjykutjdyfhgnchgmjhkyurktfgjhlu;po7urtdjyfhgklyk";
ASSERT_EQ(func(lots_of_letters), static_cast<ReturnT>(0));
}
};
template <typename ReturnType>
AtoTest(ReturnType (*)(const char *)) -> AtoTest<ReturnType>;
#define ATOI_TEST(name, func) \
using LlvmLibc##name##Test = AtoTest<decltype(func(""))>; \
TEST_F(LlvmLibc##name##Test, ValidNumbers) { validNumbers(func); } \
TEST_F(LlvmLibc##name##Test, NonBaseTenWholeNumbers) { \
nonBaseTenWholeNumbers(func); \
} \
TEST_F(LlvmLibc##name##Test, NotNumbers) { notNumbers(func); }

libc/test/src/stdlib/CMakeLists.txt

add_libc_testsuite(libc_stdlib_unittests) add_libc_testsuite(libc_stdlib_unittests)
add_libc_unittest( add_libc_unittest(
atof_test atof_test
SUITE SUITE
libc_stdlib_unittests libc_stdlib_unittests
SRCS SRCS
atof_test.cpp atof_test.cpp
DEPENDS DEPENDS
libc.src.stdlib.atof libc.src.stdlib.atof
) )
add_header_library(
atoi_test_support
HDRS
AtoiTest.h
)
add_libc_unittest( add_libc_unittest(
atoi_test atoi_test
SUITE SUITE
libc_stdlib_unittests libc_stdlib_unittests
SRCS SRCS
atoi_test.cpp atoi_test.cpp
DEPENDS DEPENDS
sivachandraUnsubmitted
Not Done
ReplyInline Actions

I think a more appropriate way would be to add a header library and list it under DEPENDS of these test targets. Same for the Bazel build - the header library can be listed as a cc_library with only hdrs.

sivachandra: I think a more appropriate way would be to add a header library and list it under `DEPENDS` of…
.atoi_test_support
libc.src.stdlib.atoi libc.src.stdlib.atoi
) )
add_libc_unittest( add_libc_unittest(
atol_test atol_test
SUITE SUITE
libc_stdlib_unittests libc_stdlib_unittests
SRCS SRCS
atol_test.cpp atol_test.cpp
DEPENDS DEPENDS
.atoi_test_support
libc.src.stdlib.atol libc.src.stdlib.atol
) )
add_libc_unittest( add_libc_unittest(
atoll_test atoll_test
SUITE SUITE
libc_stdlib_unittests libc_stdlib_unittests
SRCS SRCS
atoll_test.cpp atoll_test.cpp
DEPENDS DEPENDS
.atoi_test_support
libc.src.stdlib.atoll libc.src.stdlib.atoll
) )
add_libc_unittest( add_libc_unittest(
strtod_test strtod_test
SUITE SUITE
libc_stdlib_unittests libc_stdlib_unittests
SRCS SRCS
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

libc/test/src/stdlib/atoi_test.cpp

//===-- Unittests for atoi -----------------------------------------------===// //===-- Unittests for atoi -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AtoiTest.h"
#include "src/stdlib/atoi.h" #include "src/stdlib/atoi.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <limits.h> ATOI_TEST(Atoi, __llvm_libc::atoi)
TEST(LlvmLibcAToITest, ValidNumbers) {
const char *zero = "0";
ASSERT_EQ(__llvm_libc::atoi(zero), 0);
const char *ten = "10";
ASSERT_EQ(__llvm_libc::atoi(ten), 10);
const char *negative_hundred = "-100";
ASSERT_EQ(__llvm_libc::atoi(negative_hundred), -100);
const char *positive_thousand = "+1000";
ASSERT_EQ(__llvm_libc::atoi(positive_thousand), 1000);
const char *spaces_before = " 12345";
ASSERT_EQ(__llvm_libc::atoi(spaces_before), 12345);
const char *tabs_before = "\t\t\t\t67890";
ASSERT_EQ(__llvm_libc::atoi(tabs_before), 67890);
const char *letters_after = "123abc";
ASSERT_EQ(__llvm_libc::atoi(letters_after), 123);
const char *letters_between = "456def789";
ASSERT_EQ(__llvm_libc::atoi(letters_between), 456);
const char *all_together = "\t 110 times 5 = 550";
ASSERT_EQ(__llvm_libc::atoi(all_together), 110);
const char *biggest_int = "2147483647";
ASSERT_EQ(__llvm_libc::atoi(biggest_int), INT_MAX);
const char *smallest_int = "-2147483648";
ASSERT_EQ(__llvm_libc::atoi(smallest_int), INT_MIN);
}
TEST(LlvmLibcAToITest, NonBaseTenWholeNumbers) {
const char *hexadecimal = "0x10";
ASSERT_EQ(__llvm_libc::atoi(hexadecimal), 0);
const char *octal = "010";
ASSERT_EQ(__llvm_libc::atoi(octal), 10);
const char *decimal_point = "5.9";
ASSERT_EQ(__llvm_libc::atoi(decimal_point), 5);
}
TEST(LlvmLibcAToITest, NotNumbers) {
const char *ten_as_word = "ten";
ASSERT_EQ(__llvm_libc::atoi(ten_as_word), 0);
const char *lots_of_letters =
"wtragsdhfgjykutjdyfhgnchgmjhkyurktfgjhlu;po7urtdjyfhgklyk";
ASSERT_EQ(__llvm_libc::atoi(lots_of_letters), 0);
}

libc/test/src/stdlib/atol_test.cpp

//===-- Unittests for atol -----------------------------------------------===// //===-- Unittests for atol -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AtoiTest.h"
#include "src/stdlib/atol.h" #include "src/stdlib/atol.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <limits.h> ATOI_TEST(Atol, __llvm_libc::atol)
TEST(LlvmLibcAToLTest, ValidNumbers) {
const char *zero = "0";
ASSERT_EQ(__llvm_libc::atol(zero), 0l);
const char *ten = "10";
ASSERT_EQ(__llvm_libc::atol(ten), 10l);
const char *negative_hundred = "-100";
ASSERT_EQ(__llvm_libc::atol(negative_hundred), -100l);
const char *positive_thousand = "+1000";
ASSERT_EQ(__llvm_libc::atol(positive_thousand), 1000l);
const char *spaces_before = " 12345";
ASSERT_EQ(__llvm_libc::atol(spaces_before), 12345l);
const char *tabs_before = "\t\t\t\t67890";
ASSERT_EQ(__llvm_libc::atol(tabs_before), 67890l);
const char *letters_after = "123abc";
ASSERT_EQ(__llvm_libc::atol(letters_after), 123l);
const char *letters_between = "456def789";
ASSERT_EQ(__llvm_libc::atol(letters_between), 456l);
const char *all_together = "\t 110 times 5 = 550";
ASSERT_EQ(__llvm_libc::atol(all_together), 110l);
}
TEST(LlvmLibcAToLTest, NonBaseTenWholeNumbers) {
const char *hexadecimal = "0x10";
ASSERT_EQ(__llvm_libc::atol(hexadecimal), 0l);
const char *octal = "010";
ASSERT_EQ(__llvm_libc::atol(octal), 10l);
const char *decimal_point = "5.9";
ASSERT_EQ(__llvm_libc::atol(decimal_point), 5l);
}
TEST(LlvmLibcAToLTest, NotNumbers) {
const char *ten_as_word = "ten";
ASSERT_EQ(__llvm_libc::atol(ten_as_word), 0l);
const char *lots_of_letters =
"wtragsdhfgjykutjdyfhgnchgmjhkyurktfgjhlu;po7urtdjyfhgklyk";
ASSERT_EQ(__llvm_libc::atol(lots_of_letters), 0l);
}

libc/test/src/stdlib/atoll_test.cpp

//===-- Unittests for atoll -----------------------------------------------===// //===-- Unittests for atoll -----------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "AtoiTest.h"
#include "src/stdlib/atoll.h" #include "src/stdlib/atoll.h"
#include "utils/UnitTest/Test.h" #include "utils/UnitTest/Test.h"
#include <limits.h> ATOI_TEST(Atoll, __llvm_libc::atoll)
TEST(LlvmLibcAToLLTest, ValidNumbers) {
const char *zero = "0";
ASSERT_EQ(__llvm_libc::atoll(zero), 0ll);
const char *ten = "10";
ASSERT_EQ(__llvm_libc::atoll(ten), 10ll);
const char *negative_hundred = "-100";
ASSERT_EQ(__llvm_libc::atoll(negative_hundred), -100ll);
const char *positive_thousand = "+1000";
ASSERT_EQ(__llvm_libc::atoll(positive_thousand), 1000ll);
const char *spaces_before = " 12345";
ASSERT_EQ(__llvm_libc::atoll(spaces_before), 12345ll);
const char *tabs_before = "\t\t\t\t67890";
ASSERT_EQ(__llvm_libc::atoll(tabs_before), 67890ll);
const char *letters_after = "123abc";
ASSERT_EQ(__llvm_libc::atoll(letters_after), 123ll);
const char *letters_between = "456def789";
ASSERT_EQ(__llvm_libc::atoll(letters_between), 456ll);
const char *all_together = "\t 110 times 5 = 550";
ASSERT_EQ(__llvm_libc::atoll(all_together), 110ll);
const char *biggest_long_long = "9223372036854775807";
ASSERT_EQ(__llvm_libc::atoll(biggest_long_long), LLONG_MAX);
const char *smallest_long_long = "-9223372036854775808";
ASSERT_EQ(__llvm_libc::atoll(smallest_long_long), LLONG_MIN);
}
TEST(LlvmLibcAToLLTest, NonBaseTenWholeNumbers) {
const char *hexadecimal = "0x10";
ASSERT_EQ(__llvm_libc::atoll(hexadecimal), 0ll);
const char *octal = "010";
ASSERT_EQ(__llvm_libc::atoll(octal), 10ll);
const char *decimal_point = "5.9";
ASSERT_EQ(__llvm_libc::atoll(decimal_point), 5ll);
}
TEST(LlvmLibcAToLLTest, NotNumbers) {
const char *ten_as_word = "ten";
ASSERT_EQ(__llvm_libc::atoll(ten_as_word), 0ll);
const char *lots_of_letters =
"wtragsdhfgjykutjdyfhgnchgmjhkyurktfgjhlu;po7urtdjyfhgklyk";
ASSERT_EQ(__llvm_libc::atoll(lots_of_letters), 0ll);
}

utils/bazel/llvm-project-overlay/libc/test/src/stdlib/BUILD.bazel

# This file is licensed under the Apache License v2.0 with LLVM Exceptions. # This file is licensed under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information. # See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
# Tests for LLVM libc stdlib.h functions. # Tests for LLVM libc stdlib.h functions.
load("//libc/test:libc_test_rules.bzl", "libc_test") load("//libc/test:libc_test_rules.bzl", "libc_test")
package(default_visibility = ["//visibility:public"]) package(default_visibility = ["//visibility:public"])
licenses(["notice"]) licenses(["notice"])
cc_library(
name = "atoi_test_helper",
hdrs = ["AtoiTest.h"],
)
libc_test( libc_test(
name = "atoi_test", name = "atoi_test",
srcs = ["atoi_test.cpp"], srcs = ["atoi_test.cpp"],
deps = [":atoi_test_helper"],
libc_function_deps = [ libc_function_deps = [
"//libc:atoi", "//libc:atoi",
], ],
) )
libc_test( libc_test(
name = "atol_test", name = "atol_test",
srcs = ["atol_test.cpp"], srcs = ["atol_test.cpp"],
deps = [":atoi_test_helper"],
libc_function_deps = [ libc_function_deps = [
"//libc:atol", "//libc:atol",
], ],
) )
libc_test( libc_test(
name = "atoll_test", name = "atoll_test",
srcs = ["atoll_test.cpp"], srcs = ["atoll_test.cpp"],
deps = [":atoi_test_helper"],
libc_function_deps = [ libc_function_deps = [
"//libc:atoll", "//libc:atoll",
], ],
) )
libc_test( libc_test(
name = "bsearch_test", name = "bsearch_test",
srcs = ["bsearch_test.cpp"], srcs = ["bsearch_test.cpp"],
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines