11323194607

Committed 14 Oct 2024 07:49AM UTC coverage: 55.919% (+0.009%) from 55.91%

Build # 11323194607

Build Type

push

github

Committed by

web-flow

Commit Message

fea: use canonical TryGet style in IReadOnlyStore (#3533)

Run Details

5774 of 8906 branches covered (64.83%)

Branch coverage included in aggregate %.

22 of 31 new or added lines in 8 files covered. (70.97%)

3 existing lines in 2 files now uncovered.

21731 of 40281 relevant lines covered (53.95%)

86458.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/tests/Neo.UnitTests/Persistence/UT_MemorySnapshot.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// UT_MemorySnapshot.cs file belongs to the neo project and is free
// software distributed under the MIT software license, see the
// accompanying file LICENSE in the main directory of the
// repository or http://www.opensource.org/licenses/mit-license.php
// for more details.
//
// Redistribution and use in source and binary forms with or without
// modifications are permitted.

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Neo.Persistence;
using System.Linq;

namespace Neo.UnitTests.Persistence;

[TestClass]
public class UT_MemorySnapshot
{
    private MemoryStore _memoryStore;
    private MemorySnapshot _snapshot;

    [TestInitialize]
    public void Setup()
    {
        _memoryStore = new MemoryStore();
        _snapshot = _memoryStore.GetSnapshot() as MemorySnapshot;
    }

    [TestCleanup]
    public void CleanUp()
    {
        _memoryStore.Reset();
    }

    [TestMethod]
    public void SingleSnapshotTest()
    {
        var key1 = new byte[] { 0x01, 0x02 };
        var value1 = new byte[] { 0x03, 0x04 };

        _snapshot.Delete(key1);
        Assert.IsNull(_snapshot.TryGet(key1));

        // Both Store and Snapshot can not get the value that are cached in the snapshot
        _snapshot.Put(key1, value1);
        Assert.IsNull(_snapshot.TryGet(key1));
        Assert.IsNull(_memoryStore.TryGet(key1));

        _snapshot.Commit();

        // After commit the snapshot, the value can be get from the store but still can not get from the snapshot
        CollectionAssert.AreEqual(value1, _memoryStore.TryGet(key1));
        Assert.IsNull(_snapshot.TryGet(key1));

        _snapshot.Delete(key1);

        // Deleted value can not be found from the snapshot but can still get from the store
        // This is because snapshot has no key1 at all.
        Assert.IsFalse(_snapshot.Contains(key1));
        Assert.IsTrue(_memoryStore.Contains(key1));

        _snapshot.Commit();

        // After commit the snapshot, the value can not be found from the store
        Assert.IsFalse(_memoryStore.Contains(key1));

        // Test seek in order
        _snapshot.Put([0x00, 0x00, 0x04], [0x04]);
        _snapshot.Put([0x00, 0x00, 0x00], [0x00]);
        _snapshot.Put([0x00, 0x00, 0x01], [0x01]);
        _snapshot.Put([0x00, 0x00, 0x02], [0x02]);
        _snapshot.Put([0x00, 0x00, 0x03], [0x03]);

        // Can not get anything from the snapshot
        var entries = _snapshot.Seek([0x00, 0x00, 0x02]).ToArray();
        Assert.AreEqual(0, entries.Length);
    }

    [TestMethod]
    public void MultiSnapshotTest()
    {
        var key1 = new byte[] { 0x01, 0x02 };
        var value1 = new byte[] { 0x03, 0x04 };

        _snapshot.Delete(key1);
        Assert.IsNull(_snapshot.TryGet(key1));

        // Both Store and Snapshot can not get the value that are cached in the snapshot
        _snapshot.Put(key1, value1);
        // After commit the snapshot, the value can be get from the store but still can not get from the snapshot
        // But can get the value from a new snapshot
        _snapshot.Commit();
        var snapshot2 = _memoryStore.GetSnapshot();
        CollectionAssert.AreEqual(value1, _memoryStore.TryGet(key1));
        Assert.IsNull(_snapshot.TryGet(key1));
        CollectionAssert.AreEqual(value1, snapshot2.TryGet(key1));

        Assert.IsFalse(_snapshot.TryGet(key1, out var value2));

        Assert.IsTrue(snapshot2.TryGet(key1, out value2));
        CollectionAssert.AreEqual(value1, value2);

        Assert.IsTrue(_memoryStore.TryGet(key1, out value2));
        CollectionAssert.AreEqual(value1, value2);

        _snapshot.Delete(key1);

        // Deleted value can not being found from the snapshot but can still get from the store and snapshot2
        Assert.IsFalse(_snapshot.Contains(key1));
        Assert.IsTrue(_memoryStore.Contains(key1));
        Assert.IsTrue(snapshot2.Contains(key1));

        _snapshot.Commit();

        // After commit the snapshot, the value can not be found from the store, but can be found in snapshots
        // Cause snapshot1 or store can not change the status of snapshot2.
        Assert.IsFalse(_memoryStore.Contains(key1));
        Assert.IsTrue(snapshot2.Contains(key1));
        Assert.IsFalse(_snapshot.Contains(key1));

        // Add value via snapshot2 will not affect snapshot1 at all
        snapshot2.Put(key1, value1);
        snapshot2.Commit();
        Assert.IsNull(_snapshot.TryGet(key1));
        CollectionAssert.AreEqual(value1, snapshot2.TryGet(key1));
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// UT_MemorySnapshot.cs file belongs to the neo project and is free
4	// software distributed under the MIT software license, see the
5	// accompanying file LICENSE in the main directory of the
6	// repository or http://www.opensource.org/licenses/mit-license.php
7	// for more details.
8	//
9	// Redistribution and use in source and binary forms with or without
10	// modifications are permitted.
11
12	using Microsoft.VisualStudio.TestTools.UnitTesting;
13	using Neo.Persistence;
14	using System.Linq;
15
16	namespace Neo.UnitTests.Persistence;
17
18	[TestClass]
19	public class UT_MemorySnapshot
20	{
21	private MemoryStore _memoryStore;
22	private MemorySnapshot _snapshot;
23
24	[TestInitialize]
25	public void Setup()
26	{	×
27	_memoryStore = new MemoryStore();	×
28	_snapshot = _memoryStore.GetSnapshot() as MemorySnapshot;	×
29	}	×
30
31	[TestCleanup]
32	public void CleanUp()
33	{	×
34	_memoryStore.Reset();	×
35	}	×
36
37	[TestMethod]
38	public void SingleSnapshotTest()
39	{	×
40	var key1 = new byte[] { 0x01, 0x02 };	×
41	var value1 = new byte[] { 0x03, 0x04 };	×
42
43	_snapshot.Delete(key1);	×
44	Assert.IsNull(_snapshot.TryGet(key1));	×
45
46	// Both Store and Snapshot can not get the value that are cached in the snapshot
47	_snapshot.Put(key1, value1);	×
48	Assert.IsNull(_snapshot.TryGet(key1));	×
49	Assert.IsNull(_memoryStore.TryGet(key1));	×
50
51	_snapshot.Commit();	×
52
53	// After commit the snapshot, the value can be get from the store but still can not get from the snapshot
54	CollectionAssert.AreEqual(value1, _memoryStore.TryGet(key1));	×
55	Assert.IsNull(_snapshot.TryGet(key1));	×
56
57	_snapshot.Delete(key1);	×
58
59	// Deleted value can not be found from the snapshot but can still get from the store
60	// This is because snapshot has no key1 at all.
61	Assert.IsFalse(_snapshot.Contains(key1));	×
62	Assert.IsTrue(_memoryStore.Contains(key1));	×
63
64	_snapshot.Commit();	×
65
66	// After commit the snapshot, the value can not be found from the store
67	Assert.IsFalse(_memoryStore.Contains(key1));	×
68
69	// Test seek in order
70	_snapshot.Put([0x00, 0x00, 0x04], [0x04]);	×
71	_snapshot.Put([0x00, 0x00, 0x00], [0x00]);	×
72	_snapshot.Put([0x00, 0x00, 0x01], [0x01]);	×
73	_snapshot.Put([0x00, 0x00, 0x02], [0x02]);	×
74	_snapshot.Put([0x00, 0x00, 0x03], [0x03]);	×
75
76	// Can not get anything from the snapshot
77	var entries = _snapshot.Seek([0x00, 0x00, 0x02]).ToArray();	×
78	Assert.AreEqual(0, entries.Length);	×
79	}	×
80
81	[TestMethod]
82	public void MultiSnapshotTest()
83	{	×
84	var key1 = new byte[] { 0x01, 0x02 };	×
85	var value1 = new byte[] { 0x03, 0x04 };	×
86
87	_snapshot.Delete(key1);	×
88	Assert.IsNull(_snapshot.TryGet(key1));	×
89
90	// Both Store and Snapshot can not get the value that are cached in the snapshot
91	_snapshot.Put(key1, value1);	×
92	// After commit the snapshot, the value can be get from the store but still can not get from the snapshot
93	// But can get the value from a new snapshot
94	_snapshot.Commit();	×
95	var snapshot2 = _memoryStore.GetSnapshot();	×
96	CollectionAssert.AreEqual(value1, _memoryStore.TryGet(key1));	×
97	Assert.IsNull(_snapshot.TryGet(key1));	×
98	CollectionAssert.AreEqual(value1, snapshot2.TryGet(key1));	×
99
NEW 100	Assert.IsFalse(_snapshot.TryGet(key1, out var value2));	×
101
NEW 102	Assert.IsTrue(snapshot2.TryGet(key1, out value2));	×
NEW 103	CollectionAssert.AreEqual(value1, value2);	×
104
NEW 105	Assert.IsTrue(_memoryStore.TryGet(key1, out value2));	×
NEW 106	CollectionAssert.AreEqual(value1, value2);	×
107
UNCOV 108	_snapshot.Delete(key1);	×
109
110	// Deleted value can not being found from the snapshot but can still get from the store and snapshot2
111	Assert.IsFalse(_snapshot.Contains(key1));	×
112	Assert.IsTrue(_memoryStore.Contains(key1));	×
113	Assert.IsTrue(snapshot2.Contains(key1));	×
114
115	_snapshot.Commit();	×
116
117	// After commit the snapshot, the value can not be found from the store, but can be found in snapshots
118	// Cause snapshot1 or store can not change the status of snapshot2.
119	Assert.IsFalse(_memoryStore.Contains(key1));	×
120	Assert.IsTrue(snapshot2.Contains(key1));	×
121	Assert.IsFalse(_snapshot.Contains(key1));	×
122
123	// Add value via snapshot2 will not affect snapshot1 at all
124	snapshot2.Put(key1, value1);	×
125	snapshot2.Commit();	×
126	Assert.IsNull(_snapshot.TryGet(key1));	×
127	CollectionAssert.AreEqual(value1, snapshot2.TryGet(key1));	×
128	}	×
129	}

neo-project / neo / 11323194607

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous