change secure test

src/broker/modules/list.go

@@ -1,8 +1,6 @@
 package modules
 
-/*
-	Sub정보들을 관리할 list
-*/
+/* List to manage Sub information */
 
 type topicList struct {
 	head *topicNode
@@ -11,7 +9,7 @@ type topicList struct {
 }
 
 type topicNode struct {
-	topic []int64 // Encrypt된 topic
+	topic []int64 // Encrypted topic
 	next  *topicNode
 	prev  *topicNode
 	list  valueList
@@ -24,29 +22,30 @@ type valueList struct {
 }
 
 type valueNode struct {
-	val  []int64 // Encrypt된 value
+	val  []int64 // Encrypted topic
 	next *valueNode
 	prev *valueNode
 
 	// single //
-	single2sub_s  []int // (val < x) sub#
-	single2sub_es []int // (val <= x) sub#
-	single2sub_b  []int // (val > x) sub#
-	single2sub_eb []int // (val >= x) sub#
-	single2sub_e  []int // (val == x) sub#
+	single2sub_s  []int // (sub_val < pub_val) sub#s
+	single2sub_es []int // (sub_val <= pub_val) sub#s
+	single2sub_b  []int // (sub_val > pub_val) sub#s
+	single2sub_eb []int // (sub_val >= pub_val) sub#s
+	single2sub_e  []int // (sub_val == pub_val) sub#s
 
 	// range //
-	range2sub_s  []int // (val < x and ...) sub#
-	range2sub_es []int // (val <= x and ...) sub#
-	range2sub_b  []int // (val > x and ...) sub#
-	range2sub_eb []int // (val >= x and ...) sub#
+	range2sub_s  []int // (sub_val < pub_val) sub#s
+	range2sub_es []int // (sub_val <= pub_val) sub#s
+	range2sub_b  []int // (sub_val > pub_val) sub#s
+	range2sub_eb []int // (sub_val >= pub_val) sub#s
 }
 
-// ### To delete slice Array
+// To delete slice Array
 func remove(ary []int, i int) []int {
 	return append(ary[:i], ary[i+1:]...)
 }
 
+// To find a specific sub# in a value node
 func findSub(ary []int, sub int) int {
 	for i := 0; i < len(ary); i++ {
 		if ary[i] == sub {
@@ -56,6 +55,7 @@ func findSub(ary []int, sub int) int {
 	return -1
 }
 
+// To add a topic node to the topic list
 func (l *topicList) addTopicNode(topic []int64){
 	newNode := &topicNode{topic, nil, nil, valueList{}}
 	if l.head == nil{
@@ -69,6 +69,7 @@ func (l *topicList) addTopicNode(topic []int64){
 	l.size++
 }
 
+// To check if a specific value node is empty
 func (n *valueNode) isEmpty() bool {
 	empty := true
 	if len(n.single2sub_s) != 0 {
@@ -101,35 +102,36 @@ func (n *valueNode) isEmpty() bool {
 	return empty
 }
 
-// 노드의 operator리스트에 sub#을 in
-func (l *valueNode) insertSub(op string, sub int, issingle bool) {
+// To insert sub# into the operator list of the value node
+func (n *valueNode) insertSub(op string, sub int, issingle bool) {
 	if issingle == true {
 		switch op {
 		case "<":
-			l.single2sub_s = append(l.single2sub_s, sub)
+			n.single2sub_s = append(n.single2sub_s, sub)
 		case "<=":
-			l.single2sub_es = append(l.single2sub_es, sub)
+			n.single2sub_es = append(n.single2sub_es, sub)
 		case ">":
-			l.single2sub_b = append(l.single2sub_b, sub)
+			n.single2sub_b = append(n.single2sub_b, sub)
 		case ">=":
-			l.single2sub_eb = append(l.single2sub_eb, sub)
+			n.single2sub_eb = append(n.single2sub_eb, sub)
 		case "==":
-			l.single2sub_e = append(l.single2sub_e, sub)
+			n.single2sub_e = append(n.single2sub_e, sub)
 		}
 	} else {
 		switch op {
 		case "<":
-			l.range2sub_s = append(l.range2sub_s, sub)
+			n.range2sub_s = append(n.range2sub_s, sub)
 		case "<=":
-			l.range2sub_es = append(l.range2sub_es, sub)
+			n.range2sub_es = append(n.range2sub_es, sub)
 		case ">":
-			l.range2sub_b = append(l.range2sub_b, sub)
+			n.range2sub_b = append(n.range2sub_b, sub)
 		case ">=":
-			l.range2sub_eb = append(l.range2sub_eb, sub)
+			n.range2sub_eb = append(n.range2sub_eb, sub)
 		}
 	}
 }
 
+// To add a value node to the value list
 func (l *valueList) addValueNode(value []int64) {
 	newValNode := &valueNode{value, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil}
 	if l.head == nil{
@@ -143,6 +145,7 @@ func (l *valueList) addValueNode(value []int64) {
 	l.size++
 }
 
+// To get the position of a topic node with a specific topic
 func (l *topicList) getTopicNodePos(topic []int64) *topicNode {
 	topicPtr := l.head
 	for topicPtr != nil {
@@ -150,8 +153,7 @@ func (l *topicList) getTopicNodePos(topic []int64) *topicNode {
 			topicPtr = topicPtr.next
 			continue
 		}
-		// * compare 완성된다면 다시보기
-		if l.CompareTopic(topicPtr.topic, topic) == 0 {
+		if Compare(topicPtr.topic, topic) == 0 {
 			return topicPtr
 		}
 		topicPtr = topicPtr.next
@@ -159,59 +161,36 @@ func (l *topicList) getTopicNodePos(topic []int64) *topicNode {
 	return nil
 }
 
-func (l *topicList)CompareTopic(topic1 []int64, topic2 []int64) int {
-	// 길이 같은지 체크
-	if len(topic1) != len(topic2) {
-		return -1
-	}
-	for i := 0; i < len(topic2); i++ {
-		if topic1[i] != topic2[i] {
-			return -1
-		}
-	}
-	return 0
-}
-
-func (l *valueList) getValueNodePos(value []int64, isAlpha bool) *valueNode {
+// To get the position of a value node with a specific value
+func (l *valueList) getValueNodePos(value []int64) *valueNode {
 	valPtr := l.head
 	for valPtr != nil {
 		if len(valPtr.val) == 0{
 			valPtr = valPtr.next
 			continue
 		}
-		if isAlpha{
-			if CompareAlpha(value, valPtr.val) == 0{
-				return valPtr
-			}
-		} else{
-			if CompareDigit(value[0], valPtr.val[0]) == 0{
-				return valPtr
-			}
+		if Compare(value, valPtr.val) == 0 {
+			return valPtr
 		}
 		valPtr = valPtr.next
 	}
 	return nil
 }
 
-
-func CompareDigit(value1 int64, value2 int64) int {
-	if value1 < value2 {
+// Compare ->  To compare (topics, values) in a node
+func Compare(a []int64, b []int64) int {
+	if len(a) < len(b) {
 		return 1
-	} else if value1 > value2 {
+	} else if len(a) > len(b){
 		return -1
-	}
-	return 0
-}
-
-func CompareAlpha(value1 []int64, value2 []int64) int {
-	// 길이 같은지 체크
-	if len(value1) != len(value2) {
-		return -1
-	}
-	for i := 0; i < len(value2); i++ {
-		if value1[i] != value2[i] {
-			return -1
+	} else{
+		for i := 0; i < len(a); i++{
+			if a[i] < b[i] {
+				return 1
+			} else if a[i] > b[i]{
+				return -1
+			}
 		}
+		return 0
 	}
-	return 0
-}
+}

src/broker/modules/matching.go

@@ -1,21 +1,153 @@
 package modules
-//
-//import (
-//	_ "errors"
-//	_ "fmt"
-//)
-//
-//type match_manager struct {
-//}
-//
-//func (match_mng *match_manager) matching(queue *MsgQueue) error {
-//	msg := queue.pop(true)
-//
-//	//Implement here ~~
-//	subscription := msg.(*PublishMsg).subscription
-//	content := msg.(*PublishMsg).content
-//
-//	println(subscription, content)
-//
-//	return nil
-//}
+
+import (
+	"errors"
+	_ "errors"
+	"github.com/juliangruber/go-intersect"
+)
+
+type match_manager struct {
+	match_count	int
+}
+
+// Returns a list of IP addresses of matched subs
+func (match_mng *match_manager) Matching(queue *MsgQueue, sub_mng *sub_manager) ([]string, MsgUnit, error) {
+	msg := queue.pop(true)
+	topic := msg.(*PublishMsg).topic
+	value := msg.(*PublishMsg).value
+
+	// list
+	ret := make([]string, 0)
+
+	// list for matched range subscriptions
+	big := make([]int, 0)
+	small := make([]int, 0)
+
+	// 1. Find (topicNode[topic] == msg.topic) Node
+	topicPtr := sub_mng.list
+	pos := topicPtr.getTopicNodePos(topic)
+
+	// Don't Exist topicNode
+	if pos == nil{
+		return nil,nil,errors.New("Don't Exist topicNode")
+	}
+
+	// 2. Traverse all valueNode -> and Match
+	valPtr := pos.list.head
+	for valPtr != nil{
+		compare := Compare(valPtr.val, value)
+		if compare < 0 { // sub.val > pub.val
+		// single : { >, >= }
+
+			// (1) case : >
+			for i := 0; i < len(valPtr.single2sub_b); i++{
+				sub := valPtr.single2sub_b[i]
+				ip := sub_mng.sub2ip[sub]
+				ret = append(ret, ip)
+			}
+
+			// (2) case : >=
+			for i := 0; i < len(valPtr.single2sub_eb); i++{
+				sub := valPtr.single2sub_eb[i]
+				ip := sub_mng.sub2ip[sub]
+				ret = append(ret, ip)
+			}
+		// range : { >, >= }
+
+			// (1) case : >
+			for i := 0; i < len(valPtr.range2sub_b); i++{
+				sub := valPtr.range2sub_b[i]
+				big = append(big, sub)
+			}
+
+			// (2) case : >=
+			for i := 0; i < len(valPtr.range2sub_eb); i++{
+				sub := valPtr.range2sub_eb[i]
+				big = append(big, sub)
+			}
+
+		} else if compare > 0 { // sub.val < pub.val
+
+		// single : { <, <= }
+
+			// (1) case : <
+			for i := 0; i < len(valPtr.single2sub_s); i++{
+				sub := valPtr.single2sub_s[i]
+				ip := sub_mng.sub2ip[sub]
+				ret = append(ret, ip)
+			}
+
+			// (2) case : <=
+			for i := 0; i < len(valPtr.single2sub_es); i++{
+				sub := valPtr.single2sub_es[i]
+				ip := sub_mng.sub2ip[sub]
+				ret = append(ret, ip)
+			}
+
+		// range : { <, <= }
+
+			// (1) case : <
+			for i := 0; i < len(valPtr.range2sub_s); i++{
+				sub := valPtr.range2sub_s[i]
+				small = append(small, sub)
+			}
+			// (2) case : <=
+			for i := 0; i < len(valPtr.range2sub_es); i++{
+				sub := valPtr.range2sub_es[i]
+				small = append(small, sub)
+			}
+
+		} else{ // sub.val == pub.val
+
+		// single : { <=, >=, ==}
+
+			// (1) case : <=
+			for i := 0; i < len(valPtr.single2sub_es); i++{
+				sub := valPtr.single2sub_es[i]
+				ip := sub_mng.sub2ip[sub]
+				ret = append(ret, ip)
+			}
+
+			// (2) case : >=
+			for i := 0; i < len(valPtr.single2sub_eb); i++{
+				sub := valPtr.single2sub_eb[i]
+				ip := sub_mng.sub2ip[sub]
+				ret = append(ret, ip)
+			}
+
+			// (3) case : ==
+			for i := 0; i < len(valPtr.single2sub_e); i++{
+				sub := valPtr.single2sub_e[i]
+				ip := sub_mng.sub2ip[sub]
+				ret = append(ret, ip)
+			}
+
+		// range : { <=, >= }
+
+			// (1) case : <=
+			for i := 0; i < len(valPtr.range2sub_es); i++{
+				sub := valPtr.range2sub_es[i]
+				small = append(small, sub)
+			}
+
+			// (2) case : >=
+			for i := 0; i < len(valPtr.range2sub_eb); i++{
+				sub := valPtr.range2sub_eb[i]
+				big = append(big, sub)
+			}
+
+		}
+	}
+
+	// Add the intersection IP address of two sets (large and small) to the return list
+	hash := intersect.Hash(small, big)
+	for i := 0; i < len(hash); i++{
+		sub := hash[i].(int)
+		ip := sub_mng.sub2ip[sub]
+		ret = append(ret, ip)
+	}
+
+	match_mng.match_count++
+
+	return ret, msg, nil
+}

src/broker/modules/subscription.go

@@ -2,34 +2,32 @@ package modules
 
 import (
 	"errors"
-	"fmt"
 )
 
 type sub_manager struct {
-	// NameList의 노드들이 각각의 list를 갖음
 	list topicList
 
-	/* sub# 관리 */
+	/* Manage sub# */
 	count_sub 	 int               // Subscription #
 	emptylist  []int                // To administrate sub #
-	ip2sub     map[string][]int     // ip2sub[ip]= sub#...
-	sub2node   map[int][]*valueNode // sub2node[sub#] = node_addr
-	israngesub map[int]bool         // delete시에 관리를 위해
+	ip2sub     map[string][]int     // ip2sub[ip] = sub# ...
+	sub2ip	   map[int]string		// sub2ip[sub#] = ip
+	sub2node   map[int][]*valueNode // sub2node[sub#] = node_addr ...
+	israngesub map[int]bool         // To manage when deleted
 }
 
-// 초기화 시에 하고 싶은 처리
-func (self *sub_manager) Initialize() {
+func (manager *sub_manager) Initialize() {
 	// Some initialize
-	self.ip2sub = make(map[string][]int)
-	self.sub2node = make(map[int][]*valueNode)
-	self.israngesub = make(map[int]bool)
+	manager.ip2sub = make(map[string][]int)
+	manager.sub2ip = make(map[int]string)
+	manager.sub2node = make(map[int][]*valueNode)
+	manager.israngesub = make(map[int]bool)
 }
 
-// 생성자 함수를 정의
 func newSubmng() *sub_manager {
-	sub_mng := &sub_manager{}
-	sub_mng.Initialize()
-	return sub_mng
+	subMng := &sub_manager{}
+	subMng.Initialize()
+	return subMng
 }
 
 //	### To Insert sub#
@@ -38,12 +36,10 @@ func (manager *sub_manager) addSubscription(msg MsgUnit) error {
 	topic := msg.(*SubscriptionMsg).topic
 	value := msg.(*SubscriptionMsg).value
 	operator := msg.(*SubscriptionMsg).operator
-	isAlpha := msg.(*SubscriptionMsg).isAlpha
 	subnumber := 0
 
-	//fmt.Println("message = ", msg)
+	// * 1. Mapping incoming IP address to sub #
 
-	// * 1. 들어온 ipaddr -> sub# 매핑
 	if len(manager.emptylist) == 0 {
 		manager.ip2sub[msg.(*SubscriptionMsg).from] = append(manager.ip2sub[msg.(*SubscriptionMsg).from], manager.count_sub)
 		subnumber = manager.count_sub
@@ -55,14 +51,14 @@ func (manager *sub_manager) addSubscription(msg MsgUnit) error {
 		subnumber = subidx
 	}
 
-	// * 2. Sub 추가
 	nameptr := manager.list.head
 	findOk := false
 
-	//namelist에서 name찾고, 없으면 추가
+	// * 2. Add Subscription
+
+	// Find name in namelist, add if not found
 	for nameptr != nil {
-		// *  compare함수 구현되기 전 임시로 끼워넣은 것 (이 부분은 secure.go 완성되면 다시 확인)
-		if nameptr.topic[0] == topic[0] {
+		if Compare(nameptr.topic, topic) == 0 {
 			findOk = true
 			break
 		}
@@ -74,10 +70,9 @@ func (manager *sub_manager) addSubscription(msg MsgUnit) error {
 		nameptr = manager.list.tail
 	}
 
-	// list[name]에 value추가
-	if len(operator) == 1 { // 단일 식이라면 (single)
-		valptr := nameptr.list.getValueNodePos(value, isAlpha)
-		fmt.Println("pos = " ,valptr.val)
+	// Add value to list[name]
+	if len(operator) == 1 { // if single expression
+		valptr := nameptr.list.getValueNodePos(value)
 		if valptr == nil {
 			nameptr.list.addValueNode(value)
 			valptr = nameptr.list.tail
@@ -86,46 +81,47 @@ func (manager *sub_manager) addSubscription(msg MsgUnit) error {
 		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr)
 		valptr.insertSub(operator[0], subnumber, true)
 
-		return nil // addSubscription ok
+		return nil // AddSubscription ok
 	} else {
 
-		// '&&' , '||'로 묶여 있는 복합식에 대하여
+		// For compound expressions bounded by '&&' and '||'
+		// (ex) { (234 < x) && (x <= 1293) } , { (234 < x) || ( x < 1293) }
 		logical_operator := operator[1]
 
-		// find(namelist[name].list.val == value)인 노드
-		// * 이 부분 다시 봐야함..
-		valptr1 := nameptr.list.getValueNodePos(value, isAlpha)
-		valptr2 := nameptr.list.getValueNodePos(value, isAlpha)
+		// Find ValueNode = (namelist[name].list.val == value)
+		valptr1 := nameptr.list.getValueNodePos([]int64{value[0]})
+		valptr2 := nameptr.list.getValueNodePos([]int64{value[1]})
 
 		if valptr1 == nil {
-			nameptr.list.addValueNode(value)
+			nameptr.list.addValueNode([]int64{value[0]})
 			valptr1 = nameptr.list.tail
 		}
 		if valptr2 == nil {
-			nameptr.list.addValueNode(value)
+			nameptr.list.addValueNode([]int64{value[1]})
 			valptr2 = nameptr.list.tail
 		}
 
 		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr1)
 		manager.sub2node[subnumber] = append(manager.sub2node[subnumber], valptr2)
 
-		if logical_operator == "&&" { // '&&'로 묶여있다면
-			// rangesub check
+		if logical_operator == "&&" {
+			// If they are enclosed in '&&' -> Insert value to range_operator_list
 			manager.israngesub[subnumber] = true
 			valptr1.insertSub(operator[0], subnumber, false)
 			valptr2.insertSub(operator[2], subnumber, false)
 
 		} else {
-			// '||'로 묶여 있다면 두 식 모두 single로 처리가능
+			// if they are enclosed in '||' -> Insert value to single_operator_list
 			valptr1.insertSub(operator[0], subnumber, true)
 			valptr2.insertSub(operator[2], subnumber, true)
 		}
+
 		return nil // addSubscription ok
 	}
 	return errors.New("Can't addSubscription")
 }
 
-//	* To delete subscription
+// To delete subscription
 func (manager *sub_manager) delete(from string) error {
 
 	ip := from
@@ -162,8 +158,9 @@ func (manager *sub_manager) delete(from string) error {
 					manager.emptylist = append(manager.emptylist, sub)
 				}
 
-				// node가 비어있으면 delete
 				isempty := node[j].isEmpty()
+
+				// Delete if Value Node is empty
 				if isempty && node[j] != nil {
 					prev_node := node[j].prev
 					next_node := node[j].next
@@ -205,17 +202,18 @@ func (manager *sub_manager) delete(from string) error {
 				}
 
 				isempty := node[j].isEmpty()
-				// node가 비어있으면 delete
+
+				// Delete if Value Node is empty
 				if isempty && node[j] != nil {
-					prev_node := node[j].prev
-					next_node := node[j].next
+					prevNode := node[j].prev
+					nextNode := node[j].next
 
-					prev_node.next = node[j].next
-					next_node.prev = node[j].prev
+					prevNode.next = node[j].next
+					nextNode.prev = node[j].prev
 				}
 			}
 		}
 	}
-	manager.ip2sub[ip]=nil
+	manager.ip2sub[ip]=nil // Delete sub#s mapped to Ip address
 	return nil
 }

src/broker/modules/subscription_test.go

@@ -1,145 +1,290 @@
 package modules
-//
-//import (
-//	"fmt"
-//	_ "fmt"
-//	"math/rand"
-//	"strconv"
-//	"testing"
-//	"time"
-//	"github.com/stretchr/testify/assert"
-//)
-//
-//func dataMake(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 += "."
-//		}
-//	}
-//
-//	// Set Time
-//	msg.time += strconv.Itoa(rand.Int()%24) + ":"
-//	msg.time += strconv.Itoa(rand.Int()%60)
-//
-//	// Set Topic, Value, operator
-//	topic := []int64{}
-//	value := []int64{}
-//	operator := []string{}
-//	candOp := []string{">", ">=", "<=" ,"<", "=="}
-//	logicalOp := []string{"&&", "||"}
-//
-//	topic = append(topic, rand.Int63())
-//
-//	if isalpha{
-//		value = append(value, rand.Int63())
-//		operator = append(operator, "==")
-//	} else{
-//		len := rand.Int() % 2 + 1
-//		value = append(value, rand.Int63())
-//
-//		if len == 1{
-//			operator = append(operator, candOp[rand.Int()%5])
-//		} else{
-//			value = append(value, rand.Int63())
-//			op := rand.Int()%2
-//			operator = append(operator, candOp[rand.Int()%2])
-//			if op == 0 {
-//				operator = append(operator, logicalOp[0])
-//			} else{
-//				operator = append(operator, logicalOp[1])
-//			}
-//			operator = append(operator, candOp[rand.Int()%2 + 2])
-//		}
-//	}
-//
-//	return &SubscriptionMsg{msg, topic, value, operator, isalpha}
-//}
-//
-//func Test_addSubscription(t *testing.T) {
-//	rand.Seed(time.Now().UnixNano())
-//
-//	// To Init sub_mng
-//	mos := Moscato{sub_mng : sub_manager{}}
-//
-//	// 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))
-//		}
-//	}
-//
-//	// Watch Data set
-//	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)
-//	}
-//
-//	// Test addSubScription
-//	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
-//		subnumber := mos.sub_mng.count_sub
-//
-//		mos.sub_mng.addSubscription(msg)
-//
-//
-//		// 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")
-//
-//		// 2. Check topicNode
-//		nameptr := mos.sub_mng.list.head
-//		for nameptr != nil{
-//			if nameptr.topic[0] == topic[0]{
-//				break
-//			}
-//			nameptr = nameptr.next
-//		}
-//
-//		for i := 0 ; i < len(topic); i++{
-//			assert.Equal(t, topic[i], nameptr.topic[i], "topicNode Add is failed")
-//		}
-//
-//		// 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
-//		}
-//		fmt.Println("my value = ", valptr.val, " real value = ", value)
-//
-//		for i := 0; i < len(value); i++{
-//			assert.Equal(t, value[i], valptr.val[i], "ValNode Add is failed")
-//		}
-//	}
-//}
+
+import (
+	"fmt"
+	_ "fmt"
+	"github.com/stretchr/testify/assert"
+	"math/rand"
+	"strconv"
+	"testing"
+	"time"
+)
+
+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 += "."
+		}
+	}
+
+	// Set Time
+	msg.time += strconv.Itoa(rand.Int()%24) + ":"
+	msg.time += strconv.Itoa(rand.Int()%60)
+
+	// Set Topic, Value, operator
+	topic := []int64{}
+	value := []int64{}
+	operator := []string{}
+	candOp := []string{">", ">=", "<=" ,"<", "=="}
+	logicalOp := []string{"&&", "||"}
+
+	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())
+		}
+
+		operator = append(operator, "==")
+
+	} else{
+		valueLen := rand.Int() % 2 + 1
+
+		topic = append(topic, rand.Int63())
+		value = append(value, rand.Int63())
+
+		if valueLen == 1{
+			operator = append(operator, candOp[rand.Int()%5])
+		} else{
+			value = append(value, rand.Int63())
+			op := rand.Int()%2
+			operator = append(operator, candOp[rand.Int()%2])
+			if op == 0 {
+				operator = append(operator, logicalOp[0])
+			} else{
+				operator = append(operator, logicalOp[1])
+			}
+			operator = append(operator, candOp[rand.Int()%2 + 2])
+		}
+	}
+
+	return &SubscriptionMsg{msg, topic, value, operator, isAlpha}
+}
+
+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
+}
+
+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)
+		}
+
+	} 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
+}
+
+func watchData(msgList []MsgUnit, dataLen int){
+	for i := 0; i < dataLen; i++{
+		msg := msgList[i]
+		fmt.Println(
+			"\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)
+
+	//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
+		subnumber := mos.sub_mng.count_sub
+		isSingle := true
+
+		// 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")
+
+		// 2. Check topicNode
+		topicPtr := mos.sub_mng.list.head
+		for topicPtr != nil {
+			if Compare(topic, topicPtr.topic) == 0 {
+				break
+			}
+			topicPtr = topicPtr.next
+		}
+
+		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 & 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))
+		}
+	}
+}
+
+// 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)
+
+}
+
+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
+	}
+}