github.com/igggame/nebulas-go@v2.1.0+incompatible/common/dag/dag_test.go (about)

     1  // Copyright (C) 2017 go-nebulas authors
     2  //
     3  // This file is part of the go-nebulas library.
     4  //
     5  // the go-nebulas library is free software: you can redistribute it and/or modify
     6  // it under the terms of the GNU General Public License as published by
     7  // the Free Software Foundation, either version 3 of the License, or
     8  // (at your option) any later version.
     9  //
    10  // the go-nebulas library is distributed in the hope that it will be useful,
    11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13  // GNU General Public License for more details.
    14  //
    15  // You should have received a copy of the GNU General Public License
    16  // along with the go-nebulas library.  If not, see <http://www.gnu.org/licenses/>.
    17  //
    18  
    19  package dag
    20  
    21  import (
    22  	"testing"
    23  
    24  	"github.com/gogo/protobuf/proto"
    25  	"github.com/nebulasio/go-nebulas/common/dag/pb"
    26  	"github.com/stretchr/testify/assert"
    27  )
    28  
    29  func TestDagProto(t *testing.T) {
    30  	d := NewDag()
    31  	var pd *dagpb.Dag
    32  	assert.Equal(t, d.FromProto(pd), ErrInvalidProtoToDag)
    33  }
    34  
    35  func TestDag_AddNode(t *testing.T) {
    36  	dag := NewDag()
    37  
    38  	dag.AddNode("1")
    39  	dag.AddNode("2")
    40  	dag.AddNode("3")
    41  	dag.AddNode("4")
    42  
    43  	// Add the edges (Note that given Nodes must exist before adding an
    44  	// edge between them)
    45  	dag.AddEdge("1", "2")
    46  	dag.AddEdge("1", "3")
    47  	dag.AddEdge("2", "4")
    48  	dag.AddEdge("3", "4")
    49  
    50  	node := dag.GetNode("1")
    51  
    52  	assert.Equal(t, "1", node.key)
    53  	assert.Equal(t, 0, node.index)
    54  
    55  	assert.Equal(t, 0, node.parentCounter)
    56  
    57  	node4 := dag.GetNode("4")
    58  	assert.Equal(t, 2, node4.parentCounter)
    59  
    60  	dag.AddNode("5")
    61  	msg, err := dag.ToProto()
    62  
    63  	assert.Nil(t, err)
    64  
    65  	node1 := dag.GetNode("5")
    66  
    67  	assert.Equal(t, "5", node1.key)
    68  
    69  	msg, err1 := dag.ToProto()
    70  	assert.Nil(t, err1)
    71  
    72  	dag1 := NewDag()
    73  	err = dag1.FromProto(msg)
    74  	assert.Nil(t, err)
    75  	node1 = dag1.GetNode(int(0))
    76  
    77  	//fmt.Println(err, node1)
    78  	assert.Equal(t, 0, node1.key)
    79  
    80  	children := dag1.GetChildrenNodes(int(0))
    81  
    82  	assert.Equal(t, 2, len(children))
    83  }
    84  
    85  func TestDag_ToFromProto(t *testing.T) {
    86  	dag1 := NewDag()
    87  
    88  	dag1.AddNode("key1")
    89  	dag1.AddNode("key2")
    90  	dag1.AddNode("key3")
    91  	dag1.AddNode("key4")
    92  	dag1.AddNode("key5")
    93  
    94  	dag1.AddEdge("key1", "key2")
    95  	dag1.AddEdge("key1", "key3")
    96  	dag1.AddEdge("key2", "key4")
    97  	dag1.AddEdge("key3", "key4")
    98  
    99  	msg1, err := dag1.ToProto()
   100  	assert.Nil(t, err)
   101  
   102  	j1, err := proto.Marshal(msg1)
   103  	assert.Nil(t, err)
   104  
   105  	dag2 := NewDag()
   106  	err = dag2.FromProto(msg1)
   107  	assert.Nil(t, err)
   108  
   109  	msg2, err := dag2.ToProto()
   110  	assert.Nil(t, err)
   111  	j2, err := proto.Marshal(msg2)
   112  	assert.Nil(t, err)
   113  
   114  	assert.Equal(t, j1, j2)
   115  
   116  }
   117  func TestDag_IsCirclular(t *testing.T) {
   118  	dag := NewDag()
   119  
   120  	dag.AddNode("1")
   121  	dag.AddNode("2")
   122  	dag.AddNode("3")
   123  	dag.AddNode("4")
   124  	dag.AddNode("5")
   125  
   126  	// Add the edges (Note that given Nodes must exist before adding an
   127  	// edge between them)
   128  	dag.AddEdge("1", "2")
   129  	dag.AddEdge("1", "3")
   130  	dag.AddEdge("2", "4")
   131  	dag.AddEdge("3", "4")
   132  
   133  	assert.Equal(t, false, dag.IsCirclular())
   134  	_, err := dag.ToProto()
   135  	assert.Nil(t, err)
   136  
   137  	dag.AddEdge("4", "1")
   138  
   139  	assert.Equal(t, true, dag.IsCirclular())
   140  
   141  	msg, err := dag.ToProto()
   142  	assert.Nil(t, err)
   143  
   144  	dag1 := NewDag()
   145  	err = dag1.FromProto(msg)
   146  	assert.Nil(t, err)
   147  
   148  	dag.AddEdge("4", "5")
   149  	dag.AddEdge("5", "1")
   150  	assert.Equal(t, true, dag.IsCirclular())
   151  
   152  }
   153  
   154  func TestDag_IsCirclular1(t *testing.T) {
   155  
   156  	dag := NewDag()
   157  
   158  	dag.AddNode("1")
   159  	dag.AddNode("2")
   160  	dag.AddNode("3")
   161  	dag.AddNode("4")
   162  	dag.AddNode("5")
   163  	dag.AddNode("6")
   164  	dag.AddNode("7")
   165  	dag.AddNode("8")
   166  	dag.AddNode("9")
   167  	dag.AddNode("10")
   168  	dag.AddNode("11")
   169  	dag.AddNode("12")
   170  	dag.AddNode("13")
   171  	dag.AddNode("14")
   172  	dag.AddNode("15")
   173  	dag.AddNode("16")
   174  	dag.AddNode("17")
   175  	dag.AddNode("18")
   176  	dag.AddNode("19")
   177  	// Add the edges (Note that given vertices must exist before adding an
   178  	// edge between them)
   179  	dag.AddEdge("1", "2")
   180  	dag.AddEdge("1", "3")
   181  	dag.AddEdge("2", "4")
   182  	dag.AddEdge("3", "5")
   183  	dag.AddEdge("3", "6")
   184  	dag.AddEdge("4", "7")
   185  	dag.AddEdge("5", "8")
   186  	dag.AddEdge("5", "9")
   187  	dag.AddEdge("6", "10")
   188  	dag.AddEdge("6", "11")
   189  	dag.AddEdge("9", "12")
   190  	dag.AddEdge("10", "12")
   191  	dag.AddEdge("12", "13")
   192  	dag.AddEdge("13", "15")
   193  	dag.AddEdge("12", "14")
   194  
   195  	dag.AddEdge("16", "17")
   196  	dag.AddEdge("16", "18")
   197  	dag.AddEdge("18", "19")
   198  
   199  	assert.Equal(t, false, dag.IsCirclular())
   200  
   201  	dag.AddEdge("15", "8")
   202  	assert.Equal(t, false, dag.IsCirclular())
   203  
   204  	dag.AddEdge("19", "16")
   205  	assert.Equal(t, true, dag.IsCirclular())
   206  }