github.com/parquet-go/parquet-go@v0.21.1-0.20240501160520-b3c3a0c3ed6f/value_test.go (about) 1 package parquet_test 2 3 import ( 4 "bytes" 5 "math" 6 "testing" 7 "time" 8 "unsafe" 9 10 "github.com/parquet-go/parquet-go" 11 "github.com/parquet-go/parquet-go/deprecated" 12 ) 13 14 func TestSizeOfValue(t *testing.T) { 15 t.Logf("sizeof(parquet.Value) = %d", unsafe.Sizeof(parquet.Value{})) 16 } 17 18 func BenchmarkValueAppend(b *testing.B) { 19 const N = 1024 20 row := make(parquet.Row, 0, N) 21 val := parquet.ValueOf(42) 22 23 for i := 0; i < b.N; i++ { 24 row = row[:0] 25 for j := 0; j < N; j++ { 26 row = append(row, val) 27 } 28 } 29 30 b.SetBytes(N * int64(unsafe.Sizeof(parquet.Value{}))) 31 } 32 33 func TestValueClone(t *testing.T) { 34 tests := []struct { 35 scenario string 36 values []interface{} 37 }{ 38 { 39 scenario: "BOOLEAN", 40 values: []interface{}{false, true}, 41 }, 42 43 { 44 scenario: "INT32", 45 values: []interface{}{int32(0), int32(1), int32(math.MinInt32), int32(math.MaxInt32)}, 46 }, 47 48 { 49 scenario: "INT64", 50 values: []interface{}{int64(0), int64(1), int64(math.MinInt64), int64(math.MaxInt64)}, 51 }, 52 53 { 54 scenario: "FLOAT", 55 values: []interface{}{float32(0), float32(1), float32(-1)}, 56 }, 57 58 { 59 scenario: "DOUBLE", 60 values: []interface{}{float64(0), float64(1), float64(-1)}, 61 }, 62 63 { 64 scenario: "BYTE_ARRAY", 65 values: []interface{}{"", "A", "ABC", "Hello World!"}, 66 }, 67 68 { 69 scenario: "FIXED_LEN_BYTE_ARRAY", 70 values: []interface{}{[1]byte{42}, [16]byte{0: 1}}, 71 }, 72 73 { 74 scenario: "TIME", 75 values: []interface{}{ 76 time.Date(2020, 1, 2, 3, 4, 5, 7, time.UTC), 77 time.Date(2021, 2, 3, 4, 5, 6, 8, time.UTC), 78 }, 79 }, 80 } 81 82 for _, test := range tests { 83 t.Run(test.scenario, func(t *testing.T) { 84 for _, value := range test.values { 85 v := parquet.ValueOf(value) 86 c := v.Clone() 87 88 if !parquet.DeepEqual(v, c) { 89 t.Errorf("cloned values are not equal: want=%#v got=%#v", v, c) 90 } 91 if v.RepetitionLevel() != c.RepetitionLevel() { 92 t.Error("cloned values do not have the same repetition level") 93 } 94 if v.DefinitionLevel() != c.DefinitionLevel() { 95 t.Error("cloned values do not have the same definition level") 96 } 97 if v.Column() != c.Column() { 98 t.Error("cloned values do not have the same column index") 99 } 100 } 101 }) 102 } 103 } 104 105 func TestZeroValue(t *testing.T) { 106 var v parquet.Value 107 if !v.IsNull() { 108 t.Error("expected zero value parquet.Value to be null") 109 } 110 111 if v.Byte() != byte(0) { 112 t.Errorf("byte not zero value: got=%#v", v.Byte()) 113 } 114 115 if v.Boolean() != false { 116 t.Errorf("boolean not zero value: got=%#v", v.Boolean()) 117 } 118 119 if v.Int32() != 0 { 120 t.Errorf("int32 not zero value: got=%#v", v.Int32()) 121 } 122 123 if v.Int64() != 0 { 124 t.Errorf("int64 not zero value: got=%#v", v.Int64()) 125 } 126 127 var zeroInt96 deprecated.Int96 128 if v.Int96() != zeroInt96 { 129 t.Errorf("int96 not zero value: got=%#v", zeroInt96) 130 } 131 132 if v.Float() != 0 { 133 t.Errorf("float not zero value: got=%#v", v.Float()) 134 } 135 136 if v.Double() != 0 { 137 t.Errorf("double not zero value: got=%#v", v.Double()) 138 } 139 140 if v.Uint32() != 0 { 141 t.Errorf("uint32 not zero value: got=%#v", v.Uint32()) 142 } 143 144 if v.Uint64() != 0 { 145 t.Errorf("uint64 not zero value: got=%#v", v.Uint64()) 146 } 147 148 var zeroByte []byte 149 if !bytes.Equal(v.ByteArray(), zeroByte) { 150 t.Errorf("byte array not zero value: got=%#v", v.ByteArray()) 151 } 152 }