- 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.
cmake_minimum_required(VERSION 2.8)
project(spirv-tools)
+set(SPIRV_TOOLS "SPIRV-Tools")
if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
add_definitions(-DSPIRV_LINUX)
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)
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")
- 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")
+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()
-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
${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" OFF)
+set(SPIRV_INSTALL_TARGETS ${SPIRV_TOOLS})
+if (NOT ${SPIRV_SKIP_EXECUTABLES})
+ list(APPEND SPIRV_INSTALL_TARGETS spirv-as spirv-dis spirv-val)
-option(SPIRV_SKIP_EXECUTABLES "Skip building the executables and tests along with the library" ${SPIRV_SKIP_EXECUTABLES})
+ 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})
-set(SPIRV_BUILT_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})
-
- 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-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})
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
${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)
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
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_ &&
// 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?
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)) {
// 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;
}
}
"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
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);
}
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,
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(
// 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
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);
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>({
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) {
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
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);
}
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);
}
!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));
}
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);
}
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);
}
}
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)))
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{}));
}
}
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.
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) {
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());
}
&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);
ASSERT_TRUE(false);
}
EXPECT_NE(nullptr, resultText->str);
- EXPECT_NE(0, resultText->length);
+ EXPECT_NE(0u, resultText->length);
spvTextDestroy(resultText);
spvContextDestroy(context);
}
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) {
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})));
}
"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<
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, ""));
}
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());
}
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());
}
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());
}
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());
}
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());
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.
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());
}
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.
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());
}
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);
}
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());
}
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());
}
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());
}
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);
}
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());
}
// 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);