mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
592 lines
18 KiB
Go
592 lines
18 KiB
Go
/*
|
|
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
|
|
Copyright (C) ITsysCOM GmbH
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
package utils
|
|
|
|
import (
|
|
"bytes"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestPathItemListNext(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushFront(node3)
|
|
list.PushFront(node2)
|
|
list.PushFront(node1)
|
|
if !reflect.DeepEqual("path2", strings.Join(list.Front().Next().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path2>, received: <%+v>", strings.Join(list.Front().Next().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListNextNil(t *testing.T) {
|
|
var e PathItemElement
|
|
received := e.Next()
|
|
if received != nil {
|
|
t.Errorf("Expecting: <nil>, received: <%+v>", received)
|
|
}
|
|
}
|
|
|
|
func TestPathItemListPrev(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushFront(node3)
|
|
list.PushFront(node2)
|
|
list.PushFront(node1)
|
|
if !reflect.DeepEqual("path2", strings.Join(list.Back().Prev().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path2>, received: <%+v>", strings.Join(list.Back().Prev().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListPrevNil(t *testing.T) {
|
|
var e PathItemElement
|
|
received := e.Prev()
|
|
if received != nil {
|
|
t.Errorf("Expecting: <nil>, received: <%+v>", received)
|
|
}
|
|
}
|
|
|
|
func TestPathItemListInit(t *testing.T) {
|
|
list := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushFront(node3)
|
|
list.PushFront(node2)
|
|
list.PushFront(node1)
|
|
if !reflect.DeepEqual(list2, list.Init()) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", list2, list.Init())
|
|
}
|
|
}
|
|
|
|
func TestPathItemListNewPathItemList(t *testing.T) {
|
|
list := NewPathItemList()
|
|
list2 := new(PathItemList).Init()
|
|
if !reflect.DeepEqual(list2, list) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", list2, list)
|
|
}
|
|
}
|
|
|
|
func TestPathItemListLen(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushFront(node3)
|
|
list.PushFront(node2)
|
|
list.PushFront(node1)
|
|
if !reflect.DeepEqual(3, list.Len()) {
|
|
t.Errorf("Expecting: <3>, received: <%+v>", list.Len())
|
|
}
|
|
}
|
|
|
|
func TestPathItemListFront(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
if !reflect.DeepEqual("path1", strings.Join(list.Front().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path1>, received: <%+v>", strings.Join(list.Front().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListFrontNil(t *testing.T) {
|
|
var e PathItemList
|
|
received := e.Front()
|
|
if received != nil {
|
|
t.Errorf("Expecting: <nil>, received: <%+v>", received)
|
|
}
|
|
}
|
|
|
|
func TestPathItemListBack(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
if !reflect.DeepEqual("path2", strings.Join(list.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path2>, received: <%+v>", strings.Join(list.Back().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListBackNil(t *testing.T) {
|
|
var e PathItemList
|
|
received := e.Back()
|
|
if received != nil {
|
|
t.Errorf("Expecting: <nil>, received: <%+v>", received)
|
|
}
|
|
}
|
|
|
|
func TestPathItemListLazyInit(t *testing.T) {
|
|
list := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
list.root.next = nil
|
|
list.lazyInit()
|
|
if !reflect.DeepEqual(list2, list) {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", list2, list)
|
|
}
|
|
}
|
|
|
|
func TestPathItemListInsert(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.insert(list.Front(), list.Back())
|
|
if !reflect.DeepEqual("path1", strings.Join(list.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path1>, received: <%+v>", strings.Join(list.Back().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListInsertValue(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.insertValue([]string{"path3"}, list.Back())
|
|
if !reflect.DeepEqual("path3", strings.Join(list.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path3>, received: <%+v>", strings.Join(list.Back().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListRemoveLowerCase(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.remove(list.Back())
|
|
if !reflect.DeepEqual("path2", strings.Join(list.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path2>, received: <%+v>", strings.Join(list.Back().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListRemoveUpperCase1(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.Remove(list.Front().Next())
|
|
if !reflect.DeepEqual("path3", strings.Join(list.Front().Next().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path3>, received: <%+v>", strings.Join(list.Front().Next().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListRemoveUpperCase2(t *testing.T) {
|
|
list1 := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
node1 := []string{"pathA"}
|
|
node2 := []string{"pathB"}
|
|
list1.PushBack(node1)
|
|
list2.PushBack(node2)
|
|
list1.Remove(list2.Front())
|
|
if !reflect.DeepEqual("pathA", strings.Join(list1.Front().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <pathA>, received: <%+v>", strings.Join(list1.Front().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListMoveEqual(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.move(list.Back(), list.Back())
|
|
if !reflect.DeepEqual("path3", strings.Join(list.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path3>, received: <%+v>", strings.Join(list.Back().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListMove(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.move(list.Front(), list.Back())
|
|
if !reflect.DeepEqual("path3", strings.Join(list.Front().next.Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path3>, received: <%+v>", strings.Join(list.Front().next.Value, NestingSep))
|
|
}
|
|
if !reflect.DeepEqual("path1", strings.Join(list.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path1>, received: <%+v>", strings.Join(list.Back().Value, NestingSep))
|
|
}
|
|
if !reflect.DeepEqual("path2", strings.Join(list.Front().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path2>, received: <%+v>", strings.Join(list.Front().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListPushFront(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.PushFront([]string{"path4"})
|
|
if !reflect.DeepEqual("path4", strings.Join(list.Front().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path4>, received: <%+v>", strings.Join(list.Front().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListPushBack(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.PushBack([]string{"path4"})
|
|
if !reflect.DeepEqual("path4", strings.Join(list.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path4>, received: <%+v>", strings.Join(list.Back().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListInsertBefore(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.InsertBefore([]string{"path4"}, list.Back())
|
|
if !reflect.DeepEqual("path4", strings.Join(list.Back().Prev().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path4>, received: <%+v>", strings.Join(list.Back().Prev().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListInsertBeforeNil(t *testing.T) {
|
|
list1 := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
var received *PathItemElement
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
list1.PushBack(node1)
|
|
list2.PushBack(node2)
|
|
received = list1.InsertBefore([]string{"path4"}, list2.Back())
|
|
if received != nil {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", nil, received)
|
|
}
|
|
}
|
|
|
|
func TestPathItemListInsertAfter(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.InsertAfter([]string{"path4"}, list.Front())
|
|
if !reflect.DeepEqual("path4", strings.Join(list.Front().Next().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path4>, received: <%+v>", strings.Join(list.Front().Next().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListInsertAfterNil(t *testing.T) {
|
|
list1 := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
var received *PathItemElement
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
list1.PushBack(node1)
|
|
list2.PushBack(node2)
|
|
received = list1.InsertAfter([]string{"path4"}, list2.Back())
|
|
if received != nil {
|
|
t.Errorf("Expecting: <%+v>, received: <%+v>", nil, received)
|
|
}
|
|
}
|
|
|
|
func TestPathItemListMoveToFrontCase1(t *testing.T) {
|
|
list1 := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
list1.PushBack(node1)
|
|
list2.PushBack(node2)
|
|
list1.MoveToFront(list2.Back())
|
|
if !reflect.DeepEqual("path1", strings.Join(list1.Front().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path3>, received: <%+v>", strings.Join(list1.Front().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListMoveToFrontCase2(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.MoveToFront(list.Back())
|
|
if !reflect.DeepEqual("path3", strings.Join(list.Front().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path3>, received: <%+v>", strings.Join(list.Front().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListMoveToBackCase1(t *testing.T) {
|
|
list1 := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
list1.PushBack(node1)
|
|
list2.PushBack(node2)
|
|
list1.MoveToBack(list2.Back())
|
|
if !reflect.DeepEqual("path1", strings.Join(list1.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path1>, received: <%+v>", strings.Join(list1.Back().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListMoveToBackCase2(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.MoveToBack(list.Front())
|
|
if !reflect.DeepEqual("path1", strings.Join(list.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path1>, received: <%+v>", strings.Join(list.Front().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListMoveBeforeCase1(t *testing.T) {
|
|
list1 := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
list1.PushBack(node1)
|
|
list2.PushBack(node2)
|
|
list1.MoveBefore(list2.Front(), list1.Back())
|
|
if !reflect.DeepEqual("path1", strings.Join(list1.Front().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path1>, received: <%+v>", strings.Join(list1.Front().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListMoveBeforeCase2(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.MoveBefore(list.Front(), list.Back())
|
|
if !reflect.DeepEqual("path1", strings.Join(list.Back().Prev().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path1>, received: <%+v>", strings.Join(list.Back().Prev().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListMoveAfterCase1(t *testing.T) {
|
|
list1 := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
node1 := []string{"pathA"}
|
|
node2 := []string{"pathB"}
|
|
list1.PushBack(node1)
|
|
list2.PushBack(node2)
|
|
list1.MoveAfter(list2.Front(), list1.Back())
|
|
if !reflect.DeepEqual("pathA", strings.Join(list1.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <pathA>, received: <%+v>", strings.Join(list1.Back().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListMoveAfterCase2(t *testing.T) {
|
|
list := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
node3 := []string{"path3"}
|
|
list.PushBack(node1)
|
|
list.PushBack(node2)
|
|
list.PushBack(node3)
|
|
list.MoveAfter(list.Front(), list.Back())
|
|
if !reflect.DeepEqual("path1", strings.Join(list.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <path1>, received: <%+v>", strings.Join(list.Back().Value, NestingSep))
|
|
}
|
|
|
|
}
|
|
|
|
func TestPathItemListPushBackList(t *testing.T) {
|
|
list1 := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
nodeA := []string{"pathA"}
|
|
nodeB := []string{"pathB"}
|
|
list1.PushBack(node1)
|
|
list1.PushBack(node2)
|
|
list2.PushBack(nodeA)
|
|
list2.PushBack(nodeB)
|
|
list1.PushBackList(list2)
|
|
if !reflect.DeepEqual("pathB", strings.Join(list1.Back().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <pathB>, received: <%+v>", strings.Join(list1.Back().Value, NestingSep))
|
|
}
|
|
if !reflect.DeepEqual("pathA", strings.Join(list1.Back().Prev().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <pathA>, received: <%+v>", strings.Join(list1.Back().Prev().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
func TestPathItemListPushFrontList(t *testing.T) {
|
|
list1 := NewPathItemList()
|
|
list2 := NewPathItemList()
|
|
node1 := []string{"path1"}
|
|
node2 := []string{"path2"}
|
|
nodeA := []string{"pathA"}
|
|
nodeB := []string{"pathB"}
|
|
list1.PushBack(node1)
|
|
list1.PushBack(node2)
|
|
list2.PushBack(nodeA)
|
|
list2.PushBack(nodeB)
|
|
list1.PushFrontList(list2)
|
|
if !reflect.DeepEqual("pathA", strings.Join(list1.Front().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <pathA>, received: <%+v>", strings.Join(list1.Front().Value, NestingSep))
|
|
}
|
|
if !reflect.DeepEqual("pathB", strings.Join(list1.Front().Next().Value, NestingSep)) {
|
|
t.Errorf("Expecting: <pathB>, received: <%+v>", strings.Join(list1.Front().Next().Value, NestingSep))
|
|
}
|
|
}
|
|
|
|
// const benchPath = "~*req.Field1[0][-1][*raw][10][path1][path2][path3]"
|
|
|
|
// const benchPath = "~*req.Field1[*raw]"
|
|
|
|
const benchPath = "Field1[1000000000000000]"
|
|
|
|
// Benchmark results:
|
|
// goos: linux
|
|
// goarch: amd64
|
|
// pkg: github.com/cgrates/cgrates/utils
|
|
// cpu: Intel(R) Core(TM) i7-7700HQ CPU @ 2.80GHz
|
|
// BenchmarkGetPathIndexSlice
|
|
// BenchmarkGetPathIndexSlice 16462084 360.8 ns/op 160 B/op 2 allocs/op
|
|
// BenchmarkGetPathIndexSliceSplit
|
|
// BenchmarkGetPathIndexSliceSplit 16291755 359.4 ns/op 112 B/op 1 allocs/op
|
|
// BenchmarkGetPathIndexSliceStringsIndex
|
|
// BenchmarkGetPathIndexSliceStringsIndex 10418586 597.2 ns/op 240 B/op 4 allocs/op
|
|
// BenchmarkGetPathIndexString
|
|
// BenchmarkGetPathIndexString 96080587 61.19 ns/op 16 B/op 1 allocs/op
|
|
// PASS
|
|
// ok github.com/cgrates/cgrates/utils 25.372s
|
|
|
|
func GetPathIndexSlice1(spath string) (opath string, idx []string) {
|
|
idxStart := strings.Index(spath, IdxStart)
|
|
if idxStart == -1 || !strings.HasSuffix(spath, IdxEnd) {
|
|
return spath, nil
|
|
}
|
|
idxVal := spath[idxStart+1 : len(spath)-1]
|
|
opath = spath[:idxStart]
|
|
if len(idxVal) <= 3 {
|
|
return opath, []string{idxVal}
|
|
}
|
|
idxValB := []byte(idxVal)
|
|
n := bytes.Count(idxValB, []byte{']'}) // we number only ] as an optimization
|
|
if n <= 0 {
|
|
return opath, []string{idxVal}
|
|
}
|
|
idx = make([]string, n+1) // alloc the memory for the slice
|
|
for i := 0; i < n; i++ { // expect a valid path
|
|
ix := bytes.IndexByte(idxValB, ']') // safe to asume that ix is not -1 as we counted before
|
|
if ix == len(idxValB)-1 ||
|
|
idxValB[ix+1] != '[' { // this is clearly an error so stop
|
|
return spath, nil
|
|
}
|
|
idx[i] = idxVal[:ix]
|
|
idxValB = idxValB[ix+2:]
|
|
idxVal = idxVal[ix+2:]
|
|
}
|
|
idx[n] = idxVal
|
|
return
|
|
}
|
|
|
|
func GetPathIndexSliceStringsIndex(spath string) (opath string, idx []string) {
|
|
idxStart := strings.Index(spath, IdxStart)
|
|
if idxStart == -1 || !strings.HasSuffix(spath, IdxEnd) {
|
|
return spath, nil
|
|
}
|
|
idxVal := spath[idxStart+1 : len(spath)-1]
|
|
opath = spath[:idxStart]
|
|
if len(idxVal) <= 3 {
|
|
return opath, []string{idxVal}
|
|
}
|
|
|
|
for ix := strings.Index(idxVal, IdxCombination); ix != -1; ix = strings.Index(idxVal, IdxCombination) {
|
|
idx = append(idx, idxVal[:ix])
|
|
idxVal = idxVal[ix+1:]
|
|
|
|
}
|
|
idx = append(idx, string(idxVal))
|
|
|
|
return
|
|
}
|
|
|
|
func BenchmarkGetPathIndexSlice(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
GetPathIndexSlice1(benchPath)
|
|
}
|
|
}
|
|
|
|
/*
|
|
func BenchmarkGetPathIndexSliceSplit(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
GetPathIndexSlice(benchPath)
|
|
}
|
|
}
|
|
*/
|
|
func BenchmarkGetPathIndexSliceStringsIndex(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
GetPathIndexSliceStringsIndex(benchPath)
|
|
}
|
|
}
|
|
func BenchmarkGetPathIndexString(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
GetPathIndexString(benchPath)
|
|
}
|
|
}
|