Skip to content

G
gostnops
Commit 56c5be6e authored by AlexStocks's avatar AlexStocks
Browse files
Options

delete xorlist

parent 9e413440
Hide whitespace changes
Inline Side-by-side
Showing with 6 additions and 872 deletions
container/xorlist/example_test.go deleted 100644 → 0
View file @ 9e413440
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 gxxorlist
import (
"fmt"
)
func Example() {
// Create a new list and put some numbers in it.
l := New()
e4 := l.PushBack(4)
e1 := l.PushFront(1)
l.InsertBefore(3, e4)
l.InsertAfter(2, e1)
// Iterate through list and print its contents.
for e, p := l.Front(); e != nil; e, p = e.Next(p), e {
fmt.Println(e.Value)
}
// Output:
// 1
// 2
// 3
// 4
}
container/xorlist/xorlist.go deleted 100644 → 0
View file @ 9e413440
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 list implements a xor-doubly linked list in xor style
// whose interface is partially compatible with golang's list.
// incompatible interfaces: XorElement.Prev & XorElement.Next
// & XorList.Front & XorList.Back.
//
// To iterate over a list (where l is a *XorList):
// var p *XorElement = nil
// for e := l.Front(); e != nil; p, e = e, e.Next(p) {
// // do something with e.Value
// }
// or
// To iterate over a list in reverse (where l is a *XorList):
// var n *XorElement = nil
// for e := l.Back(); e != nil; n, e = e, e.Prev(n) {
// // do something with e.Value
// }
// or
// To delete a element in iteration
// var p *XorElement = nil
// for e := l.Front(); e != nil; p, e = e, e.Next(p) {
// if condition (e) {
// elem := e
// e, p = p, p.Prev(e)
// l.Remove(elem)
// }
// }
package gxxorlist
import (
"fmt"
"unsafe"
)
// XorElement is an element of a xor-linked list.
type XorElement struct {
// Compute the bitwise XOR of this element's previous
// element's address and its next element's address
// and @PN stores the result
PN uintptr
// The value stored with this element.
Value interface{}
}
func uptr(p *XorElement) uintptr {
return (uintptr)(unsafe.Pointer(p))
}
func ptr(u uintptr) *XorElement {
return (*XorElement)(unsafe.Pointer(u))
}
// Next returns the next list element or nil.
func (e *XorElement) Next(prev *XorElement) *XorElement {
if e == nil || e.PN == 0 {
return nil
}
next := ptr(uptr(prev) ^ e.PN)
if next != nil && ptr(next.PN) == e { // then next is list's tail
next = nil
}
return next
}
// Prev returns the previous list element or nil.
func (e *XorElement) Prev(next *XorElement) *XorElement {
if e == nil || e.PN == 0 {
return nil
}
prev := ptr(uptr(next) ^ e.PN)
if prev != nil && ptr(prev.PN) == e { // then prev is list's head
prev = nil
}
return prev
}
// XorList represents a doubly linked list.
// The zero value for XorList is an empty list ready to use.
type XorList struct {
head XorElement // first sentinel list element, only &head, head.prev, and head.next are used
tail XorElement // last sentinel list element, only &tail, tail.prev, and tail.next are used
len int // current list length excluding @list.s two sentinel element
}
// Output just for test
func (l *XorList) Output() {
fmt.Printf("fake head{addr:%p, PN:%#x, value:%v} --> \n", &l.head, l.head.PN, l.head.Value)
for e, p := l.Front(); e != nil; p, e = e, e.Next(p) {
fmt.Printf(" element{addr:%p, PN:%#x, value:%v} --> \n", &e, e.PN, e.Value)
}
fmt.Printf("fake tail{addr:%p, PN:%#x, value:%v}\n", &l.tail, l.tail.PN, l.tail.Value)
}
// Init initializes or clears list l.
func (l *XorList) Init() *XorList {
l.head.PN = uptr(&l.tail)
l.tail.PN = uptr(&l.head)
l.len = 0
return l
}
// New returns an initialized list.
func New() *XorList { return new(XorList).Init() }
// Len returns the number of elements of list l.
// The complexity is O(1).
func (l *XorList) Len() int { return l.len }
// Front returns the first element of list l or nil.
func (l *XorList) Front() (front, head *XorElement) {
if l.len == 0 {
return nil, nil
}
return ptr(l.head.PN), &l.head
}
// Back returns the last element of list l or nil.
func (l *XorList) Back() (back, tail *XorElement) {
if l.len == 0 {
return nil, nil
}
return ptr(l.tail.PN), &l.tail
}
// lazyInit lazily initializes a zero XorList value.
func (l *XorList) lazyInit() {
if l.head.PN == 0 || l.tail.PN == 0 || ptr(l.head.PN) == &l.tail {
l.Init()
}
}
// insert inserts e after @prev and before @next, increments l.len, and returns e.
func (l *XorList) insert(e, prev, next *XorElement) *XorElement {
e.PN = uptr(prev) ^ uptr(next)
prev.PN ^= uptr(next) ^ uptr(e)
next.PN ^= uptr(prev) ^ uptr(e)
l.len++
return e
}
// insertValue is a convenience wrapper for insert(&XorElement{Value: v}, prev, next).
func (l *XorList) insertValue(v interface{}, prev, next *XorElement) *XorElement {
return l.insert(&XorElement{Value: v}, prev, next)
}
// remove removes e from its list, decrements l.len, and returns e.
func (l *XorList) remove(e, prev, next *XorElement) *XorElement {
prev.PN ^= uptr(e) ^ uptr(next)
next.PN ^= uptr(e) ^ uptr(prev)
e.PN = 0
l.len--
return e
}
func (l *XorList) prev(e *XorElement) *XorElement {
prev := &l.head
cur := prev.Next(nil)
for cur != nil && cur != e && cur != &l.tail {
prev, cur = cur, cur.Next(prev)
}
if cur != e {
prev = nil
}
return prev
}
func (l *XorList) next(e *XorElement) *XorElement {
next := &l.tail
cur := next.Prev(nil)
for cur != nil && cur != e && cur != &l.head {
next, cur = cur, cur.Prev(next)
}
if cur != e {
next = nil
}
return next
}
// Remove removes e from l if e is an element of list l.
// It returns the element value e.Value.
func (l *XorList) Remove(e *XorElement) interface{} {
prev := l.prev(e)
if prev != nil {
// if e.list == l, l must have been initialized when e was inserted
// in l or l == nil (e is a zero XorElement) and l.remove will crash
next := e.Next(prev)
if next == nil {
next = &l.tail
}
l.remove(e, prev, next)
}
return e.Value
}
// PushFront inserts a new element e with value v at the front of list l and returns e.
func (l *XorList) PushFront(v interface{}) *XorElement {
l.lazyInit()
return l.insertValue(v, &l.head, ptr(l.head.PN))
}
// PushBack inserts a new element e with value v at the back of list l and returns e.
func (l *XorList) PushBack(v interface{}) *XorElement {
l.lazyInit()
return l.insertValue(v, ptr(l.tail.PN), &l.tail)
}
// InsertBefore inserts a new element e with value v immediately before mark and returns e.
// If mark is not an element of l, the list is not modified.
func (l *XorList) InsertBefore(v interface{}, mark *XorElement) *XorElement {
prev := l.prev(mark)
if prev == nil {
return nil
}
// see comment in XorList.Remove about initialization of l
return l.insertValue(v, prev, mark)
}
// InsertAfter inserts a new element e with value v immediately after mark and returns e.
// If mark is not an element of l, the list is not modified.
func (l *XorList) InsertAfter(v interface{}, mark *XorElement) *XorElement {
next := l.next(mark)
if next == nil {
return nil
}
// see comment in XorList.Remove about initialization of l
return l.insertValue(v, mark, next)
}
// MoveToFront moves element e to the front of list l.
// If e is not an element of l, the list is not modified.
func (l *XorList) MoveToFront(e *XorElement) {
prev := l.prev(e)
if prev == nil {
return
}
next := e.Next(prev)
if next == nil {
next = &l.tail
}
e = l.remove(e, prev, next)
// see comment in XorList.Remove about initialization of l
l.insert(e, &l.head, ptr(l.head.PN))
}
// MoveToBack moves element e to the back of list l.
// If e is not an element of l, the list is not modified.
func (l *XorList) MoveToBack(e *XorElement) {
prev := l.prev(e)
if prev == nil {
return
}
next := e.Next(prev)
if next == nil {
next = &l.tail
}
e = l.remove(e, prev, next)
// see comment in XorList.Remove about initialization of l
l.insert(e, ptr(l.tail.PN), &l.tail)
}
// MoveBefore moves element e to its new position before mark.
// If e or mark is not an element of l, or e == mark, the list is not modified.
func (l *XorList) MoveBefore(e, mark *XorElement) {
if e == nil || mark == nil || e == mark {
return
}
mark_prev := l.prev(mark)
if mark_prev == nil {
return
}
e_prev := l.prev(e)
if e_prev == nil {
return
}
e_next := e.Next(e_prev)
if e_next == nil {
e_next = &l.tail
}
e = l.remove(e, e_prev, e_next)
mark_prev = l.prev(mark)
if mark_prev == nil {
return
}
l.insert(e, mark_prev, mark)
}
// MoveAfter moves element e to its new position after mark.
// If e or mark is not an element of l, or e == mark, the list is not modified.
func (l *XorList) MoveAfter(e, mark *XorElement) {
if e == nil || mark == nil || e == mark {
return
}
mark_prev := l.prev(mark)
if mark_prev == nil {
return
}
e_prev := l.prev(e)
if e_prev == nil {
return
}
e_next := e.Next(e_prev)
if e_next == nil {
e_next = &l.tail
}
e = l.remove(e, e_prev, e_next)
mark_next := l.next(mark)
if mark_next == nil {
return
}
/*
mark_next = mark.Next(mark_prev)
if mark_next == nil {
mark_next = &l.tail
}
*/
l.insert(e, mark, mark_next)
}
// PushBackList inserts a copy of an other list at the back of list l.
// The lists l and other may be the same.
func (l *XorList) PushBackList(other *XorList) {
l.lazyInit()
i := other.Len()
for e, p := other.Front(); i > 0 && e != nil; e, p = e.Next(p), e {
// l.insertValue(e.Value, l.tail.Prev(nil), &l.tail)
l.PushBack(e.Value)
i--
}
}
// PushFrontList inserts a copy of an other list at the front of list l.
// The lists l and other may be the same.
func (l *XorList) PushFrontList(other *XorList) {
l.lazyInit()
i := other.Len()
for e, n := other.Back(); i > 0 && e != nil; n, e = e, e.Prev(n) {
// l.insertValue(e.Value, &l.head, (&l.head).Next(nil))
l.PushFront(e.Value)
i--
}
}
container/xorlist/xorlist_output.go deleted 100644 → 0
View file @ 9e413440
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 gxxorlist
import (
"fmt"
)
// OutputElem outputs a xorlist element.
func OutputElem(e *XorElement) {
if e != nil {
// fmt.Printf("addr:%p, value:%v", e, e)
fmt.Printf("value:%v", e.Value)
}
}
// OutputList iterates through list and print its contents.
func OutputList(l *XorList) {
idx := 0
for e, p := l.Front(); e != nil; p, e = e, e.Next(p) {
fmt.Printf("idx:%v, ", idx)
OutputElem(e)
fmt.Printf("\n")
idx++
}
}
// OutputListR iterates through list and print its contents in reverse.
func OutputListR(l *XorList) {
idx := 0
for e, n := l.Back(); e != nil; e, n = e.Next(n), e {
fmt.Printf("idx:%v, ", idx)
OutputElem(e)
fmt.Printf("\n")
idx++
}
}
container/xorlist/xorlist_test.go deleted 100644 → 0
View file @ 9e413440
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 gxxorlist
import "testing"
func checkListLen(t *testing.T, l *XorList, len int) bool {
if n := l.Len(); n != len {
t.Errorf("l.Len() = %d, want %d", n, len)
return false
}
return true
}
func checkListPointers(t *testing.T, l *XorList, es []*XorElement) {
if !checkListLen(t, l, len(es)) {
return
}
// zero length lists must be the zero value or properly initialized (sentinel circle)
if len(es) == 0 {
if ptr(l.head.PN) != &l.tail {
t.Errorf("l.head.PN = %v, &l.tail = %v; both should both be equal", l.head.PN, l.tail)
}
if ptr(l.tail.PN) != &l.head {
t.Errorf("l.tail.PN = %v, &l.head = %v; both should both be equal", l.tail.PN, l.head)
}
return
}
// len(es) > 0
i := 0
var prev *XorElement
for e, p := l.Front(); e != nil; e, p = e.Next(p), e {
if e != es[i] {
t.Errorf("elt[%d] = %p, want %p", i, es[i], e)
}
prev = &l.head
if 0 < i {
prev = es[i-1]
}
if p != prev {
t.Errorf("elt[%d](%p).prev = %p, want %p", i, e, p, prev)
}
i++
}
i = len(es) - 1
var next *XorElement
for e, n := l.Back(); e != nil; e, n = e.Prev(n), e {
if e != es[i] {
t.Errorf("elt[%d] = %p, want %p", i, es[i], e)
}
next = &l.tail
if i < len(es)-1 {
next = es[i+1]
}
if n != next {
t.Errorf("elt[%d](%p).next = %p, want %p", i, e, n, next)
}
i--
}
}
func TestList(t *testing.T) {
l := New()
checkListPointers(t, l, []*XorElement{})
// Single element list
e := l.PushFront("a")
checkListPointers(t, l, []*XorElement{e})
l.MoveToFront(e)
checkListPointers(t, l, []*XorElement{e})
l.MoveToBack(e)
checkListPointers(t, l, []*XorElement{e})
l.Remove(e)
checkListPointers(t, l, []*XorElement{})
// Bigger list
e2 := l.PushFront(2)
e1 := l.PushFront(1)
e3 := l.PushBack(3)
e4 := l.PushBack("banana")
checkListPointers(t, l, []*XorElement{e1, e2, e3, e4})
l.Remove(e2)
checkListPointers(t, l, []*XorElement{e1, e3, e4})
l.MoveToFront(e3) // move from middle
checkListPointers(t, l, []*XorElement{e3, e1, e4})
l.MoveToFront(e1)
l.MoveToBack(e3) // move from middle
checkListPointers(t, l, []*XorElement{e1, e4, e3})
l.MoveToFront(e3) // move from back
checkListPointers(t, l, []*XorElement{e3, e1, e4})
l.MoveToFront(e3) // should be no-op
checkListPointers(t, l, []*XorElement{e3, e1, e4})
l.MoveToBack(e3) // move from front
checkListPointers(t, l, []*XorElement{e1, e4, e3})
l.MoveToBack(e3) // should be no-op
checkListPointers(t, l, []*XorElement{e1, e4, e3})
e2 = l.InsertBefore(2, e1) // insert before front
checkListPointers(t, l, []*XorElement{e2, e1, e4, e3})
l.Remove(e2)
e2 = l.InsertBefore(2, e4) // insert before middle
checkListPointers(t, l, []*XorElement{e1, e2, e4, e3})
l.Remove(e2)
e2 = l.InsertBefore(2, e3) // insert before back
checkListPointers(t, l, []*XorElement{e1, e4, e2, e3})
l.Remove(e2)
e2 = l.InsertAfter(2, e1) // insert after front
checkListPointers(t, l, []*XorElement{e1, e2, e4, e3})
l.Remove(e2)
e2 = l.InsertAfter(2, e4) // insert after middle
checkListPointers(t, l, []*XorElement{e1, e4, e2, e3})
l.Remove(e2)
e2 = l.InsertAfter(2, e3) // insert after back
checkListPointers(t, l, []*XorElement{e1, e4, e3, e2})
l.Remove(e2)
// Check standard iteration.
sum := 0
for e, p := l.Front(); e != nil; e, p = e.Next(p), e {
if i, ok := e.Value.(int); ok {
sum += i
}
}
if sum != 4 {
t.Errorf("sum over l = %d, want 4", sum)
}
// Clear all elements by iterating
var next *XorElement
for e, p := l.Front(); e != nil; e = next {
next = e.Next(p)
l.Remove(e)
}
checkListPointers(t, l, []*XorElement{})
}
func checkList(t *testing.T, l *XorList, es []interface{}) {
if !checkListLen(t, l, len(es)) {
return
}
i := 0
for e, p := l.Front(); e != nil; e, p = e.Next(p), e {
le := e.Value.(int)
if le != es[i] {
t.Errorf("elt[%d].Value = %v, want %v", i, le, es[i])
}
i++
}
}
func TestExtending(t *testing.T) {
l1 := New()
l2 := New()
l1.PushBack(1)
l1.PushBack(2)
l1.PushBack(3)
l2.PushBack(4)
l2.PushBack(5)
l3 := New()
l3.PushBackList(l1)
checkList(t, l3, []interface{}{1, 2, 3})
l3.PushBackList(l2)
checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
l3 = New()
l3.PushFrontList(l2)
checkList(t, l3, []interface{}{4, 5})
l3.PushFrontList(l1)
checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
checkList(t, l1, []interface{}{1, 2, 3})
checkList(t, l2, []interface{}{4, 5})
return
l3 = New()
l3.PushBackList(l1)
checkList(t, l3, []interface{}{1, 2, 3})
l3.PushBackList(l3)
checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
l3 = New()
l3.PushFrontList(l1)
checkList(t, l3, []interface{}{1, 2, 3})
l3.PushFrontList(l3)
checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
l3 = New()
l1.PushBackList(l3)
checkList(t, l1, []interface{}{1, 2, 3})
l1.PushFrontList(l3)
checkList(t, l1, []interface{}{1, 2, 3})
}
func TestRemove(t *testing.T) {
l := New()
e1 := l.PushBack(1)
e2 := l.PushBack(2)
checkListPointers(t, l, []*XorElement{e1, e2})
e, _ := l.Front()
l.Remove(e)
checkListPointers(t, l, []*XorElement{e2})
l.Remove(e)
checkListPointers(t, l, []*XorElement{e2})
}
func TestIssue4103(t *testing.T) {
l1 := New()
l1.PushBack(1)
l1.PushBack(2)
l2 := New()
l2.PushBack(3)
l2.PushBack(4)
e, _ := l1.Front()
l2.Remove(e) // l2 should not change because e is not an element of l2
if n := l2.Len(); n != 2 {
t.Errorf("l2.Len() = %d, want 2", n)
}
l1.InsertBefore(8, e)
if n := l1.Len(); n != 3 {
t.Errorf("l1.Len() = %d, want 3", n)
}
}
func TestIssue6349(t *testing.T) {
l := New()
l.PushBack(1)
l.PushBack(2)
e, p := l.Front()
l.Remove(e)
if e.Value != 1 {
t.Errorf("e.value = %d, want 1", e.Value)
}
if e.Next(p) != nil {
t.Errorf("e.Next() != nil")
}
if e.Prev(p) != nil {
t.Errorf("e.Prev() != nil")
}
}
func TestMove(t *testing.T) {
l := New()
e1 := l.PushBack(1)
e2 := l.PushBack(2)
e3 := l.PushBack(3)
e4 := l.PushBack(4)
l.MoveAfter(e3, e3)
checkListPointers(t, l, []*XorElement{e1, e2, e3, e4})
l.MoveBefore(e2, e2)
checkListPointers(t, l, []*XorElement{e1, e2, e3, e4})
l.MoveAfter(e3, e2)
checkListPointers(t, l, []*XorElement{e1, e2, e3, e4})
l.MoveBefore(e2, e3)
checkListPointers(t, l, []*XorElement{e1, e2, e3, e4})
l.MoveBefore(e2, e4)
checkListPointers(t, l, []*XorElement{e1, e3, e2, e4})
e1, e2, e3, e4 = e1, e3, e2, e4
l.MoveBefore(e4, e1)
checkListPointers(t, l, []*XorElement{e4, e1, e2, e3})
e1, e2, e3, e4 = e4, e1, e2, e3
l.MoveAfter(e4, e1)
checkListPointers(t, l, []*XorElement{e1, e4, e2, e3})
e1, e2, e3, e4 = e1, e4, e2, e3
l.MoveAfter(e2, e3)
checkListPointers(t, l, []*XorElement{e1, e3, e2, e4})
e1, e2, e3, e4 = e1, e3, e2, e4
}
// Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized XorList
func TestZeroList(t *testing.T) {
var l1 = new(XorList)
l1.PushFront(1)
checkList(t, l1, []interface{}{1})
var l2 = new(XorList)
l2.PushBack(1)
checkList(t, l2, []interface{}{1})
var l3 = new(XorList)
l3.PushFrontList(l1)
checkList(t, l3, []interface{}{1})
var l4 = new(XorList)
l4.PushBackList(l2)
checkList(t, l4, []interface{}{1})
}
// Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l.
func TestInsertBeforeUnknownMark(t *testing.T) {
var l XorList
l.PushBack(1)
l.PushBack(2)
l.PushBack(3)
l.InsertBefore(1, new(XorElement))
checkList(t, &l, []interface{}{1, 2, 3})
}
// Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l.
func TestInsertAfterUnknownMark(t *testing.T) {
var l XorList
l.PushBack(1)
l.PushBack(2)
l.PushBack(3)
l.InsertAfter(1, new(XorElement))
checkList(t, &l, []interface{}{1, 2, 3})
}
// Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l.
func TestMoveUnkownMark(t *testing.T) {
var l1 XorList
e1 := l1.PushBack(1)
checkList(t, &l1, []interface{}{1})
var l2 XorList
e2 := l2.PushBack(2)
l1.MoveAfter(e1, e2)
checkList(t, &l1, []interface{}{1})
checkList(t, &l2, []interface{}{2})
l1.MoveBefore(e1, e2)
checkList(t, &l1, []interface{}{1})
checkList(t, &l2, []interface{}{2})
}
func TestLoopRemove(t *testing.T) {
l := New()
checkListPointers(t, l, []*XorElement{})
// build list
e1 := l.PushBack(2)
e2 := l.PushBack(1)
e3 := l.PushBack(3)
e4 := l.PushBack(2)
e5 := l.PushBack(5)
e6 := l.PushBack(2)
checkListPointers(t, l, []*XorElement{e1, e2, e3, e4, e5, e6})
for e, p := l.Front(); e != nil; e, p = e.Next(p), e {
if e.Value.(int) == 2 {
elem := e
e, p = p, p.Prev(e)
l.Remove(elem)
}
}
checkListPointers(t, l, []*XorElement{e2, e3, e5})
}
sync/task_pool_test.go
View file @ 56c5be6e
......@@ -195,7 +195,7 @@ func BenchmarkTaskPoolSimple_RandomTask(b *testing.B) {
func TestTaskPool(t *testing.T) {
numCPU := runtime.NumCPU()
taskCnt := int64(numCPU * numCPU * 100)
//taskCnt := int64(numCPU * numCPU * 100)
tp := NewTaskPool(
WithTaskPoolTaskPoolSize(1),
......@@ -203,7 +203,8 @@ func TestTaskPool(t *testing.T) {
WithTaskPoolTaskQueueLength(1),
)
task, cnt := newCountTask()
//task, cnt := newCountTask()
task, _ := newCountTask()
var wg sync.WaitGroup
for i := 0; i < numCPU*numCPU; i++ {
......@@ -221,9 +222,9 @@ func TestTaskPool(t *testing.T) {
wg.Wait()
tp.Close()
if taskCnt != atomic.LoadInt64(cnt) {
//t.Error("want ", taskCnt, " got ", *cnt)
}
//if taskCnt != atomic.LoadInt64(cnt) {
// //t.Error("want ", taskCnt, " got ", *cnt)
//}
}
func BenchmarkTaskPool_CountTask(b *testing.B) {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment