/
Timestamp_specs.cs
138 lines (117 loc) · 4.55 KB
/
Timestamp_specs.cs
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
namespace Sql.Timestamp_specs;
public class Is_invalid
{
[Test]
public void for_empty_string() => Timestamp.TryParse(string.Empty).Should().BeNull();
[Test]
public void for_null() => Timestamp.TryParse(Nil.String).Should().BeNull();
[Test]
public void for_garbage() => Timestamp.TryParse("Not a timestamp").Should().BeNull();
}
public class Is_equal_by_value
{
[Test]
public void not_equal_to_null()
=> Svo.Timestamp.Equals(null).Should().BeFalse();
[Test]
public void not_equal_to_other_type()
=> Svo.Timestamp.Equals(new object()).Should().BeFalse();
[Test]
public void not_equal_to_different_value()
=> Svo.Timestamp.Equals(Timestamp.MinValue).Should().BeFalse();
[Test]
public void equal_to_same_value()
=> Svo.Timestamp.Equals(Timestamp.Create(1234567890L)).Should().BeTrue();
[Test]
public void equal_operator_returns_true_for_same_values()
=> (Timestamp.Create(1234567890L) == Svo.Timestamp).Should().BeTrue();
[Test]
public void equal_operator_returns_false_for_different_values()
=> (Timestamp.Create(1234567890L) == Timestamp.MinValue).Should().BeFalse();
[Test]
public void not_equal_operator_returns_false_for_same_values()
=> (Timestamp.Create(1234567890L) != Svo.Timestamp).Should().BeFalse();
[Test]
public void not_equal_operator_returns_true_for_different_values()
=> (Timestamp.Create(1234567890L) != Timestamp.MinValue).Should().BeTrue();
[TestCase("0", 0)]
[TestCase("1234567890", 1849341697)]
public void hash_code_is_value_based(Timestamp svo, int hash)
{
using (Hash.WithoutRandomizer())
{
svo.GetHashCode().Should().Be(hash);
}
}
}
public class Is_comparable
{
[Test]
public void to_null_is_1() => Svo.Timestamp.CompareTo(Nil.Object).Should().Be(1);
}
public class Can_be_created
{
[Test]
public void from_byte_arrays_with_length_8()
=> Timestamp.Create([1, 2, 3, 4, 5, 6, 7, 8]).Should().Be((Timestamp)578437695752307201L);
[Test]
public void from_negative_numbers()
=> Timestamp.Create(-23).Should().Be((Timestamp)18446744073709551593L);
}
public class Can_not_be_created
{
[TestCase(7)]
[TestCase(9)]
public void form_byte_arrays_with_a_length_other_than_8(int length)
{
Func<Timestamp> create = () => Timestamp.Create(new byte[length]);
create.Should().Throw<ArgumentException>()
.WithMessage("The byte array should have size of 8.*");
}
}
public class Supports_JSON_serialization
{
#if NET6_0_OR_GREATER
[TestCase(null, null)]
[TestCase(1849341697d, "0x000000006E3AB701")]
[TestCase(1849341697L, "0x000000006E3AB701")]
[TestCase("1849341697", "0x000000006E3AB701")]
[TestCase("0x000000006E3AB701", "0x000000006E3AB701")]
public void System_Text_JSON_deserialization(object json, Timestamp svo)
=> JsonTester.Read_System_Text_JSON<Timestamp>(json).Should().Be(svo);
[TestCase(null, "0x0000000000000000")]
[TestCase("0x000000006E3AB701", "0x000000006E3AB701")]
public void System_Text_JSON_serialization(Timestamp svo, object json)
=> JsonTester.Write_System_Text_JSON(svo).Should().Be(json);
#endif
[TestCase(1849341697d, "0x000000006E3AB701")]
[TestCase(1849341697L, "0x000000006E3AB701")]
[TestCase("1849341697", "0x000000006E3AB701")]
[TestCase("0x000000006E3AB701", "0x000000006E3AB701")]
public void convention_based_deserialization(object json, Timestamp svo)
=> JsonTester.Read<Timestamp>(json).Should().Be(svo);
[TestCase(null, "0x0000000000000000")]
[TestCase("0x000000006E3AB701", "0x000000006E3AB701")]
public void convention_based_serialization(Timestamp svo, object json)
=> JsonTester.Write(svo).Should().Be(json);
[TestCase("Invalid input", typeof(FormatException))]
[TestCase("2017-06-11", typeof(FormatException))]
[TestCase(true, typeof(InvalidOperationException))]
public void throws_for_invalid_json(object json, Type exceptionType)
=> json
.Invoking(JsonTester.Read<Timestamp>)
.Should().Throw<Exception>()
.And.Should().BeOfType(exceptionType);
}
public class Is_Open_API_data_type
{
[Test]
public void with_info()
=> OpenApiDataType.FromType(typeof(Timestamp))
.Should().Be(new OpenApiDataType(
dataType: typeof(Timestamp),
description: "SQL Server timestamp notation.",
example: "0x00000000000007D9",
type: "string",
format: "timestamp"));
}