diff --git a/src/WebApi.OutputCache.Core/Constants.cs b/src/WebApi.OutputCache.Core/Constants.cs
index 139b0b7..8553bcd 100644
--- a/src/WebApi.OutputCache.Core/Constants.cs
+++ b/src/WebApi.OutputCache.Core/Constants.cs
@@ -5,5 +5,7 @@ public sealed class Constants
         public const string ContentTypeKey = ":response-ct";
         public const string EtagKey = ":response-etag";
         public const string GenerationTimestampKey = ":response-generationtimestamp";
+        public const string CustomHeaders = ":custom-headers";
+        public const string CustomContentHeaders = ":custom-content-headers";
     }
 }
diff --git a/src/WebApi.OutputCache.V2/CacheOutputAttribute.cs b/src/WebApi.OutputCache.V2/CacheOutputAttribute.cs
index f995dc9..fc79e71 100644
--- a/src/WebApi.OutputCache.V2/CacheOutputAttribute.cs
+++ b/src/WebApi.OutputCache.V2/CacheOutputAttribute.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
@@ -81,6 +82,11 @@ public int SharedTimeSpan
         /// </summary>
         public Type CacheKeyGenerator { get; set; }
 
+        /// <summary>
+        /// Comma seperated list of HTTP headers to cache
+        /// </summary>
+        public string IncludeCustomHeaders { get; set; }
+
         /// <summary>
         /// If set to something else than an empty string, this value will always be used for the Content-Type header, regardless of content negotiation.
         /// </summary>
@@ -185,6 +191,9 @@ public override void OnActionExecuting(HttpActionContext actionContext)
 
             if (!_webApiCache.Contains(cachekey)) return;
 
+            var responseHeaders = _webApiCache.Get<Dictionary<string, List<string>>>(cachekey + Constants.CustomHeaders);
+            var responseContentHeaders = _webApiCache.Get<Dictionary<string, List<string>>>(cachekey + Constants.CustomContentHeaders);
+
             if (actionContext.Request.Headers.IfNoneMatch != null)
             {
                 var etag = _webApiCache.Get<string>(cachekey + Constants.EtagKey);
@@ -194,7 +203,8 @@ public override void OnActionExecuting(HttpActionContext actionContext)
                     {
                         var time = CacheTimeQuery.Execute(DateTime.Now);
                         var quickResponse = actionContext.Request.CreateResponse(HttpStatusCode.NotModified);
-                        
+                        if (responseHeaders != null) AddCustomCachedHeaders(quickResponse, responseHeaders, responseContentHeaders);
+
                         SetEtag(quickResponse, etag);
                         ApplyCacheHeaders(quickResponse, time);
                         actionContext.Response = quickResponse;
@@ -225,6 +235,8 @@ public override void OnActionExecuting(HttpActionContext actionContext)
             var responseEtag = _webApiCache.Get<string>(cachekey + Constants.EtagKey);
             if (responseEtag != null) SetEtag(actionContext.Response,  responseEtag);
 
+            if (responseHeaders != null) AddCustomCachedHeaders(actionContext.Response, responseHeaders, responseContentHeaders);
+
             var cacheTime = CacheTimeQuery.Execute(DateTime.Now);
             ApplyCacheHeaders(actionContext.Response, cacheTime, contentGenerationTimestamp);
         }
@@ -275,10 +287,27 @@ public override async Task OnActionExecutedAsync(HttpActionExecutedContext actio
                                         etag,
                                         cacheTime.AbsoluteExpiration, baseKey);
 
-
                         _webApiCache.Add(cachekey + Constants.GenerationTimestampKey,
                                         actionExecutionTimestamp.ToString(),
                                         cacheTime.AbsoluteExpiration, baseKey);
+
+                        if (!String.IsNullOrEmpty(IncludeCustomHeaders))
+                        {
+                            // convert to dictionary of lists to ensure thread safety if implementation of IEnumerable is changed
+                            var headers = actionExecutedContext.Response.Headers.Where(h => IncludeCustomHeaders.Contains(h.Key))
+                                .ToDictionary(x => x.Key, x => x.Value.ToList());
+
+                            var contentHeaders = actionExecutedContext.Response.Content.Headers.Where(h => IncludeCustomHeaders.Contains(h.Key))
+                                .ToDictionary(x => x.Key, x => x.Value.ToList());
+
+                            _webApiCache.Add(cachekey + Constants.CustomHeaders,
+                                            headers,
+                                            cacheTime.AbsoluteExpiration, baseKey);
+
+                            _webApiCache.Add(cachekey + Constants.CustomContentHeaders,
+                                            contentHeaders,
+                                            cacheTime.AbsoluteExpiration, baseKey);
+                        }
                     }
                 }
             }
