couchbase / moss / 231

pending completion

Build # 231

Build Type

push

travis-ci

Committed by

steveyen

Commit Message

<a href="https://github.com/couchbase/moss/commit/<a class=hub.com/couchbase/moss/commit/5a8572ba8254b73b39ddceff1b8db522c1e50f26">5a8572ba8<a href="https://github.com/couchbase/moss/commit/5a8572ba8254b73b39ddceff1b8db522c1e50f26">&quot;&gt;MB-23574 - add unit test for iterator single

When run on commit (0fc17b1791), which is one commit before the fix
for MB-23567 (commit 86fdd130), the test introduced here fails.  On
the latest master, the test passes.

Change-Id: I</a><a class="double-link" href="https://github.com/couchbase/moss/commit/<a class="double-link" href="https://github.com/couchbase/moss/commit/96f23f82489798b2e270b1c9e120b5cf846ad926">96f23f824</a>">96f23f824</a><a href="https://github.com/couchbase/moss/commit/5a8572ba8254b73b39ddceff1b8db522c1e50f26">
Reviewed-on: http://review.couchbase.org/75935
Reviewed-by: Marty Schoch <marty.schoch@gmail.com>
Tested-by: Steve Yen <steve.yen@gmail.com>

Run Details

2855 of 3462 relevant lines covered (82.47%)

11534.67 hits per line

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

82.35

/iterator_single.go

//  Copyright (c) 2016 Couchbase, Inc.
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the
//  License. You may obtain a copy of the License at
//    http://www.apache.org/licenses/LICENSE-2.0
//  Unless required by applicable law or agreed to in writing,
//  software distributed under the License is distributed on an "AS
//  IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
//  express or implied. See the License for the specific language
//  governing permissions and limitations under the License.

package moss

import (
        "bytes"
        "io"
)

// An iteratorSingle implements the Iterator interface, and is an edge
// case optimization when there's only a single segment to iterate and
// there's no lower-level iterator.  In contrast to the main iterator
// implementation, iteratorSingle doesn't have any heap operations.
type iteratorSingle struct {
        s  *segment
        sc SegmentCursor

        op uint64
        k  []byte
        v  []byte

        closer io.Closer

        options *CollectionOptions

        iteratorOptions IteratorOptions
}

// Close must be invoked to release resources.
func (iter *iteratorSingle) Close() error {
        if iter.closer != nil {
                iter.closer.Close()
                iter.closer = nil
        }

        return nil
}

func (iter *iteratorSingle) InitCloser(closer io.Closer) error {
        if iter.closer != nil {
                return ErrAlreadyInitialized
        }
        iter.closer = closer
        return nil
}

// Next returns ErrIteratorDone if the iterator is done.
func (iter *iteratorSingle) Next() error {
        err := iter.sc.Next()
        if err != nil {
                iter.op = 0
                iter.k = nil
                iter.v = nil

                // we DO want to return ErrIteratorDone here
                return err
        }

        iter.op, iter.k, iter.v = iter.sc.Current()
        if iter.op != OperationDel ||
                iter.iteratorOptions.IncludeDeletions {
                return nil
        }

        return iter.Next()
}

func (iter *iteratorSingle) SeekTo(seekToKey []byte) error {
        key, _, err := iter.Current()
        if err != nil && err != ErrIteratorDone {
                return err
        }

        if key != nil {
                cmp := bytes.Compare(seekToKey, key)
                if cmp == 0 {
                        return nil
                }

                if cmp > 0 {
                        // Try a loop of naive Next()'s for several attempts.
                        err = naiveSeekTo(iter, seekToKey, DefaultNaiveSeekToMaxTries)
                        if err != ErrMaxTries {
                                return err
                        }
                }
        }

        iter.op = 0
        iter.k = nil
        iter.v = nil

        err = iter.sc.Seek(seekToKey)
        if err != nil {
                // we DO want to return ErrIteratorDone here
                return err
        }

        iter.op, iter.k, iter.v = iter.sc.Current()
        if !iter.iteratorOptions.IncludeDeletions &&
                iter.op == OperationDel {
                return iter.Next()
        }

        return nil
}

// Current returns ErrIteratorDone if the iterator is done.
// Otherwise, Current() returns the current key and val, which should
// be treated as immutable or read-only.  The key and val bytes will
// remain available until the next call to Next() or Close().
func (iter *iteratorSingle) Current() ([]byte, []byte, error) {
        if iter.op == 0 {
                return nil, nil, ErrIteratorDone
        }

        if iter.op == OperationDel {
                return nil, nil, nil
        }

        if iter.op == OperationMerge {
                var mo MergeOperator
                if iter.options != nil {
                        mo = iter.options.MergeOperator
                }
                if mo == nil {
                        return iter.k, nil, ErrMergeOperatorNil
                }

                vMerged, ok := mo.FullMerge(iter.k, nil, [][]byte{iter.v})
                if !ok {
                        return iter.k, nil, ErrMergeOperatorFullMergeFailed
                }

                return iter.k, vMerged, nil
        }

        return iter.k, iter.v, nil
}

// CurrentEx is a more advanced form of Current() that returns more
// metadata.  It returns ErrIteratorDone if the iterator is done.
// Otherwise, the current operation, key, val are returned.
func (iter *iteratorSingle) CurrentEx() (
        entryEx EntryEx, key, val []byte, err error) {
        if iter.op == 0 {
                return EntryEx{}, nil, nil, ErrIteratorDone
        }

        return EntryEx{Operation: iter.op}, iter.k, iter.v, nil
}

1	// Copyright (c) 2016 Couchbase, Inc.
2	// Licensed under the Apache License, Version 2.0 (the "License");
3	// you may not use this file except in compliance with the
4	// License. You may obtain a copy of the License at
5	// http://www.apache.org/licenses/LICENSE-2.0
6	// Unless required by applicable law or agreed to in writing,
7	// software distributed under the License is distributed on an "AS
8	// IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
9	// express or implied. See the License for the specific language
10	// governing permissions and limitations under the License.
11
12	package moss
13
14	import (
15	"bytes"
16	"io"
17	)
18
19	// An iteratorSingle implements the Iterator interface, and is an edge
20	// case optimization when there's only a single segment to iterate and
21	// there's no lower-level iterator. In contrast to the main iterator
22	// implementation, iteratorSingle doesn't have any heap operations.
23	type iteratorSingle struct {
24	s *segment
25	sc SegmentCursor
26
27	op uint64
28	k []byte
29	v []byte
30
31	closer io.Closer
32
33	options *CollectionOptions
34
35	iteratorOptions IteratorOptions
36	}
37
38	// Close must be invoked to release resources.
39	func (iter *iteratorSingle) Close() error {	169✔
40	if iter.closer != nil {	183✔
41	iter.closer.Close()	14✔
42	iter.closer = nil	14✔
43	}	14✔
44
45	return nil	169✔
46	}
47
48	func (iter *iteratorSingle) InitCloser(closer io.Closer) error {	17✔
49	if iter.closer != nil {	17✔
50	return ErrAlreadyInitialized	×
51	}	×
52	iter.closer = closer	17✔
53	return nil	17✔
54	}
55
56	// Next returns ErrIteratorDone if the iterator is done.
57	func (iter *iteratorSingle) Next() error {	9,224✔
58	err := iter.sc.Next()	9,224✔
59	if err != nil {	9,411✔
60	iter.op = 0	187✔
61	iter.k = nil	187✔
62	iter.v = nil	187✔
63		187✔
64	// we DO want to return ErrIteratorDone here	187✔
65	return err	187✔
66	}	187✔
67
68	iter.op, iter.k, iter.v = iter.sc.Current()	9,037✔
69	if iter.op != OperationDel \|\|	9,037✔
70	iter.iteratorOptions.IncludeDeletions {	18,074✔
71	return nil	9,037✔
72	}	9,037✔
73
74	return iter.Next()	×
75	}
76
77	func (iter *iteratorSingle) SeekTo(seekToKey []byte) error {	112✔
78	key, _, err := iter.Current()	112✔
79	if err != nil && err != ErrIteratorDone {	112✔
80	return err	×
81	}	×
82
83	if key != nil {	216✔
84	cmp := bytes.Compare(seekToKey, key)	104✔
85	if cmp == 0 {	160✔
86	return nil	56✔
87	}	56✔
88
89	if cmp > 0 {	88✔
90	// Try a loop of naive Next()'s for several attempts.	40✔
91	err = naiveSeekTo(iter, seekToKey, DefaultNaiveSeekToMaxTries)	40✔
92	if err != ErrMaxTries {	80✔
93	return err	40✔
94	}	40✔
95	}
96	}
97
98	iter.op = 0	16✔
99	iter.k = nil	16✔
100	iter.v = nil	16✔
101		16✔
102	err = iter.sc.Seek(seekToKey)	16✔
103	if err != nil {	24✔
104	// we DO want to return ErrIteratorDone here	8✔
105	return err	8✔
106	}	8✔
107
108	iter.op, iter.k, iter.v = iter.sc.Current()	8✔
109	if !iter.iteratorOptions.IncludeDeletions &&	8✔
110	iter.op == OperationDel {	8✔
111	return iter.Next()	×
112	}	×
113
114	return nil	8✔
115	}
116
117	// Current returns ErrIteratorDone if the iterator is done.
118	// Otherwise, Current() returns the current key and val, which should
119	// be treated as immutable or read-only. The key and val bytes will
120	// remain available until the next call to Next() or Close().
121	func (iter *iteratorSingle) Current() ([]byte, []byte, error) {	2,230✔
122	if iter.op == 0 {	2,248✔
123	return nil, nil, ErrIteratorDone	18✔
124	}	18✔
125
126	if iter.op == OperationDel {	2,212✔
127	return nil, nil, nil	×
128	}	×
129
130	if iter.op == OperationMerge {	2,213✔
131	var mo MergeOperator	1✔
132	if iter.options != nil {	2✔
133	mo = iter.options.MergeOperator	1✔
134	}	1✔
135	if mo == nil {	1✔
136	return iter.k, nil, ErrMergeOperatorNil	×
137	}	×
138
139	vMerged, ok := mo.FullMerge(iter.k, nil, [][]byte{iter.v})	1✔
140	if !ok {	1✔
141	return iter.k, nil, ErrMergeOperatorFullMergeFailed	×
142	}	×
143
144	return iter.k, vMerged, nil	1✔
145	}
146
147	return iter.k, iter.v, nil	2,211✔
148	}
149
150	// CurrentEx is a more advanced form of Current() that returns more
151	// metadata. It returns ErrIteratorDone if the iterator is done.
152	// Otherwise, the current operation, key, val are returned.
153	func (iter *iteratorSingle) CurrentEx() (
154	entryEx EntryEx, key, val []byte, err error) {	7,235✔
155	if iter.op == 0 {	7,235✔
156	return EntryEx{}, nil, nil, ErrIteratorDone	×
157	}	×
158
159	return EntryEx{Operation: iter.op}, iter.k, iter.v, nil	7,235✔
160	}

couchbase / moss / 231

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