public void MetadataReferenceCache_CachesObjectCorrectly()
        {
            //// Arrange
            var objectToCache = new ObjectCacheTest();

            var cache = new MetadataReferenceCache();

            //// Act 1
            var stringCachedBefore = cache.GetString(ObjectCacheTest.TestStringCachedBefore);
            var stringCachedOnce   = ObjectCacheTest.TestStringCachedOnce;

            //// Assert 1

            // Assert that all equal objects that will be cached should be:
            // 1 - Equal.
            // 2 - Not the same reference.

            // Strings
            Assert.NotSame(objectToCache.StringCachedBefore, stringCachedBefore);
            Assert.Equal(objectToCache.StringCachedBefore, stringCachedBefore);

            Assert.NotSame(objectToCache.StringCachedDuring1, objectToCache.StringCachedDuring2);
            Assert.Equal(objectToCache.StringCachedDuring1, objectToCache.StringCachedDuring2);

            Assert.NotSame(objectToCache.StringCachedOnce, stringCachedOnce);
            Assert.Equal(objectToCache.StringCachedOnce, stringCachedOnce);

            // Versions
            Assert.NotSame(objectToCache.VersionCachedDuring1, objectToCache.VersionCachedDuring2);
            Assert.Equal(objectToCache.VersionCachedDuring1, objectToCache.VersionCachedDuring2);

            //// Act 2
            var cachedObject           = cache.GetObject(objectToCache);
            var cachedStringCachedOnce = cache.GetString(stringCachedOnce);

            //// Assert 2

            // Assert that all equal objects that were cached should be:
            // 1 - Equal to their original value.
            // 2 - The same reference.

            // Strings
            Assert.Same(objectToCache.StringCachedBefore, stringCachedBefore);
            Assert.Equal(objectToCache.StringCachedBefore, ObjectCacheTest.TestStringCachedBefore);

            Assert.Same(objectToCache.StringCachedDuring1, objectToCache.StringCachedDuring2);
            Assert.Equal(objectToCache.StringCachedDuring1, ObjectCacheTest.TestStringCachedDuring);

            Assert.Same(objectToCache.StringCachedOnce, cachedStringCachedOnce);
            Assert.Equal(objectToCache.StringCachedOnce, ObjectCacheTest.TestStringCachedOnce);

            // Check that uncached fields are untouched.
            Assert.Equal(objectToCache.DateTimeNeverCached, ObjectCacheTest.TestDateTimeNeverCached);
        }
        public void AssertMetadataReferenceCache_CachesStringMethodCorrectly()
        {
            // Arrange
            var objectToCache = new ObjectCacheTest();
            var cache         = new MetadataReferenceCache();

            // Act
            var cachedObject = cache.GetObject(objectToCache);

            // Assert
            Assert.True(ReferenceEquals(cachedObject, objectToCache));
            Assert.Equal(objectToCache.StringCachedBefore, ObjectCacheTest.TestStringCachedBefore);
            Assert.Equal(cache.CachableMethodTypes.Count(), 1);
            Assert.Equal(cache.CachableMethodTypes.Single().Key.Name, "MetadataReferenceCache");
            Assert.Equal(cache.CachableMethodTypes.Single().Value.Name, "GetString");
        }