17917482292

Committed 22 Sep 2025 01:50PM UTC coverage: 56.562% (-10.1%) from 66.668%

Build # 17917482292

Build Type

Pull #10182

github

Committed by

web-flow

Commit Message

Merge 9efe3bd8c into 055fb436e

Pull Request Pull Request #10182: Aux feature bits

Run Details

32 of 68 new or added lines in 5 files covered. (47.06%)

29734 existing lines in 467 files now uncovered.

98449 of 174056 relevant lines covered (56.56%)

1.18 hits per line

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

68.0

/payments/db/codec.go

package paymentsdb

import (
        "encoding/binary"
        "errors"
        "io"
        "time"

        "github.com/lightningnetwork/lnd/channeldb"
)

// Big endian is the preferred byte order, due to cursor scans over
// integer keys iterating in order.
var byteOrder = binary.BigEndian

// UnknownElementType is an alias for channeldb.UnknownElementType.
type UnknownElementType = channeldb.UnknownElementType

// ReadElement deserializes a single element from the provided io.Reader.
func ReadElement(r io.Reader, element interface{}) error {
        err := channeldb.ReadElement(r, element)
        switch {
        // Known to channeldb codec.
        case err == nil:
                return nil

        // Fail if error is not UnknownElementType.
        default:
                var unknownElementType UnknownElementType
                if !errors.As(err, &unknownElementType) {
                        return err
                }
        }

        // Process any paymentsdb-specific extensions to the codec.
        switch e := element.(type) {
        case *paymentIndexType:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        // Type is still unknown to paymentsdb extensions, fail.
        default:
                return channeldb.NewUnknownElementType(
                        "ReadElement", element,
                )
        }

        return nil
}

// WriteElement serializes a single element into the provided io.Writer.
func WriteElement(w io.Writer, element interface{}) error {
        err := channeldb.WriteElement(w, element)
        switch {
        // Known to channeldb codec.
        case err == nil:
                return nil

        // Fail if error is not UnknownElementType.
        default:
                var unknownElementType UnknownElementType
                if !errors.As(err, &unknownElementType) {
                        return err
                }
        }

        // Process any paymentsdb-specific extensions to the codec.
        switch e := element.(type) {
        case paymentIndexType:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        // Type is still unknown to paymentsdb extensions, fail.
        default:
                return channeldb.NewUnknownElementType(
                        "WriteElement", element,
                )
        }

        return nil
}

// WriteElements serializes a variadic list of elements into the given
// io.Writer.
func WriteElements(w io.Writer, elements ...interface{}) error {
        for _, element := range elements {
                if err := WriteElement(w, element); err != nil {
                        return err
                }
        }

        return nil
}

// ReadElements deserializes the provided io.Reader into a variadic list of
// target elements.
func ReadElements(r io.Reader, elements ...interface{}) error {
        for _, element := range elements {
                if err := ReadElement(r, element); err != nil {
                        return err
                }
        }

        return nil
}

// deserializeTime deserializes time as unix nanoseconds.
func deserializeTime(r io.Reader) (time.Time, error) {
        var scratch [8]byte
        if _, err := io.ReadFull(r, scratch[:]); err != nil {
                return time.Time{}, err
        }

        // Convert to time.Time. Interpret unix nano time zero as a zero
        // time.Time value.
        unixNano := byteOrder.Uint64(scratch[:])
        if unixNano == 0 {
                return time.Time{}, nil
        }

        return time.Unix(0, int64(unixNano)), nil
}

// serializeTime serializes time as unix nanoseconds.
func serializeTime(w io.Writer, t time.Time) error {
        var scratch [8]byte

        // Convert to unix nano seconds, but only if time is non-zero. Calling
        // UnixNano() on a zero time yields an undefined result.
        var unixNano int64
        if !t.IsZero() {
                unixNano = t.UnixNano()
        }

        byteOrder.PutUint64(scratch[:], uint64(unixNano))
        _, err := w.Write(scratch[:])

        return err
}

