297747

Committed 19 Dec 2023 02:51PM UTC coverage: 61.911% (+0.002%) from 61.909%

Build # 297747

Build Type

push

circleci

Committed by

web-flow

Commit Message

chore(deps): Bump golang.org/x/net from 0.17.0 to 0.19.0 (#14479)

Run Details

65317 of 105502 relevant lines covered (61.91%)

83.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.27

/plugins/inputs/socket_listener/splitters.go

package socket_listener

import (
        "bufio"
        "bytes"
)

func scanNull(data []byte, atEOF bool) (advance int, token []byte, err error) {
        if atEOF && len(data) == 0 {
                return 0, nil, nil
        }
        if i := bytes.IndexByte(data, 0); i >= 0 {
                return i + 1, data[:i], nil
        }
        if atEOF {
                return len(data), data, nil
        }
        // Request more data.
        return 0, nil, nil
}

func createScanDelimiter(delimiter []byte) bufio.SplitFunc {
        return func(data []byte, atEOF bool) (advance int, token []byte, err error) {
                if atEOF && len(data) == 0 {
                        return 0, nil, nil
                }
                if i := bytes.Index(data, delimiter); i >= 0 {
                        return i + len(delimiter), data[:i], nil
                }
                if atEOF {
                        return len(data), data, nil
                }
                // Request more data.
                return 0, nil, nil
        }
}

func createScanFixedLength(length int) bufio.SplitFunc {
        return func(data []byte, atEOF bool) (advance int, token []byte, err error) {
                if atEOF && len(data) == 0 {
                        return 0, nil, nil
                }
                if len(data) >= length {
                        return length, data[:length], nil
                }
                if atEOF {
                        return len(data), data, nil
                }
                // Request more data.
                return 0, nil, nil
        }
}

func createScanVariableLength(spec lengthFieldSpec) bufio.SplitFunc {
        minlen := int(spec.Offset)
        minlen += int(spec.Bytes)
        headerLen := int(spec.HeaderLength)

        return func(data []byte, atEOF bool) (advance int, token []byte, err error) {
                if atEOF && len(data) == 0 {
                        return 0, nil, nil
                }
                dataLen := len(data)
                if dataLen >= minlen {
                        // Extract the length field and convert it to a number
                        lf := data[spec.Offset : spec.Offset+spec.Bytes]
                        length := spec.converter(lf)
                        start := headerLen
                        end := length + headerLen
                        // If we have enough data return it without the header
                        if end <= dataLen {
                                return end, data[start:end], nil
                        }
                }
                if atEOF {
                        return len(data), data, nil
                }
                // Request more data.
                return 0, nil, nil
        }
}

1	package socket_listener
2
3	import (
4	"bufio"
5	"bytes"
6	)
7
8	func scanNull(data []byte, atEOF bool) (advance int, token []byte, err error) {	4✔
9	if atEOF && len(data) == 0 {	5✔
10	return 0, nil, nil	1✔
11	}	1✔
12	if i := bytes.IndexByte(data, 0); i >= 0 {	6✔
13	return i + 1, data[:i], nil	3✔
14	}	3✔
15	if atEOF {	×
16	return len(data), data, nil	×
17	}	×
18	// Request more data.
19	return 0, nil, nil	×
20	}
21
22	func createScanDelimiter(delimiter []byte) bufio.SplitFunc {	1✔
23	return func(data []byte, atEOF bool) (advance int, token []byte, err error) {	5✔
24	if atEOF && len(data) == 0 {	5✔
25	return 0, nil, nil	1✔
26	}	1✔
27	if i := bytes.Index(data, delimiter); i >= 0 {	6✔
28	return i + len(delimiter), data[:i], nil	3✔
29	}	3✔
30	if atEOF {	×
31	return len(data), data, nil	×
32	}	×
33	// Request more data.
34	return 0, nil, nil	×
35	}
36	}
37
38	func createScanFixedLength(length int) bufio.SplitFunc {	1✔
39	return func(data []byte, atEOF bool) (advance int, token []byte, err error) {	6✔
40	if atEOF && len(data) == 0 {	6✔
41	return 0, nil, nil	1✔
42	}	1✔
43	if len(data) >= length {	8✔
44	return length, data[:length], nil	4✔
45	}	4✔
46	if atEOF {	×
47	return len(data), data, nil	×
48	}	×
49	// Request more data.
50	return 0, nil, nil	×
51	}
52	}
53
54	func createScanVariableLength(spec lengthFieldSpec) bufio.SplitFunc {	2✔
55	minlen := int(spec.Offset)	2✔
56	minlen += int(spec.Bytes)	2✔
57	headerLen := int(spec.HeaderLength)	2✔
58		2✔
59	return func(data []byte, atEOF bool) (advance int, token []byte, err error) {	10✔
60	if atEOF && len(data) == 0 {	10✔
61	return 0, nil, nil	2✔
62	}	2✔
63	dataLen := len(data)	6✔
64	if dataLen >= minlen {	12✔
65	// Extract the length field and convert it to a number	6✔
66	lf := data[spec.Offset : spec.Offset+spec.Bytes]	6✔
67	length := spec.converter(lf)	6✔
68	start := headerLen	6✔
69	end := length + headerLen	6✔
70	// If we have enough data return it without the header	6✔
71	if end <= dataLen {	11✔
72	return end, data[start:end], nil	5✔
73	}	5✔
74	}
75	if atEOF {	1✔
76	return len(data), data, nil	×
77	}	×
78	// Request more data.
79	return 0, nil, nil	1✔
80	}
81	}

influxdata / telegraf / 297747

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous