public void ShouldCreateDateTimeWithOffsetWithDateTimeComponentsWithNanoseconds()
        {
            var cypherDateTime = new CypherDateTimeWithOffset(1947, 12, 17, 23, 49, 54, 192794500, 1500);

            cypherDateTime.DateTime.Should().Be(new DateTime(1947, 12, 17, 23, 49, 54).AddTicks(1927945));
            cypherDateTime.Offset.Should().Be(TimeSpan.FromSeconds(1500));
        }
        public void ShouldConvertToDateTimeOffset()
        {
            var dateTime       = new DateTimeOffset(1947, 12, 17, 23, 49, 54, 120, TimeSpan.FromSeconds(1500));
            var cypherDateTime = new CypherDateTimeWithOffset(dateTime);

            cypherDateTime.ToDateTimeOffset().Should().Be(dateTime);
        }
        public void ShouldNotBeEqualToNull()
        {
            var dateTime = new CypherDateTimeWithOffset(1947, 12, 17, 15, 12, 01, 789000000, 1800);
            var other    = (object)null;

            dateTime.Equals(other).Should().BeFalse();
        }
        public void ShouldNotBeEqualToAnotherType()
        {
            var dateTime = new CypherDateTimeWithOffset(1947, 12, 17, 15, 12, 01, 789000000, 1800);
            var other    = "some string";

            dateTime.Equals(other).Should().BeFalse();
        }
        public void ShouldGenerateSameHashcode()
        {
            var dateTime1 = new CypherDateTimeWithOffset(1947, 12, 17, 15, 12, 01, 789000000, 1800);
            var dateTime2 = new CypherDateTimeWithOffset(new DateTime(1947, 12, 17, 15, 12, 01, 789), 1800);
            var dateTime3 = new CypherDateTimeWithOffset(-695551679, 789000000, 1800);

            dateTime1.GetHashCode().Should().Be(dateTime2.GetHashCode()).And.Be(dateTime3.GetHashCode());
        }
        public void ShouldCreateDateTimeWithOffsetWithDateTimeOffset()
        {
            var dateTime       = new DateTimeOffset(1947, 12, 17, 23, 49, 54, 120, TimeSpan.FromSeconds(1500));
            var cypherDateTime = new CypherDateTimeWithOffset(dateTime);

            cypherDateTime.DateTime.Should().Be(dateTime.DateTime);
            cypherDateTime.Offset.Should().Be(dateTime.Offset);
        }
        public void ShouldGenerateDifferentHashcode()
        {
            var dateTime1 = new CypherDateTimeWithOffset(1947, 12, 17, 15, 12, 01, 789000000, 1801);
            var dateTime2 = new CypherDateTimeWithOffset(new DateTime(1947, 12, 17, 15, 12, 01, 790), 1800);
            var dateTime3 = new CypherDateTimeWithOffset(-695553479, 789000200, 1800);

            dateTime1.GetHashCode().Should().NotBe(dateTime2.GetHashCode()).And.NotBe(dateTime3.GetHashCode());
        }
        public void ShouldGenerateCorrectString()
        {
            var cypherDateTime    = new CypherDateTimeWithOffset(1947, 12, 17, 23, 49, 54, 192794500, 1500);
            var cypherDateTimeStr = cypherDateTime.ToString();

            cypherDateTimeStr.Should()
            .Be(
                $"DateTimeWithOffset{{epochSeconds: {cypherDateTime.EpochSeconds}, nanosOfSecond: {cypherDateTime.NanosOfSecond}, offsetSeconds: {cypherDateTime.OffsetSeconds}}}");
        }
        public void ShouldCreateDateWithRawValues()
        {
            var dateTime       = new DateTime(1947, 12, 17, 23, 49, 54).AddTicks(1927945);
            var cypherDateTime = new CypherDateTimeWithOffset(TemporalHelpers.SecondsSinceEpoch(dateTime.Ticks),
                                                              TemporalHelpers.NanosOfSecond(dateTime.Ticks), 1500);

            cypherDateTime.DateTime.Should().Be(dateTime);
            cypherDateTime.Offset.Should().Be(TimeSpan.FromSeconds(1500));
        }
        public void ShouldNotBeEqual()
        {
            var dateTime1 = new CypherDateTimeWithOffset(1947, 12, 17, 15, 12, 01, 789000000, 1801);
            var dateTime2 = new CypherDateTimeWithOffset(new DateTime(1947, 12, 17, 15, 12, 01, 790), 1800);
            var dateTime3 = new CypherDateTimeWithOffset(-695553479, 789005000, 1800);

            dateTime1.Should().NotBe(dateTime2);
            dateTime1.Should().NotBe(dateTime3);
        }
Beispiel #11
0
        public void ShouldWriteDateTimeWithOffset()
        {
            var dateTime = new CypherDateTimeWithOffset(1978, 12, 16, 12, 35, 59, 128000987,
                                                        (int)TimeSpan.FromMinutes(-150).TotalSeconds);
            var writerMachine = CreateWriterMachine();
            var writer        = writerMachine.Writer();

            writer.Write(dateTime);

            var readerMachine = CreateReaderMachine(writerMachine.GetOutput());
            var reader        = readerMachine.Reader();

            reader.PeekNextType().Should().Be(PackStream.PackType.Struct);
            reader.ReadStructHeader().Should().Be(3);
            reader.ReadStructSignature().Should().Be((byte)'F');
            reader.Read().Should().Be(dateTime.EpochSeconds);
            reader.Read().Should().Be((long)dateTime.NanosOfSecond);
            reader.Read().Should().Be((long)dateTime.OffsetSeconds);
        }
Beispiel #12
0
        public void ShouldSendAndReceiveDateTimeWithOffset()
        {
            var data = new CypherDateTimeWithOffset(1976, 6, 13, 12, 34, 56, 789012587, (int)TimeSpan.FromMinutes(-90).TotalSeconds);

            TestSendAndReceiveData(
                "CYPHER runtime=interpreted WITH $x AS x RETURN x, x.year, x.month, x.day, x.hour, x.minute, x.second, x.millisecond, x.microsecond, x.nanosecond, x.offset",
                data,
                new object[]
            {
                data,
                1976L,
                6L,
                13L,
                12L,
                34L,
                56L,
                789L,
                789012L,
                789012587L,
                "-01:30"
            });
        }