github.com/hugorut/terraform@v1.1.3/src/lang/funcs/number_test.go (about)

     1  package funcs
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/zclconf/go-cty/cty"
     8  )
     9  
    10  func TestLog(t *testing.T) {
    11  	tests := []struct {
    12  		Num  cty.Value
    13  		Base cty.Value
    14  		Want cty.Value
    15  		Err  bool
    16  	}{
    17  		{
    18  			cty.NumberFloatVal(1),
    19  			cty.NumberFloatVal(10),
    20  			cty.NumberFloatVal(0),
    21  			false,
    22  		},
    23  		{
    24  			cty.NumberFloatVal(10),
    25  			cty.NumberFloatVal(10),
    26  			cty.NumberFloatVal(1),
    27  			false,
    28  		},
    29  
    30  		{
    31  			cty.NumberFloatVal(0),
    32  			cty.NumberFloatVal(10),
    33  			cty.NegativeInfinity,
    34  			false,
    35  		},
    36  		{
    37  			cty.NumberFloatVal(10),
    38  			cty.NumberFloatVal(0),
    39  			cty.NumberFloatVal(-0),
    40  			false,
    41  		},
    42  	}
    43  
    44  	for _, test := range tests {
    45  		t.Run(fmt.Sprintf("log(%#v, %#v)", test.Num, test.Base), func(t *testing.T) {
    46  			got, err := Log(test.Num, test.Base)
    47  
    48  			if test.Err {
    49  				if err == nil {
    50  					t.Fatal("succeeded; want error")
    51  				}
    52  				return
    53  			} else if err != nil {
    54  				t.Fatalf("unexpected error: %s", err)
    55  			}
    56  
    57  			if !got.RawEquals(test.Want) {
    58  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
    59  			}
    60  		})
    61  	}
    62  }
    63  
    64  func TestPow(t *testing.T) {
    65  	tests := []struct {
    66  		Num   cty.Value
    67  		Power cty.Value
    68  		Want  cty.Value
    69  		Err   bool
    70  	}{
    71  		{
    72  			cty.NumberFloatVal(1),
    73  			cty.NumberFloatVal(0),
    74  			cty.NumberFloatVal(1),
    75  			false,
    76  		},
    77  		{
    78  			cty.NumberFloatVal(1),
    79  			cty.NumberFloatVal(1),
    80  			cty.NumberFloatVal(1),
    81  			false,
    82  		},
    83  
    84  		{
    85  			cty.NumberFloatVal(2),
    86  			cty.NumberFloatVal(0),
    87  			cty.NumberFloatVal(1),
    88  			false,
    89  		},
    90  		{
    91  			cty.NumberFloatVal(2),
    92  			cty.NumberFloatVal(1),
    93  			cty.NumberFloatVal(2),
    94  			false,
    95  		},
    96  		{
    97  			cty.NumberFloatVal(3),
    98  			cty.NumberFloatVal(2),
    99  			cty.NumberFloatVal(9),
   100  			false,
   101  		},
   102  		{
   103  			cty.NumberFloatVal(-3),
   104  			cty.NumberFloatVal(2),
   105  			cty.NumberFloatVal(9),
   106  			false,
   107  		},
   108  		{
   109  			cty.NumberFloatVal(2),
   110  			cty.NumberFloatVal(-2),
   111  			cty.NumberFloatVal(0.25),
   112  			false,
   113  		},
   114  		{
   115  			cty.NumberFloatVal(0),
   116  			cty.NumberFloatVal(2),
   117  			cty.NumberFloatVal(0),
   118  			false,
   119  		},
   120  	}
   121  
   122  	for _, test := range tests {
   123  		t.Run(fmt.Sprintf("pow(%#v, %#v)", test.Num, test.Power), func(t *testing.T) {
   124  			got, err := Pow(test.Num, test.Power)
   125  
   126  			if test.Err {
   127  				if err == nil {
   128  					t.Fatal("succeeded; want error")
   129  				}
   130  				return
   131  			} else if err != nil {
   132  				t.Fatalf("unexpected error: %s", err)
   133  			}
   134  
   135  			if !got.RawEquals(test.Want) {
   136  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   137  			}
   138  		})
   139  	}
   140  }
   141  
   142  func TestSignum(t *testing.T) {
   143  	tests := []struct {
   144  		Num  cty.Value
   145  		Want cty.Value
   146  		Err  bool
   147  	}{
   148  		{
   149  			cty.NumberFloatVal(0),
   150  			cty.NumberFloatVal(0),
   151  			false,
   152  		},
   153  		{
   154  			cty.NumberFloatVal(12),
   155  			cty.NumberFloatVal(1),
   156  			false,
   157  		},
   158  		{
   159  			cty.NumberFloatVal(-29),
   160  			cty.NumberFloatVal(-1),
   161  			false,
   162  		},
   163  	}
   164  
   165  	for _, test := range tests {
   166  		t.Run(fmt.Sprintf("signum(%#v)", test.Num), func(t *testing.T) {
   167  			got, err := Signum(test.Num)
   168  
   169  			if test.Err {
   170  				if err == nil {
   171  					t.Fatal("succeeded; want error")
   172  				}
   173  				return
   174  			} else if err != nil {
   175  				t.Fatalf("unexpected error: %s", err)
   176  			}
   177  
   178  			if !got.RawEquals(test.Want) {
   179  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   180  			}
   181  		})
   182  	}
   183  }
   184  
   185  func TestParseInt(t *testing.T) {
   186  	tests := []struct {
   187  		Num  cty.Value
   188  		Base cty.Value
   189  		Want cty.Value
   190  		Err  bool
   191  	}{
   192  		{
   193  			cty.StringVal("128"),
   194  			cty.NumberIntVal(10),
   195  			cty.NumberIntVal(128),
   196  			false,
   197  		},
   198  		{
   199  			cty.StringVal("-128"),
   200  			cty.NumberIntVal(10),
   201  			cty.NumberIntVal(-128),
   202  			false,
   203  		},
   204  		{
   205  			cty.StringVal("00128"),
   206  			cty.NumberIntVal(10),
   207  			cty.NumberIntVal(128),
   208  			false,
   209  		},
   210  		{
   211  			cty.StringVal("-00128"),
   212  			cty.NumberIntVal(10),
   213  			cty.NumberIntVal(-128),
   214  			false,
   215  		},
   216  		{
   217  			cty.StringVal("FF00"),
   218  			cty.NumberIntVal(16),
   219  			cty.NumberIntVal(65280),
   220  			false,
   221  		},
   222  		{
   223  			cty.StringVal("ff00"),
   224  			cty.NumberIntVal(16),
   225  			cty.NumberIntVal(65280),
   226  			false,
   227  		},
   228  		{
   229  			cty.StringVal("-FF00"),
   230  			cty.NumberIntVal(16),
   231  			cty.NumberIntVal(-65280),
   232  			false,
   233  		},
   234  		{
   235  			cty.StringVal("00FF00"),
   236  			cty.NumberIntVal(16),
   237  			cty.NumberIntVal(65280),
   238  			false,
   239  		},
   240  		{
   241  			cty.StringVal("-00FF00"),
   242  			cty.NumberIntVal(16),
   243  			cty.NumberIntVal(-65280),
   244  			false,
   245  		},
   246  		{
   247  			cty.StringVal("1011111011101111"),
   248  			cty.NumberIntVal(2),
   249  			cty.NumberIntVal(48879),
   250  			false,
   251  		},
   252  		{
   253  			cty.StringVal("aA"),
   254  			cty.NumberIntVal(62),
   255  			cty.NumberIntVal(656),
   256  			false,
   257  		},
   258  		{
   259  			cty.StringVal("Aa"),
   260  			cty.NumberIntVal(62),
   261  			cty.NumberIntVal(2242),
   262  			false,
   263  		},
   264  		{
   265  			cty.StringVal("999999999999999999999999999999999999999999999999999999999999"),
   266  			cty.NumberIntVal(10),
   267  			cty.MustParseNumberVal("999999999999999999999999999999999999999999999999999999999999"),
   268  			false,
   269  		},
   270  		{
   271  			cty.StringVal("FF"),
   272  			cty.NumberIntVal(10),
   273  			cty.UnknownVal(cty.Number),
   274  			true,
   275  		},
   276  		{
   277  			cty.StringVal("00FF"),
   278  			cty.NumberIntVal(10),
   279  			cty.UnknownVal(cty.Number),
   280  			true,
   281  		},
   282  		{
   283  			cty.StringVal("-00FF"),
   284  			cty.NumberIntVal(10),
   285  			cty.UnknownVal(cty.Number),
   286  			true,
   287  		},
   288  		{
   289  			cty.NumberIntVal(2),
   290  			cty.NumberIntVal(10),
   291  			cty.UnknownVal(cty.Number),
   292  			true,
   293  		},
   294  		{
   295  			cty.StringVal("1"),
   296  			cty.NumberIntVal(63),
   297  			cty.UnknownVal(cty.Number),
   298  			true,
   299  		},
   300  		{
   301  			cty.StringVal("1"),
   302  			cty.NumberIntVal(-1),
   303  			cty.UnknownVal(cty.Number),
   304  			true,
   305  		},
   306  		{
   307  			cty.StringVal("1"),
   308  			cty.NumberIntVal(1),
   309  			cty.UnknownVal(cty.Number),
   310  			true,
   311  		},
   312  		{
   313  			cty.StringVal("1"),
   314  			cty.NumberIntVal(0),
   315  			cty.UnknownVal(cty.Number),
   316  			true,
   317  		},
   318  		{
   319  			cty.StringVal("1.2"),
   320  			cty.NumberIntVal(10),
   321  			cty.UnknownVal(cty.Number),
   322  			true,
   323  		},
   324  	}
   325  
   326  	for _, test := range tests {
   327  		t.Run(fmt.Sprintf("parseint(%#v, %#v)", test.Num, test.Base), func(t *testing.T) {
   328  			got, err := ParseInt(test.Num, test.Base)
   329  
   330  			if test.Err {
   331  				if err == nil {
   332  					t.Fatal("succeeded; want error")
   333  				}
   334  				return
   335  			} else if err != nil {
   336  				t.Fatalf("unexpected error: %s", err)
   337  			}
   338  
   339  			if !got.RawEquals(test.Want) {
   340  				t.Errorf("wrong result\ngot:  %#v\nwant: %#v", got, test.Want)
   341  			}
   342  		})
   343  	}
   344  }