github.com/jackc/pgx/v5@v5.5.5/pgtype/range_test.go (about)

     1  package pgtype
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  )
     7  
     8  func TestParseUntypedTextRange(t *testing.T) {
     9  	tests := []struct {
    10  		src    string
    11  		result untypedTextRange
    12  		err    error
    13  	}{
    14  		{
    15  			src:    `[1,2)`,
    16  			result: untypedTextRange{Lower: "1", Upper: "2", LowerType: Inclusive, UpperType: Exclusive},
    17  			err:    nil,
    18  		},
    19  		{
    20  			src:    `[1,2]`,
    21  			result: untypedTextRange{Lower: "1", Upper: "2", LowerType: Inclusive, UpperType: Inclusive},
    22  			err:    nil,
    23  		},
    24  		{
    25  			src:    `(1,3)`,
    26  			result: untypedTextRange{Lower: "1", Upper: "3", LowerType: Exclusive, UpperType: Exclusive},
    27  			err:    nil,
    28  		},
    29  		{
    30  			src:    ` [1,2) `,
    31  			result: untypedTextRange{Lower: "1", Upper: "2", LowerType: Inclusive, UpperType: Exclusive},
    32  			err:    nil,
    33  		},
    34  		{
    35  			src:    `[ foo , bar )`,
    36  			result: untypedTextRange{Lower: " foo ", Upper: " bar ", LowerType: Inclusive, UpperType: Exclusive},
    37  			err:    nil,
    38  		},
    39  		{
    40  			src:    `["foo","bar")`,
    41  			result: untypedTextRange{Lower: "foo", Upper: "bar", LowerType: Inclusive, UpperType: Exclusive},
    42  			err:    nil,
    43  		},
    44  		{
    45  			src:    `["f""oo","b""ar")`,
    46  			result: untypedTextRange{Lower: `f"oo`, Upper: `b"ar`, LowerType: Inclusive, UpperType: Exclusive},
    47  			err:    nil,
    48  		},
    49  		{
    50  			src:    `["f""oo","b""ar")`,
    51  			result: untypedTextRange{Lower: `f"oo`, Upper: `b"ar`, LowerType: Inclusive, UpperType: Exclusive},
    52  			err:    nil,
    53  		},
    54  		{
    55  			src:    `["","bar")`,
    56  			result: untypedTextRange{Lower: ``, Upper: `bar`, LowerType: Inclusive, UpperType: Exclusive},
    57  			err:    nil,
    58  		},
    59  		{
    60  			src:    `[f\"oo\,,b\\ar\))`,
    61  			result: untypedTextRange{Lower: `f"oo,`, Upper: `b\ar)`, LowerType: Inclusive, UpperType: Exclusive},
    62  			err:    nil,
    63  		},
    64  		{
    65  			src:    `empty`,
    66  			result: untypedTextRange{Lower: "", Upper: "", LowerType: Empty, UpperType: Empty},
    67  			err:    nil,
    68  		},
    69  	}
    70  
    71  	for i, tt := range tests {
    72  		r, err := parseUntypedTextRange(tt.src)
    73  		if err != tt.err {
    74  			t.Errorf("%d. `%v`: expected err %v, got %v", i, tt.src, tt.err, err)
    75  			continue
    76  		}
    77  
    78  		if r.LowerType != tt.result.LowerType {
    79  			t.Errorf("%d. `%v`: expected result lower type %v, got %v", i, tt.src, string(tt.result.LowerType), string(r.LowerType))
    80  		}
    81  
    82  		if r.UpperType != tt.result.UpperType {
    83  			t.Errorf("%d. `%v`: expected result upper type %v, got %v", i, tt.src, string(tt.result.UpperType), string(r.UpperType))
    84  		}
    85  
    86  		if r.Lower != tt.result.Lower {
    87  			t.Errorf("%d. `%v`: expected result lower %v, got %v", i, tt.src, tt.result.Lower, r.Lower)
    88  		}
    89  
    90  		if r.Upper != tt.result.Upper {
    91  			t.Errorf("%d. `%v`: expected result upper %v, got %v", i, tt.src, tt.result.Upper, r.Upper)
    92  		}
    93  	}
    94  }
    95  
    96  func TestParseUntypedBinaryRange(t *testing.T) {
    97  	tests := []struct {
    98  		src    []byte
    99  		result untypedBinaryRange
   100  		err    error
   101  	}{
   102  		{
   103  			src:    []byte{0, 0, 0, 0, 2, 0, 4, 0, 0, 0, 2, 0, 5},
   104  			result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: []byte{0, 5}, LowerType: Exclusive, UpperType: Exclusive},
   105  			err:    nil,
   106  		},
   107  		{
   108  			src:    []byte{1},
   109  			result: untypedBinaryRange{Lower: nil, Upper: nil, LowerType: Empty, UpperType: Empty},
   110  			err:    nil,
   111  		},
   112  		{
   113  			src:    []byte{2, 0, 0, 0, 2, 0, 4, 0, 0, 0, 2, 0, 5},
   114  			result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: []byte{0, 5}, LowerType: Inclusive, UpperType: Exclusive},
   115  			err:    nil,
   116  		},
   117  		{
   118  			src:    []byte{4, 0, 0, 0, 2, 0, 4, 0, 0, 0, 2, 0, 5},
   119  			result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: []byte{0, 5}, LowerType: Exclusive, UpperType: Inclusive},
   120  			err:    nil,
   121  		},
   122  		{
   123  			src:    []byte{6, 0, 0, 0, 2, 0, 4, 0, 0, 0, 2, 0, 5},
   124  			result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: []byte{0, 5}, LowerType: Inclusive, UpperType: Inclusive},
   125  			err:    nil,
   126  		},
   127  		{
   128  			src:    []byte{8, 0, 0, 0, 2, 0, 5},
   129  			result: untypedBinaryRange{Lower: nil, Upper: []byte{0, 5}, LowerType: Unbounded, UpperType: Exclusive},
   130  			err:    nil,
   131  		},
   132  		{
   133  			src:    []byte{12, 0, 0, 0, 2, 0, 5},
   134  			result: untypedBinaryRange{Lower: nil, Upper: []byte{0, 5}, LowerType: Unbounded, UpperType: Inclusive},
   135  			err:    nil,
   136  		},
   137  		{
   138  			src:    []byte{16, 0, 0, 0, 2, 0, 4},
   139  			result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: nil, LowerType: Exclusive, UpperType: Unbounded},
   140  			err:    nil,
   141  		},
   142  		{
   143  			src:    []byte{18, 0, 0, 0, 2, 0, 4},
   144  			result: untypedBinaryRange{Lower: []byte{0, 4}, Upper: nil, LowerType: Inclusive, UpperType: Unbounded},
   145  			err:    nil,
   146  		},
   147  		{
   148  			src:    []byte{24},
   149  			result: untypedBinaryRange{Lower: nil, Upper: nil, LowerType: Unbounded, UpperType: Unbounded},
   150  			err:    nil,
   151  		},
   152  	}
   153  
   154  	for i, tt := range tests {
   155  		r, err := parseUntypedBinaryRange(tt.src)
   156  		if err != tt.err {
   157  			t.Errorf("%d. `%v`: expected err %v, got %v", i, tt.src, tt.err, err)
   158  			continue
   159  		}
   160  
   161  		if r.LowerType != tt.result.LowerType {
   162  			t.Errorf("%d. `%v`: expected result lower type %v, got %v", i, tt.src, string(tt.result.LowerType), string(r.LowerType))
   163  		}
   164  
   165  		if r.UpperType != tt.result.UpperType {
   166  			t.Errorf("%d. `%v`: expected result upper type %v, got %v", i, tt.src, string(tt.result.UpperType), string(r.UpperType))
   167  		}
   168  
   169  		if !bytes.Equal(r.Lower, tt.result.Lower) {
   170  			t.Errorf("%d. `%v`: expected result lower %v, got %v", i, tt.src, tt.result.Lower, r.Lower)
   171  		}
   172  
   173  		if !bytes.Equal(r.Upper, tt.result.Upper) {
   174  			t.Errorf("%d. `%v`: expected result upper %v, got %v", i, tt.src, tt.result.Upper, r.Upper)
   175  		}
   176  	}
   177  }