@@ -311,6 +340,25 @@ protected virtual void ApplyCacheHeaders(HttpResponseMessage response, CacheTime
             }
         }
 
+        protected virtual void AddCustomCachedHeaders(HttpResponseMessage response, Dictionary<string, List<string>> headers, Dictionary<string, List<string>> contentHeaders)
+        {
+            foreach (var headerKey in headers.Keys)
+            {
+                foreach (var headerValue in headers[headerKey])
+                {
+                    response.Headers.Add(headerKey, headerValue);
+                }
+            }
+
+            foreach (var headerKey in contentHeaders.Keys)
+            {
+                foreach (var headerValue in contentHeaders[headerKey])
+                {
+                    response.Content.Headers.Add(headerKey, headerValue);
+                }
+            }
+        }
+
         protected virtual string CreateEtag(HttpActionExecutedContext actionExecutedContext, string cachekey, CacheTime cacheTime)
         {
             return Guid.NewGuid().ToString();
diff --git a/test/WebApi.OutputCache.Core.Tests/WebApi.OutputCache.Core.Tests.csproj b/test/WebApi.OutputCache.Core.Tests/WebApi.OutputCache.Core.Tests.csproj
index 7739329..21df54c 100644
--- a/test/WebApi.OutputCache.Core.Tests/WebApi.OutputCache.Core.Tests.csproj
+++ b/test/WebApi.OutputCache.Core.Tests/WebApi.OutputCache.Core.Tests.csproj
@@ -56,6 +56,9 @@
       <Name>WebApi.OutputCache.Core</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/test/WebApi.OutputCache.V2.Tests/ClientSideTests.cs b/test/WebApi.OutputCache.V2.Tests/ClientSideTests.cs
index 132fa5f..1dc29e2 100644
--- a/test/WebApi.OutputCache.V2.Tests/ClientSideTests.cs
+++ b/test/WebApi.OutputCache.V2.Tests/ClientSideTests.cs
@@ -122,8 +122,8 @@ public void maxage_private_true_headers_correct()
         public void maxage_mustrevalidate_headers_correct_with_cacheuntil()
         {
             var client = new HttpClient(_server);
-            var result = client.GetAsync(_url + "Get_until25012015_1700").Result;
-            var clientTimeSpanSeconds = new SpecificTime(2019, 01, 25, 17, 0, 0).Execute(DateTime.Now).ClientTimeSpan.TotalSeconds;
+            var result = client.GetAsync(_url + "Get_until25012100_1700").Result;
+            var clientTimeSpanSeconds = new SpecificTime(2100, 01, 25, 17, 0, 0).Execute(DateTime.Now).ClientTimeSpan.TotalSeconds;
             var resultCacheControlSeconds = ((TimeSpan) result.Headers.CacheControl.MaxAge).TotalSeconds;
             Assert.IsTrue(Math.Round(clientTimeSpanSeconds - resultCacheControlSeconds) == 0);
             Assert.IsFalse(result.Headers.CacheControl.MustRevalidate);
diff --git a/test/WebApi.OutputCache.V2.Tests/CustomHeadersContent.cs b/test/WebApi.OutputCache.V2.Tests/CustomHeadersContent.cs
new file mode 100644
index 0000000..1d30050
--- /dev/null
+++ b/test/WebApi.OutputCache.V2.Tests/CustomHeadersContent.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Formatting;
+using System.Net.Http.Headers;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using System.Web.Http.Results;
+
+namespace WebApi.OutputCache.V2.Tests
+{
+    public class CustomHeadersContent<T> : OkNegotiatedContentResult<T>
+    {
+        public string ContentDisposition { get; set; }
+
+        public List<string> ContentEncoding { get; set; }
+
+        public string RequestHeader1 { get; set; }
+
+        public List<string> RequestHeader2 { get; set; }
+
+        public CustomHeadersContent(T content, ApiController controller)
+            : base(content, controller) { }
+
+        public CustomHeadersContent(T content, IContentNegotiator contentNegotiator, HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
+            : base(content, contentNegotiator, request, formatters) { }
+
+        public override async Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
+        {
+            HttpResponseMessage response = await base.ExecuteAsync(cancellationToken);
+
+            if (!string.IsNullOrWhiteSpace(ContentDisposition))
+            {
+                response.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue(ContentDisposition);
+            }
+            if (ContentEncoding != null)
+            {
+                foreach (var contentEncoding in ContentEncoding)
+                {
+                    response.Content.Headers.ContentEncoding.Add(contentEncoding);
+                }
+            }
+
+            if (!string.IsNullOrWhiteSpace(RequestHeader1))
+            {
+                response.Headers.Add("RequestHeader1", RequestHeader1);
+            }
+            if (RequestHeader2 != null)
+            {
+                foreach (var requestHeader2Value in RequestHeader2)
+                {
+                    response.Headers.Add("RequestHeader2", requestHeader2Value);
+                }
+            }
+
+            return response;
+        }
+    }
+}
diff --git a/test/WebApi.OutputCache.V2.Tests/CustomHeadersTests.cs b/test/WebApi.OutputCache.V2.Tests/CustomHeadersTests.cs
new file mode 100644
index 0000000..00f1175
--- /dev/null
+++ b/test/WebApi.OutputCache.V2.Tests/CustomHeadersTests.cs
@@ -0,0 +1,176 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Security.Principal;
+using System.Threading;
+using System.Web.Http;
+using Autofac;
+using Autofac.Integration.WebApi;
+using Moq;
+using NUnit.Framework;
+using WebApi.OutputCache.Core;
+using WebApi.OutputCache.Core.Cache;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace WebApi.OutputCache.V2.Tests
+{
+    [TestFixture]
+    public class CustomHeadersTests
+    {
+        private HttpServer _server;
+        private string _url = "http://www.strathweb.com/api/customheaders/";
+        private IApiOutputCache _cache;
+
+        [SetUp]
+        public void init()
+        {
+            Thread.CurrentPrincipal = null;
+
+            _cache = new SimpleCacheForTests();
+
+            var conf = new HttpConfiguration();
+            var builder = new ContainerBuilder();
+            builder.RegisterInstance(_cache);
+
+            conf.DependencyResolver = new AutofacWebApiDependencyResolver(builder.Build());
+            conf.Routes.MapHttpRoute(
+                name: "DefaultApi",
+                routeTemplate: "api/{controller}/{action}/{id}",
+                defaults: new { id = RouteParameter.Optional }
+                );
+
+            _server = new HttpServer(conf);
+        }
+
+        [Test]
+        public void cache_custom_content_header() {
+            var client = new HttpClient(_server);
+            var req = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Custom_Content_Header");
+            var result = client.SendAsync(req).Result;
+
+            var req2 = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Custom_Content_Header");
+            var result2 = client.SendAsync(req2).Result;
+
+            Assert.That(result.Content.Headers.ContentDisposition.DispositionType, Is.EqualTo("attachment"));
+            Assert.That(result2.Content.Headers.ContentDisposition.DispositionType, Is.EqualTo("attachment"));
+        }
+
+        [Test]
+        public void cache_custom_content_header_with_multiply_values()
+        {
+            var client = new HttpClient(_server);
+            var req = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Custom_Content_Header_Multiply_Values");
+            var result = client.SendAsync(req).Result;
+
+            var req2 = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Custom_Content_Header_Multiply_Values");
+            var result2 = client.SendAsync(req2).Result;
+
+            Assert.That(result.Content.Headers.ContentEncoding.Count, Is.EqualTo(2));
+            Assert.That(result.Content.Headers.ContentEncoding.First(), Is.EqualTo("deflate"));
+            Assert.That(result.Content.Headers.ContentEncoding.Last(), Is.EqualTo("gzip"));
+
+            Assert.That(result2.Content.Headers.ContentEncoding.Count, Is.EqualTo(2));
+            Assert.That(result2.Content.Headers.ContentEncoding.First(), Is.EqualTo("deflate"));
+            Assert.That(result2.Content.Headers.ContentEncoding.Last(), Is.EqualTo("gzip"));
+        }
+
+        [Test]
+        public void cache_custom_response_header()
+        {
+            var client = new HttpClient(_server);
+            var req = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Custom_Response_Header");
+            var result = client.SendAsync(req).Result;
+
+            var req2 = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Custom_Response_Header");
+            var result2 = client.SendAsync(req2).Result;
+
+            Assert.That(result.Headers.GetValues("RequestHeader1").First(), Is.EqualTo("value1"));
+            Assert.That(result2.Headers.GetValues("RequestHeader1").First(), Is.EqualTo("value1"));
+        }
+
+        [Test]
+        public void cache_custom_response_header_with_multiply_values()
+        {
+            var client = new HttpClient(_server);
+            var req = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Custom_Response_Header_Multiply_Values");
+            var result = client.SendAsync(req).Result;
+
+            var req2 = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Custom_Response_Header_Multiply_Values");
+            var result2 = client.SendAsync(req2).Result;
+
+            Assert.That(result.Headers.GetValues("RequestHeader2").Count(), Is.EqualTo(2));
+            Assert.That(result.Headers.GetValues("RequestHeader2").First(), Is.EqualTo("value2"));
+            Assert.That(result.Headers.GetValues("RequestHeader2").Last(), Is.EqualTo("value3"));
+
+            Assert.That(result2.Headers.GetValues("RequestHeader2").Count(), Is.EqualTo(2));
+            Assert.That(result2.Headers.GetValues("RequestHeader2").First(), Is.EqualTo("value2"));
+            Assert.That(result2.Headers.GetValues("RequestHeader2").Last(), Is.EqualTo("value3"));
+        }
+
+        [Test]
+        public void cache_multiply_custom_headers()
+        {
+            var client = new HttpClient(_server);
+            var req = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Multiply_Custom_Headers");
+            var result = client.SendAsync(req).Result;
+
+            var req2 = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Multiply_Custom_Headers");
+            var result2 = client.SendAsync(req2).Result;
+
+            Assert.That(result.Content.Headers.ContentDisposition.DispositionType, Is.EqualTo("attachment"));
+            Assert.That(result.Content.Headers.ContentEncoding.Count, Is.EqualTo(2));
+            Assert.That(result.Content.Headers.ContentEncoding.First(), Is.EqualTo("deflate"));
+            Assert.That(result.Content.Headers.ContentEncoding.Last(), Is.EqualTo("gzip"));
+            Assert.That(result.Headers.GetValues("RequestHeader1").First(), Is.EqualTo("value1"));
+            Assert.That(result.Headers.GetValues("RequestHeader2").Count(), Is.EqualTo(2));
+            Assert.That(result.Headers.GetValues("RequestHeader2").First(), Is.EqualTo("value2"));
+            Assert.That(result.Headers.GetValues("RequestHeader2").Last(), Is.EqualTo("value3"));
+
+            Assert.That(result2.Content.Headers.ContentDisposition.DispositionType, Is.EqualTo("attachment"));
+            Assert.That(result2.Content.Headers.ContentEncoding.Count, Is.EqualTo(2));
+            Assert.That(result2.Content.Headers.ContentEncoding.First(), Is.EqualTo("deflate"));
+            Assert.That(result2.Content.Headers.ContentEncoding.Last(), Is.EqualTo("gzip"));
+            Assert.That(result2.Headers.GetValues("RequestHeader1").First(), Is.EqualTo("value1"));
+            Assert.That(result2.Headers.GetValues("RequestHeader2").Count(), Is.EqualTo(2));
+            Assert.That(result2.Headers.GetValues("RequestHeader2").First(), Is.EqualTo("value2"));
+            Assert.That(result2.Headers.GetValues("RequestHeader2").Last(), Is.EqualTo("value3"));
+        }
+
+        [Test]
+        public void cache_part_of_custom_headers()
+        {
+            var client = new HttpClient(_server);
+            var req = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Part_Of_Custom_Headers");
+            var result = client.SendAsync(req).Result;
+
+            var req2 = new HttpRequestMessage(HttpMethod.Get, _url + "Cache_Part_Of_Custom_Headers");
+            var result2 = client.SendAsync(req2).Result;
+
+            Assert.That(result.Content.Headers.ContentDisposition.DispositionType, Is.EqualTo("attachment"));
+            Assert.That(result.Content.Headers.ContentEncoding.Count, Is.EqualTo(2));
+            Assert.That(result.Content.Headers.ContentEncoding.First(), Is.EqualTo("deflate"));
+            Assert.That(result.Content.Headers.ContentEncoding.Last(), Is.EqualTo("gzip"));
+            Assert.That(result.Headers.GetValues("RequestHeader1").First(), Is.EqualTo("value1"));
+            Assert.That(result.Headers.GetValues("RequestHeader2").Count(), Is.EqualTo(2));
+            Assert.That(result.Headers.GetValues("RequestHeader2").First(), Is.EqualTo("value2"));
+            Assert.That(result.Headers.GetValues("RequestHeader2").Last(), Is.EqualTo("value3"));
+
+            Assert.That(result2.Content.Headers.ContentDisposition, Is.Null);
+            Assert.That(result2.Content.Headers.ContentEncoding.Count, Is.EqualTo(2));
+            Assert.That(result2.Content.Headers.ContentEncoding.First(), Is.EqualTo("deflate"));
+            Assert.That(result2.Content.Headers.ContentEncoding.Last(), Is.EqualTo("gzip"));
+
+            IEnumerable<string> headerValue = null;
+            Assert.That(result2.Headers.TryGetValues("RequestHeader1", out headerValue), Is.False);
+            Assert.That(result2.Headers.TryGetValues("RequestHeader2", out headerValue), Is.False);
+        }
+
+        [TearDown]
+        public void fixture_dispose()
+        {
+            if (_server != null) _server.Dispose();
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/WebApi.OutputCache.V2.Tests/MemoryCacheForTests.cs b/test/WebApi.OutputCache.V2.Tests/MemoryCacheForTests.cs
new file mode 100644
index 0000000..bd7431e
--- /dev/null
+++ b/test/WebApi.OutputCache.V2.Tests/MemoryCacheForTests.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using WebApi.OutputCache.Core.Cache;
+
+namespace WebApi.OutputCache.V2.Tests
+{
+    public class SimpleCacheForTests : IApiOutputCache
+    {
+        private Dictionary<string, object> _cachedItems;
+
+        public SimpleCacheForTests() {
+            _cachedItems = new Dictionary<string, object>();
+        }
+
+        public virtual void RemoveStartsWith(string key)
+        {
+            throw new NotImplementedException();
+        }
+
+        public virtual T Get<T>(string key) where T : class
+        {
+            var o = _cachedItems[key] as T;
+            return o;
+        }
+
+        [Obsolete("Use Get<T> instead")]
+        public virtual object Get(string key)
+        {
+            return _cachedItems[key];
+        }
+
+        public virtual void Remove(string key)
+        {
+            _cachedItems.Remove(key);
+        }
+
+        public virtual bool Contains(string key)
+        {
+            return _cachedItems.ContainsKey(key);
+        }
+
+        public virtual void Add(string key, object o, DateTimeOffset expiration, string dependsOnKey = null)
+        {
+            _cachedItems.Add(key, o);
+        }
+
+        public virtual IEnumerable<string> AllKeys
+        {
+            get
+            {
+                return _cachedItems.Keys;
+            }
+        }
+    }
+}
diff --git a/test/WebApi.OutputCache.V2.Tests/TestControllers/CustomHeadersController.cs b/test/WebApi.OutputCache.V2.Tests/TestControllers/CustomHeadersController.cs
new file mode 100644
index 0000000..4d9fc32
--- /dev/null
+++ b/test/WebApi.OutputCache.V2.Tests/TestControllers/CustomHeadersController.cs
@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web.Http;
+
+namespace WebApi.OutputCache.V2.Tests.TestControllers
+{
+    public class CustomHeadersController : ApiController
+    {
+        [HttpGet]
+        [CacheOutput(ClientTimeSpan = 100, ServerTimeSpan = 100, IncludeCustomHeaders = "Content-Disposition")]
+        public IHttpActionResult Cache_Custom_Content_Header()
+        {
+            var result = new CustomHeadersContent<string>("test", this)
+            {
+                ContentDisposition = "attachment"
+            };
+
+            return result;
+        }
+
+        [HttpGet]
+        [CacheOutput(ClientTimeSpan = 100, ServerTimeSpan = 100, IncludeCustomHeaders = "Content-Encoding")]
+        public IHttpActionResult Cache_Custom_Content_Header_Multiply_Values()
+        {
+            var result = new CustomHeadersContent<string>("test", this)
+            {
+                ContentEncoding = new List<string> { "deflate", "gzip" }
+            };
+
+            return result;
+        }
+
+        [HttpGet]
+        [CacheOutput(ClientTimeSpan = 100, ServerTimeSpan = 100, IncludeCustomHeaders = "RequestHeader1")]
+        public IHttpActionResult Cache_Custom_Response_Header()
+        {
+            var result = new CustomHeadersContent<string>("test", this)
+            {
+                RequestHeader1 = "value1"
+            };
+
+            return result;
+        }
+
+        [HttpGet]
+        [CacheOutput(ClientTimeSpan = 100, ServerTimeSpan = 100, IncludeCustomHeaders = "RequestHeader2")]
+        public IHttpActionResult Cache_Custom_Response_Header_Multiply_Values()
+        {
+            var result = new CustomHeadersContent<string>("test", this)
+            {
+                RequestHeader2 = new List<string> { "value2", "value3" }
+            };
+
+            return result;
+        }
+
+        [HttpGet]
+        [CacheOutput(ClientTimeSpan = 100, ServerTimeSpan = 100, IncludeCustomHeaders = "Content-Disposition,Content-Encoding,RequestHeader2,RequestHeader1")]
+        public IHttpActionResult Cache_Multiply_Custom_Headers()
+        {
+            var result = new CustomHeadersContent<string>("test", this)
+            {
+                ContentDisposition = "attachment",
+                ContentEncoding = new List<string> { "deflate", "gzip" },
+                RequestHeader1 = "value1",
+                RequestHeader2 = new List<string> { "value2", "value3" }
+            };
+
+            return result;
+        }
+
+        [HttpGet]
+        [CacheOutput(ClientTimeSpan = 100, ServerTimeSpan = 100, IncludeCustomHeaders = "Content-Encoding,NotExistingHeader")]
+        public IHttpActionResult Cache_Part_Of_Custom_Headers()
+        {
+            var result = new CustomHeadersContent<string>("test", this)
+            {
+                ContentDisposition = "attachment",
+                ContentEncoding = new List<string> { "deflate", "gzip" },
+                RequestHeader1 = "value1",
+                RequestHeader2 = new List<string> { "value2", "value3" }
+            };
+
+            return result;
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/WebApi.OutputCache.V2.Tests/TestControllers/SampleController.cs b/test/WebApi.OutputCache.V2.Tests/TestControllers/SampleController.cs
index 69c1f20..9bbe49a 100644
--- a/test/WebApi.OutputCache.V2.Tests/TestControllers/SampleController.cs
+++ b/test/WebApi.OutputCache.V2.Tests/TestControllers/SampleController.cs
@@ -1,4 +1,5 @@
-using System.Net;
+using System.Collections.Generic;
+using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Web.Http;
@@ -74,8 +75,8 @@ public string Get_s50_exclude_true(int id)
             return "test" + id;
         }
 
-        [CacheOutputUntil(2019,01,25,17,00)]
-        public string Get_until25012015_1700()
+        [CacheOutputUntil(2100, 01,25,17,00)]
+        public string Get_until25012100_1700()
         {
             return "test";
         }
diff --git a/test/WebApi.OutputCache.V2.Tests/WebApi.OutputCache.V2.Tests.csproj b/test/WebApi.OutputCache.V2.Tests/WebApi.OutputCache.V2.Tests.csproj
index 5712bbe..32837ec 100644
--- a/test/WebApi.OutputCache.V2.Tests/WebApi.OutputCache.V2.Tests.csproj
+++ b/test/WebApi.OutputCache.V2.Tests/WebApi.OutputCache.V2.Tests.csproj
@@ -84,6 +84,8 @@
     <Compile Include="ConnegTests.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="CustomHeadersContent.cs" />
+    <Compile Include="MemoryCacheForTests.cs" />
     <Compile Include="PerUserCacheKeyGeneratorTests.cs" />
     <Compile Include="DefaultCacheKeyGeneratorTests.cs" />
     <Compile Include="InlineInvalidateTests.cs">
@@ -92,6 +94,7 @@
     <Compile Include="InvalidateTests.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="CustomHeadersTests.cs" />
     <Compile Include="ServerSideTests.cs">
       <SubType>Code</SubType>
     </Compile>
@@ -99,6 +102,7 @@
     <Compile Include="TestControllers\AutoInvalidateWithTypeController.cs" />
     <Compile Include="TestControllers\CacheKeyController.cs" />
     <Compile Include="TestControllers\CacheKeyGenerationController.cs" />
+    <Compile Include="TestControllers\CustomHeadersController.cs" />
     <Compile Include="TestControllers\IgnoreController.cs" />
     <Compile Include="TestControllers\InlineInvalidateController.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -120,6 +124,9 @@
       <Name>WebApi2.OutputCache</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\nuget.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.