test: add binder tests for errors

Add a test for every error not covered, as reported by lcov for lines
changed after the stringFormat change.

dataset/csv-error-tests/union-no-conversion.csv

@@ -0,0 +1,2 @@
+"col:UNION(u UINT8, s INT8)"
+a

src/binder/bind/bind_create_macro.cpp

@@ -2,6 +2,7 @@
 #include "binder/bound_create_macro.h"
 #include "common/exception/binder.h"
 #include "common/string_format.h"
+#include "common/string_utils.h"
 #include "parser/create_macro.h"
 
 using namespace kuzu::common;
@@ -13,6 +14,7 @@ namespace binder {
 std::unique_ptr<BoundStatement> Binder::bindCreateMacro(const Statement& statement) {
     auto& createMacro = reinterpret_cast<const CreateMacro&>(statement);
     auto macroName = createMacro.getMacroName();
+    StringUtils::toUpper(macroName);
     if (catalog.getReadOnlyVersion()->containMacro(macroName)) {
         throw BinderException{stringFormat("Macro {} already exists.", macroName)};
     }
@@ -23,7 +25,7 @@ std::unique_ptr<BoundStatement> Binder::bindCreateMacro(const Statement& stateme
     auto scalarMacro =
         std::make_unique<function::ScalarMacroFunction>(createMacro.getMacroExpression()->copy(),
             createMacro.getPositionalArgs(), std::move(defaultArgs));
-    return std::make_unique<BoundCreateMacro>(macroName, std::move(scalarMacro));
+    return std::make_unique<BoundCreateMacro>(std::move(macroName), std::move(scalarMacro));
 }
 
 } // namespace binder

src/binder/bind/bind_file_scan.cpp

@@ -46,9 +46,6 @@ std::vector<std::string> Binder::bindFilePaths(const std::vector<std::string>& f
         boundFilePaths.insert(
             boundFilePaths.end(), globbedFilePaths.begin(), globbedFilePaths.end());
     }
-    if (boundFilePaths.empty()) {
-        throw BinderException{stringFormat("Invalid file path: {}.", filePaths[0])};
-    }
     return boundFilePaths;
 }
 

src/binder/bind/bind_graph_pattern.cpp

@@ -186,9 +186,10 @@ static std::unique_ptr<Expression> createPropertyExpression(const std::string& p
     }
     for (auto type : propertyDataTypes) {
         if (*propertyDataTypes[0] != *type) {
-            stringFormat("Expected the same data type for property {} but found {} and {}.",
-                propertyName, LogicalTypeUtils::dataTypeToString(*type),
-                LogicalTypeUtils::dataTypeToString(*propertyDataTypes[0]));
+            throw BinderException(
+                stringFormat("Expected the same data type for property {} but found {} and {}.",
+                    propertyName, LogicalTypeUtils::dataTypeToString(*type),
+                    LogicalTypeUtils::dataTypeToString(*propertyDataTypes[0])));
         }
     }
     return make_unique<PropertyExpression>(*propertyDataTypes[0], propertyName, uniqueVariableName,

src/catalog/catalog_content.cpp

@@ -230,10 +230,12 @@ std::unique_ptr<CatalogContent> CatalogContent::copy() const {
 void CatalogContent::validateStorageVersion(storage_version_t savedStorageVersion) {
     auto storageVersion = StorageVersionInfo::getStorageVersion();
     if (savedStorageVersion != storageVersion) {
+        // LCOV_EXCL_START
         throw RuntimeException(
             stringFormat("Trying to read a database file with a different version. "
                          "Database file version: {}, Current build storage version: {}",
                 savedStorageVersion, storageVersion));
+        // LCOV_EXCL_END
     }
 }
 

src/catalog/table_schema.cpp

@@ -30,24 +30,16 @@ std::vector<Property*> TableSchema::getProperties() const {
     return propertiesToReturn;
 }
 
-std::string TableSchema::getPropertyName(property_id_t propertyID) const {
-    for (auto& property : properties) {
-        if (property->getPropertyID() == propertyID) {
-            return property->getName();
-        }
-    }
-    throw RuntimeException(stringFormat(
-        "Table: {} doesn't have a property with propertyID={}.", tableName, propertyID));
-}
-
 property_id_t TableSchema::getPropertyID(const std::string& propertyName) const {
     for (auto& property : properties) {
         if (property->getName() == propertyName) {
             return property->getPropertyID();
         }
     }
+    // LCOV_EXCL_START
     throw RuntimeException(stringFormat(
         "Table: {} doesn't have a property with propertyName={}.", tableName, propertyName));
+    // LCOV_EXCL_END
 }
 
 // TODO(Guodong): Instead of looping over properties, cache a map between propertyID and columnID.
@@ -66,8 +58,10 @@ Property* TableSchema::getProperty(property_id_t propertyID) const {
             return property.get();
         }
     }
+    // LCOV_EXCL_START
     throw RuntimeException(stringFormat(
         "Table: {} doesn't have a property with propertyID={}.", tableName, propertyID));
+    // LCOV_EXCL_END
 }
 
 void TableSchema::renameProperty(property_id_t propertyID, const std::string& newName) {
@@ -77,7 +71,9 @@ void TableSchema::renameProperty(property_id_t propertyID, const std::string& ne
             return;
         }
     }
+    // LCOV_EXCL_START
     throw InternalException(stringFormat("Property with id={} not found.", propertyID));
+    // LCOV_EXCL_END
 }
 
 void TableSchema::serialize(FileInfo* fileInfo, uint64_t& offset) {
@@ -118,7 +114,9 @@ std::unique_ptr<TableSchema> TableSchema::deserialize(FileInfo* fileInfo, uint64
         result = RdfGraphSchema::deserialize(fileInfo, offset);
     } break;
     default: {
+        // LCOV_EXCL_START
         throw NotImplementedException{"TableSchema::deserialize"};
+        // LCOV_EXCL_END
     }
     }
     result->tableName = tableName;

src/common/assert.cpp

@@ -8,11 +8,12 @@ namespace kuzu {
 namespace common {
 
 void kuAssertInternal(bool condition, const char* condition_name, const char* file, int linenr) {
-    if (condition) {
-        return;
+    if (!condition) {
+        // LCOV_EXCL_START
+        throw InternalException(stringFormat(
+            "Assertion triggered in file \"{}\" on line {}: {}", file, linenr, condition_name));
+        // LCOV_EXCL_END
     }
-    throw InternalException(stringFormat(
-        "Assertion triggered in file \"{}\" on line {}: {}", file, linenr, condition_name));
 }
 
 } // namespace common

src/common/file_utils.cpp

@@ -4,6 +4,7 @@
 
 #include "common/exception/storage.h"
 #include "common/string_format.h"
+#include "common/system_message.h"
 #include "glob/glob.hpp"
 
 #ifdef _WIN32
@@ -32,13 +33,14 @@ int64_t FileInfo::getFileSize() {
     if (!GetFileSizeEx((HANDLE)handle, &size)) {
         auto error = GetLastError();
         throw StorageException(stringFormat("Cannot read size of file. path: {} - Error {}: {}",
-            path, error, std::system_category().message(error)));
+            path, error, systemErrMessage(error)));
     }
     return size.QuadPart;
 #else
     struct stat s;
     if (fstat(fd, &s) == -1) {
-        return -1;
+        throw StorageException(stringFormat(
+            "Cannot read size of file. path: {} - Error {}: {}", path, errno, posixErrMessage()));
     }
     return s.st_size;
 #endif
@@ -99,10 +101,6 @@ std::unique_ptr<FileInfo> FileUtils::openFile(
 
 void FileUtils::writeToFile(
     FileInfo* fileInfo, const uint8_t* buffer, uint64_t numBytes, uint64_t offset) {
-    auto fileSize = fileInfo->getFileSize();
-    if (fileSize == -1) {
-        throw Exception(stringFormat("File {} not open.", fileInfo->path));
-    }
     uint64_t remainingNumBytesToWrite = numBytes;
     uint64_t bufferOffset = 0;
     // Split large writes to 1GB at a time
@@ -128,10 +126,13 @@ void FileUtils::writeToFile(
         uint64_t numBytesWritten =
             pwrite(fileInfo->fd, buffer + bufferOffset, numBytesToWrite, offset);
         if (numBytesWritten != numBytesToWrite) {
+            // LCOV_EXCL_START
             throw Exception(
                 stringFormat("Cannot write to file. path: {} fileDescriptor: {} offsetToWrite: {} "
-                             "numBytesToWrite: {} numBytesWritten: {}.",
-                    fileInfo->path, fileInfo->fd, offset, numBytesToWrite, numBytesWritten));
+                             "numBytesToWrite: {} numBytesWritten: {}. Error: {}",
+                    fileInfo->path, fileInfo->fd, offset, numBytesToWrite, numBytesWritten,
+                    posixErrMessage()));
+            // LCOV_EXCL_END
         }
 #endif
         remainingNumBytesToWrite -= numBytesWritten;
@@ -146,8 +147,10 @@ void FileUtils::copyFile(
         return;
     std::error_code errorCode;
     if (!std::filesystem::copy_file(from, to, options, errorCode)) {
+        // LCOV_EXCL_START
         throw Exception(stringFormat(
             "Error copying file {} to {}.  ErrorMessage: {}", from, to, errorCode.message()));
+        // LCOV_EXCL_END
     }
 }
 
@@ -180,24 +183,32 @@ void FileUtils::readFromFile(
 #else
     auto numBytesRead = pread(fileInfo->fd, buffer, numBytes, position);
     if (numBytesRead != numBytes && fileInfo->getFileSize() != position + numBytesRead) {
+        // LCOV_EXCL_START
         throw Exception(stringFormat("Cannot read from file: {} fileDescriptor: {} "
                                      "numBytesRead: {} numBytesToRead: {} position: {}",
             fileInfo->path, fileInfo->fd, numBytesRead, numBytes, position));
+        // LCOV_EXCL_END
     }
 #endif
 }
 
 void FileUtils::createDir(const std::string& dir) {
     try {
         if (std::filesystem::exists(dir)) {
+            // LCOV_EXCL_START
             throw Exception(stringFormat("Directory {} already exists.", dir));
+            // LCOV_EXCL_END
         }
         if (!std::filesystem::create_directory(dir)) {
+            // LCOV_EXCL_START
             throw Exception(stringFormat(
                 "Directory {} cannot be created. Check if it exists and remove it.", dir));
+            // LCOV_EXCL_END
         }
     } catch (std::exception& e) {
+        // LCOV_EXCL_START
         throw Exception(stringFormat("Failed to create directory {} due to: {}", dir, e.what()));
+        // LCOV_EXCL_END
     }
 }
 
@@ -212,8 +223,10 @@ void FileUtils::removeDir(const std::string& dir) {
     if (!fileOrPathExists(dir))
         return;
     if (!std::filesystem::remove_all(dir, removeErrorCode)) {
+        // LCOV_EXCL_START
         throw Exception(stringFormat(
-            "Error removing directory {}.  Error Message: {}", dir, removeErrorCode.message()));
+            "Error removing directory {}. Error Message: {}", dir, removeErrorCode.message()));
+        // LCOV_EXCL_END
     }
 }
 
