lal/pkg/logic/gop_cache_test.go

package logic

import (
    `github.com/q191201771/naza/pkg/assert`
    `testing`
)

func TestGopCircularQueueCap0(t *testing.T) {
    var gcqCap int = 0
    
    gcq := NewGopCircularQueue(gcqCap)
    
    //fl
    assert.Equal(t, true, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 0, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.Front())
    assert.Equal(t, nil, gcq.Back())
    assert.Equal(t, nil, gcq.Dequeue())
    
    
    //fl
    tGOP := &GOP{
        data:nil,
    }
    gcq.Enqueue(tGOP)
    //fg
    assert.Equal(t, true, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 0, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.Front())
    assert.Equal(t, nil, gcq.Back())
    
    
    //弹出一个后
    assert.Equal(t, nil, gcq.Dequeue())
    //fg
    assert.Equal(t, true, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 0, gcq.Len())
    assert.Equal(t, 0, gcq.Cap())
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil,  gcq.At(2))
    assert.Equal(t, nil, gcq.Front())
    assert.Equal(t, nil, gcq.Back())
    assert.Equal(t, nil, gcq.Dequeue())
    
    //放入2个元素后
    gcq.Enqueue(tGOP)
    gcq.Enqueue(tGOP)
    assert.Equal(t, true, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 0, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.Front())
    assert.Equal(t, nil, gcq.Back())
    assert.Equal(t, nil, gcq.Dequeue())
}