1	package paymentsdb
2
3	import (
4	"encoding/binary"
5	"errors"
6	"io"
7	"time"
8
9	"github.com/lightningnetwork/lnd/channeldb"
10	)
11
12	// Big endian is the preferred byte order, due to cursor scans over
13	// integer keys iterating in order.
14	var byteOrder = binary.BigEndian
15
16	// UnknownElementType is an alias for channeldb.UnknownElementType.
17	type UnknownElementType = channeldb.UnknownElementType
18
19	// ReadElement deserializes a single element from the provided io.Reader.
20	func ReadElement(r io.Reader, element interface{}) error {	2✔
21	err := channeldb.ReadElement(r, element)	2✔
22	switch {	2✔
23	// Known to channeldb codec.
24	case err == nil:	2✔
25	return nil	2✔
26
27	// Fail if error is not UnknownElementType.
28	default:	2✔
29	var unknownElementType UnknownElementType	2✔
30	if !errors.As(err, &unknownElementType) {	2✔
31	return err	×
32	}	×
33	}
34
35	// Process any paymentsdb-specific extensions to the codec.
36	switch e := element.(type) {	2✔
37	case *paymentIndexType:	2✔
38	if err := binary.Read(r, byteOrder, e); err != nil {	2✔
39	return err	×
40	}	×
41
42	// Type is still unknown to paymentsdb extensions, fail.
43	default:	×
44	return channeldb.NewUnknownElementType(	×
45	"ReadElement", element,	×
46	)	×
47	}
48
49	return nil	2✔
50	}
51
52	// WriteElement serializes a single element into the provided io.Writer.
53	func WriteElement(w io.Writer, element interface{}) error {	2✔
54	err := channeldb.WriteElement(w, element)	2✔
55	switch {	2✔
56	// Known to channeldb codec.
57	case err == nil:	2✔
58	return nil	2✔
59
60	// Fail if error is not UnknownElementType.
61	default:	2✔
62	var unknownElementType UnknownElementType	2✔
63	if !errors.As(err, &unknownElementType) {	2✔
64	return err	×
65	}	×
66	}
67
68	// Process any paymentsdb-specific extensions to the codec.
69	switch e := element.(type) {	2✔
70	case paymentIndexType:	2✔
71	if err := binary.Write(w, byteOrder, e); err != nil {	2✔
72	return err	×
73	}	×
74
75	// Type is still unknown to paymentsdb extensions, fail.
76	default:	×
77	return channeldb.NewUnknownElementType(	×
78	"WriteElement", element,	×
79	)	×
80	}
81
82	return nil	2✔
83	}
84
85	// WriteElements serializes a variadic list of elements into the given
86	// io.Writer.
87	func WriteElements(w io.Writer, elements ...interface{}) error {	2✔
88	for _, element := range elements {	4✔
89	if err := WriteElement(w, element); err != nil {	2✔
90	return err	×
91	}	×
92	}
93
94	return nil	2✔
95	}
96
97	// ReadElements deserializes the provided io.Reader into a variadic list of
98	// target elements.
99	func ReadElements(r io.Reader, elements ...interface{}) error {	2✔
100	for _, element := range elements {	4✔
101	if err := ReadElement(r, element); err != nil {	2✔
102	return err	×
103	}	×
104	}
105
106	return nil	2✔
107	}
108
109	// deserializeTime deserializes time as unix nanoseconds.
110	func deserializeTime(r io.Reader) (time.Time, error) {	2✔
111	var scratch [8]byte	2✔
112	if _, err := io.ReadFull(r, scratch[:]); err != nil {	2✔
113	return time.Time{}, err	×
114	}	×
115
116	// Convert to time.Time. Interpret unix nano time zero as a zero
117	// time.Time value.
118	unixNano := byteOrder.Uint64(scratch[:])	2✔
119	if unixNano == 0 {	2✔
UNCOV 120	return time.Time{}, nil	×
UNCOV 121	}	×
122
123	return time.Unix(0, int64(unixNano)), nil	2✔
124	}
125
126	// serializeTime serializes time as unix nanoseconds.
127	func serializeTime(w io.Writer, t time.Time) error {	2✔
128	var scratch [8]byte	2✔
129		2✔
130	// Convert to unix nano seconds, but only if time is non-zero. Calling	2✔
131	// UnixNano() on a zero time yields an undefined result.	2✔
132	var unixNano int64	2✔
133	if !t.IsZero() {	4✔
134	unixNano = t.UnixNano()	2✔
135	}	2✔
136
137	byteOrder.PutUint64(scratch[:], uint64(unixNano))	2✔
138	_, err := w.Write(scratch[:])	2✔
139		2✔
140	return err	2✔
141	}

lightningnetwork / lnd / 17917482292

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