@@ -224,17 +237,21 @@ void FileUtils::renameFileIfExists(const std::string& oldName, const std::string
     std::error_code errorCode;
     std::filesystem::rename(oldName, newName, errorCode);
     if (errorCode.value() != 0) {
+        // LCOV_EXCL_START
         throw Exception(stringFormat("Error replacing file {} to {}.  ErrorMessage: {}", oldName,
             newName, errorCode.message()));
+        // LCOV_EXCL_END
     }
 }
 
 void FileUtils::removeFileIfExists(const std::string& path) {
     if (!fileOrPathExists(path))
         return;
     if (remove(path.c_str()) != 0) {
-        throw Exception(
-            stringFormat("Error removing directory or file {}.  Error Message: ", path));
+        // LCOV_EXCL_START
+        throw Exception(stringFormat(
+            "Error removing directory or file {}.  Error Message: {}", path, posixErrMessage()));
+        // LCOV_EXCL_END
     }
 }
 
@@ -268,7 +285,12 @@ void FileUtils::truncateFileToSize(FileInfo* fileInfo, uint64_t size) {
             std::system_category().message(error)));
     }
 #else
-    ftruncate(fileInfo->fd, size);
+    if (ftruncate(fileInfo->fd, size) < 0) {
+        // LCOV_EXCL_START
+        throw Exception(
+            stringFormat("Failed to truncate file {}: {}", fileInfo->path, posixErrMessage()));
+        // LCOV_EXCL_END
+    }
 #endif
 }
 

src/common/types/blob.cpp

@@ -58,9 +58,10 @@ uint64_t Blob::fromString(const char* str, uint64_t length, uint8_t* resultBuffe
         } else if (str[i] <= 127) {
             resultBuffer[resultPos++] = str[i];
         } else {
-            throw ConversionException(
-                "Invalid byte encountered in STRING -> BLOB conversion. All non-ascii characters "
-                "must be escaped with hex codes (e.g. \\xAA)");
+            // LCOV_EXCL_START
+            throw InternalException("Invalid byte encountered in STRING -> BLOB conversion that "
+                                    "should have been caught during getBlobSize");
+            // LCOV_EXCL_END
         }
     }
     return resultPos;