func TestGopCircularQueue(t *testing.T) {
    var gcqCap int = 3
   
    //元素为个数为0
    //fl,_, _, _
    gcq := NewGopCircularQueue(gcqCap)
    assert.Equal(t, true, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 0, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    //gop :=
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.Front())
    assert.Equal(t, nil, gcq.Back())
    assert.Equal(t, nil, gcq.Dequeue())
    
    //fl,, _, _
    tGOP := &GOP{
        data:[][]byte{[]byte("t")},
    }
    gcq.Enqueue(tGOP)
    //放入一个元素后
    //tf,l, _, _
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 1, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, tGOP,  gcq.At(0))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, tGOP, gcq.Front())
    assert.Equal(t, tGOP, gcq.Back())
    
    //在弹出一个元素后
    //tf,l, _,_
    assert.Equal(t, tGOP, gcq.Dequeue())
    //_,fl, _,_
    assert.Equal(t, true, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 0, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.Front())
    assert.Equal(t, nil, gcq.Back())
    assert.Equal(t, nil, gcq.Dequeue())
    
    //_,fl, _,_
    GOP0 := &GOP{
        data:[][]byte{[]byte("0")},
    }
    gcq.Enqueue(GOP0)
    //_,f0,l_,_
    GOP1 := &GOP{
        data:[][]byte{[]byte("1")},
    }
    gcq.Enqueue(GOP1)
    //_,f0, 1, l
    //验证遍历情况
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 2, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP0, gcq.At(0))
    assert.Equal(t, GOP1, gcq.At(1))
    assert.Equal(t, nil, gcq.At(2))
    assert.Equal(t, GOP0, gcq.Front())
    assert.Equal(t, GOP1, gcq.Back())
    
    GOP2 := &GOP{
        data:[][]byte{[]byte("2")},
    }
    gcq.Enqueue(GOP2)
    //l,f0, 1, 2
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 3, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP0, gcq.At(0))
    assert.Equal(t, GOP1, gcq.At(1))
    assert.Equal(t, GOP2, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, GOP0, gcq.Front())
    assert.Equal(t, GOP2, gcq.Back())
    
    //
    GOP3 := &GOP{
        data:[][]byte{[]byte("3")},
    }
    gcq.Enqueue(GOP3)
    //3, l, f1, 2
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 3, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP1, gcq.At(0))
    assert.Equal(t, GOP2, gcq.At(1))
    assert.Equal(t, GOP3, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, GOP1, gcq.Front())
    assert.Equal(t, GOP3, gcq.Back())
    
    
    
    //3, l, f1, 2
    assert.Equal(t, GOP1, gcq.Dequeue())
    //出队后
    //3, l, _, f2
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 2, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP2, gcq.At(0))
    assert.Equal(t, GOP3, gcq.At(1))
    assert.Equal(t, nil, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, GOP2, gcq.Front())
    assert.Equal(t, GOP3, gcq.Back())
    
    
    
    //3, l, _, f2
    GOP4 := &GOP{
        data:[][]byte{[]byte("4")},
    }
    gcq.Enqueue(GOP4)
    //入队后
    //3, 4, l, f2
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 3, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP2, gcq.At(0))
    assert.Equal(t, GOP3, gcq.At(1))
    assert.Equal(t, GOP4, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, GOP2, gcq.Front())
    assert.Equal(t, GOP4, gcq.Back())
    
    //3, 4, l, 2f
    assert.Equal(t, GOP2, gcq.Dequeue())
    //3f, 4, l, _
    
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 2, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP3,  gcq.At(0))
    assert.Equal(t, GOP4, gcq.At(1))
    assert.Equal(t, nil, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, GOP3, gcq.Front())
    assert.Equal(t, GOP4, gcq.Back())
    
    //3f, 4, l, _
    GOP5 := &GOP{
        data:[][]byte{[]byte("5")},
    }
    gcq.Enqueue(GOP5)
    //3f, 4, 5, l
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 3, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP3, gcq.At(0))
    assert.Equal(t, GOP4,  gcq.At(1))
    assert.Equal(t, GOP5, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, GOP3, gcq.Front())
    assert.Equal(t, GOP5, gcq.Back())
    
    
    
    //3f, 4, 5, l
    assert.Equal(t, GOP3, gcq.Dequeue())
    //_, 4f, 5, l
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 2, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP4, gcq.At(0))
    assert.Equal(t, GOP5, gcq.At(1))
    assert.Equal(t, nil,  gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, GOP4, gcq.Front())
    assert.Equal(t, GOP5, gcq.Back())
    
    //_, 4f, 5, l
    assert.Equal(t, GOP4, gcq.Dequeue())
    //_, _, 5f, l
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 1, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP5, gcq.At(0))
    assert.Equal(t, nil, gcq.At(1))
    assert.Equal(t, nil, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil,  gcq.At(4))
    assert.Equal(t, GOP5, gcq.Front())
    assert.Equal(t, GOP5, gcq.Back())
    
    //_, _, 5f, l
    assert.Equal(t, GOP5, gcq.Dequeue())
    //_, _, _, fl
    assert.Equal(t, true, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 0, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.At(1))
    assert.Equal(t, nil, gcq.At(2))
    assert.Equal(t, nil,  gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, nil, gcq.Front())
    assert.Equal(t, nil, gcq.Back())
    
    
    //_, _, _, fl
    GOP6 := &GOP{
        data:[][]byte{[]byte("6")},
    }
    gcq.Enqueue(GOP6)
    //l, _, _, f6
    GOP7 := &GOP{
        data:[][]byte{[]byte("7")},
    }
    gcq.Enqueue(GOP7)
    //7, l, _, f6
    GOP8 := &GOP{
        data:[][]byte{[]byte("8")},
    }
    gcq.Enqueue(GOP8)
    //7, 8, l, f6
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 3, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP6, gcq.At(0))
    assert.Equal(t, GOP7, gcq.At(1))
    assert.Equal(t, GOP8, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, GOP6, gcq.Front())
    assert.Equal(t, GOP8, gcq.Back())
    
    
    GOP9 := &GOP{
        data:[][]byte{[]byte("9")},
    }
    gcq.Enqueue(GOP9)
    //f7, 8, 9, l
    assert.Equal(t, false, gcq.Empty())
    assert.Equal(t, true, gcq.Full())
    assert.Equal(t, 3, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, GOP7, gcq.At(0))
    assert.Equal(t, GOP8, gcq.At(1))
    assert.Equal(t, GOP9, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, GOP7, gcq.Front())
    assert.Equal(t, GOP9,  gcq.Back())
    
    //f7, 8, 9, l
    assert.Equal(t, GOP7, gcq.Dequeue())
    //_, f8, 9, l
    assert.Equal(t, GOP8, gcq.Dequeue())
    //_, _, f9, l
    assert.Equal(t, GOP9, gcq.Dequeue())
    //_, _, _, fl
    assert.Equal(t, true, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 0, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil, gcq.At(1))
    assert.Equal(t, nil, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, nil,  gcq.Front())
    assert.Equal(t, nil, gcq.Back())
    
    
    //_, _, _, fl
    assert.Equal(t, nil, gcq.Dequeue())
    //_, _, _, fl
    assert.Equal(t, true, gcq.Empty())
    assert.Equal(t, false, gcq.Full())
    assert.Equal(t, 0, gcq.Len())
    assert.Equal(t, gcqCap, gcq.Cap())
    assert.Equal(t, nil, gcq.At(0))
    assert.Equal(t, nil,  gcq.At(1))
    assert.Equal(t, nil, gcq.At(2))
    assert.Equal(t, nil, gcq.At(3))
    assert.Equal(t, nil, gcq.At(4))
    assert.Equal(t, nil, gcq.Front())
    assert.Equal(t, nil, gcq.Back())
}