[fin] test_add_subcription

src/broker/modules/subscription_test.go

@@ -3,21 +3,19 @@ package modules
 import (
 	"fmt"
 	_ "fmt"
+	"github.com/stretchr/testify/assert"
 	"math/rand"
 	"strconv"
 	"testing"
 	"time"
-	"github.com/stretchr/testify/assert"
 )
 
-func dataMake(isalpha bool) MsgUnit{
+func makeData(isAlpha bool) MsgUnit{
 	rand.Seed(time.Now().UnixNano())
-
 	// Set Ipaddr
 	msg := Message{"", "1.0", "", SM}
 	for i := 0; i < 4; i++{
 		itoa := strconv.Itoa(rand.Int() % 256)
-
 		msg.from += itoa
 		if i != 3{
 			msg.from += "."
@@ -35,16 +33,26 @@ func dataMake(isalpha bool) MsgUnit{
 	candOp := []string{">", ">=", "<=" ,"<", "=="}
 	logicalOp := []string{"&&", "||"}
 
-	topic = append(topic, rand.Int63())
+	if isAlpha {
+		topicLen := rand.Int() % 10 + 1
+		for i := 0 ; i < topicLen; i++{
+			topic = append(topic, rand.Int63())
+		}
+
+		valueLen := rand.Int() % 10 + 1
+		for i := 0 ; i < valueLen; i++{
+			value = append(value, rand.Int63())
+		}
 
-	if isalpha{
-		value = append(value, rand.Int63())
 		operator = append(operator, "==")
+
 	} else{
-		len := rand.Int() % 2 + 1
+		valueLen := rand.Int() % 2 + 1
+
+		topic = append(topic, rand.Int63())
 		value = append(value, rand.Int63())
 
-		if len == 1{
+		if valueLen == 1{
 			operator = append(operator, candOp[rand.Int()%5])
 		} else{
 			value = append(value, rand.Int63())
@@ -59,87 +67,224 @@ func dataMake(isalpha bool) MsgUnit{
 		}
 	}
 
-	return &SubscriptionMsg{msg, topic, value, operator, isalpha}
+	return &SubscriptionMsg{msg, topic, value, operator, isAlpha}
 }
 
-func Test_addSubscription(t *testing.T) {
+func makeMsgList(dataLen int, isAlpha bool) []MsgUnit{
 	rand.Seed(time.Now().UnixNano())
+	var ret []MsgUnit
+	for i := 0 ; i < dataLen ; i++{
+		ret = append(ret, makeData(isAlpha))
+	}
+	return ret
+}
 
-	// To Init sub_mng
-	mos := Moscato{sub_mng : sub_manager{}}
+func checkOperatorList(isSingle bool, sub int, operator string, l *valueNode) int{
+	ret := -1
+	if isSingle{
+		switch operator {
+		case "<":
+			ret = findSub(l.single2sub_s, sub)
+		case "<=":
+			ret = findSub(l.single2sub_es, sub)
+		case ">":
+			ret = findSub(l.single2sub_b, sub)
+		case ">=":
+			ret = findSub(l.single2sub_eb, sub)
+		case "==":
+			ret = findSub(l.single2sub_e, sub)
+		}
 
-	// Make Data set(Subscription)
-	msgList := []MsgUnit{}
-	dataLen:= 3
-	for i := 0 ; i < dataLen ; i++{
-		seed := rand.Int()%2
-		if seed == 0{
-			msgList = append(msgList, dataMake(false))
-		} else{
-			msgList = append(msgList, dataMake(true))
+	} else{
+		switch operator {
+		case "<":
+			ret = findSub(l.range2sub_s, sub)
+		case "<=":
+			ret = findSub(l.range2sub_es, sub)
+		case ">":
+			ret = findSub(l.range2sub_b, sub)
+		case ">=":
+			ret = findSub(l.range2sub_eb, sub)
 		}
 	}
+	return ret
+}
 
-	// Watch Data set
-	for i := 0; i < dataLen ; i++{
+func watchData(msgList []MsgUnit, dataLen int){
+	for i := 0; i < dataLen; i++{
 		msg := msgList[i]
 		fmt.Println(
-			" from = ", msg.(*SubscriptionMsg).Message.from,
-			" time = ", msg.(*SubscriptionMsg).Message.time,
-			" topic = ", msg.(*SubscriptionMsg).topic,
-			" value = ", msg.(*SubscriptionMsg).value,
-			" operator = ", msg.(*SubscriptionMsg).operator,
-			" isAlpha ?= ", msg.(*SubscriptionMsg).isAlpha)
+			"\nfrom = ", msg.(*SubscriptionMsg).Message.from,
+			"\ntime = ", msg.(*SubscriptionMsg).Message.time,
+			"\ntopic = ", msg.(*SubscriptionMsg).topic,
+			"\nvalue = ", msg.(*SubscriptionMsg).value,
+			"\noperator = ", msg.(*SubscriptionMsg).operator,
+			"\nisAlpha ?= ", msg.(*SubscriptionMsg).isAlpha,
+		)
+	}
+}
+
+//Test addSubScription(1) (dif all [topic, value, operator])
+func Test_addSubscription_allDif(t *testing.T) {
+	rand.Seed(time.Now().UnixNano())
+
+	// To Init sub_mng
+	s := sub_manager{
+		ip2sub:     make(map[string][]int),
+		sub2node:   make(map[int][]*valueNode),
+		israngesub: make(map[int]bool),
 	}
+	mos := Moscato{sub_mng: s}
+
+	// Make Data set(Subscription)
+	var msgList []MsgUnit
+	dataLen := 100
+	msgList = makeMsgList(dataLen, false)
 
-	// Test addSubScription
-	for i := 0; i < dataLen ; i++{
+	//Watch Data set
+	//watchData(msgList, dataLen)
 
+	for i := 0; i < dataLen; i++ {
 		msg := msgList[i]
 		ip := msg.(*SubscriptionMsg).Message.from
 		topic := msg.(*SubscriptionMsg).topic
 		value := msg.(*SubscriptionMsg).value
-		//operator := msg.(*SubscriptionMsg).operator
-		//isAlpha := msg.(*SubscriptionMsg).isAlpha
+		operator := msg.(*SubscriptionMsg).operator
 		subnumber := mos.sub_mng.count_sub
+		isSingle := true
 
-		mos.sub_mng.addSubscription(msg)
-
+		// 0. Check addSubscription
+		err := mos.sub_mng.addSubscription(msg)
+		assert.Equal(t, nil, err)
 
 		// 1. Check if ip mapping is correct
-		assert.Equal(t, subnumber, mos.sub_mng.ip2sub[ip][len(mos.sub_mng.ip2sub[ip]) - 1], "Ip mapping is failed")
+		assert.Equal(t, subnumber, mos.sub_mng.ip2sub[ip][len(mos.sub_mng.ip2sub[ip])-1], "Ip mapping is failed")
 
 		// 2. Check topicNode
-		nameptr := mos.sub_mng.list.head
-		for nameptr != nil{
-			if nameptr.topic[0] == topic[0]{
+		topicPtr := mos.sub_mng.list.head
+		for topicPtr != nil {
+			if Compare(topic, topicPtr.topic) == 0 {
 				break
 			}
-			nameptr = nameptr.next
+			topicPtr = topicPtr.next
 		}
 
-		for i := 0 ; i < len(topic); i++{
-			assert.Equal(t, topic[i], nameptr.topic[i], "topicNode Add is failed")
+		assert.Equal(t, topic, topicPtr.topic, "topicNode Add is failed")
+
+		// Check isSingle ?
+		if len(operator) == 3 && operator[1] == "&&" {
+			isSingle = false
 		}
 
-		// 3. Check Value in ValueNode
-		valptr := nameptr.list.head
-		for valptr != nil{
-			for i:=0 ; i < len(value); i++{
-				find := true
-				if value[i] != valptr.val[i]{
-					find = false
-				}
-				if find{
-					break
-				}
-			}
-			valptr = valptr.next
+		// 3. Check Value in ValueNode & Check Operator in ValueNode
+		if !isSingle || (len(operator) == 3 && operator[1] == "||") {
+			valptr1 := topicPtr.list.getValueNodePos([]int64{value[0]})
+			valptr2 := topicPtr.list.getValueNodePos([]int64{value[1]})
+
+			assert.Equal(t, []int64{value[0]}, valptr1.val)
+			assert.Equal(t, []int64{value[1]}, valptr2.val)
+
+			assert.NotEqual(t, -1, checkOperatorList(isSingle, subnumber, operator[0], valptr1))
+			assert.NotEqual(t, -1, checkOperatorList(isSingle, subnumber, operator[2], valptr2))
+
+		} else {
+			valptr := topicPtr.list.getValueNodePos(value)
+			assert.Equal(t, value, valptr.val)
+			assert.NotEqual(t, -1, checkOperatorList(isSingle, subnumber, operator[0], valptr))
 		}
-		fmt.Println("my value = ", valptr.val, " real value = ", value)
+	}
+}
+
+// Test addSubScription(2) (same [topic, value] dif [operator])
+func Test_addSubscription_same_topicNvalue(t *testing.T) {
+	rand.Seed(time.Now().UnixNano())
+
+	// To Init sub_mng
+	s := sub_manager{
+		ip2sub:     make(map[string][]int),
+		sub2node:   make(map[int][]*valueNode),
+		israngesub: make(map[int]bool),
+	}
+
+	mos := Moscato{sub_mng: s}
+
+	// Fix Topic & Value
+	topicLen := rand.Int()%10 + 1
+	staticTopic := make([]int64, topicLen)
+	staticValue := []int64{rand.Int63()}
+
+
+	// Make Data
+	var msgList []MsgUnit
+	dataLen := 100
+	msgList = makeMsgList(dataLen, false)
+
+	for i := 0; i < topicLen; i++ {
+		staticTopic[i] = rand.Int63()
+	}
+
+	// Fix Same Topic & Value
+	for i := 0; i < dataLen; i++ {
+		operator := msgList[i].(*SubscriptionMsg).operator
+		msgList[i].(*SubscriptionMsg).topic = staticTopic
+
+		if len(operator) == 1{
+			msgList[i].(*SubscriptionMsg).value = staticValue
+		}
+	}
+
+	// Watch Data set
+	// watchData(msgList, dataLen)
+
+	for i := 0; i < dataLen; i++ {
+		msg := msgList[i]
+		err := mos.sub_mng.addSubscription(msg)
+		assert.Equal(t, nil, err)
+	}
+
+	topicPtr := mos.sub_mng.list.head
+	for topicPtr != nil {
+		if Compare(topicPtr.topic, staticTopic) == 0 {
+			break
+		}
+		topicPtr = topicPtr.next
+	}
+	watchValueNode(topicPtr.list.head)
+
+}
 
-		for i := 0; i < len(value); i++{
-			assert.Equal(t, value[i], valptr.val[i], "ValNode Add is failed")
+func watchValueNode(ptr *valueNode) {
+	valPtr := ptr
+	for valPtr != nil{
+		fmt.Println("Value = ", valPtr.val)
+		if len(valPtr.single2sub_s) != 0 {
+			fmt.Println("Single2sub (<) List = ", valPtr.single2sub_s)
+		}
+		if len(valPtr.single2sub_es) != 0 {
+			fmt.Println("Single2sub (<=) List = ", valPtr.single2sub_es)
+		}
+		if len(valPtr.single2sub_b) != 0 {
+			fmt.Println("Single2sub (>) List = ", valPtr.single2sub_b)
+		}
+		if len(valPtr.single2sub_eb) != 0 {
+			fmt.Println("Single2sub (>=) List = ", valPtr.single2sub_eb)
+		}
+		if len(valPtr.single2sub_e) != 0 {
+			fmt.Println("Single2sub (==) List = ", valPtr.single2sub_e)
+		}
+
+		if len(valPtr.range2sub_s) != 0 {
+			fmt.Println("range2sub (<) List = ", valPtr.range2sub_s)
+		}
+		if len(valPtr.range2sub_es) != 0 {
+			fmt.Println("range2sub (<=) List = ", valPtr.range2sub_es)
+		}
+		if len(valPtr.range2sub_b) != 0 {
+			fmt.Println("range2sub (>) List = ", valPtr.range2sub_b)
+		}
+		if len(valPtr.range2sub_eb) != 0 {
+			fmt.Println("range2sub (>=) List = ", valPtr.range2sub_eb)
 		}
+		valPtr = valPtr.next
 	}
 }