16968362988

Committed 14 Aug 2025 02:39PM UTC coverage: 66.754%. First build

Build # 16968362988

Build Type

Pull #9847

github

Committed by

web-flow

Commit Message

Merge b4419dd27 into 4b3ede5cb

Pull Request Pull Request #9847: Refactor Payment PR 4

Run Details

210 of 264 new or added lines in 19 files covered. (79.55%)

135930 of 203628 relevant lines covered (66.75%)

21512.07 hits per line

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

70.67

/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 {	14,016✔
21	err := channeldb.ReadElement(r, element)	14,016✔
22	switch {	14,016✔
23	// Known to channeldb codec.
24	case err == nil:	13,957✔
25	return nil	13,957✔
26
27	// Fail if error is not UnknownElementType.
28	default:	62✔
29	var unknownElementType UnknownElementType	62✔
30	if !errors.As(err, &unknownElementType) {	62✔
NEW 31	return err	×
NEW 32	}	×
33	}
34
35	// Process any paymentsdb-specific extensions to the codec.
36	switch e := element.(type) {	62✔
37	case *paymentIndexType:	62✔
38	if err := binary.Read(r, byteOrder, e); err != nil {	62✔
NEW 39	return err	×
NEW 40	}	×
41
42	// Type is still unknown to paymentsdb extensions, fail.
NEW 43	default:	×
NEW 44	return channeldb.NewUnknownElementType(	×
NEW 45	"ReadElement", element,	×
NEW 46	)	×
47	}
48
49	return nil	62✔
50	}
51
52	// WriteElement serializes a single element into the provided io.Writer.
53	func WriteElement(w io.Writer, element interface{}) error {	1,778✔
54	err := channeldb.WriteElement(w, element)	1,778✔
55	switch {	1,778✔
56	// Known to channeldb codec.
57	case err == nil:	1,612✔
58	return nil	1,612✔
59
60	// Fail if error is not UnknownElementType.
61	default:	169✔
62	var unknownElementType UnknownElementType	169✔
63	if !errors.As(err, &unknownElementType) {	169✔
NEW 64	return err	×
NEW 65	}	×
66	}
67
68	// Process any paymentsdb-specific extensions to the codec.
69	switch e := element.(type) {	169✔
70	case paymentIndexType:	169✔
71	if err := binary.Write(w, byteOrder, e); err != nil {	169✔
NEW 72	return err	×
NEW 73	}	×
74
75	// Type is still unknown to paymentsdb extensions, fail.
NEW 76	default:	×
NEW 77	return channeldb.NewUnknownElementType(	×
NEW 78	"WriteElement", element,	×
NEW 79	)	×
80	}
81
82	return nil	169✔
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 {	986✔
88	for _, element := range elements {	2,764✔
89	if err := WriteElement(w, element); err != nil {	1,778✔
NEW 90	return err	×
NEW 91	}	×
92	}
93
94	return nil	986✔
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 {	10,125✔
100	for _, element := range elements {	24,141✔
101	if err := ReadElement(r, element); err != nil {	14,016✔
NEW 102	return err	×
NEW 103	}	×
104	}
105
106	return nil	10,125✔
107	}
108
109	// deserializeTime deserializes time as unix nanoseconds.
110	func deserializeTime(r io.Reader) (time.Time, error) {	1,742✔
111	var scratch [8]byte	1,742✔
112	if _, err := io.ReadFull(r, scratch[:]); err != nil {	1,742✔
NEW 113	return time.Time{}, err	×
NEW 114	}	×
115
116	// Convert to time.Time. Interpret unix nano time zero as a zero
117	// time.Time value.
118	unixNano := byteOrder.Uint64(scratch[:])	1,742✔
119	if unixNano == 0 {	2,837✔
120	return time.Time{}, nil	1,095✔
121	}	1,095✔
122
123	return time.Unix(0, int64(unixNano)), nil	647✔
124	}
125
126	// serializeTime serializes time as unix nanoseconds.
127	func serializeTime(w io.Writer, t time.Time) error {	294✔
128	var scratch [8]byte	294✔
129		294✔
130	// Convert to unix nano seconds, but only if time is non-zero. Calling	294✔
131	// UnixNano() on a zero time yields an undefined result.	294✔
132	var unixNano int64	294✔
133	if !t.IsZero() {	471✔
134	unixNano = t.UnixNano()	177✔
135	}	177✔
136
137	byteOrder.PutUint64(scratch[:], uint64(unixNano))	294✔
138	_, err := w.Write(scratch[:])	294✔
139		294✔
140	return err	294✔
141	}

lightningnetwork / lnd / 16968362988

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