forked from npgsql/npgsql
-
Notifications
You must be signed in to change notification settings - Fork 3
Expand file tree
/
Copy pathTextTests.cs
More file actions
159 lines (138 loc) · 6.46 KB
/
TextTests.cs
File metadata and controls
159 lines (138 loc) · 6.46 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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
using System;
using System.Data;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using NpgsqlTypes;
using NUnit.Framework;
using static Npgsql.Tests.TestUtil;
namespace Npgsql.Tests.Types;
/// <summary>
/// Tests on PostgreSQL text
/// </summary>
/// <remarks>
/// https://www.postgresql.org/docs/current/static/datatype-character.html
/// </remarks>
public class TextTests : TestBase
{
[Test]
public Task Text_as_string()
=> AssertType("foo", "foo", "text", dbType: DbType.String);
[Test]
public Task Text_as_array_of_chars()
=> AssertType("foo".ToCharArray(), "foo", "text", dataTypeInference: DataTypeInference.Mismatch,
dbType: DbType.String, valueTypeEqualsFieldType: false);
[Test]
public Task Text_as_ArraySegment_of_chars()
=> AssertTypeWrite(new ArraySegment<char>("foo".ToCharArray()), "foo", "text", dbType: DbType.String);
[Test]
public Task Text_as_array_of_bytes()
=> AssertType("foo"u8.ToArray(), "foo", "text", dataTypeInference: DataTypeInference.Mismatch,
new(DbType.String, DbType.Binary), valueTypeEqualsFieldType: false);
[Test]
public Task Text_as_ReadOnlyMemory_of_bytes()
=> AssertTypeWrite(new ReadOnlyMemory<byte>("foo"u8.ToArray()), "foo",
"text", dataTypeInference: DataTypeInference.Mismatch,
new(DbType.String, DbType.Binary));
[Test]
public Task Char_as_char()
=> AssertType('f', "f",
"character", dataTypeInference: DataTypeInference.Mismatch,
dbType: DbType.String, valueTypeEqualsFieldType: false, skipArrayCheck: true); // char[] maps to text
[Test]
public async Task Citext_as_string()
{
await using var conn = await OpenConnectionAsync();
await EnsureExtensionAsync(conn, "citext");
await AssertType("foo", "foo",
"citext", dataTypeInference: DataTypeInference.Mismatch,
dbType: DbType.String);
}
[Test]
public Task Text_as_MemoryStream()
=> AssertTypeWrite(() => new MemoryStream("foo"u8.ToArray()), "foo",
"text", dataTypeInference: DataTypeInference.Mismatch,
new(DbType.String, DbType.Binary));
[Test]
public async Task Text_long()
{
await using var conn = await OpenConnectionAsync();
var builder = new StringBuilder("ABCDEééé", conn.Settings.WriteBufferSize);
builder.Append('X', conn.Settings.WriteBufferSize);
var value = builder.ToString();
await AssertType(value, value, "text", dbType: DbType.String);
}
[Test, Description("Tests that strings are truncated when the NpgsqlParameter's Size is set")]
public async Task Truncate()
{
const string data = "SomeText";
using var conn = await OpenConnectionAsync();
using var cmd = new NpgsqlCommand("SELECT @p::TEXT", conn);
var p = new NpgsqlParameter("p", data) { Size = 4 };
cmd.Parameters.Add(p);
Assert.That(await cmd.ExecuteScalarAsync(), Is.EqualTo(data.Substring(0, 4)));
// NpgsqlParameter.Size needs to persist when value is changed
const string data2 = "AnotherValue";
p.Value = data2;
Assert.That(await cmd.ExecuteScalarAsync(), Is.EqualTo(data2.Substring(0, 4)));
// NpgsqlParameter.Size larger than the value size should mean the value size, as well as 0 and -1
p.Value = data2;
p.Size = data2.Length + 10;
Assert.That(await cmd.ExecuteScalarAsync(), Is.EqualTo(data2));
p.Size = 0;
Assert.That(await cmd.ExecuteScalarAsync(), Is.EqualTo(data2));
p.Size = -1;
Assert.That(await cmd.ExecuteScalarAsync(), Is.EqualTo(data2));
Assert.That(() => p.Size = -2, Throws.Exception.TypeOf<ArgumentException>());
}
[Test, IssueLink("https://github.com/npgsql/npgsql/issues/488")]
public async Task Null_character()
{
var exception = await AssertTypeUnsupportedWrite<string, PostgresException>("string with \0\0\0 null \0bytes");
Assert.That(exception.SqlState, Is.EqualTo(PostgresErrorCodes.CharacterNotInRepertoire));
}
[Test, Description("Tests some types which are aliased to strings")]
[TestCase("character varying")]
[TestCase("name")]
public Task Aliased_postgres_types(string dataTypeName)
=> AssertType("foo", "foo", dataTypeName, dataTypeInference: DataTypeInference.Mismatch, dbType: DbType.String);
[Test]
[TestCase(DbType.AnsiString)]
[TestCase(DbType.AnsiStringFixedLength)]
public async Task Aliased_DbTypes(DbType dbType)
{
await using var conn = await OpenConnectionAsync();
await using var command = new NpgsqlCommand("SELECT @p", conn);
command.Parameters.Add(new NpgsqlParameter("p", dbType) { Value = "SomeString" });
Assert.That(await command.ExecuteScalarAsync(), Is.EqualTo("SomeString")); // Inferred DbType...
}
[Test, Description("Tests the PostgreSQL internal \"char\" type")]
public async Task Internal_char()
{
using var conn = await OpenConnectionAsync();
using var cmd = conn.CreateCommand();
var testArr = new byte[] { (byte)'}', (byte)'"', 3 };
var testArr2 = new char[] { '}', '"', (char)3 };
cmd.CommandText = "Select 'a'::\"char\", (-3)::\"char\", :p1, :p2, :p3, :p4, :p5";
cmd.Parameters.Add(new NpgsqlParameter("p1", NpgsqlDbType.InternalChar) { Value = 'b' });
cmd.Parameters.Add(new NpgsqlParameter("p2", NpgsqlDbType.InternalChar) { Value = (byte)66 });
cmd.Parameters.Add(new NpgsqlParameter("p3", NpgsqlDbType.InternalChar) { Value = (byte)230 });
cmd.Parameters.Add(new NpgsqlParameter("p4", NpgsqlDbType.InternalChar | NpgsqlDbType.Array) { Value = testArr });
cmd.Parameters.Add(new NpgsqlParameter("p5", NpgsqlDbType.InternalChar | NpgsqlDbType.Array) { Value = testArr2 });
using var reader = await cmd.ExecuteReaderAsync();
reader.Read();
var expected = new char[] { 'a', (char)(256 - 3), 'b', (char)66, (char)230 };
for (var i = 0; i < expected.Length; i++)
{
Assert.That(reader.GetChar(i), Is.EqualTo(expected[i]));
}
var arr = (char[])reader.GetValue(5);
var arr2 = (char[])reader.GetValue(6);
Assert.That(arr.Length, Is.EqualTo(testArr.Length));
for (var i = 0; i < arr.Length; i++)
{
Assert.That(arr[i], Is.EqualTo(testArr[i]));
Assert.That(arr2[i], Is.EqualTo(testArr2[i]));
}
}
}