public TimeConverter(ITimeParser timeParser, TimeValidator timeValidator)
{
_timeParser = timeParser;
_timeValidator = timeValidator;
_lightParsers = new ITimePartParser[]
{
new TimePartParser(new List <string>
{
LampState.Yellow
}, time => time.Seconds % 2 == 0 ? 1 : 0),
new TimePartParser(new List <string>
{
LampState.Red, LampState.Red, LampState.Red, LampState.Red
}, time => time.Hours / 5),
new TimePartParser(new List <string>
{
LampState.Red, LampState.Red, LampState.Red, LampState.Red
}, time => time.Hours % 5),
new TimePartParser(new List <string>
{
LampState.Yellow, LampState.Yellow, LampState.Red,
LampState.Yellow, LampState.Yellow, LampState.Red,
LampState.Yellow, LampState.Yellow, LampState.Red,
LampState.Yellow, LampState.Yellow
}, time => time.Minutes / 5),
new TimePartParser(new List <string>
{
LampState.Yellow, LampState.Yellow, LampState.Yellow, LampState.Yellow
}, time => time.Minutes % 5)
};
}
public void TimeParserTest()
{
parser = new TimeParser24H();
string input = "24:00:00";
TimeSpan expected = new TimeSpan(1, 0, 0, 0);
Assert.AreEqual(expected, parser.ParseStringToTimeSpan(input));
input = "23:59:59";
expected = new TimeSpan(0, 23, 59, 59);
Assert.AreEqual(expected, parser.ParseStringToTimeSpan(input));
input = "00:00:00";
expected = new TimeSpan(0, 0, 0, 0);
Assert.AreEqual(expected, parser.ParseStringToTimeSpan(input));
input = "13:17:01";
expected = new TimeSpan(0, 13, 17, 1);
Assert.AreEqual(expected, parser.ParseStringToTimeSpan(input));
}
public TimeConverter()
{
// This constructor should not exist always use DI
// added to avoid change the feature steps
timeParser = new TimeParser();
clockParser = new BerlinClockParser();
}
public ClockBuilder(ITimeParser timeParser)
{
if (timeParser == null)
{
throw new ArgumentNullException(nameof(timeParser), IncorrectParserErrorMessage);
}
this._timeParser = timeParser;
}
public ToModelConverter(ITimeParser timeParser, IHeaderConverter headerConverter,
IHourConverter hourConverter, IMinuteConverter minuteConverter)
{
_timeParser = timeParser;
_headerConverter = headerConverter;
_hourConverter = hourConverter;
_minuteConverter = minuteConverter;
}
public JogoParser(ILogger <JogoParser> logger,
IArbitroParser arbitroParser,
IGolParser golParser,
ITimeParser timeParser)
{
this.logger = logger;
this.arbitroParser = arbitroParser;
this.timeParser = timeParser;
}
public void RunApplication(ITimeParser parser, IScreenGenerator generator, IFaceDigitGenerator faceGenerator)
{
Console.WriteLine("GenieClock By Brent Edwards");
Console.WriteLine("Enter x to exit");
bool keepGoing = true;
while (keepGoing == true)
{
Console.WriteLine("\n");
Console.WriteLine("Enter a time in 24 hour format hh:mm");
Console.Write("> ");
var enteredTime = Console.ReadLine();
Console.WriteLine("\n");
if (enteredTime == "x")
{
keepGoing = false;
}
else
{
try
{
Tuple <int, int> timeValues = null;
try
{
timeValues = parser.Parse(enteredTime);
}
catch
{
Console.WriteLine("Invalid Input. Please use hh:mm");
}
if (timeValues != null)
{
var points = faceGenerator.Generate(timeValues.Item1, timeValues.Item2);
var screen = generator.Generate(points);
var rows = screen.GetLongLength(0);
var cols = screen.GetLongLength(1);
for (var row = 0; row < rows; row++)
{
for (var col = 0; col < cols; col++)
{
Console.Write(screen[row, col]);
}
Console.WriteLine("");
}
}
}
catch
{
Console.WriteLine("Error Processing Clock");
}
}
}
}
public TimeConverter(
ITimeParser timeParser,
IPartialConverter secondsConverter,
IPartialConverter minutesConverter,
IPartialConverter hourssConverter)
{
_timeParser = timeParser;
_secondsConverter = secondsConverter;
_minutesConverter = minutesConverter;
_hoursConverter = hourssConverter;
}
public void TimeParserTestRandom()
{
parser = new TimeParser24H();
var date = DateTime.Now;
string input = date.ToString("HH:mm:ss", CultureInfo.InvariantCulture);;
TimeSpan expected = new TimeSpan(0, date.Hour, date.Minute, date.Second);
Assert.AreEqual(expected, parser.ParseStringToTimeSpan(input));
}
public TimeConverter()
{
this.timeParser = new TimeParser();
this.builders = new ILampRowDrawer[]
{
new LampRowBuilder().WithMaximumValue(2).WithYellowOnCharacter().WithValue(time => (time.Seconds + 1) % 2).Build(),
new LampRowBuilder().WithMaximumValue(24).WithIncrement(5).WithRedOnCharacter().WithValue(time => time.Hours).Build(),
new LampRowBuilder().WithMaximumValue(5).WithRedOnCharacter().WithValue(time => time.Hours % 5).Build(),
new LampRowBuilder().WithMaximumValue(60).WithIncrement(5).WithCustomOnCharacter(val => val % 15 == 10 ? 'R' : 'Y').WithValue(time => time.Minutes).Build(),
new LampRowBuilder().WithMaximumValue(5).WithYellowOnCharacter().WithValue(time => time.Minutes % 5).Build(),
};
}
public void Setup()
{
formatter = Substitute.For <ITimeFormatter>();
parser = Substitute.For <ITimeParser>();
}
public TimeConverter(ITimeParser timeParser)
{
this.TimeParser = timeParser;
}
public TalkingClockService(ITimeParser timeParser, ITimeMapper timeMapper)
{
_timeParser = timeParser;
_timeMapper = timeMapper;
}
public TimeConverter(IBerlinClockEntityBuilder berlinClockEntityBuilder, ITimeParser timeParser)
{
_berlinClockEntityBuilder = berlinClockEntityBuilder;
_timeParser = timeParser;
}
public void Initialize()
{
_parser = new TimeParser();
}
public BerlinClockTimeConverter(ITimeFormatter timeFormatter, ITimeParser timeParser)
{
this.timeFormatter = timeFormatter;
this.timeParser = timeParser;
}
public TheBerlinClockSteps()
{
timeParser = new TimeParser(new TimeValidator());
consoleSerializer = new ClockConsoleSerializer();
berlinClock = new TimeConverter(timeParser, consoleSerializer);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="timeParser">Implementation of ITimeParser</param>
public TimeFileWriter(ITimeParser timeParser)
{
_timeParser = timeParser;
}
public TimeConverter(ITimeParser timeParser,
IClockParser clockParser)
{
this.timeParser = timeParser;
this.clockParser = clockParser;
}
public TimeConverter()
{
_timeParser = new TimeParser();
_colourMapper = new DefaultColourMapper();
}
public TimeParserTest()
{
timeParser = new TimeParser();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="timeParser"></param>
public LineParser(ITimeParser timeParser)
{
_timeParser = timeParser;
}
public BerlinClockTimeConverter(ITimeParser timeParser, Clock.BerlinClock clock, IBerlinClockOutputFormatter outputFormatter)
{
_timeParser = timeParser;
_clock = clock;
_outputFormatter = outputFormatter;
}
public TimeConverter(ITimeParser timeParser, IBerlinClockBuilder berlinClockBuilder)
{
this.timeParser = timeParser;
this.berlinClockBuilder = berlinClockBuilder;
}
public TimeConverter(ITimeParser timeParser, IClockRenderer clockRenderer)
{
_timeParser = timeParser;
_clockRenderer = clockRenderer;
}
public void SetUp()
{
parser = new TimeParser();
}
public void Setup()
{
_timeParser = new TimeParser();
}
public TimeConverter(ITimeParser timeParser, IClockConsoleSerializer consoleSerializer)
{
this.timeParser = timeParser ?? throw new ArgumentNullException(nameof(timeParser));
this.consoleSerializer = consoleSerializer ?? throw new ArgumentNullException(nameof(consoleSerializer));
}
public TimeConverter()
{
this.clockBuilder = new ClockBuilder();
this.timeParser = new TimeParser();
}
public TimeTransformingFactory(ITimeParser <TTimeIn, TTimeTarget> timeParser, ITimeDecorator <TTimeTarget, TTimeOut> timeDecorator)
{
_timeParser = timeParser;
_timeDecorator = timeDecorator;
}
// using constructor parameters allows us to configure it in IoC container and test it easily
public TimeConverter(IEnumerable <ITimePartConverter> converters, ITimeParser timeParser, string separator)
{
this.converters = converters;
this.timeParser = timeParser;
this.separator = separator;
}
