gopkg.in/essentialkaos/ek.v5@v5.7.1/sliceutil/sliceutil_test.go (about)

     1  package sliceutil
     2  
     3  // ////////////////////////////////////////////////////////////////////////////////// //
     4  //                                                                                    //
     5  //                     Copyright (c) 2009-2016 Essential Kaos                         //
     6  //      Essential Kaos Open Source License <http://essentialkaos.com/ekol?en>         //
     7  //                                                                                    //
     8  // ////////////////////////////////////////////////////////////////////////////////// //
     9  
    10  import (
    11  	"errors"
    12  	"testing"
    13  
    14  	. "pkg.re/check.v1"
    15  )
    16  
    17  // ////////////////////////////////////////////////////////////////////////////////// //
    18  
    19  func Test(t *testing.T) { TestingT(t) }
    20  
    21  type SliceSuite struct{}
    22  
    23  // ////////////////////////////////////////////////////////////////////////////////// //
    24  
    25  var _ = Suite(&SliceSuite{})
    26  
    27  // ////////////////////////////////////////////////////////////////////////////////// //
    28  
    29  func (s *SliceSuite) TestStr2Interface(c *C) {
    30  	source := []string{"1", "2", "3"}
    31  	result := StringToInterface(source)
    32  
    33  	c.Assert(result, DeepEquals, []interface{}{"1", "2", "3"})
    34  }
    35  
    36  func (s *SliceSuite) TestInt2Interface(c *C) {
    37  	source := []int{1, 2, 3}
    38  	result := IntToInterface(source)
    39  
    40  	c.Assert(result, DeepEquals, []interface{}{1, 2, 3})
    41  }
    42  
    43  func (s *SliceSuite) TestString2Error(c *C) {
    44  	source := []string{"A", "B", "C"}
    45  	result := StringToError(source)
    46  
    47  	c.Assert(result, DeepEquals,
    48  		[]error{
    49  			errors.New("A"),
    50  			errors.New("B"),
    51  			errors.New("C"),
    52  		})
    53  }
    54  
    55  func (s *SliceSuite) TestError2String(c *C) {
    56  	source := []error{
    57  		errors.New("A"),
    58  		errors.New("B"),
    59  		errors.New("C"),
    60  	}
    61  
    62  	result := ErrorToString(source)
    63  
    64  	c.Assert(result, DeepEquals, []string{"A", "B", "C"})
    65  }
    66  
    67  func (s *SliceSuite) TestContains(c *C) {
    68  	source := []string{"1", "2", "3"}
    69  
    70  	c.Assert(Contains(source, "1"), Equals, true)
    71  	c.Assert(Contains(source, "4"), Equals, false)
    72  	c.Assert(Contains([]string{}, "1"), Equals, false)
    73  }
    74  
    75  func (s *SliceSuite) TestExclude(c *C) {
    76  	source := []string{"1", "2", "3", "4", "5", "6"}
    77  
    78  	c.Assert(Exclude(source, []string{"1"}), DeepEquals, []string{"2", "3", "4", "5", "6"})
    79  	c.Assert(Exclude(source, []string{"1", "3", "6"}), DeepEquals, []string{"2", "4", "5"})
    80  	c.Assert(Exclude(source, []string{"1", "2", "3", "4", "5", "6"}), IsNil)
    81  }
    82  
    83  func (s *SliceSuite) TestDeduplicate(c *C) {
    84  	source := []string{"1", "2", "2", "2", "3", "4", "5", "5", "6", "6"}
    85  
    86  	c.Assert(Deduplicate(source), DeepEquals, []string{"1", "2", "3", "4", "5", "6"})
    87  	c.Assert(Deduplicate([]string{"1"}), DeepEquals, []string{"1"})
    88  }