public static Quarter Create(string ticker, uint fiscalYear, uint fiscalQuarter, PropertyDictionary properties, PropertyDescriptionDictionary descriptions)
{
JpTickerValidator.Validate(ticker);
var period = FiscalQuarterPeriod.Create(fiscalYear, fiscalQuarter);
return(new Quarter(ticker, period, properties, descriptions));
}
public void CreateTest()
{
var ticker = "1234";
var latestQuarter = FiscalQuarterPeriod.Create(2020, 2);
// latest
Assert.AreEqual(TickerDayParameter.Create(ticker, LatestDayPeriod.GetInstance()), TickerPeriodParameterCreator.Create(ticker, "latest", null));
// day
Assert.AreEqual(TickerDayParameter.Create(ticker,
DayPeriod.Create(2020, 1, 1)), TickerPeriodParameterCreator.Create(ticker, "2020-01-01", null));
// LYLQ
Assert.AreEqual(TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.Create(0, 0)), TickerPeriodParameterCreator.Create(ticker, "LYLQ", null));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.Create(1, 0)), TickerPeriodParameterCreator.Create(ticker, "LY-1LQ", null));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.Create(0, 2)), TickerPeriodParameterCreator.Create(ticker, "LYLQ-2", null));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, RelativeFiscalQuarterPeriod.Create(1, 2)), TickerPeriodParameterCreator.Create(ticker, "LY-1LQ-2", null));
// Quarter
Assert.AreEqual(TickerQuarterParameter.Create(ticker, FiscalQuarterPeriod.Create(2020, 1)), TickerPeriodParameterCreator.Create(ticker, "2020Q1", null));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, "2019", "LQ-1", FiscalQuarterPeriod.Create(2019, 1)), TickerPeriodParameterCreator.Create(ticker, "2019LQ-1", latestQuarter));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, "2019", "LQ-2", FiscalQuarterPeriod.Create(2018, 4)), TickerPeriodParameterCreator.Create(ticker, "2019LQ-2", latestQuarter));
Assert.AreEqual(TickerQuarterParameter.Create(ticker, "LY-2", "4", FiscalQuarterPeriod.Create(2018, 4)), TickerPeriodParameterCreator.Create(ticker, "LY-2Q4", latestQuarter));
// others
Assert.ThrowsException <ValidationError>(() => TickerPeriodParameterCreator.Create(ticker, "dummy", null));
}
public static CsvDownloadParameters Create(string ticker, FiscalQuarterPeriod from, FiscalQuarterPeriod to, CsvDownloadOutputSettings outputSettings)
{
JpTickerValidator.Validate(ticker);
var range = PeriodRange <FiscalQuarterPeriod> .Create(from, to);
return(new CsvDownloadParameters(ticker, range, outputSettings));
}
public void GetHashCodeTest()
{
var hashCode = FiscalQuarterPeriod.Create(2018, 1).GetHashCode();
Assert.AreEqual((2018, 1).GetHashCode(), hashCode);
Assert.AreNotEqual((2018, 2).GetHashCode(), hashCode);
}
public void GetQuarterTest()
{
var client = new BuffettCodeApiV2Client(mockApiCore);
var parameter = TickerQuarterParameter.Create("6501", FiscalQuarterPeriod.Create(2019, 4));
Assert.IsNotNull(client.GetQuarter(parameter, false, true, false));
}
public FixedTierRange(FiscalQuarterPeriod oldestQuarter, FiscalQuarterPeriod latestQuarter, DayPeriod oldestDate
)
{
this.oldestQuarter = oldestQuarter;
this.latestQuarter = latestQuarter;
this.oldestDate = oldestDate;
}
private Quarter(string ticker, FiscalQuarterPeriod period, PropertyDictionary properties, PropertyDescriptionDictionary descriptions)
{
this.ticker = ticker;
this.period = period;
this.properties = properties;
this.descriptions = descriptions;
}
public void BeforeTest()
{
Assert.AreEqual(FiscalQuarterPeriod.Create(2020, 3), FiscalQuarterPeriod.Create(2021, 1).Before(0, 2));
Assert.AreEqual(FiscalQuarterPeriod.Create(2020, 3), FiscalQuarterPeriod.Create(2022, 3).Before(1, 4));
Assert.AreEqual(FiscalQuarterPeriod.Create(2020, 2), FiscalQuarterPeriod.Create(2022, 3).Before(1, 5));
Assert.AreEqual(FiscalQuarterPeriod.Create(2020, 1), FiscalQuarterPeriod.Create(2021, 3).Before(1, 2));
Assert.AreEqual(FiscalQuarterPeriod.Create(2020, 1), FiscalQuarterPeriod.Create(2021, 3).Before(0, 6));
}
public void GetPeriodTest()
{
var ticker = "1234";
var period = FiscalQuarterPeriod.Create(2020, 1);
Assert.AreEqual(period, TickerQuarterParameter.Create(ticker, period).GetPeriod());
Assert.AreEqual(period, TickerQuarterParameter.Create(ticker, "LY", "LQ", period).GetPeriod());
}
public void GetQuarterRangeTest()
{
var client = new BuffettCodeApiV2Client(mockApiCore);
var from = FiscalQuarterPeriod.Create(2019, 4);
var to = FiscalQuarterPeriod.Create(2019, 4);
var parameter = TickerPeriodRangeParameter.Create("6501", from, to);
Assert.IsNotNull(client.GetQuarterRange(parameter, false, false));
}
private SupportedTier ResolveQuarterPeriod(string ticker, FiscalQuarterPeriod period, bool isConfigureAwait, bool useCache)
{
if (!quarterDict.Has(ticker))
{
var company = GetCompany(ticker, isConfigureAwait, useCache);
quarterDict.Add(company.Ticker, company.SupportedQuarterRanges);
}
return(quarterDict.Get(ticker, period));
}
private static Quarter CreateQuarter(string ticker, FiscalQuarterPeriod period, IDictionary <string, string> properties, IDictionary <string, PropertyDescription> descriptions)
{
return(Quarter.Create(
ticker,
period,
properties is null ? PropertyDictionary.Empty() : new PropertyDictionary(properties),
descriptions is null ? PropertyDescriptionDictionary.Empty() : new PropertyDescriptionDictionary(descriptions)
));
}
public void CreateFromStringTest()
{
var fyFqStr = "2018Q1";
var period = FiscalQuarterPeriod.Parse(fyFqStr);
Assert.AreEqual((uint)2018, period.Year);
Assert.AreEqual((uint)1, period.Quarter);
Assert.AreEqual(fyFqStr, period.ToString());
}
public void FixedTierRengeLengthTest()
{
var from = FiscalQuarterPeriod.Create(2020, 1);
var to = FiscalQuarterPeriod.Create(2021, 2);
var range = PeriodRange <FiscalQuarterPeriod> .Create(from, to);
var supportedTierRange = new SupportedTierRange <FiscalQuarterPeriod>(range, null);
Assert.AreEqual((uint)5, supportedTierRange.FixedTierRengeLength());
}
public void CreateForFiscalQuarterPeriodTest()
{
var from = FiscalQuarterPeriod.Create(2020, 1);
var to = FiscalQuarterPeriod.Create(2020, 2);
var fqRange = PeriodRange <FiscalQuarterPeriod> .Create(from, to);
Assert.AreEqual(from, fqRange.From);
Assert.AreEqual(to, fqRange.To);
Assert.ThrowsException <ValidationError>(() => PeriodRange <FiscalQuarterPeriod> .Create(to, from));
}
public void GetRangeTest()
{
var client = new BuffettCodeApiV2Client(mockApiCore);
var ticker = "2345";
var day = DayPeriod.Create(2021, 2, 1);
var fyFq = FiscalQuarterPeriod.Create(2019, 4);
Assert.IsNotNull(client.GetRange(DataTypeConfig.Quarter, TickerPeriodRangeParameter.Create(ticker, fyFq, fyFq), false, true, false));
Assert.ThrowsException <NotSupportedDataTypeException>(() => client.GetRange(DataTypeConfig.Daily, TickerPeriodRangeParameter.Create(ticker, day, day), false, true, false));
}
public void ToApiV2ParametersTest()
{
var ticker = "1234";
var from = FiscalQuarterPeriod.Create(2020, 1);
var to = FiscalQuarterPeriod.Create(2020, 2);
var parameter = TickerPeriodRangeParameter.Create(ticker, from, to).ToApiV2Parameters();
Assert.AreEqual(ticker, parameter["tickers"]);
Assert.AreEqual(from.ToString(), parameter["from"]);
Assert.AreEqual(to.ToString(), parameter["to"]);
}
public static CsvDownloadParameters Load()
{
var ticker = Properties.Settings.Default.CSVTicker;
JpTickerValidator.Validate(ticker);
var from = FiscalQuarterPeriod.Parse(Properties.Settings.Default.CSVFrom);
var to = FiscalQuarterPeriod.Parse(Properties.Settings.Default.CSVTo);
var outputSettings = LoadOutputSettings();
return(CsvDownloadParameters.Create(ticker, from, to, outputSettings));
}
private CsvDownloadParameters CreateParametersFromFormValues()
{
var ticker = textTicker.Text;
var from = FiscalQuarterPeriod.Parse(textFrom.Text);
var to = FiscalQuarterPeriod.Parse(textTo.Text);
var encoding = radioUTF8.Checked ? TabularOutputEncoding.UTF8 : TabularOutputEncoding.SJIS;
var destination = radioCSV.Checked ? TabularOutputDestination.NewCsvFile
: TabularOutputDestination.NewWorksheet;
return(CsvDownloadParameters.Create(ticker, from, to, CsvDownloadOutputSettings.Create(encoding, destination)));
}
public void EqualsTest()
{
var a = FiscalQuarterPeriod.Create(2018, 1);
var b = FiscalQuarterPeriod.Create("2018", "1");
var c = FiscalQuarterPeriod.Create(2018, 2);
Assert.IsTrue(a.Equals(b));
Assert.IsTrue(b.Equals(a));
Assert.IsFalse(a.Equals(c));
Assert.IsFalse(b.Equals(c));
Assert.IsFalse(a.Equals(null));
}
public void GetGapFiscalQuarterPeriodTest()
{
var fq2020Q1 = FiscalQuarterPeriod.Create(2020, 1);
var fq2020Q2 = FiscalQuarterPeriod.Create(2020, 2);
var fq2021Q1 = FiscalQuarterPeriod.Create(2021, 1);
var fq2021Q4 = FiscalQuarterPeriod.Create(2021, 4);
Assert.AreEqual(0, ComparablePeriodUtil.GetGap(fq2020Q1, fq2020Q1));
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(fq2020Q1, fq2020Q2));
Assert.AreEqual(4, ComparablePeriodUtil.GetGap(fq2020Q1, fq2021Q1));
Assert.AreEqual(7, ComparablePeriodUtil.GetGap(fq2020Q1, fq2021Q4));
}
public static ITickerPeriodParameter Create(string ticker, string periodParam, FiscalQuarterPeriod latestFiscalQuarterPeriod)
{
if (periodParam.Equals("latest"))
{
return(TickerDayParameter.Create(ticker, LatestDayPeriod.GetInstance()));
}
else if (PeriodRegularExpressionConfig.DayRegex.IsMatch(periodParam))
{
return(TickerDayParameter.Create(ticker, DayPeriod.Parse(periodParam)));
}
else if (PeriodRegularExpressionConfig.FiscalQuarterRegex.IsMatch(periodParam))
{
var period = FiscalQuarterPeriod.Parse(periodParam);
return(TickerQuarterParameter.Create(ticker, period));
}
else if (PeriodRegularExpressionConfig.RelativeFiscalQuarterRegex.IsMatch(periodParam))
{
var period = RelativeFiscalQuarterPeriod.Parse(periodParam);
return(TickerQuarterParameter.Create(ticker, period));
}
else if (PeriodRegularExpressionConfig.BCodeUdfFiscalQuarterInputRegex.IsMatch(periodParam))
{
var match = PeriodRegularExpressionConfig.BCodeUdfFiscalQuarterInputRegex
.Match(periodParam);
var fy = match.Groups["fiscalYear"].Value.Trim();
var fq = match.Groups["fiscalQuarter"].Value.Trim();
if (fy.Contains("LY"))
{
var prevYears = RelativeFiscalQuarterPeriod.ParseRelativeValue("years", match);
if (prevYears > latestFiscalQuarterPeriod.Year)
{
throw new ValidationError($"{prevYears} is bigger than {latestFiscalQuarterPeriod.Year}");
}
var fiscalQuarter = fq.Replace("Q", "");
var period = FiscalQuarterPeriod.Create(latestFiscalQuarterPeriod.Year - prevYears, uint.Parse(fiscalQuarter));
return(TickerQuarterParameter.Create(ticker, fy, fiscalQuarter, period));
}
else if (fq.Contains("LQ"))
{
var prevQuarters = RelativeFiscalQuarterPeriod.ParseRelativeValue("quarters", match);
var period = FiscalQuarterPeriod.Create(uint.Parse(fy), latestFiscalQuarterPeriod.Quarter).Before(0, prevQuarters);
return(TickerQuarterParameter.Create(ticker, fy, fq, period));
}
else
{
throw new ValidationError($"{periodParam} is not supported input format");
}
}
else
{
throw new ValidationError($"{periodParam} is not supported input format");
}
}
public void IncludesTest()
{
var from = FiscalQuarterPeriod.Create(2020, 1);
var to = FiscalQuarterPeriod.Create(2020, 3);
var range = PeriodRange <FiscalQuarterPeriod> .Create(from, to);
Assert.IsTrue(range.Includes(from));
Assert.IsTrue(range.Includes(FiscalQuarterPeriod.Create(2020, 2)));
Assert.IsTrue(range.Includes(to));
Assert.IsFalse(range.Includes(FiscalQuarterPeriod.Create(2020, 4)));
Assert.IsFalse(range.Includes(FiscalQuarterPeriod.Create(2019, 4)));
}
public void GetTest()
{
var ticker = "2345";
var client = new BuffettCodeApiV2Client(mockApiCore);
var day = TickerDayParameter.Create(ticker, DayPeriod.Create(2021, 2, 1));
var fyFq = TickerQuarterParameter.Create(ticker, FiscalQuarterPeriod.Create(2019, 4));
var empty = TickerEmptyPeriodParameter.Create(ticker, Snapshot.GetInstance());
Assert.IsNotNull(client.Get(DataTypeConfig.Indicator, empty, false, true, false));
Assert.IsNotNull(client.Get(DataTypeConfig.Quarter, fyFq, false, true, false));
Assert.IsNotNull(client.Get(DataTypeConfig.Company, empty, false, true, false));
Assert.ThrowsException <NotSupportedDataTypeException>(() => client.Get(DataTypeConfig.Daily, day, false, true, false));
}
public void GetHashCodeTest()
{
var a = CreateQuarter(ticker, period, properties, descriptions);
var b = CreateQuarter(ticker, period, properties, descriptions);
var c = CreateQuarter(ticker, period, null, null);
var d = CreateQuarter("2345", period, properties, descriptions);
var e = CreateQuarter(ticker, FiscalQuarterPeriod.Create(2000, 1), properties, descriptions);
Assert.AreEqual(a, b);
Assert.AreNotEqual(a, c);
Assert.AreNotEqual(a, d);
Assert.AreNotEqual(a, e);
}
public void GetGapTest()
{
// quarter
var fq2020Q1 = FiscalQuarterPeriod.Create(2020, 1);
var fq2020Q2 = FiscalQuarterPeriod.Create(2020, 2);
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(fq2020Q1, (IPeriod)fq2020Q2));
// day
var day20200101 = DayPeriod.Create(2020, 1, 1);
var day20200102 = DayPeriod.Create(2020, 1, 2);
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(day20200101, (IPeriod)day20200102));
}
public void SortByPeriodTest()
{
var a = CreateQuarter(ticker, FiscalQuarterPeriod.Create(2021, 3), null, null);
var b = CreateQuarter(ticker, FiscalQuarterPeriod.Create(2021, 4), null, null);
var c = CreateQuarter(ticker, FiscalQuarterPeriod.Create(2018, 1), null, null);
var list = new List <Quarter> {
a, b, c
};
var sorted = list.OrderBy(q => q.Period).ToList();
Assert.AreEqual(FiscalQuarterPeriod.Create(2018, 1), sorted[0].Period);
Assert.AreEqual(FiscalQuarterPeriod.Create(2021, 3), sorted[1].Period);
Assert.AreEqual(FiscalQuarterPeriod.Create(2021, 4), sorted[2].Period);
}
public void TotalGapTest()
{
// quarter
var fromFqp = FiscalQuarterPeriod.Create(2020, 1);
var toFqp = FiscalQuarterPeriod.Create(2021, 2);
Assert.AreEqual((uint)5, PeriodRange <FiscalQuarterPeriod> .Create(fromFqp, toFqp).TotalGap());
// day
var fromDay = DayPeriod.Create(2016, 1, 1);
var toDay = DayPeriod.Create(2016, 2, 1);
Assert.AreEqual((uint)31, PeriodRange <DayPeriod> .Create(fromDay, toDay).TotalGap());
}
public void CompareToTest()
{
var a = FiscalQuarterPeriod.Create(2018, 2);
var b = FiscalQuarterPeriod.Create(2019, 1);
var c = FiscalQuarterPeriod.Create("2017", "1");
var d = FiscalQuarterPeriod.Create(2018, 2);
Assert.AreEqual(-1, a.CompareTo(b));
Assert.AreEqual(1, a.CompareTo(c));
Assert.AreEqual(0, a.CompareTo(d));
Assert.AreEqual(1, b.CompareTo(c));
Assert.AreEqual(1, b.CompareTo(d));
// null given
Assert.ThrowsException <ArgumentNullException>(() => a.CompareTo(null));
}
public void SortTest()
{
var a = FiscalQuarterPeriod.Create(2018, 2);
var b = FiscalQuarterPeriod.Create(2019, 1);
var c = FiscalQuarterPeriod.Create("2017", "1");
var d = FiscalQuarterPeriod.Create(2018, 3);
var sorted = new List <FiscalQuarterPeriod> {
a, b, c, d
}.OrderBy(_ => _).ToArray();
Assert.AreEqual(c, sorted[0]);
Assert.AreEqual(a, sorted[1]);
Assert.AreEqual(d, sorted[2]);
Assert.AreEqual(b, sorted[3]);
}
