github.com/informationsea/shellflow@v0.1.3/flowscript/flowscript_builtin_test.go (about)

     1  package flowscript
     2  
     3  import (
     4  	"errors"
     5  	"reflect"
     6  	"strings"
     7  	"testing"
     8  )
     9  
    10  type BadValue struct{}
    11  
    12  func (v BadValue) Value() interface{} {
    13  	return nil
    14  }
    15  
    16  func (v BadValue) String() string {
    17  	return "bad value"
    18  }
    19  
    20  func (v BadValue) AsString() (string, error) {
    21  	return "", errors.New("Cannot convert bad value to string")
    22  }
    23  
    24  func (v BadValue) AsInt() (int64, error) {
    25  	return 0, errors.New("Cannot convert bad value to int")
    26  }
    27  
    28  func TestScriptFunctionCallBasename(t *testing.T) {
    29  	if BuiltinFunctions["basename"].name != "basename" {
    30  		t.Fatalf("Invalid function name: %s", BuiltinFunctions["basename"].name)
    31  	}
    32  
    33  	if BuiltinFunctions["basename"].String() != "basename" {
    34  		t.Fatalf("Invalid function name: %s", BuiltinFunctions["basename"].name)
    35  	}
    36  
    37  	arg1 := [...]Value{StringValue{"a/b/c.c"}, StringValue{".c"}, IntValue{1}}
    38  	if v, e := BuiltinFunctions["basename"].call(arg1[:1]); e != nil || v != (StringValue{"c.c"}) {
    39  		t.Fatalf("bad result: %s / error: %s", v, e)
    40  	}
    41  
    42  	if v, e := BuiltinFunctions["basename"].call(arg1[:2]); e != nil || v != (StringValue{"c"}) {
    43  		t.Fatalf("bad result: %s / error: %s", v, e)
    44  	}
    45  
    46  	if v, e := BuiltinFunctions["basename"].call(arg1[:]); e == nil || e.Error() != "Too many arguments for basename" || v != nil {
    47  		t.Fatalf("bad result: %s / error: %s", v, e)
    48  	}
    49  
    50  	if v, e := BuiltinFunctions["basename"].call(arg1[:0]); e == nil || e.Error() != "one or two arguments are required for basename" || v != nil {
    51  		t.Fatalf("bad result: %s / error: %s", v, e)
    52  	}
    53  
    54  	arg2 := [...]Value{StringValue{"a/b/c.c"}, BadValue{}}
    55  	if v, e := BuiltinFunctions["basename"].call(arg2[:]); e == nil || !strings.HasPrefix(e.Error(), "Cannot convert bad value to string") || v != nil {
    56  		t.Fatalf("bad result: %s / error: %s", v, e)
    57  	}
    58  
    59  	arg3 := [...]Value{BadValue{}, StringValue{"a/b/c.c"}}
    60  	if v, e := BuiltinFunctions["basename"].call(arg3[:]); e == nil || !strings.HasPrefix(e.Error(), "Cannot convert bad value to string") || v != nil {
    61  		t.Fatalf("bad result: %s / error: %s", v, e)
    62  	}
    63  }
    64  
    65  func TestScriptFunctionCallDirname(t *testing.T) {
    66  	if BuiltinFunctions["dirname"].name != "dirname" {
    67  		t.Fatalf("Invalid function name: %s", BuiltinFunctions["dirname"].name)
    68  	}
    69  
    70  	if BuiltinFunctions["dirname"].String() != "dirname" {
    71  		t.Fatalf("Invalid function name: %s", BuiltinFunctions["dirname"].name)
    72  	}
    73  
    74  	arg1 := [...]Value{StringValue{"a/b/c.c"}, StringValue{".c"}, IntValue{1}}
    75  	if v, e := BuiltinFunctions["dirname"].call(arg1[:1]); e != nil || v != (StringValue{"a/b"}) {
    76  		t.Fatalf("bad result: %s / error: %s", v, e)
    77  	}
    78  
    79  	if v, e := BuiltinFunctions["dirname"].call(arg1[:2]); e == nil || e.Error() != "Too many arguments for dirname" || v != nil {
    80  		t.Fatalf("bad result: %s / error: %s", v, e)
    81  	}
    82  
    83  	if v, e := BuiltinFunctions["dirname"].call(arg1[:0]); e == nil || e.Error() != "one argument are required for dirname" || v != nil {
    84  		t.Fatalf("bad result: %s / error: %s", v, e)
    85  	}
    86  
    87  	arg3 := [...]Value{BadValue{}}
    88  	if v, e := BuiltinFunctions["dirname"].call(arg3[:]); e == nil || !strings.HasPrefix(e.Error(), "Cannot convert bad value to string") || v != nil {
    89  		t.Fatalf("bad result: %s / error: %s", v, e)
    90  	}
    91  }
    92  
    93  func TestScriptFunctionCallPrefix(t *testing.T) {
    94  	if BuiltinFunctions["prefix"].name != "prefix" {
    95  		t.Fatalf("Invalid function name: %s", BuiltinFunctions["prefix"].name)
    96  	}
    97  
    98  	if BuiltinFunctions["prefix"].String() != "prefix" {
    99  		t.Fatalf("Invalid function name: %s", BuiltinFunctions["prefix"].name)
   100  	}
   101  
   102  	array := [...]Value{StringValue{"a"}, StringValue{"b"}, StringValue{"c"}}
   103  	arg1 := [...]Value{StringValue{"x"}, ArrayValue{array[:]}, IntValue{1}}
   104  	expected := [...]Value{StringValue{"xa"}, StringValue{"xb"}, StringValue{"xc"}}
   105  
   106  	if v, e := BuiltinFunctions["prefix"].call(arg1[:2]); e != nil || reflect.DeepEqual(v, expected) {
   107  		t.Fatalf("bad result: %s / error: %s", v, e)
   108  	}
   109  
   110  	if v, e := BuiltinFunctions["prefix"].call(arg1[:3]); e == nil || e.Error() != "two arguments are required for prefix" || v != nil {
   111  		t.Fatalf("bad result: %s / error: %s", v, e)
   112  	}
   113  
   114  	if v, e := BuiltinFunctions["prefix"].call(arg1[:1]); e == nil || e.Error() != "two arguments are required for prefix" || v != nil {
   115  		t.Fatalf("bad result: %s / error: %s", v, e)
   116  	}
   117  
   118  	if v, e := BuiltinFunctions["prefix"].call(arg1[:0]); e == nil || e.Error() != "two arguments are required for prefix" || v != nil {
   119  		t.Fatalf("bad result: %s / error: %s", v, e)
   120  	}
   121  
   122  	arg3 := [...]Value{IntValue{1}, IntValue{2}}
   123  	if v, e := BuiltinFunctions["prefix"].call(arg3[:]); e == nil || e.Error() != "2 is not array" || v != nil {
   124  		t.Fatalf("bad result: %s / error: %s", v, e)
   125  	}
   126  
   127  	badArray := [...]Value{BadValue{}, BadValue{}, BadValue{}}
   128  	badArg := [...]Value{StringValue{"hoge"}, ArrayValue{badArray[:]}}
   129  	if v, e := BuiltinFunctions["prefix"].call(badArg[:]); e == nil || !strings.HasPrefix(e.Error(), "Cannot convert bad value to string") || v != nil {
   130  		t.Fatalf("bad result: %s / error: %s", v, e)
   131  	}
   132  
   133  	badArgs2 := [...]Value{BadValue{}, ArrayValue{array[:]}}
   134  	if v, e := BuiltinFunctions["prefix"].call(badArgs2[:]); e == nil || !strings.HasPrefix(e.Error(), "Cannot convert bad value to string") || v != nil {
   135  		t.Fatalf("bad result: %s / error: %s", v, e)
   136  	}
   137  }
   138  
   139  func TestScriptFunctionCallZip(t *testing.T) {
   140  	{
   141  		array1 := [...]Value{IntValue{1}, IntValue{2}, IntValue{3}, IntValue{4}}
   142  		array2 := [...]Value{IntValue{5}, IntValue{6}, IntValue{7}}
   143  		args := [...]Value{ArrayValue{array1[:]}, ArrayValue{array2[:]}}
   144  		expectedArray := [...]Value{CreateArrayValue2(IntValue{1}, IntValue{5}), CreateArrayValue2(IntValue{2}, IntValue{6}), CreateArrayValue2(IntValue{3}, IntValue{7})}
   145  
   146  		result, err := BuiltinFunctions["zip"].call(args[:])
   147  		if err != nil {
   148  			t.Fatalf("bad result: %s / error: %s", result, err)
   149  		}
   150  		resultArray, ok := result.(ArrayValue)
   151  		if !ok {
   152  			t.Fatalf("bad result: %s / error: %s", result, err)
   153  		}
   154  		if !reflect.DeepEqual(resultArray.Value(), expectedArray[:]) {
   155  			t.Fatalf("bad result: %s / error: %s", result, err)
   156  		}
   157  	}
   158  
   159  	{
   160  		array1 := [...]Value{IntValue{5}, IntValue{6}, IntValue{7}}
   161  		array2 := [...]Value{IntValue{1}, IntValue{2}, IntValue{3}, IntValue{4}}
   162  		args := [...]Value{ArrayValue{array1[:]}, ArrayValue{array2[:]}}
   163  		expectedArray := [...]Value{CreateArrayValue2(IntValue{5}, IntValue{1}), CreateArrayValue2(IntValue{6}, IntValue{2}), CreateArrayValue2(IntValue{7}, IntValue{3})}
   164  
   165  		result, err := BuiltinFunctions["zip"].call(args[:])
   166  		if err != nil {
   167  			t.Fatalf("bad result: %s / error: %s", result, err)
   168  		}
   169  		resultArray, ok := result.(ArrayValue)
   170  		if !ok {
   171  			t.Fatalf("bad result: %s / error: %s", result, err)
   172  		}
   173  		if !reflect.DeepEqual(resultArray.Value(), expectedArray[:]) {
   174  			t.Fatalf("bad result: %s / error: %s", result, err)
   175  		}
   176  	}
   177  
   178  	{
   179  		array1 := [...]Value{IntValue{5}, IntValue{6}, IntValue{7}}
   180  		args := [...]Value{ArrayValue{array1[:]}, IntValue{1}}
   181  
   182  		result, err := BuiltinFunctions["zip"].call(args[:])
   183  		if err == nil || err.Error() != "1 is not array" {
   184  			t.Fatalf("bad result: %s / error: %s", result, err)
   185  		}
   186  	}
   187  
   188  	{
   189  		array1 := [...]Value{IntValue{5}, IntValue{6}, IntValue{7}}
   190  		args := [...]Value{IntValue{1}, ArrayValue{array1[:]}}
   191  
   192  		result, err := BuiltinFunctions["zip"].call(args[:])
   193  		if err == nil || err.Error() != "1 is not array" {
   194  			t.Fatalf("bad result: %s / error: %s", result, err)
   195  		}
   196  	}
   197  
   198  	{
   199  		args := [...]Value{IntValue{1}}
   200  
   201  		result, err := BuiltinFunctions["zip"].call(args[:])
   202  		if err == nil || err.Error() != "two arguments are required for zip" {
   203  			t.Fatalf("bad result: %s / error: %s", result, err)
   204  		}
   205  	}
   206  }