Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
40 changes: 40 additions & 0 deletions gemma/gemma_args_test.cc
Original file line number Diff line number Diff line change
Expand Up @@ -71,4 +71,44 @@ TEST(GemmaArgsTest, UnconsumedArgs) {
CheckUnconsumed({"gemma", "--UNDEFINED", "--weights=x", "--XXX"}, 1);
}

// Parses `args` (including argv[0]) into `InferenceArgs`.
static InferenceArgs ParseInferenceArgs(const std::vector<std::string>& args) {
std::vector<char*> ptrs;
FillPtrs(args, ptrs);
const int argc = static_cast<int>(args.size());
char** argv = const_cast<char**>(ptrs.data());
ConsumedArgs consumed(argc, argv);
InferenceArgs inference(argc, argv, consumed);
consumed.ClearUnconsumed();
return inference;
}

TEST(GemmaArgsTest, ParsesValidNumbers) {
const InferenceArgs a =
ParseInferenceArgs({"gemma", "--top_k=40", "--temperature", "0.5",
"--verbosity=-1", "--seq_len=3000000000"});
EXPECT_EQ(a.top_k, size_t{40});
EXPECT_FLOAT_EQ(a.temperature, 0.5f);
EXPECT_EQ(a.verbosity, -1);
EXPECT_EQ(a.seq_len, size_t{3000000000});
}

// Invalid numeric values must produce the "Invalid value" abort message rather
// than being silently accepted (negative values for unsigned args wrapped to
// SIZE_MAX, trailing garbage was ignored) or escaping as an uncaught exception.
TEST(GemmaArgsDeathTest, RejectsInvalidNumbers) {
EXPECT_DEATH(ParseInferenceArgs({"gemma", "--top_k=-1"}),
"Invalid value for top_k");
EXPECT_DEATH(ParseInferenceArgs({"gemma", "--top_k", "abc"}),
"Invalid value for top_k");
EXPECT_DEATH(ParseInferenceArgs({"gemma", "--max_generated_tokens=10x"}),
"Invalid value for max_generated_tokens");
EXPECT_DEATH(ParseInferenceArgs({"gemma", "--verbosity=3000000000"}),
"Invalid value for verbosity");
EXPECT_DEATH(ParseInferenceArgs({"gemma", "--temperature=1.0x"}),
"Invalid value for temperature");
EXPECT_DEATH(ParseInferenceArgs({"gemma", "--temperature="}),
"Invalid value for temperature");
}

} // namespace gcpp
39 changes: 37 additions & 2 deletions util/args.h
Original file line number Diff line number Diff line change
Expand Up @@ -18,10 +18,16 @@
#ifndef THIRD_PARTY_GEMMA_CPP_UTIL_ARGS_H_
#define THIRD_PARTY_GEMMA_CPP_UTIL_ARGS_H_

#include <errno.h>
#include <math.h> // isinf
#include <stdio.h>
#include <stdlib.h> // strtoll, strtoull, strtof
#include <string.h> // strchr

#include <algorithm> // std::transform
#include <limits>
#include <string>
#include <type_traits>
#include <vector>

#include "io/io.h" // Path
Expand Down Expand Up @@ -179,15 +185,44 @@ class ArgsBase {

private:
// Returns false if an invalid value is detected.
// Rejects empty strings, trailing characters, values outside the range of
// `T` (including negative values for unsigned `T`) instead of silently
// wrapping or throwing.
template <typename T, HWY_IF_NOT_FLOAT(T)>
static bool SetValue(const char* string, T& t) {
t = std::stoi(string);
// `strtoull` accepts a leading '-' and wraps, so reject it up front.
if (std::is_unsigned_v<T> && strchr(string, '-')) return false;

errno = 0;
char* end = nullptr;
if constexpr (std::is_unsigned_v<T>) {
const unsigned long long value = strtoull(string, &end, 10);
if (end == string || *end != '\0' || errno == ERANGE ||
value > static_cast<unsigned long long>(
std::numeric_limits<T>::max())) {
return false;
}
t = static_cast<T>(value);
} else {
const long long value = strtoll(string, &end, 10);
if (end == string || *end != '\0' || errno == ERANGE ||
value < static_cast<long long>(std::numeric_limits<T>::min()) ||
value > static_cast<long long>(std::numeric_limits<T>::max())) {
return false;
}
t = static_cast<T>(value);
}
return true;
}

template <typename T, HWY_IF_FLOAT(T)>
static bool SetValue(const char* string, T& t) {
t = std::stof(string);
errno = 0;
char* end = nullptr;
const float value = strtof(string, &end);
if (end == string || *end != '\0') return false;
if (errno == ERANGE && isinf(value)) return false; // overflow
t = static_cast<T>(value);
return true;
}

Expand Down