@@ -89,7 +90,7 @@ void Blob::validateHexCode(const uint8_t* blobStr, uint64_t length, uint64_t cur
     if (curPos + HexFormatConstants::LENGTH > length) {
         throw ConversionException(
             "Invalid hex escape code encountered in string -> blob conversion: "
-            "unterminated escape code at end of blob");
+            "unterminated escape code at end of string");
     }
     if (memcmp(blobStr + curPos, HexFormatConstants::PREFIX, HexFormatConstants::PREFIX_LENGTH) !=
             0 ||

src/function/base_lower_upper_operation.cpp

@@ -18,10 +18,12 @@ uint32_t BaseLowerUpperFunction::getResultLen(char* inputStr, uint32_t inputLen,
             int size = 0;
             int codepoint = utf8proc_codepoint(inputStr + i, size);
             if (codepoint < 0) {
+                // LCOV_EXCL_START
                 // TODO(Xiyang): We shouldn't allow invalid UTF-8 to enter a string column.
                 std::string funcName = isUpper ? "UPPER" : "LOWER";
                 throw RuntimeException(
                     common::stringFormat("Failed calling {}: Invalid UTF-8.", funcName));
+                // LCOV_EXCL_END
             }
             int convertedCodepoint =
                 isUpper ? utf8proc_toupper(codepoint) : utf8proc_tolower(codepoint);

src/function/vector_path_functions.cpp

@@ -55,7 +55,7 @@ std::unique_ptr<FunctionBindData> PropertiesVectorFunction::bindFunc(
     const binder::expression_vector& arguments, FunctionDefinition* definition) {
     if (arguments[1]->expressionType != ExpressionType::LITERAL) {
         throw BinderException(stringFormat(
-            "Expect literal input as the second argument for {}().", PROPERTIES_FUNC_NAME));
+            "Expected literal input as the second argument for {}().", PROPERTIES_FUNC_NAME));
     }
     auto key = ((binder::LiteralExpression&)*arguments[1]).getValue()->getValue<std::string>();
     auto listType = arguments[0]->getDataType();

src/include/catalog/table_schema.h

@@ -62,8 +62,6 @@ class TableSchema {
             std::move(propertyName), std::move(dataType), increaseNextPropertyID(), tableID));
     }
 
-    std::string getPropertyName(common::property_id_t propertyID) const;
-
     common::property_id_t getPropertyID(const std::string& propertyName) const;
     common::column_id_t getColumnID(common::property_id_t propertyID) const;
 

src/processor/map/expression_mapper.cpp

@@ -68,8 +68,10 @@ std::unique_ptr<ExpressionEvaluator> ExpressionMapper::getEvaluator(
     } else if (canEvaluateAsFunction(expressionType)) {
         return getFunctionEvaluator(expression, schema);
     } else {
+        // LCOV_EXCL_START
         throw NotImplementedException(stringFormat(
             "Cannot evaluate expression with type {}.", expressionTypeToString(expressionType)));
+        // LCOV_EXCL_END
     }
 }
 
@@ -84,8 +86,10 @@ std::unique_ptr<ExpressionEvaluator> ExpressionMapper::getConstantEvaluator(
     } else if (canEvaluateAsFunction(expressionType)) {
         return getFunctionEvaluator(expression, nullptr);
     } else {
+        // LCOV_EXCL_START
         throw NotImplementedException(stringFormat(
             "Cannot evaluate expression with type {}.", expressionTypeToString(expressionType)));
+        // LCOV_EXCL_END
     }
 }
 

src/processor/operator/persistent/reader/csv/driver.cpp

@@ -586,7 +586,8 @@ void copyStringToVector(ValueVector* vector, uint64_t rowToAdd, std::string_view
             }
         }
         if (selectedFieldIdx == INVALID_STRUCT_FIELD_IDX) {
-            throw ParserException{stringFormat("No parsing rule matches value: {}.", strVal)};
+            throw ConversionException{stringFormat("Could not convert to union type {}: {}.",
+                LogicalTypeUtils::dataTypeToString(type), strVal)};
         }
         StructVector::getFieldVector(vector, UnionType::TAG_FIELD_IDX)
             ->setValue(rowToAdd, selectedFieldIdx);

src/storage/in_mem_storage_structure/in_mem_lists.cpp

@@ -88,7 +88,7 @@ void InMemLists::copyArrowArray(arrow::Array* boundNodeOffsets, arrow::Array* po
     } break;
         // TODO(Ziyi): Add support of VAR_LIST and more native parquet data types.
     default: {
-        throw CopyException("Unsupported data type ");
+        throw CopyException("Unsupported data type");
     }
     }
 }

src/storage/storage_info.cpp

@@ -11,8 +11,10 @@ namespace storage {
 storage_version_t StorageVersionInfo::getStorageVersion() {
     auto storageVersionInfo = getStorageVersionInfo();
     if (!storageVersionInfo.contains(KUZU_STORAGE_VERSION)) {
+        // LCOV_EXCL_START
         throw RuntimeException(
             stringFormat("Invalid storage version name: {}", KUZU_STORAGE_VERSION));
+        // LCOV_EXCL_END
     }
     return storageVersionInfo.at(KUZU_STORAGE_VERSION);
 }