Clean up CMake configuration and address compiler warnings.
- Removed dead configuration in CMakeLists.txt.
- Used target_compile_options() instead of CMAKE_{C|CXX}_FLAGS.
- Turned on warnings on tests.
- Fixed various warnings for comparing signed with unsigned values.
- Removed dead code exposed by compiler warnings.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 53399a1..e35b8d5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -26,6 +26,7 @@
cmake_minimum_required(VERSION 2.8)
project(spirv-tools)
+set(SPIRV_TOOLS "SPIRV-Tools")
if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
add_definitions(-DSPIRV_LINUX)
@@ -37,36 +38,26 @@
message(FATAL_ERROR "Your platform '${CMAKE_SYSTEM_NAME}' is not supported!")
endif()
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)
-if (UNIX)
- set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)
-elseif(WIN32)
- set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
-endif()
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/bin)
-
-if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+if ("${CMAKE_BUILD_TYPE}" STREQUAL "")
message(STATUS "No build type selected, default to Debug")
set(CMAKE_BUILD_TYPE "Debug")
endif()
if(UNIX)
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fno-exceptions -fno-rtti")
+ set(SPIRV_WARNINGS -Wall -Wextra -Wno-missing-field-initializers)
- # For good call stacks in profiles, keep the frame pointers.
- if(NOT SPIRV_PERF STREQUAL "")
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-omit-frame-pointer")
+ option(SPIRV_WARN_EVERYTHING "Enable -Weverything" OFF)
+ if(${SPIRV_WARN_EVERYTHING})
+ set(SPIRV_WARNINGS ${SPIRV_WARNINGS}
+ -Weverything -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-padded)
endif()
- if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")
- set(SPIRV_USE_SANITIZER "" CACHE STRING
- "Use the clang sanitizer [address|memory|thread|...]")
- if(NOT "${SPIRV_USE_SANITIZER}" STREQUAL "")
- set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=${SPIRV_USE_SANITIZER}")
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=${SPIRV_USE_SANITIZER}")
- endif()
+ option(SPIRV_WERROR "Enable error on warning" OFF)
+ if(${SPIRV_WERROR})
+ set(SPIRV_WARNINGS ${SPIRV_WARNINGS} -Werror)
endif()
+elseif(WIN32)
+ set(SPIRV_WARNINGS -D_CRT_SECURE_NO_WARNINGS /wd4800)
endif()
option(SPIRV_COLOR_TERMINAL "Enable color terminal output" ON)
@@ -74,34 +65,32 @@
add_definitions(-DSPIRV_COLOR_TERMINAL)
endif()
-if(UNIX)
- set(SPIRV_WARNINGS "-Wall -Wextra -Wno-missing-field-initializers")
- option(SPIRV_WARN_EVERYTHING "Enable -Weverything for SPIRV library" OFF)
- if(${SPIRV_WARN_EVERYTHING})
- set(SPIRV_WARNINGS
- "${SPIRV_WARNINGS} -Weverything -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-padded")
+function(default_compile_options TARGET)
+ target_compile_options(${TARGET} PRIVATE ${SPIRV_WARNINGS})
+ if (UNIX)
+ target_compile_options(${TARGET} PRIVATE
+ -std=c++11 -fno-exceptions -fno-rtti)
+ # For good call stacks in profiles, keep the frame pointers.
+ if(NOT "${SPIRV_PERF}" STREQUAL "")
+ target_compile_options(${TARGET} PRIVATE -fno-omit-frame-pointer)
+ endif()
+ if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+ target_compile_options(${TARGET} PRIVATE -fcolor-diagnostics)
+ set(SPIRV_USE_SANITIZER "" CACHE STRING
+ "Use the clang sanitizer [address|memory|thread|...]")
+ if(NOT "${SPIRV_USE_SANITIZER}" STREQUAL "")
+ target_compile_options(${TARGET} PRIVATE
+ -fsanitize=${SPIRV_USE_SANITIZER})
+ endif()
+ endif()
endif()
-elseif(WIN32)
- set(SPIRV_WARNINGS "-D_CRT_SECURE_NO_WARNINGS /wd4800")
-endif()
-
-if(UNIX)
- option(SPIRV_WERROR "Enable error on warning" OFF)
- if(${SPIRV_WERROR})
- set(SPIRV_WARNINGS "${SPIRV_WARNINGS} -Werror")
- endif()
-endif()
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/external/include)
-
-include_directories(
- ${CMAKE_CURRENT_SOURCE_DIR}/include)
+endfunction()
set(SPIRV_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/include/libspirv/libspirv.h
${CMAKE_CURRENT_SOURCE_DIR}/include/util/bitutils.h
- ${CMAKE_CURRENT_SOURCE_DIR}/source/assembly_grammar.h
${CMAKE_CURRENT_SOURCE_DIR}/include/util/hex_float.h
+ ${CMAKE_CURRENT_SOURCE_DIR}/source/assembly_grammar.h
${CMAKE_CURRENT_SOURCE_DIR}/source/binary.h
${CMAKE_CURRENT_SOURCE_DIR}/source/diagnostic.h
${CMAKE_CURRENT_SOURCE_DIR}/source/endian.h
@@ -131,33 +120,29 @@
${CMAKE_CURRENT_SOURCE_DIR}/source/validate.cpp
${CMAKE_CURRENT_SOURCE_DIR}/source/validate_id.cpp)
-set(SPIRV_TOOLS "SPIRV-Tools")
add_library(${SPIRV_TOOLS} ${SPIRV_SOURCES})
-target_link_libraries(${SPIRV_TOOLS} ${SPIRV_LIBS})
-set_target_properties(${SPIRV_TOOLS} PROPERTIES COMPILE_FLAGS ${SPIRV_WARNINGS})
+default_compile_options(${SPIRV_TOOLS})
+target_include_directories(${SPIRV_TOOLS} PUBLIC
+ ${CMAKE_CURRENT_SOURCE_DIR}/include
+ ${CMAKE_CURRENT_SOURCE_DIR}/external/include)
-option(SPIRV_SKIP_EXECUTABLES "Skip building the executables and tests along with the library" ${SPIRV_SKIP_EXECUTABLES})
-
-set(SPIRV_BUILT_TARGETS ${SPIRV_TOOLS})
+option(SPIRV_SKIP_EXECUTABLES
+ "Skip building the executables and tests along with the library" OFF)
+set(SPIRV_INSTALL_TARGETS ${SPIRV_TOOLS})
if (NOT ${SPIRV_SKIP_EXECUTABLES})
- list(APPEND SPIRV_BUILT_TARGETS spirv-as spirv-dis spirv-val)
- add_executable(spirv-as
- ${CMAKE_CURRENT_SOURCE_DIR}/include/libspirv/libspirv.h
- ${CMAKE_CURRENT_SOURCE_DIR}/tools/as/as.cpp)
- set_target_properties(spirv-as PROPERTIES COMPILE_FLAGS ${SPIRV_WARNINGS})
- target_link_libraries(spirv-as ${SPIRV_TOOLS})
+ list(APPEND SPIRV_INSTALL_TARGETS spirv-as spirv-dis spirv-val)
- add_executable(spirv-dis
- ${CMAKE_CURRENT_SOURCE_DIR}/include/libspirv/libspirv.h
- ${CMAKE_CURRENT_SOURCE_DIR}/tools/dis/dis.cpp)
- set_target_properties(spirv-dis PROPERTIES COMPILE_FLAGS ${SPIRV_WARNINGS})
- target_link_libraries(spirv-dis ${SPIRV_TOOLS})
+ add_executable(spirv-as ${CMAKE_CURRENT_SOURCE_DIR}/tools/as/as.cpp)
+ default_compile_options(spirv-as)
+ target_link_libraries(spirv-as PRIVATE ${SPIRV_TOOLS})
- add_executable(spirv-val
- ${CMAKE_CURRENT_SOURCE_DIR}/include/libspirv/libspirv.h
- ${CMAKE_CURRENT_SOURCE_DIR}/tools/val/val.cpp)
- set_target_properties(spirv-val PROPERTIES COMPILE_FLAGS ${SPIRV_WARNINGS})
- target_link_libraries(spirv-val ${SPIRV_TOOLS})
+ add_executable(spirv-dis ${CMAKE_CURRENT_SOURCE_DIR}/tools/dis/dis.cpp)
+ default_compile_options(spirv-dis)
+ target_link_libraries(spirv-dis PRIVATE ${SPIRV_TOOLS})
+
+ add_executable(spirv-val ${CMAKE_CURRENT_SOURCE_DIR}/tools/val/val.cpp)
+ default_compile_options(spirv-val)
+ target_link_libraries(spirv-val PRIVATE ${SPIRV_TOOLS})
set(GMOCK_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/googletest/googlemock)
if(EXISTS ${GMOCK_DIR})
@@ -172,11 +157,7 @@
if (TARGET gmock)
message(STATUS "Found Google Mock, building tests.")
- include_directories(SYSTEM
- ${gmock_SOURCE_DIR}/include
- ${gtest_SOURCE_DIR}/include)
-
- add_executable(UnitSPIRV
+ set(TEST_SOURCES
${CMAKE_CURRENT_SOURCE_DIR}/test/TestFixture.h
${CMAKE_CURRENT_SOURCE_DIR}/test/UnitSPIRV.h
@@ -232,14 +213,18 @@
${CMAKE_CURRENT_SOURCE_DIR}/test/ValidateID.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test/main.cpp)
- target_link_libraries(UnitSPIRV ${SPIRV_TOOLS} gmock)
+ add_executable(UnitSPIRV ${TEST_SOURCES})
+ default_compile_options(UnitSPIRV)
+ target_include_directories(UnitSPIRV PRIVATE
+ ${gmock_SOURCE_DIR}/include ${gtest_SOURCE_DIR}/include)
+ target_link_libraries(UnitSPIRV PRIVATE ${SPIRV_TOOLS} gmock)
else()
message(STATUS "Did not find googletest, tests will not be built."
"To enable tests place googletest in '<spirv-dir>/external/googletest'.")
endif()
endif()
-install(TARGETS ${SPIRV_BUILT_TARGETS}
+install(TARGETS ${SPIRV_INSTALL_TARGETS}
RUNTIME DESTINATION bin
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib)
diff --git a/include/util/hex_float.h b/include/util/hex_float.h
index 7c17c75..b0f7522 100644
--- a/include/util/hex_float.h
+++ b/include/util/hex_float.h
@@ -488,7 +488,7 @@
fraction = (fraction >> HF::fraction_right_shift) & HF::fraction_encode_mask;
- const uint_type max_exponent =
+ const int_type max_exponent =
SetBits<uint_type, 0, HF::num_exponent_bits>::get;
// Handle actual denorm numbers
diff --git a/source/disassemble.cpp b/source/disassemble.cpp
index 6ffd661..14ae53a 100644
--- a/source/disassemble.cpp
+++ b/source/disassemble.cpp
@@ -51,9 +51,8 @@
public:
Disassembler(const libspirv::AssemblyGrammar& grammar, uint32_t const* words,
- size_t num_words, uint32_t options)
+ uint32_t options)
: words_(words),
- num_words_(num_words),
grammar_(grammar),
print_(spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_PRINT, options)),
color_(print_ &&
@@ -115,7 +114,6 @@
// The SPIR-V binary. The endianness is not necessarily converted
// to native endianness.
const uint32_t* const words_;
- const size_t num_words_;
const libspirv::AssemblyGrammar& grammar_;
const bool print_; // Should we also print to the standard output stream?
const bool color_; // Should we print in colour?
@@ -391,7 +389,7 @@
const libspirv::AssemblyGrammar grammar(context);
if (!grammar.isValid()) return SPV_ERROR_INVALID_TABLE;
- Disassembler disassembler(grammar, code, wordCount, options);
+ Disassembler disassembler(grammar, code, options);
if (auto error = spvBinaryParse(context, &disassembler, code, wordCount,
DisassembleHeader, DisassembleInstruction,
pDiagnostic)) {
diff --git a/source/text_handler.cpp b/source/text_handler.cpp
index c8d3d78..b7ee587 100644
--- a/source/text_handler.cpp
+++ b/source/text_handler.cpp
@@ -501,8 +501,9 @@
// should be zero.
failed = (value & overflow_mask);
} else {
+ const uint64_t value_as_u64 = static_cast<uint64_t>(value);
// Check overflow in the ordinary case.
- failed = (value & magnitude_mask) != value;
+ failed = (value_as_u64 & magnitude_mask) != value_as_u64;
}
}
diff --git a/test/AssemblyFormat.cpp b/test/AssemblyFormat.cpp
index aa5bda8..732ae4c 100644
--- a/test/AssemblyFormat.cpp
+++ b/test/AssemblyFormat.cpp
@@ -40,7 +40,7 @@
"Expected <result-id> at the beginning of an instruction, found "
"'OpTypeMatrix'.",
diagnostic->error);
- EXPECT_EQ(0, diagnostic->position.line);
+ EXPECT_EQ(0u, diagnostic->position.line);
}
} // anonymous namespace
diff --git a/test/BinaryHeaderGet.cpp b/test/BinaryHeaderGet.cpp
index b128aed..118d399 100644
--- a/test/BinaryHeaderGet.cpp
+++ b/test/BinaryHeaderGet.cpp
@@ -62,7 +62,7 @@
ASSERT_EQ(SPV_SUCCESS, spvBinaryHeaderGet(&const_bin, endian, &header));
ASSERT_EQ(static_cast<uint32_t>(SpvMagicNumber), header.magic);
- ASSERT_EQ(0x10000, header.version);
+ ASSERT_EQ(0x10000u, header.version);
ASSERT_EQ(static_cast<uint32_t>(SPV_GENERATOR_CODEPLAY), header.generator);
ASSERT_EQ(1u, header.bound);
ASSERT_EQ(0u, header.schema);
@@ -83,7 +83,7 @@
}
TEST_F(BinaryHeaderGet, TruncatedHeader) {
- for (int i = 1; i < SPV_INDEX_INSTRUCTION; i++) {
+ for (uint8_t i = 1; i < SPV_INDEX_INSTRUCTION; i++) {
binary.wordCount = i;
spv_const_binary_t const_bin = get_const_binary();
ASSERT_EQ(SPV_ERROR_INVALID_BINARY,
diff --git a/test/BinaryToText.cpp b/test/BinaryToText.cpp
index 3156d07..f1b464a 100644
--- a/test/BinaryToText.cpp
+++ b/test/BinaryToText.cpp
@@ -120,7 +120,7 @@
CompileSuccessfully("");
EXPECT_EQ(SPV_INDEX_INSTRUCTION, binary->wordCount);
- for (int length = 0; length < SPV_INDEX_INSTRUCTION; length++) {
+ for (size_t length = 0; length < SPV_INDEX_INSTRUCTION; length++) {
spv_text text = nullptr;
spv_diagnostic diagnostic = nullptr;
EXPECT_EQ(
@@ -230,9 +230,6 @@
// This could detect problems in updating the expected-set-of-operands
// list.
TEST_F(TextToBinaryTest, OperandWithOperands) {
- spv_binary binary;
- spv_diagnostic diagnostic = nullptr;
-
const std::string input = R"(OpEntryPoint Kernel %1 "foo"
OpExecutionMode %1 LocalSizeHint 100 200 300
%2 = OpTypeVoid
@@ -428,7 +425,7 @@
TEST_P(GeneratorStringTest, Sample) {
auto words = CompileSuccessfully("");
- EXPECT_EQ(SPV_INDEX_GENERATOR_NUMBER, 2);
+ EXPECT_EQ(2u, SPV_INDEX_GENERATOR_NUMBER);
words[SPV_INDEX_GENERATOR_NUMBER] =
SPV_GENERATOR_WORD(GetParam().generator, GetParam().misc);
diff --git a/test/ExtInstGLSLstd450.cpp b/test/ExtInstGLSLstd450.cpp
index 4e21f3a..f30232f 100644
--- a/test/ExtInstGLSLstd450.cpp
+++ b/test/ExtInstGLSLstd450.cpp
@@ -113,12 +113,6 @@
spvContextDestroy(context);
}
-static const char* kF32Type = R"(%4 = OpTypeFloat 32)";
-static const char* kF32Const = R"(%5 = OpConstant %4 1)";
-static const char* kU32Type = R"(%4 = OpTypeInt 32 0)";
-static const char* kS32Type = R"(%4 = OpTypeInt 32 1)";
-static const char* kI32Const = R"(%5 = OpConstant %4 1)";
-
INSTANTIATE_TEST_CASE_P(
ExtInstParameters, ExtInstGLSLstd450RoundTripTest,
::testing::ValuesIn(std::vector<ExtInstContext>({
diff --git a/test/HexFloat.cpp b/test/HexFloat.cpp
index b4e96d7..d73f6f4 100644
--- a/test/HexFloat.cpp
+++ b/test/HexFloat.cpp
@@ -349,18 +349,18 @@
EXPECT_TRUE(std::isnan(FloatProxy<float>(uint32_t(0x7F80F000)).getAsFloat()));
EXPECT_TRUE(std::isnan(FloatProxy<float>(uint32_t(0x7FFFFFFF)).getAsFloat()));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0xFF800000)).data(), Eq(0xFF800000));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0x7F800000)).data(), Eq(0x7F800000));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0xFFC00000)).data(), Eq(0xFFC00000));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0xFF800100)).data(), Eq(0xFF800100));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0xFF800c00)).data(), Eq(0xFF800c00));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0xFF80F000)).data(), Eq(0xFF80F000));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0xFFFFFFFF)).data(), Eq(0xFFFFFFFF));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0x7FC00000)).data(), Eq(0x7FC00000));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0x7F800100)).data(), Eq(0x7F800100));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0x7f800c00)).data(), Eq(0x7f800c00));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0x7F80F000)).data(), Eq(0x7F80F000));
- EXPECT_THAT(FloatProxy<float>(uint32_t(0x7FFFFFFF)).data(), Eq(0x7FFFFFFF));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0xFF800000)).data(), Eq(0xFF800000u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0x7F800000)).data(), Eq(0x7F800000u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0xFFC00000)).data(), Eq(0xFFC00000u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0xFF800100)).data(), Eq(0xFF800100u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0xFF800c00)).data(), Eq(0xFF800c00u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0xFF80F000)).data(), Eq(0xFF80F000u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0xFFFFFFFF)).data(), Eq(0xFFFFFFFFu));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0x7FC00000)).data(), Eq(0x7FC00000u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0x7F800100)).data(), Eq(0x7F800100u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0x7f800c00)).data(), Eq(0x7f800c00u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0x7F80F000)).data(), Eq(0x7F80F000u));
+ EXPECT_THAT(FloatProxy<float>(uint32_t(0x7FFFFFFF)).data(), Eq(0x7FFFFFFFu));
}
TEST(FloatProxy, Nan) {
@@ -425,7 +425,7 @@
std::string NormalizeExponentInFloatString(std::string in) {
std::string result;
// Reserve one spot for the terminating null, even when the sscanf fails.
- std::vector<char> prefix(in.size()+1);
+ std::vector<char> prefix(in.size() + 1);
char e;
char plus_or_minus;
int exponent; // in base 10
diff --git a/test/ImmediateInt.cpp b/test/ImmediateInt.cpp
index e78ddfe..4778709 100644
--- a/test/ImmediateInt.cpp
+++ b/test/ImmediateInt.cpp
@@ -48,7 +48,7 @@
SetText("!0x00FF00FF");
ASSERT_EQ(SPV_SUCCESS, spvTextToBinary(context, text.str, text.length,
&binary, &diagnostic));
- EXPECT_EQ(0x00FF00FF, binary->code[5]);
+ EXPECT_EQ(0x00FF00FFu, binary->code[5]);
if (diagnostic) {
spvDiagnosticPrint(diagnostic);
}
@@ -58,7 +58,7 @@
SetText("OpCapability !0x00FF00FF");
EXPECT_EQ(SPV_SUCCESS, spvTextToBinary(context, text.str, text.length,
&binary, &diagnostic));
- EXPECT_EQ(0x00FF00FF, binary->code[6]);
+ EXPECT_EQ(0x00FF00FFu, binary->code[6]);
if (diagnostic) {
spvDiagnosticPrint(diagnostic);
}
@@ -241,7 +241,7 @@
!0x0002003D %10 %1 %2 !1
OpCopyMemorySized %3 %4 %1
)");
- EXPECT_EQ(0x0002003D, alternate[kFirstInstruction]);
+ EXPECT_EQ(0x0002003Du, alternate[kFirstInstruction]);
EXPECT_EQ(Subvector(original, kFirstInstruction + 1),
Subvector(alternate, kFirstInstruction + 1));
}
diff --git a/test/OpcodeTableGet.cpp b/test/OpcodeTableGet.cpp
index 03ffd4d..f908987 100644
--- a/test/OpcodeTableGet.cpp
+++ b/test/OpcodeTableGet.cpp
@@ -31,7 +31,7 @@
TEST(OpcodeTableGet, Default) {
spv_opcode_table table;
ASSERT_EQ(SPV_SUCCESS, spvOpcodeTableGet(&table));
- ASSERT_NE(0, table->count);
+ ASSERT_NE(0u, table->count);
ASSERT_NE(nullptr, table->entries);
}
diff --git a/test/Operand.cpp b/test/Operand.cpp
index e9f5abe..df4077b 100644
--- a/test/Operand.cpp
+++ b/test/Operand.cpp
@@ -31,7 +31,7 @@
TEST(OperandTableGet, Default) {
spv_operand_table table;
ASSERT_EQ(SPV_SUCCESS, spvOperandTableGet(&table));
- ASSERT_NE(0, table->count);
+ ASSERT_NE(0u, table->count);
ASSERT_NE(nullptr, table->types);
}
@@ -40,7 +40,8 @@
}
TEST(OperandString, AllAreDefinedExceptVariable) {
- EXPECT_EQ(0, SPV_OPERAND_TYPE_NONE); // None has no string, so don't test it.
+ // None has no string, so don't test it.
+ EXPECT_EQ(0u, SPV_OPERAND_TYPE_NONE);
// Start testing at enum with value 1, skipping None.
for (int i = 1; i < int(SPV_OPERAND_TYPE_FIRST_VARIABLE_TYPE); i++) {
EXPECT_NE(nullptr, spvOperandTypeStr(static_cast<spv_operand_type_t>(i)))
diff --git a/test/OperandPattern.cpp b/test/OperandPattern.cpp
index eaf4d4c..12049e8 100644
--- a/test/OperandPattern.cpp
+++ b/test/OperandPattern.cpp
@@ -139,7 +139,7 @@
if (!spvOperandIsVariable(type)) {
spv_operand_pattern_t pattern;
const bool did_expand = spvExpandOperandSequenceOnce(type, &pattern);
- EXPECT_EQ(false, did_expand);
+ EXPECT_FALSE(did_expand);
EXPECT_THAT(pattern, Eq(spv_operand_pattern_t{}));
}
}
@@ -156,7 +156,7 @@
if (spvOperandIsVariable(type)) {
spv_operand_pattern_t pattern;
const bool did_expand = spvExpandOperandSequenceOnce(type, &pattern);
- EXPECT_EQ(true, did_expand);
+ EXPECT_TRUE(did_expand);
EXPECT_FALSE(pattern.empty());
// For the existing rules, the first expansion of a zero-or-more operand
// type yields a matchable operand type. This isn't strictly necessary.
diff --git a/test/TextAdvance.cpp b/test/TextAdvance.cpp
index ed435ee..38e43b5 100644
--- a/test/TextAdvance.cpp
+++ b/test/TextAdvance.cpp
@@ -35,45 +35,45 @@
AutoText input("\n\nWord");
AssemblyContext data(input, nullptr);
ASSERT_EQ(SPV_SUCCESS, data.advance());
- ASSERT_EQ(0, data.position().column);
- ASSERT_EQ(2, data.position().line);
- ASSERT_EQ(2, data.position().index);
+ ASSERT_EQ(0u, data.position().column);
+ ASSERT_EQ(2u, data.position().line);
+ ASSERT_EQ(2u, data.position().index);
}
TEST(TextAdvance, LeadingSpaces) {
AutoText input(" Word");
AssemblyContext data(input, nullptr);
ASSERT_EQ(SPV_SUCCESS, data.advance());
- ASSERT_EQ(4, data.position().column);
- ASSERT_EQ(0, data.position().line);
- ASSERT_EQ(4, data.position().index);
+ ASSERT_EQ(4u, data.position().column);
+ ASSERT_EQ(0u, data.position().line);
+ ASSERT_EQ(4u, data.position().index);
}
TEST(TextAdvance, LeadingTabs) {
AutoText input("\t\t\tWord");
AssemblyContext data(input, nullptr);
ASSERT_EQ(SPV_SUCCESS, data.advance());
- ASSERT_EQ(3, data.position().column);
- ASSERT_EQ(0, data.position().line);
- ASSERT_EQ(3, data.position().index);
+ ASSERT_EQ(3u, data.position().column);
+ ASSERT_EQ(0u, data.position().line);
+ ASSERT_EQ(3u, data.position().index);
}
TEST(TextAdvance, LeadingNewLinesSpacesAndTabs) {
AutoText input("\n\n\t Word");
AssemblyContext data(input, nullptr);
ASSERT_EQ(SPV_SUCCESS, data.advance());
- ASSERT_EQ(3, data.position().column);
- ASSERT_EQ(2, data.position().line);
- ASSERT_EQ(5, data.position().index);
+ ASSERT_EQ(3u, data.position().column);
+ ASSERT_EQ(2u, data.position().line);
+ ASSERT_EQ(5u, data.position().index);
}
TEST(TextAdvance, LeadingWhitespaceAfterCommentLine) {
AutoText input("; comment\n \t \tWord");
AssemblyContext data(input, nullptr);
ASSERT_EQ(SPV_SUCCESS, data.advance());
- ASSERT_EQ(4, data.position().column);
- ASSERT_EQ(1, data.position().line);
- ASSERT_EQ(14, data.position().index);
+ ASSERT_EQ(4u, data.position().column);
+ ASSERT_EQ(1u, data.position().line);
+ ASSERT_EQ(14u, data.position().index);
}
TEST(TextAdvance, EOFAfterCommentLine) {
@@ -91,7 +91,7 @@
TEST(TextAdvance, NoNullTerminator) {
spv_text_t text = {"OpNop\nSomething else in memory", 6};
AssemblyContext data(&text, nullptr);
- const spv_position_t line_break = {1, 5, 5};
+ const spv_position_t line_break = {1u, 5u, 5u};
data.setPosition(line_break);
ASSERT_EQ(SPV_END_OF_STREAM, data.advance());
}
diff --git a/test/TextDestroy.cpp b/test/TextDestroy.cpp
index a55d572..60323d1 100644
--- a/test/TextDestroy.cpp
+++ b/test/TextDestroy.cpp
@@ -60,7 +60,7 @@
&binary, &diagnostic));
EXPECT_NE(nullptr, binary);
EXPECT_NE(nullptr, binary->code);
- EXPECT_NE(0, binary->wordCount);
+ EXPECT_NE(0u, binary->wordCount);
if (diagnostic) {
spvDiagnosticPrint(diagnostic);
ASSERT_TRUE(false);
@@ -77,7 +77,7 @@
ASSERT_TRUE(false);
}
EXPECT_NE(nullptr, resultText->str);
- EXPECT_NE(0, resultText->length);
+ EXPECT_NE(0u, resultText->length);
spvTextDestroy(resultText);
spvContextDestroy(context);
}
diff --git a/test/TextLiteral.cpp b/test/TextLiteral.cpp
index 301ad6c..24f40a2 100644
--- a/test/TextLiteral.cpp
+++ b/test/TextLiteral.cpp
@@ -71,7 +71,7 @@
ASSERT_EQ(SPV_SUCCESS, spvTextToLiteral("4294967296", &l));
EXPECT_EQ(SPV_LITERAL_TYPE_UINT_64, l.type);
- EXPECT_EQ(4294967296, l.value.u64);
+ EXPECT_EQ(4294967296u, l.value.u64);
}
TEST(TextLiteral, GoodFloat) {
diff --git a/test/TextToBinary.Memory.cpp b/test/TextToBinary.Memory.cpp
index 9d60ee2..2672852 100644
--- a/test/TextToBinary.Memory.cpp
+++ b/test/TextToBinary.Memory.cpp
@@ -68,7 +68,7 @@
const std::string input = "OpStore %ptr %value Volatile|Aligned 16";
const uint32_t expected_mask =
SpvMemoryAccessVolatileMask | SpvMemoryAccessAlignedMask;
- EXPECT_THAT(expected_mask, Eq(3));
+ EXPECT_THAT(expected_mask, Eq(3u));
EXPECT_THAT(CompiledInstructions(input),
Eq(MakeInstruction(SpvOpStore, {1, 2, expected_mask, 16})));
}
diff --git a/test/TextToBinary.cpp b/test/TextToBinary.cpp
index a5f5493..c847a05 100644
--- a/test/TextToBinary.cpp
+++ b/test/TextToBinary.cpp
@@ -187,32 +187,32 @@
"found 'Google'.",
CompileFailure(
"\nOpSource OpenCL_C 12\nOpMemoryModel Physical64 OpenCL\nGoogle\n"));
- EXPECT_EQ(4, diagnostic->position.line + 1);
- EXPECT_EQ(1, diagnostic->position.column + 1);
+ EXPECT_EQ(4u, diagnostic->position.line + 1);
+ EXPECT_EQ(1u, diagnostic->position.column + 1);
}
TEST_F(TextToBinaryTest, NoEqualSign) {
EXPECT_EQ("Expected '=', found end of stream.",
CompileFailure("\nOpSource OpenCL_C 12\n"
"OpMemoryModel Physical64 OpenCL\n%2\n"));
- EXPECT_EQ(5, diagnostic->position.line + 1);
- EXPECT_EQ(1, diagnostic->position.column + 1);
+ EXPECT_EQ(5u, diagnostic->position.line + 1);
+ EXPECT_EQ(1u, diagnostic->position.column + 1);
}
TEST_F(TextToBinaryTest, NoOpCode) {
EXPECT_EQ("Expected opcode, found end of stream.",
CompileFailure("\nOpSource OpenCL_C 12\n"
"OpMemoryModel Physical64 OpenCL\n%2 =\n"));
- EXPECT_EQ(5, diagnostic->position.line + 1);
- EXPECT_EQ(1, diagnostic->position.column + 1);
+ EXPECT_EQ(5u, diagnostic->position.line + 1);
+ EXPECT_EQ(1u, diagnostic->position.column + 1);
}
TEST_F(TextToBinaryTest, WrongOpCode) {
EXPECT_EQ("Invalid Opcode prefix 'Wahahaha'.",
CompileFailure("\nOpSource OpenCL_C 12\n"
"OpMemoryModel Physical64 OpenCL\n%2 = Wahahaha\n"));
- EXPECT_EQ(4, diagnostic->position.line + 1);
- EXPECT_EQ(6, diagnostic->position.column + 1);
+ EXPECT_EQ(4u, diagnostic->position.line + 1);
+ EXPECT_EQ(6u, diagnostic->position.column + 1);
}
using TextToBinaryFloatValueTest = spvtest::TextToBinaryTestBase<
@@ -322,12 +322,12 @@
EXPECT_EQ(SPV_FAILED_MATCH, context.parseNumber("", ec, &u64, ""));
EXPECT_EQ(SPV_FAILED_MATCH, context.parseNumber("0=", ec, &u64, ""));
EXPECT_EQ(SPV_SUCCESS, context.parseNumber("0", ec, &u64, ""));
- EXPECT_EQ(0, u64);
+ EXPECT_EQ(0u, u64);
EXPECT_EQ(SPV_SUCCESS,
context.parseNumber("0xffffffffffffffff", ec, &u64, ""));
EXPECT_EQ(0xffffffffffffffffULL, u64);
EXPECT_EQ(SPV_SUCCESS, context.parseNumber("-0", ec, &u64, ""));
- EXPECT_EQ(0, u64);
+ EXPECT_EQ(0u, u64);
EXPECT_EQ(SPV_FAILED_MATCH, context.parseNumber("-1", ec, &u64, ""));
}
diff --git a/test/TextWordGet.cpp b/test/TextWordGet.cpp
index 4345795..f5e58ef 100644
--- a/test/TextWordGet.cpp
+++ b/test/TextWordGet.cpp
@@ -41,9 +41,9 @@
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS, AssemblyContext(AutoText("Word"), nullptr)
.getWord(word, &endPosition));
- ASSERT_EQ(4, endPosition.column);
- ASSERT_EQ(0, endPosition.line);
- ASSERT_EQ(4, endPosition.index);
+ ASSERT_EQ(4u, endPosition.column);
+ ASSERT_EQ(0u, endPosition.line);
+ ASSERT_EQ(4u, endPosition.index);
ASSERT_STREQ("Word", word.c_str());
}
@@ -52,9 +52,9 @@
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS, AssemblyContext(AutoText("Word\t"), nullptr)
.getWord(word, &endPosition));
- ASSERT_EQ(4, endPosition.column);
- ASSERT_EQ(0, endPosition.line);
- ASSERT_EQ(4, endPosition.index);
+ ASSERT_EQ(4u, endPosition.column);
+ ASSERT_EQ(0u, endPosition.line);
+ ASSERT_EQ(4u, endPosition.index);
ASSERT_STREQ("Word", word.c_str());
}
@@ -63,9 +63,9 @@
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS, AssemblyContext(AutoText("Word "), nullptr)
.getWord(word, &endPosition));
- ASSERT_EQ(4, endPosition.column);
- ASSERT_EQ(0, endPosition.line);
- ASSERT_EQ(4, endPosition.index);
+ ASSERT_EQ(4u, endPosition.column);
+ ASSERT_EQ(0u, endPosition.line);
+ ASSERT_EQ(4u, endPosition.index);
ASSERT_STREQ("Word", word.c_str());
}
@@ -74,9 +74,9 @@
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS, AssemblyContext(AutoText("Wo;rd"), nullptr)
.getWord(word, &endPosition));
- ASSERT_EQ(2, endPosition.column);
- ASSERT_EQ(0, endPosition.line);
- ASSERT_EQ(2, endPosition.index);
+ ASSERT_EQ(2u, endPosition.column);
+ ASSERT_EQ(0u, endPosition.line);
+ ASSERT_EQ(2u, endPosition.index);
ASSERT_STREQ("Wo", word.c_str());
}
@@ -92,7 +92,7 @@
ASSERT_EQ(SPV_SUCCESS, data.getWord(word, &endPosition));
ASSERT_EQ(strlen(words[wordIndex]),
endPosition.column - data.position().column);
- ASSERT_EQ(0, endPosition.line);
+ ASSERT_EQ(0u, endPosition.line);
ASSERT_EQ(strlen(words[wordIndex]),
endPosition.index - data.position().index);
ASSERT_STREQ(words[wordIndex], word.c_str());
@@ -114,9 +114,9 @@
std::string word;
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS, data.getWord(word, &endPosition));
- EXPECT_EQ(8, endPosition.column);
- EXPECT_EQ(0, endPosition.line);
- EXPECT_EQ(8, endPosition.index);
+ EXPECT_EQ(8u, endPosition.column);
+ EXPECT_EQ(0u, endPosition.line);
+ EXPECT_EQ(8u, endPosition.index);
EXPECT_STREQ(expected[0], word.c_str());
// Move to the next word.
@@ -124,9 +124,9 @@
data.seekForward(1);
ASSERT_EQ(SPV_SUCCESS, data.getWord(word, &endPosition));
- EXPECT_EQ(23, endPosition.column);
- EXPECT_EQ(0, endPosition.line);
- EXPECT_EQ(23, endPosition.index);
+ EXPECT_EQ(23u, endPosition.column);
+ EXPECT_EQ(0u, endPosition.line);
+ EXPECT_EQ(23u, endPosition.index);
EXPECT_STREQ(expected[1], word.c_str());
}
@@ -138,9 +138,9 @@
std::string word;
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS, data.getWord(word, &endPosition));
- EXPECT_EQ(16, endPosition.column);
- EXPECT_EQ(0, endPosition.line);
- EXPECT_EQ(16, endPosition.index);
+ EXPECT_EQ(16u, endPosition.column);
+ EXPECT_EQ(0u, endPosition.line);
+ EXPECT_EQ(16u, endPosition.index);
EXPECT_STREQ(expected[0], word.c_str());
// Move to the next word.
@@ -148,9 +148,9 @@
data.seekForward(1);
ASSERT_EQ(SPV_SUCCESS, data.getWord(word, &endPosition));
- EXPECT_EQ(22, endPosition.column);
- EXPECT_EQ(0, endPosition.line);
- EXPECT_EQ(22, endPosition.index);
+ EXPECT_EQ(22u, endPosition.column);
+ EXPECT_EQ(0u, endPosition.line);
+ EXPECT_EQ(22u, endPosition.index);
EXPECT_STREQ(expected[1], word.c_str());
}
@@ -158,12 +158,11 @@
AutoText input(QUOTE "white " NEWLINE TAB " space" QUOTE);
// Whitespace surrounded by quotes acts like glue.
std::string word;
- spv_position_t startPosition = {};
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS,
AssemblyContext(input, nullptr).getWord(word, &endPosition));
EXPECT_EQ(input.str.length(), endPosition.column);
- EXPECT_EQ(0, endPosition.line);
+ EXPECT_EQ(0u, endPosition.line);
EXPECT_EQ(input.str.length(), endPosition.index);
EXPECT_EQ(input.str, word);
}
@@ -174,9 +173,9 @@
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS,
AssemblyContext(input, nullptr).getWord(word, &endPosition));
- ASSERT_EQ(1, endPosition.column);
- ASSERT_EQ(0, endPosition.line);
- ASSERT_EQ(1, endPosition.index);
+ ASSERT_EQ(1u, endPosition.column);
+ ASSERT_EQ(0u, endPosition.line);
+ ASSERT_EQ(1u, endPosition.index);
ASSERT_STREQ(QUOTE, word.c_str());
}
@@ -186,9 +185,9 @@
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS,
AssemblyContext(input, nullptr).getWord(word, &endPosition));
- ASSERT_EQ(1, endPosition.column);
- ASSERT_EQ(0, endPosition.line);
- ASSERT_EQ(1, endPosition.index);
+ ASSERT_EQ(1u, endPosition.column);
+ ASSERT_EQ(0u, endPosition.line);
+ ASSERT_EQ(1u, endPosition.index);
ASSERT_STREQ(BACKSLASH, word.c_str());
}
@@ -198,9 +197,9 @@
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS,
AssemblyContext(input, nullptr).getWord(word, &endPosition));
- ASSERT_EQ(5, endPosition.column);
- ASSERT_EQ(0, endPosition.line);
- ASSERT_EQ(5, endPosition.index);
+ ASSERT_EQ(5u, endPosition.column);
+ ASSERT_EQ(0u, endPosition.line);
+ ASSERT_EQ(5u, endPosition.index);
ASSERT_STREQ("word" BACKSLASH, word.c_str());
}
@@ -210,9 +209,9 @@
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS,
AssemblyContext(input, nullptr).getWord(word, &endPosition));
- ASSERT_EQ(10, endPosition.column);
- ASSERT_EQ(0, endPosition.line);
- ASSERT_EQ(10, endPosition.index);
+ ASSERT_EQ(10u, endPosition.column);
+ ASSERT_EQ(0u, endPosition.line);
+ ASSERT_EQ(10u, endPosition.index);
ASSERT_EQ(input.str, word);
}
@@ -222,9 +221,9 @@
spv_position_t endPosition = {};
ASSERT_EQ(SPV_SUCCESS,
AssemblyContext(input, nullptr).getWord(word, &endPosition));
- ASSERT_EQ(6, endPosition.column);
- ASSERT_EQ(0, endPosition.line);
- ASSERT_EQ(6, endPosition.index);
+ ASSERT_EQ(6u, endPosition.column);
+ ASSERT_EQ(0u, endPosition.line);
+ ASSERT_EQ(6u, endPosition.index);
ASSERT_STREQ("word" BACKSLASH BACKSLASH, word.c_str());
}
diff --git a/test/UnitSPIRV.h b/test/UnitSPIRV.h
index 7b7fb5b..1545915 100644
--- a/test/UnitSPIRV.h
+++ b/test/UnitSPIRV.h
@@ -202,7 +202,7 @@
// characters. Ideally, we would just use a C++11 UTF-8 string literal,
// but we want to support older Microsoft compilers.
const std::basic_string<char> earth_africa("\xF0\x9F\x8C\x8D");
- EXPECT_EQ(4, earth_africa.size());
+ EXPECT_EQ(4u, earth_africa.size());
std::string result;
result.reserve(num_4_byte_chars * 4);
