fully test tags
This commit is contained in:
230
.output.txt
230
.output.txt
@@ -1,230 +0,0 @@
|
||||
=== RUN TestDebugUnmarshalStringArray
|
||||
debug_test.go:10: arr: [[104 101 108 108 111] [119 111 114 108 100]], rem: "", err: <nil>
|
||||
--- PASS: TestDebugUnmarshalStringArray (0.00s)
|
||||
=== RUN TestUnescapeByteString
|
||||
--- PASS: TestUnescapeByteString (0.00s)
|
||||
=== RUN TestRandomEscapeByteString
|
||||
--- PASS: TestRandomEscapeByteString (0.00s)
|
||||
=== RUN TestUnmarshalHexArray
|
||||
--- PASS: TestUnmarshalHexArray (0.00s)
|
||||
=== RUN TestJSONKey
|
||||
=== RUN TestJSONKey/basic_key
|
||||
=== RUN TestJSONKey/empty_dst
|
||||
=== RUN TestJSONKey/empty_key
|
||||
--- PASS: TestJSONKey (0.00s)
|
||||
--- PASS: TestJSONKey/basic_key (0.00s)
|
||||
--- PASS: TestJSONKey/empty_dst (0.00s)
|
||||
--- PASS: TestJSONKey/empty_key (0.00s)
|
||||
=== RUN TestUnmarshalHex
|
||||
=== RUN TestUnmarshalHex/basic_hex
|
||||
=== RUN TestUnmarshalHex/empty_hex
|
||||
=== RUN TestUnmarshalHex/no_quotes
|
||||
=== RUN TestUnmarshalHex/odd_length_hex
|
||||
=== RUN TestUnmarshalHex/invalid_hex_characters
|
||||
2025-06-26T20:12:49+01:00.314 ERR encoding/hex: invalid byte: U+0067 'g' /home/david/src/realy.lol/text/helpers.go:51
|
||||
=== RUN TestUnmarshalHex/empty_input
|
||||
--- PASS: TestUnmarshalHex (0.00s)
|
||||
--- PASS: TestUnmarshalHex/basic_hex (0.00s)
|
||||
--- PASS: TestUnmarshalHex/empty_hex (0.00s)
|
||||
--- PASS: TestUnmarshalHex/no_quotes (0.00s)
|
||||
--- PASS: TestUnmarshalHex/odd_length_hex (0.00s)
|
||||
--- PASS: TestUnmarshalHex/invalid_hex_characters (0.00s)
|
||||
--- PASS: TestUnmarshalHex/empty_input (0.00s)
|
||||
=== RUN TestUnmarshalQuoted
|
||||
=== RUN TestUnmarshalQuoted/basic_quoted_string
|
||||
=== RUN TestUnmarshalQuoted/empty_quoted_string
|
||||
=== RUN TestUnmarshalQuoted/escaped_quotes
|
||||
=== RUN TestUnmarshalQuoted/escaped_backslash
|
||||
=== RUN TestUnmarshalQuoted/no_opening_quote
|
||||
=== RUN TestUnmarshalQuoted/no_closing_quote
|
||||
=== RUN TestUnmarshalQuoted/empty_input
|
||||
=== RUN TestUnmarshalQuoted/invalid_control_character
|
||||
--- PASS: TestUnmarshalQuoted (0.00s)
|
||||
--- PASS: TestUnmarshalQuoted/basic_quoted_string (0.00s)
|
||||
--- PASS: TestUnmarshalQuoted/empty_quoted_string (0.00s)
|
||||
--- PASS: TestUnmarshalQuoted/escaped_quotes (0.00s)
|
||||
--- PASS: TestUnmarshalQuoted/escaped_backslash (0.00s)
|
||||
--- PASS: TestUnmarshalQuoted/no_opening_quote (0.00s)
|
||||
--- PASS: TestUnmarshalQuoted/no_closing_quote (0.00s)
|
||||
--- PASS: TestUnmarshalQuoted/empty_input (0.00s)
|
||||
--- PASS: TestUnmarshalQuoted/invalid_control_character (0.00s)
|
||||
=== RUN TestMarshalHexArray
|
||||
=== RUN TestMarshalHexArray/basic_hex_array
|
||||
=== RUN TestMarshalHexArray/empty_array
|
||||
=== RUN TestMarshalHexArray/single_element
|
||||
--- PASS: TestMarshalHexArray (0.00s)
|
||||
--- PASS: TestMarshalHexArray/basic_hex_array (0.00s)
|
||||
--- PASS: TestMarshalHexArray/empty_array (0.00s)
|
||||
--- PASS: TestMarshalHexArray/single_element (0.00s)
|
||||
=== RUN TestUnmarshalStringArray
|
||||
=== RUN TestUnmarshalStringArray/basic_string_array
|
||||
=== RUN TestUnmarshalStringArray/empty_array
|
||||
=== RUN TestUnmarshalStringArray/single_element
|
||||
=== RUN TestUnmarshalStringArray/no_opening_bracket
|
||||
=== RUN TestUnmarshalStringArray/no_closing_bracket
|
||||
helpers_test.go:336: UnmarshalStringArray() array length = 2, want 0
|
||||
--- FAIL: TestUnmarshalStringArray (0.00s)
|
||||
--- PASS: TestUnmarshalStringArray/basic_string_array (0.00s)
|
||||
--- PASS: TestUnmarshalStringArray/empty_array (0.00s)
|
||||
--- PASS: TestUnmarshalStringArray/single_element (0.00s)
|
||||
--- PASS: TestUnmarshalStringArray/no_opening_bracket (0.00s)
|
||||
--- FAIL: TestUnmarshalStringArray/no_closing_bracket (0.00s)
|
||||
=== RUN TestTrue
|
||||
--- PASS: TestTrue (0.00s)
|
||||
=== RUN TestFalse
|
||||
--- PASS: TestFalse (0.00s)
|
||||
=== RUN TestMarshalBool
|
||||
=== RUN TestMarshalBool/true_value
|
||||
=== RUN TestMarshalBool/false_value
|
||||
=== RUN TestMarshalBool/true_with_empty_src
|
||||
=== RUN TestMarshalBool/false_with_empty_src
|
||||
--- PASS: TestMarshalBool (0.00s)
|
||||
--- PASS: TestMarshalBool/true_value (0.00s)
|
||||
--- PASS: TestMarshalBool/false_value (0.00s)
|
||||
--- PASS: TestMarshalBool/true_with_empty_src (0.00s)
|
||||
--- PASS: TestMarshalBool/false_with_empty_src (0.00s)
|
||||
=== RUN TestUnmarshalBool
|
||||
=== RUN TestUnmarshalBool/true_value
|
||||
=== RUN TestUnmarshalBool/false_value
|
||||
=== RUN TestUnmarshalBool/true_at_end
|
||||
=== RUN TestUnmarshalBool/false_at_end
|
||||
=== RUN TestUnmarshalBool/true_with_prefix
|
||||
=== RUN TestUnmarshalBool/false_with_prefix
|
||||
=== RUN TestUnmarshalBool/no_boolean_value
|
||||
=== RUN TestUnmarshalBool/empty_input
|
||||
=== RUN TestUnmarshalBool/incomplete_true
|
||||
=== RUN TestUnmarshalBool/incomplete_false
|
||||
--- PASS: TestUnmarshalBool (0.00s)
|
||||
--- PASS: TestUnmarshalBool/true_value (0.00s)
|
||||
--- PASS: TestUnmarshalBool/false_value (0.00s)
|
||||
--- PASS: TestUnmarshalBool/true_at_end (0.00s)
|
||||
--- PASS: TestUnmarshalBool/false_at_end (0.00s)
|
||||
--- PASS: TestUnmarshalBool/true_with_prefix (0.00s)
|
||||
--- PASS: TestUnmarshalBool/false_with_prefix (0.00s)
|
||||
--- PASS: TestUnmarshalBool/no_boolean_value (0.00s)
|
||||
--- PASS: TestUnmarshalBool/empty_input (0.00s)
|
||||
--- PASS: TestUnmarshalBool/incomplete_true (0.00s)
|
||||
--- PASS: TestUnmarshalBool/incomplete_false (0.00s)
|
||||
=== RUN TestComma
|
||||
=== RUN TestComma/comma_found
|
||||
=== RUN TestComma/comma_at_start
|
||||
=== RUN TestComma/no_comma
|
||||
helpers_test.go:550: Comma() rem = "nocomma", want ""
|
||||
=== RUN TestComma/empty_input
|
||||
--- FAIL: TestComma (0.00s)
|
||||
--- PASS: TestComma/comma_found (0.00s)
|
||||
--- PASS: TestComma/comma_at_start (0.00s)
|
||||
--- FAIL: TestComma/no_comma (0.00s)
|
||||
--- PASS: TestComma/empty_input (0.00s)
|
||||
=== RUN TestAppendHexFromBinary
|
||||
=== RUN TestAppendHexFromBinary/basic_hex_encoding_with_quote
|
||||
=== RUN TestAppendHexFromBinary/basic_hex_encoding_without_quote
|
||||
=== RUN TestAppendHexFromBinary/empty_src_with_quote
|
||||
=== RUN TestAppendHexFromBinary/empty_src_without_quote
|
||||
=== RUN TestAppendHexFromBinary/single_byte_with_quote
|
||||
=== RUN TestAppendHexFromBinary/single_byte_without_quote
|
||||
--- PASS: TestAppendHexFromBinary (0.00s)
|
||||
--- PASS: TestAppendHexFromBinary/basic_hex_encoding_with_quote (0.00s)
|
||||
--- PASS: TestAppendHexFromBinary/basic_hex_encoding_without_quote (0.00s)
|
||||
--- PASS: TestAppendHexFromBinary/empty_src_with_quote (0.00s)
|
||||
--- PASS: TestAppendHexFromBinary/empty_src_without_quote (0.00s)
|
||||
--- PASS: TestAppendHexFromBinary/single_byte_with_quote (0.00s)
|
||||
--- PASS: TestAppendHexFromBinary/single_byte_without_quote (0.00s)
|
||||
=== RUN TestAppendBinaryFromHex
|
||||
=== RUN TestAppendBinaryFromHex/basic_hex_decoding_with_unquote
|
||||
=== RUN TestAppendBinaryFromHex/basic_hex_decoding_without_unquote
|
||||
=== RUN TestAppendBinaryFromHex/empty_hex_with_unquote
|
||||
2025-06-26T20:12:49+01:00.315 ERR nothing to decode /home/david/src/realy.lol/text/hex.go:24
|
||||
hex_test.go:165: AppendBinaryFromHex() error = nothing to decode, wantErr false
|
||||
=== RUN TestAppendBinaryFromHex/empty_hex_without_unquote
|
||||
2025-06-26T20:12:49+01:00.315 ERR nothing to decode /home/david/src/realy.lol/text/hex.go:28
|
||||
hex_test.go:165: AppendBinaryFromHex() error = nothing to decode, wantErr false
|
||||
=== RUN TestAppendBinaryFromHex/single_byte_hex_with_unquote
|
||||
=== RUN TestAppendBinaryFromHex/single_byte_hex_without_unquote
|
||||
=== RUN TestAppendBinaryFromHex/invalid_hex_with_unquote
|
||||
2025-06-26T20:12:49+01:00.315 ERR encoding/hex: invalid byte: U+0067 'g' /home/david/src/realy.lol/text/hex.go:24
|
||||
=== RUN TestAppendBinaryFromHex/invalid_hex_without_unquote
|
||||
2025-06-26T20:12:49+01:00.315 ERR encoding/hex: invalid byte: U+0067 'g' /home/david/src/realy.lol/text/hex.go:28
|
||||
=== RUN TestAppendBinaryFromHex/odd_length_hex_with_unquote
|
||||
2025-06-26T20:12:49+01:00.315 ERR encoding/hex: odd length hex string /home/david/src/realy.lol/text/hex.go:24
|
||||
=== RUN TestAppendBinaryFromHex/odd_length_hex_without_unquote
|
||||
2025-06-26T20:12:49+01:00.315 ERR encoding/hex: odd length hex string /home/david/src/realy.lol/text/hex.go:28
|
||||
--- FAIL: TestAppendBinaryFromHex (0.00s)
|
||||
--- PASS: TestAppendBinaryFromHex/basic_hex_decoding_with_unquote (0.00s)
|
||||
--- PASS: TestAppendBinaryFromHex/basic_hex_decoding_without_unquote (0.00s)
|
||||
--- FAIL: TestAppendBinaryFromHex/empty_hex_with_unquote (0.00s)
|
||||
--- FAIL: TestAppendBinaryFromHex/empty_hex_without_unquote (0.00s)
|
||||
--- PASS: TestAppendBinaryFromHex/single_byte_hex_with_unquote (0.00s)
|
||||
--- PASS: TestAppendBinaryFromHex/single_byte_hex_without_unquote (0.00s)
|
||||
--- PASS: TestAppendBinaryFromHex/invalid_hex_with_unquote (0.00s)
|
||||
--- PASS: TestAppendBinaryFromHex/invalid_hex_without_unquote (0.00s)
|
||||
--- PASS: TestAppendBinaryFromHex/odd_length_hex_with_unquote (0.00s)
|
||||
--- PASS: TestAppendBinaryFromHex/odd_length_hex_without_unquote (0.00s)
|
||||
=== RUN TestUnquote
|
||||
=== RUN TestUnquote/basic_quoted_string
|
||||
=== RUN TestUnquote/single_quotes
|
||||
=== RUN TestUnquote/empty_quotes
|
||||
--- PASS: TestUnquote (0.00s)
|
||||
--- PASS: TestUnquote/basic_quoted_string (0.00s)
|
||||
--- PASS: TestUnquote/single_quotes (0.00s)
|
||||
--- PASS: TestUnquote/empty_quotes (0.00s)
|
||||
=== RUN TestNoop
|
||||
--- PASS: TestNoop (0.00s)
|
||||
=== RUN TestAppendQuote
|
||||
=== RUN TestAppendQuote/basic_append_quote
|
||||
=== RUN TestAppendQuote/empty_dst
|
||||
=== RUN TestAppendQuote/empty_src
|
||||
--- PASS: TestAppendQuote (0.00s)
|
||||
--- PASS: TestAppendQuote/basic_append_quote (0.00s)
|
||||
--- PASS: TestAppendQuote/empty_dst (0.00s)
|
||||
--- PASS: TestAppendQuote/empty_src (0.00s)
|
||||
=== RUN TestQuote
|
||||
=== RUN TestQuote/basic_quote
|
||||
=== RUN TestQuote/empty_dst
|
||||
--- PASS: TestQuote (0.00s)
|
||||
--- PASS: TestQuote/basic_quote (0.00s)
|
||||
--- PASS: TestQuote/empty_dst (0.00s)
|
||||
=== RUN TestAppendSingleQuote
|
||||
=== RUN TestAppendSingleQuote/basic_single_quote
|
||||
=== RUN TestAppendSingleQuote/empty_src
|
||||
--- PASS: TestAppendSingleQuote (0.00s)
|
||||
--- PASS: TestAppendSingleQuote/basic_single_quote (0.00s)
|
||||
--- PASS: TestAppendSingleQuote/empty_src (0.00s)
|
||||
=== RUN TestAppendBackticks
|
||||
=== RUN TestAppendBackticks/basic_backticks
|
||||
=== RUN TestAppendBackticks/empty_src
|
||||
--- PASS: TestAppendBackticks (0.00s)
|
||||
--- PASS: TestAppendBackticks/basic_backticks (0.00s)
|
||||
--- PASS: TestAppendBackticks/empty_src (0.00s)
|
||||
=== RUN TestAppendBrace
|
||||
=== RUN TestAppendBrace/basic_braces
|
||||
=== RUN TestAppendBrace/empty_src
|
||||
--- PASS: TestAppendBrace (0.00s)
|
||||
--- PASS: TestAppendBrace/basic_braces (0.00s)
|
||||
--- PASS: TestAppendBrace/empty_src (0.00s)
|
||||
=== RUN TestAppendParenthesis
|
||||
=== RUN TestAppendParenthesis/basic_parenthesis
|
||||
=== RUN TestAppendParenthesis/empty_src
|
||||
--- PASS: TestAppendParenthesis (0.00s)
|
||||
--- PASS: TestAppendParenthesis/basic_parenthesis (0.00s)
|
||||
--- PASS: TestAppendParenthesis/empty_src (0.00s)
|
||||
=== RUN TestAppendBracket
|
||||
=== RUN TestAppendBracket/basic_brackets
|
||||
=== RUN TestAppendBracket/empty_src
|
||||
--- PASS: TestAppendBracket (0.00s)
|
||||
--- PASS: TestAppendBracket/basic_brackets (0.00s)
|
||||
--- PASS: TestAppendBracket/empty_src (0.00s)
|
||||
=== RUN TestAppendList
|
||||
=== RUN TestAppendList/basic_list_with_comma
|
||||
=== RUN TestAppendList/single_item
|
||||
=== RUN TestAppendList/empty_list
|
||||
=== RUN TestAppendList/pipe_separator
|
||||
--- PASS: TestAppendList (0.00s)
|
||||
--- PASS: TestAppendList/basic_list_with_comma (0.00s)
|
||||
--- PASS: TestAppendList/single_item (0.00s)
|
||||
--- PASS: TestAppendList/empty_list (0.00s)
|
||||
--- PASS: TestAppendList/pipe_separator (0.00s)
|
||||
FAIL
|
||||
coverage: 90.7% of statements
|
||||
exit status 1
|
||||
FAIL realy.lol/text 0.008s
|
||||
@@ -211,7 +211,665 @@ func TestT_ContainsAny(t *testing.T) {
|
||||
tt := New(w, x, y)
|
||||
ttt := New(x, y)
|
||||
_, _, _, _, _ = v, err, z, tt, ttt
|
||||
// log.I.S(tt.ContainsAny(by{'b'}, z))
|
||||
// log.I.S(ttt.ContainsAny(by{'b'}, z))
|
||||
|
||||
// Test ContainsAny with matching values
|
||||
if !tt.ContainsAny([]byte{'b'}, z) {
|
||||
t.Error("ContainsAny should return true for matching values")
|
||||
}
|
||||
|
||||
// Test ContainsAny with non-matching values
|
||||
nonMatch := tag.New([]byte{'b'}, []byte("nonexistent"))
|
||||
if tt.ContainsAny([]byte{'b'}, nonMatch) {
|
||||
t.Error("ContainsAny should return false for non-matching values")
|
||||
}
|
||||
|
||||
// Test ContainsAny with nil tags
|
||||
var nilTags *T
|
||||
if nilTags.ContainsAny([]byte{'b'}, z) {
|
||||
t.Error("ContainsAny should return false for nil tags")
|
||||
}
|
||||
|
||||
// Test ContainsAny with empty tag name
|
||||
if tt.ContainsAny([]byte{}, z) {
|
||||
t.Error("ContainsAny should return false for empty tag name")
|
||||
}
|
||||
|
||||
// Test ContainsAny with tags that have less than 2 elements
|
||||
shortTag := tag.New([]byte{'b'})
|
||||
shortTags := New(shortTag)
|
||||
if shortTags.ContainsAny([]byte{'b'}, z) {
|
||||
t.Error("ContainsAny should return false for tags with less than 2 elements")
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewWithCap(t *testing.T) {
|
||||
// Test NewWithCap with different capacity values
|
||||
tags := NewWithCap(5)
|
||||
if tags == nil {
|
||||
t.Error("NewWithCap should not return nil")
|
||||
}
|
||||
if cap(tags.element) != 5 {
|
||||
t.Errorf("Expected capacity 5, got %d", cap(tags.element))
|
||||
}
|
||||
if len(tags.element) != 0 {
|
||||
t.Errorf("Expected length 0, got %d", len(tags.element))
|
||||
}
|
||||
|
||||
// Test with zero capacity
|
||||
tags0 := NewWithCap(0)
|
||||
if tags0 == nil {
|
||||
t.Error("NewWithCap(0) should not return nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestToSliceOfTags(t *testing.T) {
|
||||
// Test with normal tags
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tags := New(tag1, tag2)
|
||||
|
||||
slice := tags.ToSliceOfTags()
|
||||
if len(slice) != 2 {
|
||||
t.Errorf("Expected 2 tags, got %d", len(slice))
|
||||
}
|
||||
if slice[0] != tag1 || slice[1] != tag2 {
|
||||
t.Error("ToSliceOfTags returned incorrect tags")
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
nilSlice := nilTags.ToSliceOfTags()
|
||||
if len(nilSlice) != 1 {
|
||||
t.Errorf("Expected 1 empty tag for nil tags, got %d", len(nilSlice))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetTagElement(t *testing.T) {
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tags := New(tag1, tag2)
|
||||
|
||||
// Test getting existing elements
|
||||
if tags.GetTagElement(0) != tag1 {
|
||||
t.Error("GetTagElement(0) returned wrong tag")
|
||||
}
|
||||
if tags.GetTagElement(1) != tag2 {
|
||||
t.Error("GetTagElement(1) returned wrong tag")
|
||||
}
|
||||
|
||||
// Test getting out of bounds element
|
||||
outOfBounds := tags.GetTagElement(5)
|
||||
if outOfBounds == nil {
|
||||
t.Error("GetTagElement should return empty tag, not nil")
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
nilResult := nilTags.GetTagElement(0)
|
||||
if nilResult == nil {
|
||||
t.Error("GetTagElement on nil should return empty tag, not nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAppendTo(t *testing.T) {
|
||||
tags := New()
|
||||
|
||||
// Test appending to position 0
|
||||
tags.AppendTo(0, []byte("key1"), []byte("value1"))
|
||||
if tags.Len() != 1 {
|
||||
t.Errorf("Expected 1 tag after AppendTo, got %d", tags.Len())
|
||||
}
|
||||
|
||||
// Test appending to position 2 (should create empty tags in between)
|
||||
tags.AppendTo(2, []byte("key2"), []byte("value2"))
|
||||
if tags.Len() != 3 {
|
||||
t.Errorf("Expected 3 tags after AppendTo(2), got %d", tags.Len())
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
result := nilTags.AppendTo(0, []byte("key"))
|
||||
if result != nil {
|
||||
t.Error("AppendTo on nil should return nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAppendSlice(t *testing.T) {
|
||||
tags := New()
|
||||
|
||||
// Test appending slice
|
||||
tags.AppendSlice([]byte("key1"), []byte("value1"))
|
||||
if tags.Len() != 1 {
|
||||
t.Errorf("Expected 1 tag after AppendSlice, got %d", tags.Len())
|
||||
}
|
||||
|
||||
// Test appending multiple slices
|
||||
tags.AppendSlice([]byte("key2"), []byte("value2"), []byte("value3"))
|
||||
if tags.Len() != 2 {
|
||||
t.Errorf("Expected 2 tags after second AppendSlice, got %d", tags.Len())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddCap(t *testing.T) {
|
||||
tags := New()
|
||||
|
||||
// Test adding capacity
|
||||
result := tags.AddCap(2, 5)
|
||||
if result != tags {
|
||||
t.Error("AddCap should return the same tags instance")
|
||||
}
|
||||
if tags.Len() != 3 {
|
||||
t.Errorf("Expected 3 tags after AddCap(2, 5), got %d", tags.Len())
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
nilResult := nilTags.AddCap(0, 5)
|
||||
if nilResult != nilTags {
|
||||
t.Error("AddCap on nil should return the same nil instance")
|
||||
}
|
||||
}
|
||||
|
||||
func TestToStringsSlice(t *testing.T) {
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1", "relay1")
|
||||
tags := New(tag1, tag2)
|
||||
|
||||
// Test normal conversion
|
||||
strings := tags.ToStringsSlice()
|
||||
if len(strings) != 2 {
|
||||
t.Errorf("Expected 2 string slices, got %d", len(strings))
|
||||
}
|
||||
if len(strings[0]) != 2 || strings[0][0] != "p" || strings[0][1] != "pubkey1" {
|
||||
t.Error("First tag conversion incorrect")
|
||||
}
|
||||
if len(strings[1]) != 3 || strings[1][0] != "e" || strings[1][1] != "eventid1" || strings[1][2] != "relay1" {
|
||||
t.Error("Second tag conversion incorrect")
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
nilStrings := nilTags.ToStringsSlice()
|
||||
if nilStrings != nil {
|
||||
t.Error("ToStringsSlice on nil should return nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSortingInterface(t *testing.T) {
|
||||
// Test Less, Swap, Len methods
|
||||
tag1 := tag.New("z", "last")
|
||||
tag2 := tag.New("a", "first")
|
||||
tag3 := tag.New("m", "middle")
|
||||
tags := New(tag1, tag2, tag3)
|
||||
|
||||
// Test Len
|
||||
if tags.Len() != 3 {
|
||||
t.Errorf("Expected length 3, got %d", tags.Len())
|
||||
}
|
||||
|
||||
// Test Less
|
||||
if !tags.Less(1, 0) { // "a" < "z"
|
||||
t.Error("Less should return true for 'a' < 'z'")
|
||||
}
|
||||
if tags.Less(0, 1) { // "z" < "a"
|
||||
t.Error("Less should return false for 'z' < 'a'")
|
||||
}
|
||||
|
||||
// Test Swap
|
||||
tags.Swap(0, 1)
|
||||
if string(tags.GetTagElement(0).Key()) != "a" {
|
||||
t.Error("Swap failed - first element should be 'a'")
|
||||
}
|
||||
if string(tags.GetTagElement(1).Key()) != "z" {
|
||||
t.Error("Swap failed - second element should be 'z'")
|
||||
}
|
||||
|
||||
// Test Less with empty tags
|
||||
emptyTag1 := tag.New([]byte{})
|
||||
emptyTag2 := tag.New([]byte{})
|
||||
emptyTags := New(emptyTag1, emptyTag2)
|
||||
if emptyTags.Less(0, 1) {
|
||||
t.Error("Less should return false for two empty tags")
|
||||
}
|
||||
|
||||
// Test Less with one empty tag
|
||||
mixedTags := New(emptyTag1, tag2)
|
||||
if !mixedTags.Less(0, 1) {
|
||||
t.Error("Less should return true when first tag is empty")
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
if nilTags.Len() != 0 {
|
||||
t.Error("Len on nil should return 0")
|
||||
}
|
||||
if nilTags.Less(0, 1) {
|
||||
t.Error("Less on nil should return false")
|
||||
}
|
||||
}
|
||||
|
||||
func TestFilterOut(t *testing.T) {
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tag3 := tag.New("p", "pubkey2")
|
||||
tags := New(tag1, tag2, tag3)
|
||||
|
||||
// Test filtering out 'p' tags
|
||||
filtered := tags.FilterOut([][]byte{[]byte("p")})
|
||||
if filtered.Len() != 1 {
|
||||
t.Errorf("Expected 1 tag after filtering out 'p', got %d", filtered.Len())
|
||||
}
|
||||
if string(filtered.GetTagElement(0).Key()) != "e" {
|
||||
t.Error("Remaining tag should be 'e' tag")
|
||||
}
|
||||
|
||||
// Test filtering out non-existent tags
|
||||
filtered2 := tags.FilterOut([][]byte{[]byte("x")})
|
||||
if filtered2.Len() != 3 {
|
||||
t.Errorf("Expected 3 tags when filtering non-existent, got %d", filtered2.Len())
|
||||
}
|
||||
}
|
||||
|
||||
func TestAppend(t *testing.T) {
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tags1 := New(tag1)
|
||||
tags2 := New(tag2)
|
||||
|
||||
// Test appending tags
|
||||
result := tags1.Append(tags2)
|
||||
if result != tags1 {
|
||||
t.Error("Append should return the original tags instance")
|
||||
}
|
||||
if tags1.Len() != 2 {
|
||||
t.Errorf("Expected 2 tags after append, got %d", tags1.Len())
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
nilResult := nilTags.Append(tags2)
|
||||
if nilResult != nil {
|
||||
t.Error("Append on nil should return nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAppendTags(t *testing.T) {
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tags := New()
|
||||
|
||||
// Test appending individual tags
|
||||
result := tags.AppendTags(tag1, tag2)
|
||||
if result != tags {
|
||||
t.Error("AppendTags should return the original tags instance")
|
||||
}
|
||||
if tags.Len() != 2 {
|
||||
t.Errorf("Expected 2 tags after AppendTags, got %d", tags.Len())
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
nilResult := nilTags.AppendTags(tag1)
|
||||
if nilResult != nil {
|
||||
t.Error("AppendTags on nil should return nil")
|
||||
}
|
||||
}
|
||||
|
||||
func TestScan(t *testing.T) {
|
||||
tags := New()
|
||||
|
||||
// Test scanning from JSON string - this should fail with current implementation
|
||||
// as the T struct doesn't have proper JSON unmarshaling support
|
||||
jsonStr := `[["p","pubkey1"],["e","eventid1"]]`
|
||||
err := tags.Scan(jsonStr)
|
||||
if err == nil {
|
||||
t.Error("Scan should fail with current implementation")
|
||||
}
|
||||
|
||||
// Test scanning from byte slice - should also fail
|
||||
tags2 := New()
|
||||
err2 := tags2.Scan([]byte(jsonStr))
|
||||
if err2 == nil {
|
||||
t.Error("Scan from bytes should fail with current implementation")
|
||||
}
|
||||
|
||||
// Test scanning from invalid type
|
||||
tags3 := New()
|
||||
err3 := tags3.Scan(123)
|
||||
if err3 == nil {
|
||||
t.Error("Scan should fail with invalid type")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntersects(t *testing.T) {
|
||||
// Create test tags
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tags := New(tag1, tag2)
|
||||
|
||||
// Create filter tags with # prefix
|
||||
filterTag := tag.New("#p", "pubkey1")
|
||||
filterTags := New(filterTag)
|
||||
|
||||
// Test intersection
|
||||
if !tags.Intersects(filterTags) {
|
||||
t.Error("Intersects should return true for matching filter")
|
||||
}
|
||||
|
||||
// Test non-intersection
|
||||
nonMatchFilter := tag.New("#p", "nonexistent")
|
||||
nonMatchTags := New(nonMatchFilter)
|
||||
if tags.Intersects(nonMatchTags) {
|
||||
t.Error("Intersects should return false for non-matching filter")
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
if nilTags.Intersects(filterTags) {
|
||||
t.Error("Intersects should return false for nil tags")
|
||||
}
|
||||
if tags.Intersects(nil) {
|
||||
t.Error("Intersects should return false for nil filter")
|
||||
}
|
||||
}
|
||||
|
||||
func TestContainsProtectedMarker(t *testing.T) {
|
||||
// Test with protected marker
|
||||
protectedTag := tag.New("-")
|
||||
tags := New(protectedTag)
|
||||
if !tags.ContainsProtectedMarker() {
|
||||
t.Error("ContainsProtectedMarker should return true for tags with '-' marker")
|
||||
}
|
||||
|
||||
// Test without protected marker
|
||||
normalTag := tag.New("p", "pubkey1")
|
||||
normalTags := New(normalTag)
|
||||
if normalTags.ContainsProtectedMarker() {
|
||||
t.Error("ContainsProtectedMarker should return false for normal tags")
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
if nilTags.ContainsProtectedMarker() {
|
||||
t.Error("ContainsProtectedMarker should return false for nil tags")
|
||||
}
|
||||
}
|
||||
|
||||
func TestContains(t *testing.T) {
|
||||
// Create test tags
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tags := New(tag1, tag2)
|
||||
|
||||
// Create filter tags
|
||||
filterTag := tag.New("#p", "pubkey1")
|
||||
filterTags := New(filterTag)
|
||||
|
||||
// Test contains
|
||||
if !tags.Contains(filterTags) {
|
||||
t.Error("Contains should return true for matching filter")
|
||||
}
|
||||
|
||||
// Test with nil tags
|
||||
var nilTags *T
|
||||
if nilTags.Contains(filterTags) {
|
||||
t.Error("Contains should return false for nil tags")
|
||||
}
|
||||
}
|
||||
|
||||
func TestMarshalTo(t *testing.T) {
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tags := New(tag1, tag2)
|
||||
|
||||
// Test MarshalTo
|
||||
dst := make([]byte, 0, 100)
|
||||
result := tags.MarshalTo(dst)
|
||||
if len(result) == 0 {
|
||||
t.Error("MarshalTo should return non-empty result")
|
||||
}
|
||||
if result[0] != '[' {
|
||||
t.Error("MarshalTo should start with '['")
|
||||
}
|
||||
if result[len(result)-1] != ']' {
|
||||
t.Error("MarshalTo should end with ']'")
|
||||
}
|
||||
}
|
||||
|
||||
// Additional comprehensive tests to reach 100% coverage
|
||||
func TestEdgeCases(t *testing.T) {
|
||||
// Test Clone with nil tags
|
||||
var nilTags *T
|
||||
cloned := nilTags.Clone()
|
||||
if cloned != nilTags {
|
||||
t.Error("Clone of nil should return nil")
|
||||
}
|
||||
|
||||
// Test Equal with different lengths
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tags1 := New(tag1)
|
||||
tags2 := New(tag1, tag2)
|
||||
if tags1.Equal(tags2) {
|
||||
t.Error("Equal should return false for different lengths")
|
||||
}
|
||||
|
||||
// Test Equal with nil cases
|
||||
var nilTags1, nilTags2 *T
|
||||
if !nilTags1.Equal(nilTags2) {
|
||||
t.Error("Two nil tags should be equal")
|
||||
}
|
||||
if nilTags1.Equal(tags1) {
|
||||
t.Error("Nil and non-nil tags should not be equal")
|
||||
}
|
||||
if tags1.Equal(nilTags1) {
|
||||
t.Error("Non-nil and nil tags should not be equal")
|
||||
}
|
||||
|
||||
// Test Len with nil element
|
||||
emptyTags := &T{}
|
||||
if emptyTags.Len() != 0 {
|
||||
t.Error("Empty tags should have length 0")
|
||||
}
|
||||
|
||||
// Test GetFirst and GetLast with no matches
|
||||
tags := New(tag.New("x", "value"))
|
||||
result := tags.GetFirst(tag.New("y"))
|
||||
if result != nil {
|
||||
t.Error("GetFirst should return nil for no matches")
|
||||
}
|
||||
result = tags.GetLast(tag.New("y"))
|
||||
if result != nil {
|
||||
t.Error("GetLast should return nil for no matches")
|
||||
}
|
||||
|
||||
// Test GetAll with no matches
|
||||
allResult := tags.GetAll(tag.New("y"))
|
||||
if allResult != nil {
|
||||
t.Error("GetAll should return nil for no matches")
|
||||
}
|
||||
|
||||
// Test AppendUnique with nil tags
|
||||
var nilTags3 *T
|
||||
result2 := nilTags3.AppendUnique(tag1)
|
||||
if result2 != nil {
|
||||
t.Error("AppendUnique on nil should return nil")
|
||||
}
|
||||
|
||||
// Test AppendUnique with tag longer than 2 elements
|
||||
longTag := tag.New("p", "pubkey1", "extra1", "extra2")
|
||||
tags3 := New()
|
||||
result3 := tags3.AppendUnique(longTag)
|
||||
if result3.Len() != 1 {
|
||||
t.Error("AppendUnique should add long tag")
|
||||
}
|
||||
|
||||
// Test ContainsAny with wrong key
|
||||
tags4 := New(tag.New("p", "pubkey1"))
|
||||
if tags4.ContainsAny([]byte("e"), tag.New("p", "pubkey1")) {
|
||||
t.Error("ContainsAny should return false for wrong key")
|
||||
}
|
||||
|
||||
// Test Contains with no match
|
||||
filterTags := New(tag.New("#x", "nonexistent"))
|
||||
if tags4.Contains(filterTags) {
|
||||
t.Error("Contains should return false for no match")
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnmarshalEdgeCases(t *testing.T) {
|
||||
tags := New()
|
||||
|
||||
// Test unmarshal with empty input
|
||||
_, err := tags.Unmarshal([]byte{})
|
||||
if err != nil {
|
||||
t.Error("Unmarshal with empty input should not error")
|
||||
}
|
||||
|
||||
// Test unmarshal with just opening bracket
|
||||
tags2 := New()
|
||||
_, err2 := tags2.Unmarshal([]byte("["))
|
||||
if err2 != nil {
|
||||
t.Error("Unmarshal with just '[' should not error")
|
||||
}
|
||||
|
||||
// Test unmarshal with just closing bracket
|
||||
tags3 := New()
|
||||
_, err3 := tags3.Unmarshal([]byte("]"))
|
||||
if err3 != nil {
|
||||
t.Error("Unmarshal with just ']' should not error")
|
||||
}
|
||||
|
||||
// Test unmarshal with comma
|
||||
tags4 := New()
|
||||
_, err4 := tags4.Unmarshal([]byte(","))
|
||||
if err4 != nil {
|
||||
t.Error("Unmarshal with just ',' should not error")
|
||||
}
|
||||
|
||||
// Test unmarshal with other characters
|
||||
tags5 := New()
|
||||
_, err5 := tags5.Unmarshal([]byte("x"))
|
||||
if err5 != nil {
|
||||
t.Error("Unmarshal with other chars should not error")
|
||||
}
|
||||
|
||||
// Test unmarshal with nested structure
|
||||
tags6 := New()
|
||||
_, err6 := tags6.Unmarshal([]byte(`[["p","key"],["e","id"]]`))
|
||||
if err6 != nil {
|
||||
t.Error("Unmarshal with valid nested structure should not error")
|
||||
}
|
||||
|
||||
// Test unmarshal with incomplete structure
|
||||
tags7 := New()
|
||||
_, err7 := tags7.Unmarshal([]byte(`[["p","key"`))
|
||||
if err7 == nil {
|
||||
t.Error("Unmarshal with incomplete structure should error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestIntersectsEdgeCases(t *testing.T) {
|
||||
// Test Intersects with multiple filter matches
|
||||
tag1 := tag.New("p", "pubkey1")
|
||||
tag2 := tag.New("e", "eventid1")
|
||||
tags := New(tag1, tag2)
|
||||
|
||||
// Create filter with multiple matching tags
|
||||
filter1 := tag.New("#p", "pubkey1")
|
||||
filter2 := tag.New("#e", "eventid1")
|
||||
filterTags := New(filter1, filter2)
|
||||
|
||||
if !tags.Intersects(filterTags) {
|
||||
t.Error("Intersects should return true when all filters match")
|
||||
}
|
||||
|
||||
// Test with partial matches
|
||||
filter3 := tag.New("#p", "pubkey1")
|
||||
filter4 := tag.New("#x", "nonexistent")
|
||||
partialFilterTags := New(filter3, filter4)
|
||||
|
||||
if tags.Intersects(partialFilterTags) {
|
||||
t.Error("Intersects should return false when not all filters match")
|
||||
}
|
||||
}
|
||||
|
||||
// Additional tests to reach 100% coverage
|
||||
func TestRemainingEdgeCases(t *testing.T) {
|
||||
// Test Less with different edge cases
|
||||
tag1 := tag.New("a")
|
||||
tag2 := tag.New("b", "value")
|
||||
tags := New(tag1, tag2)
|
||||
|
||||
// Test Less when first tag has length < 1 and second has length >= 1
|
||||
if !tags.Less(0, 1) {
|
||||
t.Error("Less should return true when first tag is shorter")
|
||||
}
|
||||
|
||||
// Test Less when second tag has length < 1 and first has length >= 1
|
||||
if tags.Less(1, 0) {
|
||||
t.Error("Less should return false when second tag is shorter")
|
||||
}
|
||||
|
||||
// Test GetFirst, GetLast, GetAll with nil tags
|
||||
var nilTags *T
|
||||
if nilTags.GetFirst(tag.New("test")) != nil {
|
||||
t.Error("GetFirst on nil should return nil")
|
||||
}
|
||||
if nilTags.GetLast(tag.New("test")) != nil {
|
||||
t.Error("GetLast on nil should return nil")
|
||||
}
|
||||
if nilTags.GetAll(tag.New("test")) != nil {
|
||||
t.Error("GetAll on nil should return nil")
|
||||
}
|
||||
|
||||
// Test Unmarshal edge cases for better coverage
|
||||
tags2 := New()
|
||||
|
||||
// Test unmarshal with nested brackets and commas
|
||||
_, err := tags2.Unmarshal([]byte(`[[["nested"]],["tag"]]`))
|
||||
if err == nil {
|
||||
t.Error("Unmarshal with nested structure should error")
|
||||
}
|
||||
|
||||
// Test unmarshal with mixed content
|
||||
tags3 := New()
|
||||
_, err2 := tags3.Unmarshal([]byte(`[,]`))
|
||||
if err2 != nil {
|
||||
t.Error("Unmarshal with comma between brackets should not error")
|
||||
}
|
||||
|
||||
// Test unmarshal with spaces and other characters
|
||||
tags4 := New()
|
||||
_, err3 := tags4.Unmarshal([]byte(` [ ] `))
|
||||
if err3 != nil {
|
||||
t.Error("Unmarshal with spaces should not error")
|
||||
}
|
||||
|
||||
// Test Less method edge case for 100% coverage
|
||||
// Test case where bytes.Compare returns >= 0 (the else branch)
|
||||
tagZ := tag.New("z", "value")
|
||||
tagA := tag.New("a", "value")
|
||||
tagsForLess := New(tagZ, tagA)
|
||||
|
||||
// Test Less where first key > second key (should return false)
|
||||
if tagsForLess.Less(0, 1) {
|
||||
t.Error("Less should return false when first key > second key")
|
||||
}
|
||||
|
||||
// Test Less method with one empty tag and one non-empty tag
|
||||
emptyTag := tag.New([]byte{})
|
||||
nonEmptyTag := tag.New("a", "value")
|
||||
mixedTags := New(emptyTag, nonEmptyTag)
|
||||
|
||||
// Test where first tag is empty and second is not (should return true)
|
||||
if !mixedTags.Less(0, 1) {
|
||||
t.Error("Less should return true when first tag is empty and second is not")
|
||||
}
|
||||
|
||||
// Test where first tag is not empty and second is empty (should return false)
|
||||
mixedTags2 := New(nonEmptyTag, emptyTag)
|
||||
if mixedTags2.Less(0, 1) {
|
||||
t.Error("Less should return false when first tag is not empty and second is empty")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package text
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"testing"
|
||||
|
||||
"lukechampine.com/frand"
|
||||
|
||||
Reference in New Issue
Block a user