mirror of
https://github.com/lordmathis/llamactl.git
synced 2025-11-06 00:54:23 +00:00
372 lines
9.5 KiB
Go
372 lines
9.5 KiB
Go
package llamacpp
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
func TestParseLlamaCommand(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
command string
|
|
expectErr bool
|
|
}{
|
|
{
|
|
name: "basic command with model",
|
|
command: "llama-server --model /path/to/model.gguf",
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "command with multiple flags",
|
|
command: "llama-server --model /path/to/model.gguf --gpu-layers 32 --ctx-size 4096",
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "command with short flags",
|
|
command: "llama-server -m /path/to/model.gguf -ngl 32 -c 4096",
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "command with equals format",
|
|
command: "llama-server --model=/path/to/model.gguf --gpu-layers=32",
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "command with boolean flags",
|
|
command: "llama-server --model /path/to/model.gguf --verbose --no-mmap",
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "empty command",
|
|
command: "",
|
|
expectErr: true,
|
|
},
|
|
{
|
|
name: "case insensitive command",
|
|
command: "LLAMA-SERVER --model /path/to/model.gguf",
|
|
expectErr: false,
|
|
},
|
|
// New test cases for improved functionality
|
|
{
|
|
name: "args only without llama-server",
|
|
command: "--model /path/to/model.gguf --gpu-layers 32",
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "full path to executable",
|
|
command: "/usr/local/bin/llama-server --model /path/to/model.gguf",
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "negative number handling",
|
|
command: "llama-server --gpu-layers -1 --model test.gguf",
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "multiline command with backslashes",
|
|
command: "llama-server --model /path/to/model.gguf \\\n --ctx-size 4096 \\\n --batch-size 512",
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "quoted string with special characters",
|
|
command: `llama-server --model test.gguf --chat-template "{% for message in messages %}{{ message.role }}: {{ message.content }}\n{% endfor %}"`,
|
|
expectErr: false,
|
|
},
|
|
{
|
|
name: "unterminated quoted string",
|
|
command: `llama-server --model test.gguf --chat-template "unterminated quote`,
|
|
expectErr: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := ParseLlamaCommand(tt.command)
|
|
|
|
if tt.expectErr {
|
|
if err == nil {
|
|
t.Errorf("expected error but got none")
|
|
}
|
|
return
|
|
}
|
|
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
return
|
|
}
|
|
|
|
if result == nil {
|
|
t.Errorf("expected result but got nil")
|
|
return
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandSpecificValues(t *testing.T) {
|
|
// Test specific value parsing
|
|
command := "llama-server --model /test/model.gguf --gpu-layers 32 --ctx-size 4096 --verbose"
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Model != "/test/model.gguf" {
|
|
t.Errorf("expected model '/test/model.gguf', got '%s'", result.Model)
|
|
}
|
|
|
|
if result.GPULayers != 32 {
|
|
t.Errorf("expected gpu_layers 32, got %d", result.GPULayers)
|
|
}
|
|
|
|
if result.CtxSize != 4096 {
|
|
t.Errorf("expected ctx_size 4096, got %d", result.CtxSize)
|
|
}
|
|
|
|
if !result.Verbose {
|
|
t.Errorf("expected verbose to be true, got %v", result.Verbose)
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandArrayFlags(t *testing.T) {
|
|
// Test array flag handling (critical for lora, override-tensor, etc.)
|
|
command := "llama-server --model test.gguf --lora adapter1.bin --lora adapter2.bin"
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if len(result.Lora) != 2 {
|
|
t.Errorf("expected 2 lora adapters, got %d", len(result.Lora))
|
|
}
|
|
|
|
if result.Lora[0] != "adapter1.bin" || result.Lora[1] != "adapter2.bin" {
|
|
t.Errorf("expected lora adapters [adapter1.bin, adapter2.bin], got %v", result.Lora)
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandMixedFormats(t *testing.T) {
|
|
// Test mixing --flag=value and --flag value formats
|
|
command := "llama-server --model=/path/model.gguf --gpu-layers 16 --batch-size=512 --verbose"
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Model != "/path/model.gguf" {
|
|
t.Errorf("expected model '/path/model.gguf', got '%s'", result.Model)
|
|
}
|
|
|
|
if result.GPULayers != 16 {
|
|
t.Errorf("expected gpu_layers 16, got %d", result.GPULayers)
|
|
}
|
|
|
|
if result.BatchSize != 512 {
|
|
t.Errorf("expected batch_size 512, got %d", result.BatchSize)
|
|
}
|
|
|
|
if !result.Verbose {
|
|
t.Errorf("expected verbose to be true, got %v", result.Verbose)
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandTypeConversion(t *testing.T) {
|
|
// Test that values are converted to appropriate types
|
|
command := "llama-server --model test.gguf --temp 0.7 --top-k 40 --no-mmap"
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Temperature != 0.7 {
|
|
t.Errorf("expected temperature 0.7, got %f", result.Temperature)
|
|
}
|
|
|
|
if result.TopK != 40 {
|
|
t.Errorf("expected top_k 40, got %d", result.TopK)
|
|
}
|
|
|
|
if !result.NoMmap {
|
|
t.Errorf("expected no_mmap to be true, got %v", result.NoMmap)
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandArgsOnly(t *testing.T) {
|
|
// Test parsing arguments without llama-server command
|
|
command := "--model /path/to/model.gguf --gpu-layers 32 --ctx-size 4096"
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Model != "/path/to/model.gguf" {
|
|
t.Errorf("expected model '/path/to/model.gguf', got '%s'", result.Model)
|
|
}
|
|
|
|
if result.GPULayers != 32 {
|
|
t.Errorf("expected gpu_layers 32, got %d", result.GPULayers)
|
|
}
|
|
|
|
if result.CtxSize != 4096 {
|
|
t.Errorf("expected ctx_size 4096, got %d", result.CtxSize)
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandFullPath(t *testing.T) {
|
|
// Test full path to executable
|
|
command := "/usr/local/bin/llama-server --model test.gguf --gpu-layers 16"
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Model != "test.gguf" {
|
|
t.Errorf("expected model 'test.gguf', got '%s'", result.Model)
|
|
}
|
|
|
|
if result.GPULayers != 16 {
|
|
t.Errorf("expected gpu_layers 16, got %d", result.GPULayers)
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandNegativeNumbers(t *testing.T) {
|
|
// Test negative number parsing
|
|
command := "llama-server --model test.gguf --gpu-layers -1 --seed -12345"
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.GPULayers != -1 {
|
|
t.Errorf("expected gpu_layers -1, got %d", result.GPULayers)
|
|
}
|
|
|
|
if result.Seed != -12345 {
|
|
t.Errorf("expected seed -12345, got %d", result.Seed)
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandMultiline(t *testing.T) {
|
|
// Test multiline command with backslashes
|
|
command := `llama-server --model /path/to/model.gguf \
|
|
--ctx-size 4096 \
|
|
--batch-size 512 \
|
|
--gpu-layers 32`
|
|
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Model != "/path/to/model.gguf" {
|
|
t.Errorf("expected model '/path/to/model.gguf', got '%s'", result.Model)
|
|
}
|
|
|
|
if result.CtxSize != 4096 {
|
|
t.Errorf("expected ctx_size 4096, got %d", result.CtxSize)
|
|
}
|
|
|
|
if result.BatchSize != 512 {
|
|
t.Errorf("expected batch_size 512, got %d", result.BatchSize)
|
|
}
|
|
|
|
if result.GPULayers != 32 {
|
|
t.Errorf("expected gpu_layers 32, got %d", result.GPULayers)
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandQuotedStrings(t *testing.T) {
|
|
// Test quoted strings with special characters
|
|
command := `llama-server --model test.gguf --api-key "sk-1234567890abcdef" --chat-template "User: {user}\nAssistant: "`
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
if result.Model != "test.gguf" {
|
|
t.Errorf("expected model 'test.gguf', got '%s'", result.Model)
|
|
}
|
|
|
|
if result.APIKey != "sk-1234567890abcdef" {
|
|
t.Errorf("expected api_key 'sk-1234567890abcdef', got '%s'", result.APIKey)
|
|
}
|
|
|
|
expectedTemplate := "User: {user}\\nAssistant: "
|
|
if result.ChatTemplate != expectedTemplate {
|
|
t.Errorf("expected chat_template '%s', got '%s'", expectedTemplate, result.ChatTemplate)
|
|
}
|
|
}
|
|
|
|
func TestParseLlamaCommandUnslothExample(t *testing.T) {
|
|
// Test with realistic unsloth-style command
|
|
command := `llama-server --model /path/to/model.gguf \
|
|
--ctx-size 4096 \
|
|
--batch-size 512 \
|
|
--gpu-layers -1 \
|
|
--temp 0.7 \
|
|
--repeat-penalty 1.1 \
|
|
--top-k 40 \
|
|
--top-p 0.95 \
|
|
--host 0.0.0.0 \
|
|
--port 8000 \
|
|
--api-key "sk-1234567890abcdef"`
|
|
|
|
result, err := ParseLlamaCommand(command)
|
|
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
|
|
// Verify key fields
|
|
if result.Model != "/path/to/model.gguf" {
|
|
t.Errorf("expected model '/path/to/model.gguf', got '%s'", result.Model)
|
|
}
|
|
|
|
if result.CtxSize != 4096 {
|
|
t.Errorf("expected ctx_size 4096, got %d", result.CtxSize)
|
|
}
|
|
|
|
if result.BatchSize != 512 {
|
|
t.Errorf("expected batch_size 512, got %d", result.BatchSize)
|
|
}
|
|
|
|
if result.GPULayers != -1 {
|
|
t.Errorf("expected gpu_layers -1, got %d", result.GPULayers)
|
|
}
|
|
|
|
if result.Temperature != 0.7 {
|
|
t.Errorf("expected temperature 0.7, got %f", result.Temperature)
|
|
}
|
|
|
|
if result.RepeatPenalty != 1.1 {
|
|
t.Errorf("expected repeat_penalty 1.1, got %f", result.RepeatPenalty)
|
|
}
|
|
|
|
if result.TopK != 40 {
|
|
t.Errorf("expected top_k 40, got %d", result.TopK)
|
|
}
|
|
|
|
if result.TopP != 0.95 {
|
|
t.Errorf("expected top_p 0.95, got %f", result.TopP)
|
|
}
|
|
|
|
if result.Host != "0.0.0.0" {
|
|
t.Errorf("expected host '0.0.0.0', got '%s'", result.Host)
|
|
}
|
|
|
|
if result.Port != 8000 {
|
|
t.Errorf("expected port 8000, got %d", result.Port)
|
|
}
|
|
|
|
if result.APIKey != "sk-1234567890abcdef" {
|
|
t.Errorf("expected api_key 'sk-1234567890abcdef', got '%s'", result.APIKey)
|
|
}
|
|
} |