private static void TestToUnixTimeSeconds(TestTime test)
{
long expectedSeconds = test.UnixTimeSeconds;
long actualSeconds = test.DateTimeOffset.ToUnixTimeSeconds();
Assert.AreEqual(expectedSeconds, actualSeconds);
}
private static void TestToUnixTimeMilliseconds(TestTime test)
{
long expectedMilliseconds = test.UnixTimeMilliseconds;
long actualMilliseconds = test.DateTimeOffset.ToUnixTimeMilliseconds();
Assert.Equals(expectedMilliseconds, actualMilliseconds);
}
static void Main(string[] args)
{
/*Функция решает систему 4х4 вида: [4, 1, 1, 1]
* [1, 4, 1, 1]
* [1, 1, 4, 1]
* [1, 1, 1, 4]
* с единичным вектором правой части
*/
//Test();
TestTime test_time = new TestTime();
//Имя файла для загрузки и сохранения
string filename = "people.dat";
TestTime.Load(filename, ref test_time);
while (true)
{
try
{
//Вводим порядок матрицы
Console.WriteLine("Введите порядок матрицы или 'end' для выхода: ");
string str = Console.ReadLine();
if (str == "end")
{
break;
}
else
{
int a = Convert.ToInt32(str);
TestTimeItem test_time_item = new TestTimeItem();
test_time_item.calculateCoef(a);
test_time.Add(test_time_item);
}
}
catch (System.IO.IOException ex)
{
Console.WriteLine(ex.Message);
break;
}
catch (FormatException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine("Необходимо ввеcти число или 'end'\n");
}
}
TestTime.Save(filename, test_time);
Console.Write(test_time);
/*foreach (var ass in AppDomain.CurrentDomain.GetAssemblies())
* foreach (var type in ass.GetTypes())
* if (type.IsSubclassOf(typeof(Exception)))
* Console.WriteLine(type);
*/
System.Threading.Thread.Sleep(5000);
}
// Next Trial button action
private void NextTrialButton_Click(object sender, EventArgs e)
{
// Clear notification area content
InfoTextBox.Clear();
// There is an upcoming set
if (++IdxSet < TestSetPathList.Length)
{
// Reset image index
IdxImg = Const_NrPicPerSet;
// Reset Image Display Time array
Array.Clear(TestData.ImgDispTime, 0, Const_NrPicPerSet);
// Enable Next Picture and Got It buttons
btn_NextPicture.Enabled = true;
btn_GotIt.Enabled = true;
// Disable Next Trial button
btn_NextTrial.Enabled = false;
// Disable Category and Name input fields
txt_Description.Enabled = false;
txt_Category.Enabled = false;
// Display current picture
DisplayImage(IdxSet, IdxImg);
// Enable timer
TestTime.Start();
}
// Last set was reached
else
{
// Disable Test Control box
box_TestControls.Enabled = false;
// Enable Finish button
btn_Finish.Enabled = true;
}
}
private void TestTime_Tick(object sender, EventArgs e)
{
ss = ss - 1;
string s = Convert.ToString(ss);
Seclabel.Text = s;
string h = Convert.ToString(hh);
Hourlabel.Text = h;
string m = Convert.ToString(mm);
Minlabel.Text = m;
if (ss == -1)
{
mm = mm - 1;
ss = 59;
}
if (mm == -1)
{
hh = hh - 1;
mm = 59;
}
if (hh == 0 && mm == 0 && ss == 0)
{
TestTime.Stop();
DialogResult done = MessageBox.Show("Please your time is up click ok to display your Results",
"Times Up", MessageBoxButtons.OK, MessageBoxIcon.Information);
if (done == DialogResult.OK)
{
Hide();
UserResult result = new UserResult();
result.Show();
}
}
}
public static void ToQuaranTimeSeconds(TestTime test)
{
long expectedSeconds = test.QuaranTimeSeconds;
long actualSeconds = test.DateTimeOffset.ToQuaranTimeSeconds();
Assert.Equal(expectedSeconds, actualSeconds);
}
public static void FromUnixTimeMilliseconds(TestTime test)
{
// Only assert that expected == actual up to millisecond precision for conversion from milliseconds
long expectedTicks = (test.DateTimeOffset.UtcTicks / TimeSpan.TicksPerMillisecond) * TimeSpan.TicksPerMillisecond;
long actualTicks = DateTimeOffset.FromUnixTimeMilliseconds(test.UnixTimeMilliseconds).UtcTicks;
Assert.Equal(expectedTicks, actualTicks);
}
public static void FromQuaranTimeSeconds(TestTime test)
{
// Only assert that expected == actual up to second precision for conversion from seconds
long expectedTicks = (test.DateTimeOffset.UtcTicks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond;
long actualTicks = QuaranTime.FromQuaranTimeSeconds(test.QuaranTimeSeconds).UtcTicks;
Assert.Equal(expectedTicks, actualTicks);
}
private static void TestFromUnixTimeSeconds(TestTime test)
{
// Only assert that expected == actual up to second precision for conversion from seconds
long expectedTicks = (test.DateTimeOffset.UtcTicks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond;
long actualTicks = DateTimeOffset.FromUnixTimeSeconds(test.UnixTimeSeconds).UtcTicks;
Assert.AreEqual(expectedTicks, actualTicks);
}
private void Start_Click_2(object sender, EventArgs e)
{
TestTime.Enabled = true;
TestTime.Start();
Start.Visible = false;
Welcome.Visible = false;
GetQuestion();
}
private static void TestToUnixTimeSeconds(TestTime test)
{
long expectedSeconds = test.UnixTimeSeconds;
long actualSeconds = test.DateTimeOffset.ToUnixTimeSeconds();
if (expectedSeconds != actualSeconds)
{
Assert.True(false,
string.Format("Unix time converted from DateTimeOffset {0} ticks is inaccurate, expected: {1} seconds, actual: {2} seconds",
test.DateTimeOffset.UtcTicks, expectedSeconds, actualSeconds));
}
}
private static void TestToUnixTimeSeconds(TestTime test)
{
long expectedSeconds = test.UnixTimeSeconds;
long actualSeconds = test.DateTimeOffset.ToUnixTimeSeconds();
if (expectedSeconds != actualSeconds)
{
Assert.True(false,
string.Format("Unix time converted from DateTimeOffset {0} ticks is inaccurate, expected: {1} seconds, actual: {2} seconds",
test.DateTimeOffset.UtcTicks, expectedSeconds, actualSeconds));
}
}
public void 位置接入()
{
player.MoveTo(new Vector2()
{
x = 6, y = 6
});
TestTime.SetTimeAndUpdate(100);
Assert.AreEqual(6, stru.pos.GetPos().x);
Assert.AreEqual(6, stru.pos.GetPos().y);
}
public static void TestRoundtripUnixTimes()
{
foreach (var test in s_testTimes)
{
// Roundtrip Unix time in milliseconds
DateTimeOffset dateTime = DateTimeOffset.FromUnixTimeMilliseconds(test.UnixTimeMilliseconds);
TestToUnixTimeMilliseconds(TestTime.FromMilliseconds(dateTime, test.UnixTimeMilliseconds));
// Roundtrip Unix time in seconds
dateTime = DateTimeOffset.FromUnixTimeSeconds(test.UnixTimeSeconds);
TestToUnixTimeSeconds(TestTime.FromSeconds(dateTime, test.UnixTimeSeconds));
}
}
public static void TestRoundtripDateTimes()
{
foreach (var test in s_testTimes)
{
// Roundtrip through Unix time in milliseconds
long unixTimeMilliseconds = test.DateTimeOffset.ToUnixTimeMilliseconds();
TestFromUnixTimeMilliseconds(TestTime.FromMilliseconds(test.DateTimeOffset, unixTimeMilliseconds));
// Roundtrip through Unix time in seconds
long unixTimeSeconds = test.DateTimeOffset.ToUnixTimeSeconds();
TestFromUnixTimeSeconds(TestTime.FromSeconds(test.DateTimeOffset, unixTimeSeconds));
}
}
private static void TestFromUnixTimeMilliseconds(TestTime test)
{
// Only assert that expected == actual up to millisecond precision for conversion from milliseconds
long expectedTicks = (test.DateTimeOffset.UtcTicks / TimeSpan.TicksPerMillisecond) * TimeSpan.TicksPerMillisecond;
long actualTicks = DateTimeOffset.FromUnixTimeMilliseconds(test.UnixTimeMilliseconds).UtcTicks;
if (expectedTicks != actualTicks)
{
Assert.True(false,
string.Format("DateTimeOffset converted from Unix time {0} ms is inaccurate, expected: {1} ticks, actual: {2} ticks",
test.UnixTimeMilliseconds,
expectedTicks,
actualTicks));
}
}
public void 移动到目标()
{
RPGLogicBase.Vector2 pos = new RPGLogicBase.Vector2()
{
x = 10, y = 0
};
initer.NotifyEvent(new IE_MovePos()
{
Pos = pos
});
TestTime.SetTimeAndUpdate(1);
Assert.AreEqual(new RPGLogicBase.Vector2()
{
x = 5, y = 0
}, posBehaviour.posControl.GetPos());
TestTime.SetTimeAndUpdate(2);
Assert.AreEqual(pos, posBehaviour.posControl.GetPos());
}
internal string StoreTestResults()
{
StringBuilder sb = new StringBuilder();
sb.Append(AppName);
sb.Append(",");
sb.Append(AppBrowser);
sb.Append(",");
sb.Append(TestSuiteName);
sb.Append(",");
sb.Append(TestName);
sb.Append(",");
sb.Append(Status);
sb.Append(",");
sb.Append(TestTime.ToString("##.#####"));
sb.Append(",");
sb.Append(CSVErrorMessage.Replace("\n", ";"));
return(sb.ToString());
}
// Stop button action
private void StopButton_Click(object sender, EventArgs e)
{
int Idx = Const_NrPicPerSet - IdxImg;
// Stop timer
TestTime.Stop();
// Get image display time
TestData.ImgDispTime[Idx] = Time.GetImgDispTime_100ms();
// Make picture area visible
box_PictureArea.Visible = false;
// Enable Category and Name input fields
txt_Category.Enabled = true;
txt_Description.Enabled = true;
// Enable Submit button
btn_Complete.Enabled = true;
// Disable Next Picture and Got It buttons
btn_GotIt.Enabled = false;
btn_NextPicture.Enabled = false;
}
public void 频繁移动()
{
float currTime = 0;
RPGLogicBase.Vector2 pos = new RPGLogicBase.Vector2()
{
x = 10, y = 0
};
while (currTime < 2)
{
pos += new RPGLogicBase.Vector2(-0.01f, 0f);
initer.NotifyEvent(new IE_MovePos()
{
Pos = pos
});
TestTime.SetTimeAndUpdate(currTime += 0.1f);
}
Assert.AreEqual(pos, posBehaviour.posControl.GetPos());
}
//private void Start_Click_1(object sender, EventArgs e)
//{
// TestTime.Enabled = true;
// Start.Visible = false;
// Welcome.Visible = false;
// GetQuestion();
// OK.Visible = true;
// ShowControls();
// OptionState();
//}
private void TestTime_Tick_1(object sender, EventArgs e)
{
_seconds = _seconds - 1;
string s = Convert.ToString(_seconds);
secondLabel.Text = s;
string h = Convert.ToString(_hour);
Hourlabel.Text = h;
string m = Convert.ToString(_minutes);
MinLabel.Text = m;
if (_seconds == -1)
{
_minutes = _minutes - 1;
_seconds = 59;
}
if (_minutes == -1)
{
_hour = _hour - 1;
_minutes = 59;
}
switch (_hour)
{
case 0 when _minutes == 0 && _seconds == 0:
{
TestTime.Stop();
var done = MessageBox.Show("Please your time is up click ok to display your Results",
"Times Up", MessageBoxButtons.OK, MessageBoxIcon.Information);
if (done == DialogResult.OK)
{
Hide();
//_userResultPage.Show();
}
break;
}
}
}
public static IEnumerable <object[]> QuaranTime_TestData()
{
yield return(new object[] { TestTime.FromMilliseconds(DateTimeOffset.MinValue, -63720270000000) });
yield return(new object[] { TestTime.FromMilliseconds(DateTimeOffset.MaxValue, 251817627599999) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(2020, 3, 20, 0, 0, 0, TimeSpan.FromHours(-3)), 0) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(2014, 6, 13, 17, 21, 50, TimeSpan.Zero), -181993090000) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(2830, 12, 15, 1, 23, 45, TimeSpan.Zero), 25584416625000) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(2830, 12, 15, 1, 23, 45, 399, TimeSpan.Zero), 25584416625399) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(9999, 12, 30, 23, 24, 25, TimeSpan.Zero), 251817539065000) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(1907, 7, 7, 7, 7, 7, TimeSpan.Zero), -3556641173000) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(1907, 7, 7, 7, 7, 7, 1, TimeSpan.Zero), -3556641172999) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(1907, 7, 7, 7, 7, 7, 777, TimeSpan.Zero), -3556641172223) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(601636288270011234, TimeSpan.Zero), -3556641172999) });
}
private static IEnumerable <object[]> UnixTime_TestData()
{
yield return(new object[] { TestTime.FromMilliseconds(DateTimeOffset.MinValue, -62135596800000) });
yield return(new object[] { TestTime.FromMilliseconds(DateTimeOffset.MaxValue, 253402300799999) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(1970, 1, 1, 0, 0, 0, TimeSpan.Zero), 0) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(2014, 6, 13, 17, 21, 50, TimeSpan.Zero), 1402680110000) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(2830, 12, 15, 1, 23, 45, TimeSpan.Zero), 27169089825000) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(2830, 12, 15, 1, 23, 45, 399, TimeSpan.Zero), 27169089825399) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(9999, 12, 30, 23, 24, 25, TimeSpan.Zero), 253402212265000) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(1907, 7, 7, 7, 7, 7, TimeSpan.Zero), -1971967973000) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(1907, 7, 7, 7, 7, 7, 1, TimeSpan.Zero), -1971967972999) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(1907, 7, 7, 7, 7, 7, 777, TimeSpan.Zero), -1971967972223) });
yield return(new object[] { TestTime.FromMilliseconds(new DateTimeOffset(601636288270011234, TimeSpan.Zero), -1971967972999) });
}
public static void ToUnixTimeSeconds_RoundTrip(TestTime test)
{
long unixTimeSeconds = test.DateTimeOffset.ToUnixTimeSeconds();
FromUnixTimeSeconds(TestTime.FromSeconds(test.DateTimeOffset, unixTimeSeconds));
}
public static void oUnixTimeMilliseconds_RountTrip(TestTime test)
{
long unixTimeMilliseconds = test.DateTimeOffset.ToUnixTimeMilliseconds();
FromUnixTimeMilliseconds(TestTime.FromMilliseconds(test.DateTimeOffset, unixTimeMilliseconds));
}
private static void TestFromUnixTimeSeconds(TestTime test)
{
// Only assert that expected == actual up to second precision for conversion from seconds
long expectedTicks = (test.DateTimeOffset.UtcTicks / TimeSpan.TicksPerSecond) * TimeSpan.TicksPerSecond;
long actualTicks = DateTimeOffset.FromUnixTimeSeconds(test.UnixTimeSeconds).UtcTicks;
if (expectedTicks != actualTicks)
{
Assert.True(false,
string.Format("DateTimeOffset converted from Unix time {0} seconds ({1} ms) is inaccurate, expected: {2} ticks, actual: {3} ticks",
test.UnixTimeSeconds,
test.UnixTimeMilliseconds,
expectedTicks,
actualTicks));
}
}
private static void TestFromUnixTimeMilliseconds(TestTime test)
{
// Only assert that expected == actual up to millisecond precision for conversion from milliseconds
long expectedTicks = (test.DateTimeOffset.UtcTicks / TimeSpan.TicksPerMillisecond) * TimeSpan.TicksPerMillisecond;
long actualTicks = DateTimeOffset.FromUnixTimeMilliseconds(test.UnixTimeMilliseconds).UtcTicks;
Assert.Equal(expectedTicks, actualTicks);
}
private static void TestToUnixTimeSeconds(TestTime test)
{
long expectedSeconds = test.UnixTimeSeconds;
long actualSeconds = test.DateTimeOffset.ToUnixTimeSeconds();
Assert.Equal(expectedSeconds, actualSeconds);
}
public static void FromQuaranTimeMilliseconds_RoundTrip(TestTime test)
{
DateTimeOffset dateTime = QuaranTime.FromQuaranTimeMilliseconds(test.QuaranTimeMilliseconds);
ToQuaranTimeMilliseconds(TestTime.FromMilliseconds(dateTime, test.QuaranTimeMilliseconds));
}
static void Main(string[] args)
{
try
{
Test();
TestTime tt = new TestTime();
TestTime.Load("result", ref tt);
Console.WriteLine("Конец ввода - q");
while (true)
{
Console.Write("Порядок блочной матрицы: ");
try
{
string input = Console.ReadLine();
if (input == "q")
{
break;
}
int blocks = Convert.ToInt32(input);
if (blocks <= 0)
{
throw new Exception();
}
Console.Write("Порядок матриц-элементов: ");
input = Console.ReadLine();
if (input == "q")
{
break;
}
int smallOrder = Convert.ToInt32(input);
if (smallOrder <= 0)
{
throw new Exception();
}
double msSharp = 0.0, msPlus = 0.0;
GenerateAndSolve(blocks, smallOrder, ref msSharp, ref msPlus);
string s = "Порядок блочной матрицы: " + blocks.ToString() +
"\nПорядок матриц-элементов: " + smallOrder.ToString() +
"\nВремя на C#: " + msSharp.ToString() +
"\nВремя на C++: " + msPlus.ToString() +
"\nОтношение: " + (msSharp / msPlus).ToString() + "\n";
tt.Add(s);
}
catch (Exception)
{
Console.WriteLine("Неправильный ввод\n");
}
}
Console.WriteLine("==================================");
Console.WriteLine(tt);
TestTime.Save("result", tt);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public static void FromUnixTimeSeconds_RoundTrip(TestTime test)
{
DateTimeOffset dateTime = DateTimeOffset.FromUnixTimeSeconds(test.UnixTimeSeconds);
ToUnixTimeSeconds(TestTime.FromSeconds(dateTime, test.UnixTimeSeconds));
}
public static void oUnixTimeMilliseconds_RountTrip(TestTime test)
{
long unixTimeMilliseconds = test.DateTimeOffset.ToUnixTimeMilliseconds();
FromUnixTimeMilliseconds(TestTime.FromMilliseconds(test.DateTimeOffset, unixTimeMilliseconds));
}
public static void ToUnixTimeMilliseconds(TestTime test)
{
long expectedMilliseconds = test.UnixTimeMilliseconds;
long actualMilliseconds = test.DateTimeOffset.ToUnixTimeMilliseconds();
Assert.Equal(expectedMilliseconds, actualMilliseconds);
}
public static void TesToUnixTimeSeconds_RoundTrip(TestTime test)
{
long unixTimeSeconds = test.DateTimeOffset.ToUnixTimeSeconds();
TestFromUnixTimeSeconds(TestTime.FromSeconds(test.DateTimeOffset, unixTimeSeconds));
}
public static void TestFromUnixTimeSeconds_RoundTrip(TestTime test)
{
DateTimeOffset dateTime = DateTimeOffset.FromUnixTimeSeconds(test.UnixTimeSeconds);
TestToUnixTimeSeconds(TestTime.FromSeconds(dateTime, test.UnixTimeSeconds));
}
public void InitEnvironment()
{
TestTime time = new TestTime();
TestGameLoopController controller = new TestGameLoopController();
}
public static void FromUnixTimeMilliseconds_RoundTrip(TestTime test)
{
DateTimeOffset dateTime = DateTimeOffset.FromUnixTimeMilliseconds(test.UnixTimeMilliseconds);
ToUnixTimeMilliseconds(TestTime.FromMilliseconds(dateTime, test.UnixTimeMilliseconds));
}
public static void ToQuaranTimeSeconds_RoundTrip(TestTime test)
{
long quaranTimeSeconds = test.DateTimeOffset.ToQuaranTimeSeconds();
FromQuaranTimeSeconds(TestTime.FromSeconds(test.DateTimeOffset, quaranTimeSeconds));
}
public static void TestFromUnixTimeMilliseconds_RoundTrip(TestTime test)
{
DateTimeOffset dateTime = DateTimeOffset.FromUnixTimeMilliseconds(test.UnixTimeMilliseconds);
TestToUnixTimeMilliseconds(TestTime.FromMilliseconds(dateTime, test.UnixTimeMilliseconds));
}
