public FixedTierRange(FiscalQuarterPeriod oldestQuarter, FiscalQuarterPeriod latestQuarter, DayPeriod oldestDate
)
{
this.oldestQuarter = oldestQuarter;
this.latestQuarter = latestQuarter;
this.oldestDate = oldestDate;
}
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 void ParseCompanyTest()
{
var json = ApiGetResponseBodyParser.Parse(File.ReadAllText(@"TestData/ApiV3Company.json"));
var company = (Company)parser.Parse(DataTypeConfig.Company, json);
Assert.AreEqual(company.Ticker, "2801");
Assert.AreEqual(company.GetDescription("tosyo_33category").JpName, "東証33業種");
Assert.AreEqual(company.GetDescription("url").Unit, "");
Assert.AreEqual(company.GetValue("url"), @"http://www.kikkoman.co.jp/");
Assert.AreEqual(company.GetValue("accounting_standard"), "IFRS");
var supportedQuarterRanges = company.SupportedQuarterRanges;
Assert.AreEqual((uint)2004, supportedQuarterRanges.OndemandTierRange.From.Year);
Assert.AreEqual((uint)1, supportedQuarterRanges.OndemandTierRange.From.Quarter);
Assert.AreEqual((uint)2021, supportedQuarterRanges.OndemandTierRange.To.Year);
Assert.AreEqual((uint)2, supportedQuarterRanges.OndemandTierRange.To.Quarter);
Assert.AreEqual((uint)2016, supportedQuarterRanges.FixedTierRange
.From.Year);
Assert.AreEqual((uint)3, supportedQuarterRanges.FixedTierRange.From.Quarter);
var supportedDailyRanges = company.SupportedDailyRanges;
var today = DayPeriod.Create(DateTime.Today);
Assert.AreEqual(DayPeriod.Create(2016, 11, 15), supportedDailyRanges.FixedTierRange.From);
Assert.AreEqual(today, supportedDailyRanges.FixedTierRange.To);
Assert.AreEqual(DayPeriod.Create(2000, 4, 3), supportedDailyRanges.OndemandTierRange.From);
Assert.AreEqual(today, supportedDailyRanges.FixedTierRange.To);
}
public void GetDayPeriods__ShortBreak_ForNotSmokeres__ReturnsExpectedDayPeriodCollection()
{
// Arrange:
var shortBreak = GetShortBreakForNotSmokers();
var expectedColl = new DayPeriod[] {
new DayPeriod(new TimeSpan(1, 55, 0), new TimeSpan(2, 5, 0)),
new DayPeriod(new TimeSpan(3, 55, 0), new TimeSpan(4, 5, 0)),
new DayPeriod(new TimeSpan(5, 55, 0), new TimeSpan(6, 5, 0)),
new DayPeriod(new TimeSpan(7, 55, 0), new TimeSpan(8, 5, 0)),
new DayPeriod(new TimeSpan(9, 55, 0), new TimeSpan(10, 5, 0)),
new DayPeriod(new TimeSpan(11, 55, 0), new TimeSpan(12, 5, 0)),
new DayPeriod(new TimeSpan(13, 55, 0), new TimeSpan(14, 5, 0)),
new DayPeriod(new TimeSpan(15, 55, 0), new TimeSpan(16, 5, 0)),
new DayPeriod(new TimeSpan(17, 55, 0), new TimeSpan(18, 5, 0)),
new DayPeriod(new TimeSpan(19, 55, 0), new TimeSpan(20, 5, 0)),
new DayPeriod(new TimeSpan(21, 55, 0), new TimeSpan(22, 5, 0)),
new DayPeriod(new TimeSpan(23, 55, 0), new TimeSpan(0, 5, 0)),
};
var breakRepo = GetBreakRepository();
// Action:
var res = breakRepo.GetDayPeriods(shortBreak);
// Assert:
Assert.That(res, Is.EquivalentTo(expectedColl));
}
void OnTimePeriodUpdate(object args)
{
DayPeriod period = (DayPeriod)args;
this.period = period;
if (period == DayPeriod.DAWN)
{
dayCount++;
if (dayCount > 1)
{
SpawnManyWolfs(fishCount + dayCount);
}
foreach (var slab in map)
{
if (slab.type == IslandSlab.BEACH)
{
float left = slab.transform.position.x < camp.position.x ? 3 : -3;
SpawnFish(slab.transform.position.Vec2() + Vector2.up * left);
}
}
}
else if (period == DayPeriod.DUSK)
{
int count = FindObjectsOfType <WolfSpawn>().Length;
if (count > 0)
{
speaker.clip = wolfComing;
speaker.Play();
}
}
}
private Daily(string ticker, DayPeriod period, PropertyDictionary properties, PropertyDescriptionDictionary descriptions)
{
this.ticker = ticker;
this.period = period;
this.properties = properties;
this.descriptions = descriptions;
}
public void GetDailyTest()
{
var parameter = TickerDayParameter.Create("6501", DayPeriod.Create(2021, 2, 1));
var client = new BuffettCodeApiV3Client(mockApiCore);
Assert.IsNotNull(client.GetDaily(parameter, false, true, false));
}
private static Daily CreateDaily(string ticker, DayPeriod period, IDictionary <string, string> properties, IDictionary <string, PropertyDescription> descriptions)
{
return(Daily.Create(
ticker,
period,
properties is null ? PropertyDictionary.Empty() : new PropertyDictionary(properties),
descriptions is null ? PropertyDescriptionDictionary.Empty() : new PropertyDescriptionDictionary(descriptions)
));
}
public void EqualsTest()
{
var a = DayPeriod.Create(2020, 1, 1);
var b = DayPeriod.Create(2020, 1, 1);
var c = DayPeriod.Create(2021, 1, 1);
Assert.AreEqual(a, b);
Assert.AreNotEqual(a, c);
}
public void CreateForDayPeriodTest()
{
var from = DayPeriod.Create(2020, 1, 1);
var to = DayPeriod.Create(2020, 1, 2);
var fqRange = PeriodRange <DayPeriod> .Create(from, to);
Assert.AreEqual(from, fqRange.From);
Assert.AreEqual(to, fqRange.To);
Assert.ThrowsException <ValidationError>(() => PeriodRange <DayPeriod> .Create(to, from));
}
void OnPeriodUpdate(object args)
{
DayPeriod period = (DayPeriod)args;
if (period == DayPeriod.NIGHT)
{
Instantiate(wolfPrefab, transform.position, Quaternion.identity);
Destroy(gameObject);
}
}
public void GetGapDayPeriodTest()
{
var day20200101 = DayPeriod.Create(2020, 1, 1);
var day20200102 = DayPeriod.Create(2020, 1, 2);
var day20210101 = DayPeriod.Create(2021, 1, 1);
Assert.AreEqual(0, ComparablePeriodUtil.GetGap(day20200101, day20200101));
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(day20200101, day20200102));
Assert.AreEqual(366, ComparablePeriodUtil.GetGap(day20200101, day20210101));
}
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 ToApiV3ParametersTest()
{
var ticker = "1234";
var parameter1 = TickerDayParameter.Create(ticker, DayPeriod.Create(2021, 1, 1)).ToApiV3Parameters();
Assert.AreEqual("2021-01-01", parameter1["date"]);
var parameter2 = TickerDayParameter.Create(ticker, LatestDayPeriod.GetInstance()).ToApiV3Parameters();
Assert.AreEqual("latest", parameter2["date"]);
}
private static Daily ParseDaily(PropertyDictionary properties, PropertyDescriptionDictionary descriptions)
{
var period = DayPeriod.Parse(properties.Get(PropertyNames.Day));
return(Daily.Create(
properties.Get(PropertyNames.Ticker),
period,
properties,
descriptions
));
}
public void ParseTest()
{
// yyyy-MM-dd
var dateString = "2012-01-02";
var period = DayPeriod.Parse(dateString);
Assert.AreEqual(2012, period.Value.Year);
Assert.AreEqual(1, period.Value.Month);
Assert.AreEqual(2, period.Value.Day);
Assert.AreEqual(dateString, period.ToString());
}
public void CreateTest()
{
var ticker = "1234";
var period = DayPeriod.Create(2021, 1, 1);
Assert.AreEqual(period, TickerDayParameter.Create(ticker, period).GetPeriod());
Assert.AreEqual(LatestDayPeriod.GetInstance(), TickerDayParameter.Create(ticker, "latest").GetPeriod());
Assert.AreEqual(period, TickerDayParameter.Create(ticker, "2021-01-01").GetPeriod());
// validation error
Assert.ThrowsException <ValidationError>(() => TickerDayParameter.Create("dummy", period));
}
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 CompareToTest()
{
var a = DayPeriod.Create(2020, 1, 1);
var b = DayPeriod.Create(2020, 1, 1);
var c = DayPeriod.Create(2021, 1, 1);
var d = DayPeriod.Create(2020, 2, 3);
Assert.AreEqual(0, a.CompareTo(b));
Assert.AreEqual(-1, a.CompareTo(c));
Assert.AreEqual(-1, a.CompareTo(d));
Assert.AreEqual(1, c.CompareTo(d));
}
public void CreateTest()
{
uint y = 2011;
uint m = 1;
uint d = 1;
var day = DayPeriod.Create(y, m, d);
Assert.AreEqual((int)y, day.Value.Year);
Assert.AreEqual((int)m, day.Value.Month);
Assert.AreEqual((int)y, day.Value.Year);
}
public void SortTest()
{
var a = DayPeriod.Create(2020, 1, 1);
var b = DayPeriod.Create(2021, 1, 1);
var c = DayPeriod.Create(2020, 2, 3);
var sorted = new List <DayPeriod> {
a, b, c
}.OrderBy(_ => _).ToArray();
Assert.AreEqual(a, sorted[0]);
Assert.AreEqual(c, sorted[1]);
Assert.AreEqual(b, sorted[2]);
}
public void GetHashCodeTest()
{
var a = DayPeriod.Create(2020, 1, 1).GetHashCode();
var b = DayPeriod.Create(2020, 1, 1).GetHashCode();
var c = DayPeriod.Create(2021, 1, 1).GetHashCode();
var d = DayPeriod.Create(2020, 2, 1).GetHashCode();
var e = DayPeriod.Create(2020, 1, 2).GetHashCode();
Assert.AreEqual(a, b);
Assert.AreNotEqual(a, c);
Assert.AreNotEqual(a, d);
Assert.AreNotEqual(a, e);
}
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));
}
void OnPeriodUpdate(object args)
{
DayPeriod period = (DayPeriod)args;
if (period == DayPeriod.DAWN)
{
DisableLight();
}
else if (period == DayPeriod.DUSK)
{
EnableLight();
}
}
void OnPeriodUpdate(object args)
{
DayPeriod period = (DayPeriod)args;
if (period == DayPeriod.DAWN)
{
Play();
}
else if (period == DayPeriod.DUSK)
{
Stop();
}
}
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 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 SliceDayTest()
{
var from = DayPeriod.Create(2016, 1, 1);
var to = DayPeriod.Create(2016, 2, 1);
var dayRange = PeriodRange <DayPeriod> .Create(from, to);
// size = 1
var chunks = PeriodRange <DayPeriod> .Slice(dayRange, 1).ToArray();
Assert.AreEqual(32, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from, chunks[0].To);
Assert.AreEqual(from.Next(), chunks[1].From);
Assert.AreEqual(to, chunks[31].From);
Assert.AreEqual(to, chunks[31].To);
for (uint i = 0; i < chunks.Length; i++)
{
Assert.AreEqual(0, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
// size = 2
chunks = PeriodRange <DayPeriod> .Slice(dayRange, 2).ToArray();
Assert.AreEqual(16, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from.Next(), chunks[0].To);
Assert.AreEqual(from.Next().Next(), chunks[1].From);
Assert.AreEqual(to, chunks[15].To);
for (uint i = 0; i < chunks.Length; i++)
{
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
// size = 3
chunks = PeriodRange <DayPeriod> .Slice(dayRange, 3).ToArray();
Assert.AreEqual(11, chunks.Length);
Assert.AreEqual(from, chunks[0].From);
Assert.AreEqual(from.Next().Next(), chunks[0].To);
Assert.AreEqual(from.Next().Next().Next(), chunks[1].From);
Assert.AreEqual(to, chunks[10].To);
for (uint i = 0; i < chunks.Length - 1; i++)
{
Assert.AreEqual(2, ComparablePeriodUtil.GetGap(chunks[i].From, chunks[i].To));
}
Assert.AreEqual(1, ComparablePeriodUtil.GetGap(chunks.Last().From, chunks.Last().To));
}
void UpdateLight()
{
relativeTime = time;
float dayBegins = Mathf.PI / 2;
float dayEnds = dayBegins + 2 * Mathf.PI * dayLength;
float nightBegins = dayEnds + Mathf.PI;
float nightEnds = nightBegins + 2 * Mathf.PI * nightLength;
float boundTime = time % (2 * Mathf.PI * (dayLength + nightLength + 1));
if (boundTime >= dayBegins && boundTime <= dayEnds)
{
relativeTime = 1;
if (period == DayPeriod.DAWN)
{
period = DayPeriod.DAY;
Pubsub.instance.Publish(EventName.PeriodUpdate, period);
}
}
else if (boundTime >= nightBegins && boundTime <= nightEnds)
{
relativeTime = 0;
if (period == DayPeriod.DUSK)
{
period = DayPeriod.NIGHT;
Pubsub.instance.Publish(EventName.PeriodUpdate, period);
}
}
else
{
relativeTime = Mathf.Sin(time) / 2 + 0.5f;
if (period == DayPeriod.DAY)
{
period = DayPeriod.DUSK;
Pubsub.instance.Publish(EventName.PeriodUpdate, period);
}
else if (period == DayPeriod.NIGHT)
{
period = DayPeriod.DAWN;
Pubsub.instance.Publish(EventName.PeriodUpdate, period);
}
}
skylight.intensity = Mathf.LerpAngle(nightIntensity, dayIntensity, relativeTime);
skylight.color = Color.Lerp(nightTint, dayTint, relativeTime);
}
public static FixedTierRange Parse(IEnumerable <JProperty> jProperties)
{
try
{
var properties = jProperties.ToDictionary(p => p.Name, p => p.Value.ToString());
var oldestQuarter = FiscalQuarterPeriod.Create(properties[PropertyNames.OldestFiscalYear].ToString(), properties[PropertyNames.OldestFiscalQuarter].ToString());
var latestQuarter = FiscalQuarterPeriod.Create(properties[PropertyNames.LatestFiscalYear], properties[PropertyNames.LatestFiscalQuarter]);
var oldestDate = DayPeriod.Create(DateTime.Parse(properties[PropertyNames.OldestDate]));
return(new FixedTierRange(oldestQuarter, latestQuarter, oldestDate));
}
catch (Exception e)
{
throw new ApiResponseParserException($"parse {PropertyNames.FixedTierRange} failed", e);
}
}
public Painting(ITeacher te, DayPeriod time)
{
Console.Out.Write("Create Painting Course object : ");
Console.Out.WriteLine(time);
gradCourse = false;
}
public OS(ITeacher te, DayPeriod time)
{
Console.Out.Write("Create OS Course object : ");
Console.Out.WriteLine(time);
gradCourse = true;
}
public Automata( ITeacher te, DayPeriod time)
{
Console.Out.Write("Create Automata Course object : ");
Console.Out.WriteLine(time);
gradCourse = false;
}
public void SetSkybox(DayPeriod period)
{
currentPeriod = period;
switch(currentPeriod){
case DayPeriod.day:
RenderSettings.skybox = sunny;
break;
case DayPeriod.dawn:
RenderSettings.skybox = dawn;
break;
case DayPeriod.night:
RenderSettings.skybox = night;
break;
default:
RenderSettings.skybox = morning;
break;
}
}
