github.com/rclone/rclone@v1.66.1-0.20240517100346-7b89735ae726/fs/sizesuffix_test.go (about)

     1  package fs
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"testing"
     7  
     8  	"github.com/spf13/pflag"
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  // Interface which flags must satisfy - only defined for _test.go
    14  // since we don't want to pull in pflag here
    15  type flagger interface {
    16  	pflag.Value
    17  	json.Unmarshaler
    18  }
    19  
    20  // Interface which non-pointer flags must satisfy
    21  //
    22  // These are from pflag.Value and need to be non-pointer due the the
    23  // way the backend flags are inserted into the flags.
    24  type flaggerNP interface {
    25  	String() string
    26  	Type() string
    27  }
    28  
    29  // Check it satisfies the interfaces
    30  var (
    31  	_ flagger   = (*SizeSuffix)(nil)
    32  	_ flaggerNP = SizeSuffix(0)
    33  )
    34  
    35  func TestSizeSuffixString(t *testing.T) {
    36  	for _, test := range []struct {
    37  		in   float64
    38  		want string
    39  	}{
    40  		{0, "0"},
    41  		{102, "102"},
    42  		{1024, "1Ki"},
    43  		{1024 * 1024, "1Mi"},
    44  		{1024 * 1024 * 1024, "1Gi"},
    45  		{10 * 1024 * 1024 * 1024, "10Gi"},
    46  		{10.1 * 1024 * 1024 * 1024, "10.100Gi"},
    47  		{-1, "off"},
    48  		{-100, "off"},
    49  	} {
    50  		ss := SizeSuffix(test.in)
    51  		got := ss.String()
    52  		assert.Equal(t, test.want, got)
    53  	}
    54  }
    55  
    56  func TestSizeSuffixByteUnit(t *testing.T) {
    57  	for _, test := range []struct {
    58  		in   float64
    59  		want string
    60  	}{
    61  		{0, "0 B"},
    62  		{102, "102 B"},
    63  		{1024, "1 KiB"},
    64  		{1024 * 1024, "1 MiB"},
    65  		{1024 * 1024 * 1024, "1 GiB"},
    66  		{10 * 1024 * 1024 * 1024, "10 GiB"},
    67  		{10.1 * 1024 * 1024 * 1024, "10.100 GiB"},
    68  		{10 * 1024 * 1024 * 1024 * 1024, "10 TiB"},
    69  		{10 * 1024 * 1024 * 1024 * 1024 * 1024, "10 PiB"},
    70  		{1 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "1 EiB"},
    71  		{-1, "off"},
    72  		{-100, "off"},
    73  	} {
    74  		ss := SizeSuffix(test.in)
    75  		got := ss.ByteUnit()
    76  		assert.Equal(t, test.want, got)
    77  	}
    78  }
    79  
    80  func TestSizeSuffixBitRateUnit(t *testing.T) {
    81  	for _, test := range []struct {
    82  		in   float64
    83  		want string
    84  	}{
    85  		{0, "0 bit/s"},
    86  		{1024, "1 Kibit/s"},
    87  		{1024 * 1024, "1 Mibit/s"},
    88  		{1024 * 1024 * 1024, "1 Gibit/s"},
    89  		{10 * 1024 * 1024 * 1024, "10 Gibit/s"},
    90  		{10.1 * 1024 * 1024 * 1024, "10.100 Gibit/s"},
    91  		{10 * 1024 * 1024 * 1024 * 1024, "10 Tibit/s"},
    92  		{10 * 1024 * 1024 * 1024 * 1024 * 1024, "10 Pibit/s"},
    93  		{1 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024, "1 Eibit/s"},
    94  		{-1, "off"},
    95  		{-100, "off"},
    96  	} {
    97  		ss := SizeSuffix(test.in)
    98  		got := ss.BitRateUnit()
    99  		assert.Equal(t, test.want, got)
   100  	}
   101  }
   102  
   103  func TestSizeSuffixSet(t *testing.T) {
   104  	for _, test := range []struct {
   105  		in   string
   106  		want int64
   107  		err  bool
   108  	}{
   109  		{"0", 0, false},
   110  		{"1b", 1, false},
   111  		{"102B", 102, false},
   112  		{"0.1k", 102, false},
   113  		{"0.1", 102, false},
   114  		{"1K", 1024, false},
   115  		{"1k", 1024, false},
   116  		//{"1KB", 1024, false},
   117  		//{"1kB", 1024, false},
   118  		//{"1kb", 1024, false},
   119  		{"1KI", 1024, false},
   120  		{"1Ki", 1024, false},
   121  		{"1kI", 1024, false},
   122  		{"1ki", 1024, false},
   123  		{"1KiB", 1024, false},
   124  		{"1KiB", 1024, false},
   125  		{"1kib", 1024, false},
   126  		{"1", 1024, false},
   127  		{"2.5", 1024 * 2.5, false},
   128  		{"1M", 1024 * 1024, false},
   129  		//{"1MB", 1024 * 1024, false},
   130  		{"1Mi", 1024 * 1024, false},
   131  		{"1MiB", 1024 * 1024, false},
   132  		{"1.g", 1024 * 1024 * 1024, false},
   133  		{"10G", 10 * 1024 * 1024 * 1024, false},
   134  		{"10T", 10 * 1024 * 1024 * 1024 * 1024, false},
   135  		{"10P", 10 * 1024 * 1024 * 1024 * 1024 * 1024, false},
   136  		{"off", -1, false},
   137  		{"OFF", -1, false},
   138  		{"", 0, true},
   139  		{"1q", 0, true},
   140  		{"1.q", 0, true},
   141  		{"1q", 0, true},
   142  		{"-1K", 0, true},
   143  		{"1i", 0, true},
   144  		{"1iB", 0, true},
   145  		{"1MB", 0, true},
   146  	} {
   147  		ss := SizeSuffix(0)
   148  		err := ss.Set(test.in)
   149  		if test.err {
   150  			require.Error(t, err, test.in)
   151  		} else {
   152  			require.NoError(t, err, test.in)
   153  		}
   154  		assert.Equal(t, test.want, int64(ss))
   155  	}
   156  }
   157  
   158  func TestSizeSuffixScan(t *testing.T) {
   159  	var v SizeSuffix
   160  	n, err := fmt.Sscan(" 17M ", &v)
   161  	require.NoError(t, err)
   162  	assert.Equal(t, 1, n)
   163  	assert.Equal(t, SizeSuffix(17<<20), v)
   164  }
   165  
   166  func TestSizeSuffixUnmarshalJSON(t *testing.T) {
   167  	for _, test := range []struct {
   168  		in   string
   169  		want int64
   170  		err  bool
   171  	}{
   172  		{`"0"`, 0, false},
   173  		{`"102B"`, 102, false},
   174  		{`"1K"`, 1024, false},
   175  		{`"2.5"`, 1024 * 2.5, false},
   176  		{`"1M"`, 1024 * 1024, false},
   177  		{`"1.g"`, 1024 * 1024 * 1024, false},
   178  		{`"10G"`, 10 * 1024 * 1024 * 1024, false},
   179  		{`"off"`, -1, false},
   180  		{`""`, 0, true},
   181  		{`"1q"`, 0, true},
   182  		{`"-1K"`, 0, true},
   183  		{`0`, 0, false},
   184  		{`102`, 102, false},
   185  		{`1024`, 1024, false},
   186  		{`1000000000`, 1000000000, false},
   187  		{`1.1.1`, 0, true},
   188  	} {
   189  		var ss SizeSuffix
   190  		err := json.Unmarshal([]byte(test.in), &ss)
   191  		if test.err {
   192  			require.Error(t, err, test.in)
   193  		} else {
   194  			require.NoError(t, err, test.in)
   195  		}
   196  		assert.Equal(t, test.want, int64(ss))
   197  	}
   198  }