forked from npgsql/npgsql
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathBitStringTests.cs
More file actions
126 lines (110 loc) · 4.61 KB
/
BitStringTests.cs
File metadata and controls
126 lines (110 loc) · 4.61 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
using System;
using System.Collections;
using System.Collections.Specialized;
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(MultiplexingMode multiplexingMode) : MultiplexingTestBase(multiplexingMode)
{
[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})", isDefaultForWriting: false);
}
[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", isDefaultForReading: 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)", isDefault: false);
[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", isDefault: false);
[Test]
public Task Write_as_string_validation()
=> AssertTypeUnsupportedWrite<string, ArgumentException>("001q0", "bit varying");
}