forked from npgsql/npgsql
-
Notifications
You must be signed in to change notification settings - Fork 3
Expand file tree
/
Copy pathBitStringTests.cs
More file actions
129 lines (113 loc) · 4.79 KB
/
BitStringTests.cs
File metadata and controls
129 lines (113 loc) · 4.79 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
using System;
using System.Collections;
using System.Collections.Specialized;
using System.Data;
using System.Threading.Tasks;
using NpgsqlTypes;
using NUnit.Framework;
namespace Npgsql.Tests.Types;
/// <summary>
/// Tests on the PostgreSQL BitString type
/// </summary>
/// <remarks>
/// https://www.postgresql.org/docs/current/static/datatype-bit.html
/// </remarks>
public class BitStringTests : TestBase
{
[Test]
[TestCase("10110110", TestName = "BitArray")]
[TestCase("1011011000101111010110101101011011", TestName = "BitArray_with_34_bits")]
[TestCase("", TestName = "BitArray_empty")]
public async Task BitArray(string sqlLiteral)
{
var len = sqlLiteral.Length;
var bitArray = new BitArray(len);
for (var i = 0; i < sqlLiteral.Length; i++)
bitArray[i] = sqlLiteral[i] == '1';
await AssertType(bitArray, sqlLiteral, "bit varying");
if (len > 0)
await AssertType(bitArray, sqlLiteral, $"bit({len})", dataTypeInference: DataTypeInference.Mismatch);
}
[Test]
public async Task BitArray_long()
{
await using var conn = await OpenConnectionAsync();
var bitLen = (conn.Settings.WriteBufferSize + 10) * 8;
var chars = new char[bitLen];
for (var i = 0; i < bitLen; i++)
chars[i] = i % 2 == 0 ? '0' : '1';
await BitArray(new string(chars));
}
[Test]
public Task BitVector32()
=> AssertType(
new BitVector32(4), "00000000000000000000000000000100", "bit varying", valueTypeEqualsFieldType: false);
[Test]
public Task BitVector32_too_long()
=> AssertTypeUnsupportedRead<BitVector32, InvalidCastException>(new string('0', 34), "bit varying");
[Test]
public Task Bool()
=> AssertType(true, "1", "bit(1)", dataTypeInference: DataTypeInference.Mismatch, dbType: new(DbType.Object, DbType.Boolean));
[Test]
public async Task Bitstring_with_multiple_bits_as_bool_throws()
{
await AssertTypeUnsupportedRead<bool, InvalidCastException>("01", "varbit");
await AssertTypeUnsupportedRead<bool, InvalidCastException>("01", "bit(2)");
}
[Test]
public async Task Array()
{
using var conn = await OpenConnectionAsync();
using var cmd = new NpgsqlCommand("SELECT @p", conn);
var expected = new[] { new BitArray([true, false, true]), new BitArray([false]) };
var p = new NpgsqlParameter("p", NpgsqlDbType.Array | NpgsqlDbType.Varbit) { Value = expected };
cmd.Parameters.Add(p);
p.Value = expected;
using var reader = await cmd.ExecuteReaderAsync();
reader.Read();
Assert.That(reader.GetValue(0), Is.EqualTo(expected));
Assert.That(reader.GetFieldValue<BitArray[]>(0), Is.EqualTo(expected));
Assert.That(reader.GetFieldType(0), Is.EqualTo(typeof(Array)));
}
[Test]
public async Task Array_of_single_bits()
{
using var conn = await OpenConnectionAsync();
using var cmd = new NpgsqlCommand("SELECT @p::BIT(1)[]", conn);
var expected = new[] { true, false };
var p = new NpgsqlParameter("p", NpgsqlDbType.Array | NpgsqlDbType.Bit) {Value = expected};
cmd.Parameters.Add(p);
p.Value = expected;
using var reader = await cmd.ExecuteReaderAsync();
reader.Read();
var x = reader.GetValue(0);
Assert.That(reader.GetValue(0), Is.EqualTo(expected));
Assert.That(reader.GetFieldValue<bool[]>(0), Is.EqualTo(expected));
Assert.That(reader.GetFieldType(0), Is.EqualTo(typeof(Array)));
}
[Test]
public async Task Array_of_single_bits_and_null()
{
var dataSource = CreateDataSource(builder => builder.ArrayNullabilityMode = ArrayNullabilityMode.Always);
using var conn = await dataSource.OpenConnectionAsync();
using var cmd = new NpgsqlCommand("SELECT @p::BIT(1)[]", conn);
var expected = new bool?[] { true, false, null };
var p = new NpgsqlParameter("p", NpgsqlDbType.Array | NpgsqlDbType.Bit) {Value = expected};
cmd.Parameters.Add(p);
p.Value = expected;
using var reader = await cmd.ExecuteReaderAsync();
reader.Read();
var x = reader.GetValue(0);
Assert.That(reader.GetValue(0), Is.EqualTo(expected));
Assert.That(reader.GetFieldValue<bool?[]>(0), Is.EqualTo(expected));
Assert.That(reader.GetFieldType(0), Is.EqualTo(typeof(Array)));
}
[Test]
public Task As_string()
=> AssertType("010101", "010101",
"bit varying", dataTypeInference: DataTypeInference.Mismatch,
dbType: new(DbType.Object, DbType.String), valueTypeEqualsFieldType: false);
[Test]
public Task Write_as_string_validation()
=> AssertTypeUnsupportedWrite<string, ArgumentException>("001q0", "bit varying");
}