private static async Task <CurrentTzdbProvider> DownloadAsync()
{
using (var client = new HttpClient())
{
var latest = new Uri((await client.GetStringAsync("http://nodatime.org/tzdb/latest.txt")).TrimEnd());
var fileName = latest.Segments.Last();
var path = Path.Combine(Path.GetTempPath(), fileName);
if (!File.Exists(path))
{
using (var httpStream = await client.GetStreamAsync(latest))
using (var fileStream = File.Create(path))
{
await httpStream.CopyToAsync(fileStream);
}
}
using (var fileStream = File.OpenRead(path))
{
var source = TzdbDateTimeZoneSource.FromStream(fileStream);
var provider = new DateTimeZoneCache(source);
return(new CurrentTzdbProvider(provider, source.Aliases));
}
}
}
public void NullIdRejected()
{
var provider = new DateTimeZoneCache(new TestDateTimeZoneSource("Test1", "Test2"));
// GetType call just to avoid trying to use a property as a statement...
Assert.Throws <ArgumentNullException>(() => provider[null].GetType());
}
public void InvalidSource_ReturnsNullForAdvertisedId()
{
var source = new NullReturningTestDateTimeZoneSource("foo", "bar");
var cache = new DateTimeZoneCache(source);
Assert.Throws <InvalidDateTimeZoneSourceException>(() => cache.GetZoneOrNull("foo"));
}
public void GetSystemDefault_SourceReturnsNullId()
{
var source = new NullReturningTestDateTimeZoneSource("foo", "bar");
var cache = new DateTimeZoneCache(source);
Assert.Throws <DateTimeZoneNotFoundException>(() => cache.GetSystemDefault());
}
public void UtcIsNotReturnedInIdsIfNotAdvertisedByProvider()
{
var source = new TestDateTimeZoneSource("Test1", "Test2");
var provider = new DateTimeZoneCache(source);
Assert.False(provider.Ids.Contains(DateTimeZone.UtcId));
}
public void ProviderReturnsBclDateTimeZoneForAllAdvertisedIds()
{
var source = new BclDateTimeZoneSource();
var provider = new DateTimeZoneCache(source);
var nonBclZones = provider.Ids.Select(id => provider[id]).Where(zone => !(zone is BclDateTimeZone));
Assert.IsEmpty(nonBclZones);
}
public void SourceIsNotAskedForUnknownIds()
{
var source = new TestDateTimeZoneSource("Test1", "Test2");
var provider = new DateTimeZoneCache(source);
Assert.Throws <DateTimeZoneNotFoundException>(() => { var ignored = provider["Unknown"]; });
Assert.IsNull(source.LastRequestedId);
}
/// <summary>
/// Runs the compiler from the command line.
/// </summary>
/// <param name="arguments">The command line arguments. Each compiler defines its own.</param>
/// <returns>0 for success, non-0 for error.</returns>
private static async Task <int> Main(string[] arguments)
{
CompilerOptions options = new CompilerOptions();
ICommandLineParser parser = new CommandLineParser(new CommandLineParserSettings(Console.Error)
{
MutuallyExclusive = true
});
if (!parser.ParseArguments(arguments, options))
{
return(1);
}
var tzdbCompiler = new TzdbZoneInfoCompiler();
var tzdb = await tzdbCompiler.CompileAsync(options.SourceDirectoryName !);
tzdb.LogCounts();
if (options.ZoneId != null)
{
tzdb.GenerateDateTimeZone(options.ZoneId);
return(0);
}
var windowsZones = LoadWindowsZones(options, tzdb.Version);
if (options.WindowsOverride != null)
{
var overrideFile = CldrWindowsZonesParser.Parse(options.WindowsOverride);
windowsZones = MergeWindowsZones(windowsZones, overrideFile);
}
LogWindowsZonesSummary(windowsZones);
var writer = new TzdbStreamWriter();
using (var stream = CreateOutputStream(options))
{
writer.Write(tzdb, windowsZones, NameIdMappingSupport.StandardNameToIdMap, stream);
}
if (options.OutputFileName != null)
{
Console.WriteLine("Reading generated data and validating...");
var source = Read(options);
source.Validate();
}
if (options.XmlSchema is object)
{
Console.WriteLine($"Writing XML schema to {options.XmlSchema}");
var source = Read(options);
var provider = new DateTimeZoneCache(source);
XmlSerializationSettings.DateTimeZoneProvider = provider;
var settings = new XmlWriterSettings {
Indent = true, NewLineChars = "\n", Encoding = new UTF8Encoding()
};
using var xmlWriter = XmlWriter.Create(options.XmlSchema, settings);
XmlSchemaDefinition.NodaTimeXmlSchema.Write(xmlWriter);
}
return(0);
}
public void SourceIsNotAskedForUtcIfAdvertised()
{
var source = new TestDateTimeZoneSource("Test1", "Test2", "UTC");
var provider = new DateTimeZoneCache(source);
var zone = provider[DateTimeZone.UtcId];
Assert.IsNotNull(zone);
Assert.IsNull(source.LastRequestedId);
}
private static void CreateTextDump(TzdbDateTimeZoneSource source, string file)
{
var provider = new DateTimeZoneCache(source);
using (var writer = File.CreateText(file))
{
provider.Dump(writer);
}
}
public void VersionIdPassThrough()
{
var provider = new DateTimeZoneCache(new TestDateTimeZoneSource("Test1", "Test2")
{
VersionId = "foo"
});
Assert.AreEqual("foo", provider.VersionId);
}
public void FixedOffsetConsultsSourceWhenAdvertised()
{
string id = "UTC+05:30";
var source = new TestDateTimeZoneSource("Test1", "Test2", id);
var provider = new DateTimeZoneCache(source);
DateTimeZone zone = provider[id];
Assert.AreEqual(id, zone.Id);
Assert.AreEqual(id, source.LastRequestedId);
}
public void FixedOffsetZeroReturnsUtc()
{
string id = "UTC+00:00";
var source = new TestDateTimeZoneSource("Test1", "Test2", id);
var provider = new DateTimeZoneCache(source);
DateTimeZone zone = provider[id];
Assert.AreEqual(DateTimeZone.Utc, zone);
Assert.IsNull(source.LastRequestedId);
}
public void FixedOffsetSucceedsWithoutConsultingSourceWhenAdvertised()
{
string id = "UTC+05:30";
var source = new TestDateTimeZoneSource("Test1", "Test2", id);
var provider = new DateTimeZoneCache(source);
DateTimeZone zone = provider[id];
Assert.AreEqual(DateTimeZone.ForOffset(Offset.FromHoursAndMinutes(5, 30)), zone);
Assert.AreEqual(id, zone.Id);
Assert.IsNull(source.LastRequestedId);
}
public void FixedOffsetUncached()
{
string id = "UTC+05:26";
var source = new TestDateTimeZoneSource("Test1", "Test2");
var provider = new DateTimeZoneCache(source);
DateTimeZone zone1 = provider[id];
DateTimeZone zone2 = provider[id];
Assert.AreNotSame(zone1, zone2);
Assert.AreEqual(zone1, zone2);
}
private static int Main(string[] args)
{
Options options = new Options();
ICommandLineParser parser = new CommandLineParser(new CommandLineParserSettings(Console.Error));
if (!parser.ParseArguments(args, options))
{
return(1);
}
if (options.FromYear > options.ToYear)
{
Console.WriteLine("Error: 'from' year must be not be later than 'to' year");
return(1);
}
IDateTimeZoneSource source = TzdbDateTimeZoneSource.Default;
if (options.File != null)
{
using (var stream = File.OpenRead(options.File))
{
source = TzdbDateTimeZoneSource.FromStream(stream);
}
}
Console.WriteLine("TZDB version: {0}", source.VersionId);
var provider = new DateTimeZoneCache(source);
if (options.Zone != null)
{
var zone = provider.GetZoneOrNull(options.Zone);
if (zone == null)
{
Console.WriteLine("Unknown time zone: {0}", options.Zone);
return(1);
}
DumpZone(zone, Console.Out, options.FromYear, options.ToYear);
}
else
{
foreach (var id in provider.Ids)
{
DumpZone(provider[id], Console.Out, options.FromYear, options.ToYear);
}
}
return(0);
}
public void CachingForPresentValues()
{
var source = new TestDateTimeZoneSource("Test1", "Test2");
var provider = new DateTimeZoneCache(source);
var zone1a = provider["Test1"];
Assert.IsNotNull(zone1a);
Assert.AreEqual("Test1", source.LastRequestedId);
// Hit up the cache (and thus the source) for Test2
Assert.IsNotNull(provider["Test2"]);
Assert.AreEqual("Test2", source.LastRequestedId);
// Ask for Test1 again
var zone1b = provider["Test1"];
// We won't have consulted the source again
Assert.AreEqual("Test2", source.LastRequestedId);
Assert.AreSame(zone1a, zone1b);
}
private static ICollection <string> GetIanaTimeZoneIds()
{
var tempDir = Path.GetTempPath() + Path.GetRandomFileName().Substring(0, 8);
try
{
TestHelpers.DownloadLatestNodaTimeDataAsync(tempDir).Wait();
using (var stream = File.OpenRead(Directory.GetFiles(tempDir, "*.nzd")[0]))
{
var source = TzdbDateTimeZoneSource.FromStream(stream);
var provider = new DateTimeZoneCache(source);
return(provider.Ids.OrderBy(x => x).ToArray());
}
}
finally
{
Directory.Delete(tempDir, true);
}
}
public void FindLongestZoneId()
{
var source = new FakeDateTimeZoneSource.Builder
{
CreateZone("ABC"),
CreateZone("ABCA"),
CreateZone("ABCB"),
CreateZone("ABCBX"),
CreateZone("ABCD")
}.Build();
var provider = new DateTimeZoneCache(source);
var pattern = ZonedDateTimePattern.Create("z 'x'", CultureInfo.InvariantCulture, Resolvers.StrictResolver,
provider, NodaConstants.UnixEpoch.InUtc());
foreach (var id in provider.Ids)
{
var value = pattern.Parse($"{id} x").Value;
Assert.AreEqual(id, value.Zone.Id);
}
DateTimeZone CreateZone(string id) =>
new SingleTransitionDateTimeZone(NodaConstants.UnixEpoch - Duration.FromDays(1), Offset.FromHours(-1), Offset.FromHours(0), id);
}
static DateTimeHelper()
{
Cache = new DateTimeZoneCache(TzdbDateTimeZoneSource.Default);
}
public static IDateTimeZoneProvider LoadTzdb(string path = null)
{
IDateTimeZoneProvider provider;
// Load the time zone database from a file, if specified.
path = path ?? UtilityConfiguration.Active.TimeZoneDB;
if (!string.IsNullOrWhiteSpace(path))
{
Uri uri = new Uri(path.TrimStart('\\', '/'), UriKind.RelativeOrAbsolute);
if (!uri.IsAbsoluteUri)
{
uri = new Uri(UtilityExtensions.AppDomainBaseUri, uri);
}
// If the URI is a file, load it from the file system, otherwise download it
if (uri.IsFile)
{
path = uri.LocalPath;
if (!File.Exists(path))
{
throw new FileNotFoundException(
// ReSharper disable once AssignNullToNotNullAttribute
string.Format(Resources.TimeHelper_TimeHelper_TimeZoneDB_Not_Found, path));
}
try
{
using (FileStream stream = File.OpenRead(path))
// ReSharper disable once AssignNullToNotNullAttribute
provider = new DateTimeZoneCache(TzdbDateTimeZoneSource.FromStream(stream));
}
catch (Exception e)
{
// ReSharper disable once AssignNullToNotNullAttribute
throw new FileLoadException(
string.Format(Resources.TimeHelper_TimeHelper_TimeZoneDB_Failed, path),
e);
}
}
else
{
path = uri.AbsoluteUri;
try
{
// ReSharper disable AssignNullToNotNullAttribute
WebRequest request = WebRequest.Create(uri);
using (WebResponse response = request.GetResponse())
using (Stream stream = response.GetResponseStream())
provider = new DateTimeZoneCache(TzdbDateTimeZoneSource.FromStream(stream));
// ReSharper restore AssignNullToNotNullAttribute
}
catch (Exception e)
{
// ReSharper disable once AssignNullToNotNullAttribute
throw new FileLoadException(
string.Format(Resources.TimeHelper_TimeHelper_TimeZoneDB_Failed, path),
e);
}
}
}
// ReSharper disable once AssignNullToNotNullAttribute
else
{
// ReSharper disable once AssignNullToNotNullAttribute
provider = DateTimeZoneProviders.Tzdb;
}
Debug.Assert(provider != null);
return(provider);
}
// Usage:
// $ dotnet run -- [--help] [--start_year start] [--until_year until]
// [--nzd_file {file}]
// < zones.txt
// > validation_data.json
//
// Based on the equivalent Java program 'compare_java'.
//
static void Main(string[] args)
{
// Parse command line flags
int argc = args.Length;
int argi = 0;
/*
* if (argc == 0) {
* UsageAndExit(1);
* }
*/
string start = "2000";
string until = "2050";
string nzdFilePath = "";
while (argc > 0)
{
string arg0 = args[argi];
if ("--start_year".Equals(arg0))
{
{ argc--; argi++; arg0 = args[argi]; } // shift-left
start = arg0;
}
else if ("--until_year".Equals(arg0))
{
{ argc--; argi++; arg0 = args[argi]; } // shift-left
until = arg0;
}
else if ("--nzd_file".Equals(arg0))
{
{ argc--; argi++; arg0 = args[argi]; } // shift-left
nzdFilePath = arg0;
}
else if ("--help".Equals(arg0))
{
UsageAndExit(0);
break;
}
else if ("--".Equals(arg0))
{
break;
}
else if (arg0.StartsWith("-"))
{
Console.Error.WriteLine($"Unknown flag '{arg0}'");
UsageAndExit(1);
}
else if (!arg0.StartsWith("-"))
{
break;
}
{ argc--; argi++; } // shift-left
}
int startYear = int.Parse(start);
int untilYear = int.Parse(until);
// https://nodatime.org/3.0.x/userguide/tzdb
IDateTimeZoneProvider provider;
if (!string.IsNullOrEmpty(nzdFilePath))
{
// Read the TZDB file from disk.
using (var stream = File.OpenRead(nzdFilePath))
{
var source = TzdbDateTimeZoneSource.FromStream(stream);
provider = new DateTimeZoneCache(source);
}
}
else
{
provider = DateTimeZoneProviders.Tzdb;
}
List <string> zones = ReadZones();
GenerateData generator = new GenerateData(startYear, untilYear, provider);
IDictionary <string, List <TestItem> > testData = generator.CreateTestData(zones);
generator.PrintJson(testData);
}
public void EmptyIdAccepted()
{
var provider = new DateTimeZoneCache(new TestDateTimeZoneSource("Test1", "Test2"));
Assert.Throws <DateTimeZoneNotFoundException>(() => { var ignored = provider[""]; });
}
